diff --git a/.azdo/ci-pr.yaml b/.azdo/ci-pr.yaml index ad3b3112..9fa0f87a 100644 --- a/.azdo/ci-pr.yaml +++ b/.azdo/ci-pr.yaml @@ -72,6 +72,7 @@ steps: python -m pip install ./dist/microsoft_agents_authentication_msal*.whl python -m pip install ./dist/microsoft_agents_copilotstudio_client*.whl python -m pip install ./dist/microsoft_agents_hosting_aiohttp*.whl + python -m pip install ./dist/microsoft_agents_hosting_dialogs*.whl python -m pip install ./dist/microsoft_agents_hosting_teams*.whl python -m pip install ./dist/microsoft_agents_storage_blob*.whl python -m pip install ./dist/microsoft_agents_storage_cosmos*.whl diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 8e8e8dfa..25a753a2 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -61,6 +61,7 @@ jobs: python -m pip install ./dist/microsoft_agents_authentication_msal*.whl python -m pip install ./dist/microsoft_agents_copilotstudio_client*.whl python -m pip install ./dist/microsoft_agents_hosting_aiohttp*.whl + python -m pip install ./dist/microsoft_agents_hosting_dialogs*.whl python -m pip install ./dist/microsoft_agents_hosting_teams*.whl python -m pip install ./dist/microsoft_agents_storage_blob*.whl python -m pip install ./dist/microsoft_agents_storage_cosmos*.whl diff --git a/dev/testing/microsoft-agents-testing/microsoft_agents/testing/__init__.py b/dev/testing/microsoft-agents-testing/microsoft_agents/testing/__init__.py index 0a411674..340c6ee3 100644 --- a/dev/testing/microsoft-agents-testing/microsoft_agents/testing/__init__.py +++ b/dev/testing/microsoft-agents-testing/microsoft_agents/testing/__init__.py @@ -57,6 +57,11 @@ AiohttpScenario, ) +from .activity_handler_scenario import ( + ActivityHandlerEnvironment, + ActivityHandlerScenario, +) + from .transcript_formatter import ( DetailLevel, ConversationTranscriptFormatter, @@ -88,6 +93,8 @@ "Unset", "AgentEnvironment", "AiohttpScenario", + "ActivityHandlerEnvironment", + "ActivityHandlerScenario", "ScenarioEntry", "scenario_registry", "load_scenarios", @@ -95,4 +102,4 @@ "ConversationTranscriptFormatter", "ActivityTranscriptFormatter", "TranscriptFormatter", -] \ No newline at end of file +] diff --git a/dev/testing/microsoft-agents-testing/microsoft_agents/testing/activity_handler_scenario.py b/dev/testing/microsoft-agents-testing/microsoft_agents/testing/activity_handler_scenario.py new file mode 100644 index 00000000..8c405c7c --- /dev/null +++ b/dev/testing/microsoft-agents-testing/microsoft_agents/testing/activity_handler_scenario.py @@ -0,0 +1,185 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""ActivityHandlerScenario - In-process testing for ActivityHandler-based agents. + +Provides a scenario that hosts an ActivityHandler-based agent within the test +process using aiohttp, enabling integration testing of dialog-heavy agents. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Callable, Awaitable +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager + +from aiohttp.web import Application, Request, Response, middleware +from aiohttp.test_utils import TestServer + +from microsoft_agents.hosting.core import ( + ActivityHandler, + ConversationState, + UserState, + MemoryStorage, + Storage, +) +from microsoft_agents.hosting.core.authorization import ClaimsIdentity +from microsoft_agents.hosting.aiohttp import CloudAdapter + +from .core import ( + AiohttpCallbackServer, + _AiohttpClientFactory, + ClientFactory, + Scenario, + ScenarioConfig, +) + + +@dataclass +class ActivityHandlerEnvironment: + """Components available when an ActivityHandler-based agent is running. + + Attributes: + storage: In-memory state storage shared by all state objects. + conversation_state: Conversation-scoped state accessor. + user_state: User-scoped state accessor. + adapter: CloudAdapter instance (anonymous auth, no real credentials). + handler: The ActivityHandler instance under test. + """ + + storage: Storage + conversation_state: ConversationState + user_state: UserState + adapter: CloudAdapter + handler: ActivityHandler + + +class ActivityHandlerScenario(Scenario): + """Test scenario for ActivityHandler-based agents. + + Use this scenario when your agent extends ``ActivityHandler`` rather than + ``AgentApplication``. The scenario creates ``MemoryStorage``, + ``ConversationState``, ``UserState``, and a ``CloudAdapter`` (no auth), then + wires them up and hosts the handler on an ephemeral aiohttp test server. + + Example:: + + def create_agent(conv_state, user_state, storage): + dialog = UserProfileDialog(user_state) + return DialogAgent(conv_state, user_state, dialog) + + scenario = ActivityHandlerScenario(create_agent) + async with scenario.client() as client: + await client.send("hello", wait=1.0) + client.expect().that_for_any(text="~Please enter") + + :param create_handler: A callable that receives ``(conv_state, user_state, + storage)`` and returns an ``ActivityHandler`` (sync or async factory). + :param config: Optional scenario configuration. + """ + + def __init__( + self, + create_handler: Callable[ + [ConversationState, UserState, Storage], + ActivityHandler | Awaitable[ActivityHandler], + ], + config: ScenarioConfig | None = None, + ) -> None: + super().__init__(config) + if not create_handler: + raise ValueError("create_handler must be provided.") + self._create_handler = create_handler + self._env: ActivityHandlerEnvironment | None = None + + @property + def environment(self) -> ActivityHandlerEnvironment: + """Get the agent environment (only valid while the scenario is running).""" + if self._env is None: + raise RuntimeError( + "Agent environment not available. Is the scenario running?" + ) + return self._env + + async def _setup(self) -> None: + """Create storage, state objects, adapter, and handler.""" + storage = MemoryStorage() + conv_state = ConversationState(storage) + user_state = UserState(storage) + adapter = CloudAdapter() + + result = self._create_handler(conv_state, user_state, storage) + if hasattr(result, "__await__"): + handler = await result # type: ignore[misc] + else: + handler = result # type: ignore[assignment] + + self._env = ActivityHandlerEnvironment( + storage=storage, + conversation_state=conv_state, + user_state=user_state, + adapter=adapter, + handler=handler, + ) + + def _build_app(self) -> Application: + """Build the aiohttp Application with an /api/messages POST route. + + An anonymous-identity middleware is applied so that the adapter's + auth pipeline succeeds without real credentials. The middleware sets + ``request["claims_identity"]`` to an unauthenticated anonymous + ``ClaimsIdentity``, which causes the adapter to skip token acquisition + and use an empty bearer token for outbound calls (acceptable for + in-process integration tests where ``serviceUrl`` is the local + callback server). + """ + assert self._env is not None + agent = self._env.handler + adapter = self._env.adapter + + _anonymous = ClaimsIdentity({}, False, authentication_type="Anonymous") + + @middleware + async def anonymous_auth(request: Request, handler): + request["claims_identity"] = _anonymous + return await handler(request) + + app = Application(middlewares=[anonymous_auth]) + + async def entry_point(request: Request) -> Response: + return await adapter.process(request, agent) + + app.router.add_post("/api/messages", entry_point) + return app + + @asynccontextmanager + async def run(self) -> AsyncIterator[ClientFactory]: + """Start the scenario and yield a client factory. + + The agent server binds to an ephemeral port; the callback server + (which receives ``send_activity`` calls from the handler) uses the + port from ``ScenarioConfig.callback_server_port`` (default 9378). + """ + await self._setup() + app = self._build_app() + + callback_server = AiohttpCallbackServer(self._config.callback_server_port) + + async with callback_server.listen() as transcript: + # port=None → aiohttp picks an available ephemeral port + async with TestServer(app, port=None) as server: + agent_endpoint = f"http://127.0.0.1:{server.port}/api/messages" + + factory = _AiohttpClientFactory( + agent_endpoint=agent_endpoint, + response_endpoint=callback_server.service_endpoint, + sdk_config={}, + default_config=self._config.client_config, + transcript=transcript, + ) + + try: + yield factory + finally: + await factory.cleanup() diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/__init__.py b/dev/testing/python-sdk-tests/tests/activity_handler/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/__init__.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/__init__.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/booking_dialog.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/booking_dialog.py new file mode 100644 index 00000000..78c2340c --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/booking_dialog.py @@ -0,0 +1,118 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""BookingDialog — collects origin, destination, and passenger count for a flight booking. + +Steps: + 1. origin_step — TextPrompt: departure city + 2. destination_step — TextPrompt: arrival city + 3. passengers_step — NumberPrompt (validator: 1 <= n <= 9) with retry + 4. confirm_step — ConfirmPrompt: shows summary, asks to confirm + 5. finalize_step — confirms or cancels the booking +""" + +from microsoft_agents.hosting.core import MessageFactory +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + DialogTurnResult, + WaterfallDialog, + WaterfallStepContext, +) +from microsoft_agents.hosting.dialogs.prompts import ( + ConfirmPrompt, + NumberPrompt, + PromptOptions, + PromptValidatorContext, + TextPrompt, +) + + +class BookingDialog(ComponentDialog): + """ComponentDialog that collects a simple flight booking.""" + + def __init__(self) -> None: + super().__init__(BookingDialog.__name__) + + self.add_dialog( + WaterfallDialog( + WaterfallDialog.__name__, + [ + self._origin_step, + self._destination_step, + self._passengers_step, + self._confirm_step, + self._finalize_step, + ], + ) + ) + self.add_dialog(TextPrompt(TextPrompt.__name__)) + self.add_dialog( + NumberPrompt(NumberPrompt.__name__, self._passengers_validator) + ) + self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) + + self.initial_dialog_id = WaterfallDialog.__name__ + + # ------------------------------------------------------------------ + # Steps + # ------------------------------------------------------------------ + + async def _origin_step(self, step: WaterfallStepContext) -> DialogTurnResult: + return await step.prompt( + TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Where are you flying from?")), + ) + + async def _destination_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["origin"] = step.result + return await step.prompt( + TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Where are you flying to?")), + ) + + async def _passengers_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["destination"] = step.result + return await step.prompt( + NumberPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("How many passengers? (1-9)"), + retry_prompt=MessageFactory.text( + "Please enter a number between 1 and 9." + ), + ), + ) + + async def _confirm_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["passengers"] = int(step.result) + origin = step.values["origin"] + dest = step.values["destination"] + pax = step.values["passengers"] + summary = f"Route: {origin} → {dest} for {pax} passenger(s). Confirm?" + return await step.prompt( + ConfirmPrompt.__name__, + PromptOptions(prompt=MessageFactory.text(summary)), + ) + + async def _finalize_step(self, step: WaterfallStepContext) -> DialogTurnResult: + if step.result: + origin = step.values["origin"] + dest = step.values["destination"] + pax = step.values["passengers"] + await step.context.send_activity( + MessageFactory.text( + f"Booking confirmed: {origin} to {dest} for {pax} passenger(s)." + ) + ) + else: + await step.context.send_activity( + MessageFactory.text("Booking cancelled.") + ) + return await step.end_dialog() + + # ------------------------------------------------------------------ + # Validators + # ------------------------------------------------------------------ + + @staticmethod + async def _passengers_validator(pc: PromptValidatorContext) -> bool: + return pc.recognized.succeeded and 1 <= int(pc.recognized.value) <= 9 \ No newline at end of file diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/dialog_agent.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/dialog_agent.py new file mode 100644 index 00000000..dfae68e4 --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/dialog_agent.py @@ -0,0 +1,49 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""DialogAgent — generic ActivityHandler that drives a single root Dialog.""" + +from microsoft_agents.hosting.core import ( + ActivityHandler, + ConversationState, + TurnContext, + UserState, +) +from microsoft_agents.hosting.dialogs import Dialog, DialogSet, DialogTurnStatus + + +class DialogAgent(ActivityHandler): + """ActivityHandler that routes every message turn through a dialog.""" + + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ) -> None: + super().__init__() + if conversation_state is None: + raise TypeError("conversation_state is required") + if user_state is None: + raise TypeError("user_state is required") + if dialog is None: + raise TypeError("dialog is required") + + self._conversation_state = conversation_state + self._user_state = user_state + self._dialog = dialog + self._dialog_state = conversation_state.create_property("DialogState") + + async def on_turn(self, turn_context: TurnContext) -> None: + await super().on_turn(turn_context) + await self._conversation_state.save(turn_context) + await self._user_state.save(turn_context) + + async def on_message_activity(self, turn_context: TurnContext) -> None: + dialog_set = DialogSet(self._dialog_state) + dialog_set.add(self._dialog) + + dc = await dialog_set.create_context(turn_context) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog(self._dialog.id) diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile.py new file mode 100644 index 00000000..b194ca9d --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile.py @@ -0,0 +1,15 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass +from microsoft_agents.activity import Attachment + + +@dataclass +class UserProfile: + """User profile collected by UserProfileDialog.""" + + name: str | None = None + transport: str | None = None + age: int = 0 + picture: Attachment | None = None diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile_dialog.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile_dialog.py new file mode 100644 index 00000000..dbef7325 --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/sample/user_profile_dialog.py @@ -0,0 +1,196 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""UserProfileDialog — multi-step waterfall that collects a user profile. + +Steps: + 1. transport_step — ChoicePrompt: Car / Bus / Bicycle + 2. name_step — TextPrompt + 3. confirm_age_step — ConfirmPrompt: ask whether to collect age + 4. age_step — NumberPrompt (validator: 0 < age < 150), or skip with -1 + 5. picture_step — AttachmentPrompt (jpeg/png); plain-text skips gracefully + 6. summary_step — display summary, ConfirmPrompt: save? + 7. save_step — persist or discard UserProfile +""" + +from microsoft_agents.hosting.core import MessageFactory, UserState +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + DialogTurnResult, + WaterfallDialog, + WaterfallStepContext, +) +from microsoft_agents.hosting.dialogs.choices import Choice +from microsoft_agents.hosting.dialogs.prompts import ( + AttachmentPrompt, + ChoicePrompt, + ConfirmPrompt, + NumberPrompt, + PromptOptions, + PromptValidatorContext, + TextPrompt, +) + +from .user_profile import UserProfile + + +class UserProfileDialog(ComponentDialog): + """ComponentDialog that collects transport, name, age, and a profile picture.""" + + def __init__(self, user_state: UserState) -> None: + super().__init__(UserProfileDialog.__name__) + + self._profile_accessor = user_state.create_property("UserProfile") + + self.add_dialog( + WaterfallDialog( + WaterfallDialog.__name__, + [ + self._transport_step, + self._name_step, + self._confirm_age_step, + self._age_step, + self._picture_step, + self._summary_step, + self._save_step, + ], + ) + ) + self.add_dialog(ChoicePrompt(ChoicePrompt.__name__)) + self.add_dialog(TextPrompt(TextPrompt.__name__)) + self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) + self.add_dialog( + NumberPrompt(NumberPrompt.__name__, self._age_validator) + ) + self.add_dialog( + AttachmentPrompt(AttachmentPrompt.__name__, self._picture_validator) + ) + + self.initial_dialog_id = WaterfallDialog.__name__ + + # ------------------------------------------------------------------ + # Steps + # ------------------------------------------------------------------ + + async def _transport_step(self, step: WaterfallStepContext) -> DialogTurnResult: + return await step.prompt( + ChoicePrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Please enter your mode of transport."), + choices=[Choice("Car"), Choice("Bus"), Choice("Bicycle")], + ), + ) + + async def _name_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["transport"] = step.result.value + return await step.prompt( + TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Please enter your name.")), + ) + + async def _confirm_age_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["name"] = step.result + await step.context.send_activity( + MessageFactory.text(f"Thanks {step.result}") + ) + return await step.prompt( + ConfirmPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Would you like to give your age?")), + ) + + async def _age_step(self, step: WaterfallStepContext) -> DialogTurnResult: + if step.result: + return await step.prompt( + NumberPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Please enter your age."), + retry_prompt=MessageFactory.text( + "The value entered must be greater than 0 and less than 150." + ), + ), + ) + return await step.next(-1) + + async def _picture_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["age"] = step.result + msg = ( + "No age given." + if step.result == -1 + else f"I have your age as {step.result}." + ) + await step.context.send_activity(MessageFactory.text(msg)) + + return await step.prompt( + AttachmentPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text( + "Please attach a profile picture (or type any message to skip)." + ), + retry_prompt=MessageFactory.text( + "The attachment must be a jpeg/png image file." + ), + ), + ) + + async def _summary_step(self, step: WaterfallStepContext) -> DialogTurnResult: + step.values["picture"] = ( + None if not step.result else step.result[0] + ) + + transport = step.values["transport"] + name = step.values["name"] + age = step.values["age"] + + summary = f"I have your mode of transport as {transport} and your name as {name}." + if age != -1: + summary += f" And age as {age}." + await step.context.send_activity(MessageFactory.text(summary)) + + if step.values["picture"]: + await step.context.send_activity( + MessageFactory.attachment(step.values["picture"], "Your profile picture.") + ) + else: + await step.context.send_activity("No profile picture provided.") + + return await step.prompt( + ConfirmPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Is this ok?")), + ) + + async def _save_step(self, step: WaterfallStepContext) -> DialogTurnResult: + if step.result: + profile = await self._profile_accessor.get(step.context, UserProfile) + profile.transport = step.values["transport"] + profile.name = step.values["name"] + profile.age = step.values["age"] + profile.picture = step.values["picture"] + msg = "Thanks. Your profile was saved successfully." + else: + msg = "Thanks. Your profile will not be kept." + + await step.context.send_activity(MessageFactory.text(msg)) + return await step.end_dialog() + + # ------------------------------------------------------------------ + # Validators + # ------------------------------------------------------------------ + + @staticmethod + async def _age_validator(pc: PromptValidatorContext) -> bool: + return pc.recognized.succeeded and 0 < pc.recognized.value < 150 + + @staticmethod + async def _picture_validator(pc: PromptValidatorContext) -> bool: + if not pc.recognized.succeeded: + await pc.context.send_activity( + "No attachments received. Proceeding without a profile picture..." + ) + return True # allow skipping + + valid = [ + a for a in pc.recognized.value + if a.content_type in ("image/jpeg", "image/png") + ] + pc.recognized.value = valid + return len(valid) > 0 diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/scenario.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/scenario.py new file mode 100644 index 00000000..c0136522 --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/scenario.py @@ -0,0 +1,27 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""Scenario definition for ActivityHandler-based dialog integration tests.""" + +from microsoft_agents.hosting.core import ConversationState, UserState, Storage +from microsoft_agents.testing import ActivityHandlerScenario, ScenarioConfig + +from tests.activity_handler.dialogs.sample.dialog_agent import DialogAgent +from tests.activity_handler.dialogs.sample.user_profile_dialog import UserProfileDialog + + +def _create_handler( + conv_state: ConversationState, + user_state: UserState, + _storage: Storage, +) -> DialogAgent: + """Factory consumed by ActivityHandlerScenario.""" + dialog = UserProfileDialog(user_state) + return DialogAgent(conv_state, user_state, dialog) + + +def create_dialog_scenario( + config: ScenarioConfig | None = None, +) -> ActivityHandlerScenario: + """Create a ready-to-use ActivityHandlerScenario for the UserProfileDialog.""" + return ActivityHandlerScenario(_create_handler, config=config) diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_booking_dialog.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_booking_dialog.py new file mode 100644 index 00000000..79b876c1 --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_booking_dialog.py @@ -0,0 +1,254 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""End-to-end integration tests for BookingDialog. + +BookingDialog is a 5-step WaterfallDialog: + 1. origin — TextPrompt + 2. destination — TextPrompt + 3. passengers — NumberPrompt (validator: 1 ≤ n ≤ 9, retry on failure) + 4. confirm — ConfirmPrompt showing the route summary + 5. finalize — confirms or cancels the booking + +Turn flow summary (happy path) +------------------------------- +1. User sends any message → bot asks "Where are you flying from?" +2. User sends "London" → bot asks "Where are you flying to?" +3. User sends "Paris" → bot asks "How many passengers? (1-9)" +4. User sends "2" → bot shows "Route: London → Paris for 2 passenger(s). Confirm?" +5. User sends "yes" → bot says "Booking confirmed: London to Paris for 2 passenger(s)." +""" + +import pytest + +from microsoft_agents.testing import ( + ActivityHandlerScenario, + AgentClient, + ClientConfig, + ScenarioConfig, + ActivityTemplate, +) + +from tests.activity_handler.dialogs.sample.dialog_agent import DialogAgent +from tests.activity_handler.dialogs.sample.booking_dialog import BookingDialog + +# --------------------------------------------------------------------------- +# Shared scenario +# --------------------------------------------------------------------------- + +_TEMPLATE = ActivityTemplate( + { + "channel_id": "webchat", + "locale": "en-US", + "conversation": {"id": "booking-conv-1"}, + "from": {"id": "booking-user", "name": "BookingUser"}, + "recipient": {"id": "bot", "name": "Bot"}, + } +) + + +def _make_scenario(config: ScenarioConfig | None = None) -> ActivityHandlerScenario: + def _create_handler(conv_state, user_state, storage): + return DialogAgent(conv_state, user_state, BookingDialog()) + + return ActivityHandlerScenario(_create_handler, config=config) + + +_SCENARIO = _make_scenario( + config=ScenarioConfig(client_config=ClientConfig(activity_template=_TEMPLATE)) +) + + +# --------------------------------------------------------------------------- +# Happy-path tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestBookingDialogHappyPath: + """Full happy-path flows through BookingDialog.""" + + @pytest.mark.asyncio + async def test_full_booking_confirmed(self, agent_client: AgentClient): + """Drive every step to completion and confirm the booking.""" + await agent_client.send("hi", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~flying from") + agent_client.clear() + + await agent_client.send("London", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~flying to") + agent_client.clear() + + await agent_client.send("Paris", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~passengers") + agent_client.clear() + + await agent_client.send("2", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~London") + agent_client.expect().that_for_any(type="message", text="~Paris") + agent_client.expect().that_for_any(type="message", text="~2 passenger") + agent_client.clear() + + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~confirmed") + + @pytest.mark.asyncio + async def test_booking_cancelled_at_confirm_step(self, agent_client: AgentClient): + """Replying 'no' at the summary step cancels the booking.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("NYC", wait=0.5) + agent_client.clear() + await agent_client.send("Miami", wait=0.5) + agent_client.clear() + await agent_client.send("1", wait=0.5) + agent_client.clear() + + await agent_client.send("no", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~cancelled") + + @pytest.mark.asyncio + async def test_single_passenger_accepted(self, agent_client: AgentClient): + """Minimum (1) passenger count is accepted and echoed in the summary.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Tokyo", wait=0.5) + agent_client.clear() + await agent_client.send("Osaka", wait=0.5) + agent_client.clear() + + await agent_client.send("1", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~1 passenger") + agent_client.clear() + + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~confirmed") + + @pytest.mark.asyncio + async def test_max_nine_passengers_accepted(self, agent_client: AgentClient): + """Maximum (9) passenger count is accepted and appears in the final message.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Berlin", wait=0.5) + agent_client.clear() + await agent_client.send("Madrid", wait=0.5) + agent_client.clear() + + await agent_client.send("9", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~9 passenger") + agent_client.clear() + + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~9 passenger") + + +# --------------------------------------------------------------------------- +# Passenger validator tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestBookingDialogPassengerValidation: + """Tests the NumberPrompt validator that enforces 1 ≤ passengers ≤ 9.""" + + @pytest.mark.asyncio + async def test_zero_passengers_triggers_retry(self, agent_client: AgentClient): + """Passenger count of 0 is rejected and the retry prompt is shown.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Amsterdam", wait=0.5) + agent_client.clear() + await agent_client.send("Brussels", wait=0.5) + agent_client.clear() + + await agent_client.send("0", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~1 and 9") + agent_client.clear() + + await agent_client.send("3", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~3 passenger") + + @pytest.mark.asyncio + async def test_ten_passengers_triggers_retry(self, agent_client: AgentClient): + """Passenger count of 10 exceeds the maximum and the retry prompt is shown.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Vienna", wait=0.5) + agent_client.clear() + await agent_client.send("Prague", wait=0.5) + agent_client.clear() + + await agent_client.send("10", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~1 and 9") + agent_client.clear() + + await agent_client.send("5", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~5 passenger") + + @pytest.mark.asyncio + async def test_multiple_invalid_values_then_valid( + self, agent_client: AgentClient + ): + """Several out-of-range values each trigger the retry prompt before a valid entry.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Rome", wait=0.5) + agent_client.clear() + await agent_client.send("Florence", wait=0.5) + agent_client.clear() + + await agent_client.send("0", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~1 and 9") + agent_client.clear() + + await agent_client.send("100", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~1 and 9") + agent_client.clear() + + await agent_client.send("7", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~7 passenger") + + +# --------------------------------------------------------------------------- +# Summary content tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestBookingDialogSummary: + """Tests that verify the summary shown at the ConfirmPrompt step.""" + + @pytest.mark.asyncio + async def test_summary_includes_origin_and_destination( + self, agent_client: AgentClient + ): + """The confirm prompt contains both origin and destination city names.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Lisbon", wait=0.5) + agent_client.clear() + await agent_client.send("Porto", wait=0.5) + agent_client.clear() + + await agent_client.send("2", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Lisbon") + agent_client.expect().that_for_any(type="message", text="~Porto") + + @pytest.mark.asyncio + async def test_confirmed_message_includes_full_route( + self, agent_client: AgentClient + ): + """The confirmed booking message includes origin, destination, and passenger count.""" + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Dublin", wait=0.5) + agent_client.clear() + await agent_client.send("Edinburgh", wait=0.5) + agent_client.clear() + await agent_client.send("4", wait=0.5) + agent_client.clear() + + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Dublin") + agent_client.expect().that_for_any(type="message", text="~Edinburgh") + agent_client.expect().that_for_any(type="message", text="~4 passenger") diff --git a/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_user_profile_dialog.py b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_user_profile_dialog.py new file mode 100644 index 00000000..b5be3d9a --- /dev/null +++ b/dev/testing/python-sdk-tests/tests/activity_handler/dialogs/test_user_profile_dialog.py @@ -0,0 +1,414 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""End-to-end integration tests for UserProfileDialog. + +These tests drive the full 7-step WaterfallDialog (transport → name → +name_confirm → age → picture → summary → confirm) through a real in-process +aiohttp server. No external credentials are needed; state is held in +MemoryStorage. + +Turn flow summary +----------------- +1. User sends any message → bot asks for transport choice (Car/Bus/Bicycle) +2. User picks "Car" → bot asks for name +3. User sends "Alice" → bot says "Thanks Alice", asks for age confirmation +4. User sends "yes" → bot asks for age (with validator: 0 < age < 150) +5. User sends "25" → bot says "I have your age as 25.", asks for picture +6. User sends any text → picture validator accepts the no-attachment case, + bot sends summary + "Is this ok?" +7. User sends "yes" → bot saves profile, says "Thanks. Your profile was saved" +""" + +import pytest + +from microsoft_agents.activity import Activity, Attachment, ActivityTypes +from microsoft_agents.testing import AgentClient, ScenarioConfig, ClientConfig, ActivityTemplate + +from tests.activity_handler.dialogs.scenario import create_dialog_scenario + +# --------------------------------------------------------------------------- +# Shared activity template — identifies the test user and conversation +# --------------------------------------------------------------------------- +_TEMPLATE = ActivityTemplate( + { + "channel_id": "webchat", + "locale": "en-US", + "conversation": {"id": "dialog-conv-1"}, + "from": {"id": "user1", "name": "Alice"}, + "recipient": {"id": "bot", "name": "Bot"}, + } +) + +_SCENARIO = create_dialog_scenario( + config=ScenarioConfig( + client_config=ClientConfig(activity_template=_TEMPLATE), + ) +) + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestUserProfileDialogHappyPath: + """Full happy-path walk-through of UserProfileDialog.""" + + @pytest.mark.asyncio + async def test_full_flow_save_profile(self, agent_client: AgentClient): + """Drive every step to completion and confirm the profile is saved.""" + + # Turn 1 — start dialog, expect transport prompt + await agent_client.send("hi", wait=0.5) + agent_client.expect().that_for_any( + type="message", text="~mode of transport" + ) + agent_client.clear() + + # Turn 2 — pick a transport, expect name prompt + await agent_client.send("Car", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~name") + agent_client.clear() + + # Turn 3 — provide name, expect thanks + age-confirmation prompt + await agent_client.send("Alice", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Thanks Alice") + agent_client.expect().that_for_any(type="message", text="~age") + agent_client.clear() + + # Turn 4 — confirm age ("yes"), expect age-number prompt + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~enter your age") + agent_client.clear() + + # Turn 5 — provide valid age, expect age acknowledgement + picture prompt + await agent_client.send("25", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~age as 25") + agent_client.expect().that_for_any(type="message", text="~profile picture") + agent_client.clear() + + # Turn 6 — skip picture (plain text message, no attachment) + # picture_prompt_validator returns True even without attachments + await agent_client.send("skip", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~No attachments") + agent_client.expect().that_for_any(type="message", text="~Is this ok") + agent_client.clear() + + # Turn 7 — confirm save + await agent_client.send("yes", wait=0.5) + agent_client.expect().that_for_any( + type="message", text="~profile was saved" + ) + + @pytest.mark.asyncio + async def test_full_flow_discard_profile(self, agent_client: AgentClient): + """Walk through all steps but decline to save at the end.""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + + await agent_client.send("Bus", wait=0.5) + agent_client.clear() + + await agent_client.send("Bob", wait=0.5) + agent_client.clear() + + # skip age + await agent_client.send("no", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~No age given") + agent_client.clear() + + # skip picture + await agent_client.send("skip", wait=0.5) + agent_client.clear() + + # decline to save + await agent_client.send("no", wait=0.5) + agent_client.expect().that_for_any( + type="message", text="~will not be kept" + ) + + +@pytest.mark.agent_test(_SCENARIO) +class TestUserProfileDialogValidation: + """Tests that cover validator-rejection paths.""" + + @pytest.mark.asyncio + async def test_age_validator_rejects_out_of_range(self, agent_client: AgentClient): + """An age ≤ 0 or ≥ 150 triggers the retry prompt.""" + + # Start dialog through to the age-number prompt + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Car", wait=0.5) + agent_client.clear() + await agent_client.send("Alice", wait=0.5) + agent_client.clear() + await agent_client.send("yes", wait=0.5) # confirm age prompt + agent_client.clear() + + # Send invalid age + await agent_client.send("200", wait=0.5) + agent_client.expect().that_for_any( + type="message", text="~greater than 0 and less than 150" + ) + agent_client.clear() + + # Send another invalid age + await agent_client.send("0", wait=0.5) + agent_client.expect().that_for_any( + type="message", text="~greater than 0 and less than 150" + ) + agent_client.clear() + + # Valid age accepted + await agent_client.send("30", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~age as 30") + + @pytest.mark.asyncio + async def test_skip_age_goes_directly_to_picture_step(self, agent_client: AgentClient): + """Answering 'no' to the age-confirmation question skips NumberPrompt.""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Bicycle", wait=0.5) + agent_client.clear() + await agent_client.send("Carol", wait=0.5) + agent_client.clear() + + # Decline age + await agent_client.send("no", wait=0.5) + # Should jump straight to picture step (age = -1 → "No age given.") + agent_client.expect().that_for_any(type="message", text="~No age given") + agent_client.expect().that_for_any(type="message", text="~profile picture") + + +# --------------------------------------------------------------------------- +# ChoicePrompt retry tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestUserProfileDialogChoicePrompt: + """Tests for the ChoicePrompt at step 1 (transport selection).""" + + @pytest.mark.asyncio + async def test_unrecognized_choice_triggers_retry(self, agent_client: AgentClient): + """Entering a value not in the choices list causes ChoicePrompt to re-ask.""" + + await agent_client.send("hi", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~mode of transport") + agent_client.clear() + + # "Train" is not among Car / Bus / Bicycle + await agent_client.send("Train", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~mode of transport") + agent_client.clear() + + await agent_client.send("Bus", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~name") + + @pytest.mark.asyncio + async def test_multiple_invalid_choices_then_valid( + self, agent_client: AgentClient + ): + """Two consecutive invalid choices both trigger retries before a valid pick.""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + + await agent_client.send("Hovercraft", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~mode of transport") + agent_client.clear() + + await agent_client.send("Rocket", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~mode of transport") + agent_client.clear() + + await agent_client.send("Bicycle", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~name") + + +# --------------------------------------------------------------------------- +# AttachmentPrompt tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestUserProfileDialogAttachment: + """Tests for the AttachmentPrompt at step 5 (profile picture).""" + + async def _navigate_to_picture_step(self, client: AgentClient) -> None: + """Helper: drive through steps 1-4 to land on the picture prompt.""" + await client.send("hi", wait=0.5) + client.clear() + await client.send("Car", wait=0.5) + client.clear() + await client.send("Eli", wait=0.5) + client.clear() + await client.send("no", wait=0.5) # skip age + client.clear() + + @pytest.mark.asyncio + async def test_valid_jpeg_attachment_accepted(self, agent_client: AgentClient): + """A jpeg attachment passes the picture validator and advances to the summary.""" + + await self._navigate_to_picture_step(agent_client) + + jpeg = Activity( + type=ActivityTypes.message, + attachments=[ + Attachment( + name="photo.jpg", + content_type="image/jpeg", + content_url="https://example.com/photo.jpg", + ) + ], + ) + await agent_client.send(jpeg, wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Is this ok") + + @pytest.mark.asyncio + async def test_png_attachment_accepted(self, agent_client: AgentClient): + """A png attachment is also accepted by the picture validator.""" + + await self._navigate_to_picture_step(agent_client) + + png = Activity( + type=ActivityTypes.message, + attachments=[ + Attachment( + name="avatar.png", + content_type="image/png", + content_url="https://example.com/avatar.png", + ) + ], + ) + await agent_client.send(png, wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Is this ok") + + @pytest.mark.asyncio + async def test_non_image_attachment_triggers_retry( + self, agent_client: AgentClient + ): + """A PDF attachment fails validation and the retry prompt is shown.""" + + await self._navigate_to_picture_step(agent_client) + + pdf = Activity( + type=ActivityTypes.message, + attachments=[ + Attachment( + name="resume.pdf", + content_type="application/pdf", + content_url="https://example.com/resume.pdf", + ) + ], + ) + await agent_client.send(pdf, wait=0.5) + agent_client.expect().that_for_any(type="message", text="~jpeg/png") + + @pytest.mark.asyncio + async def test_invalid_attachment_then_valid_accepted( + self, agent_client: AgentClient + ): + """A bad attachment type triggers the retry, then a valid jpeg is accepted.""" + + await self._navigate_to_picture_step(agent_client) + + # First send a PDF (rejected) + pdf = Activity( + type=ActivityTypes.message, + attachments=[ + Attachment( + name="doc.pdf", + content_type="application/pdf", + content_url="https://example.com/doc.pdf", + ) + ], + ) + await agent_client.send(pdf, wait=0.5) + agent_client.expect().that_for_any(type="message", text="~jpeg/png") + agent_client.clear() + + # Then send a valid jpeg (accepted) + jpeg = Activity( + type=ActivityTypes.message, + attachments=[ + Attachment( + name="photo.jpg", + content_type="image/jpeg", + content_url="https://example.com/photo.jpg", + ) + ], + ) + await agent_client.send(jpeg, wait=0.5) + agent_client.expect().that_for_any(type="message", text="~Is this ok") + + +# --------------------------------------------------------------------------- +# Summary content tests +# --------------------------------------------------------------------------- + + +@pytest.mark.agent_test(_SCENARIO) +class TestUserProfileDialogSummaryContent: + """Tests that verify what appears in the summary message at step 6.""" + + @pytest.mark.asyncio + async def test_summary_includes_transport_and_name( + self, agent_client: AgentClient + ): + """The summary message includes the chosen transport mode and the user's name.""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Bicycle", wait=0.5) + agent_client.clear() + await agent_client.send("Charlie", wait=0.5) + agent_client.clear() + await agent_client.send("no", wait=0.5) # skip age + agent_client.clear() + await agent_client.send("skip", wait=0.5) # skip picture + # summary messages arrive before the confirm prompt + agent_client.expect().that_for_any(type="message", text="~Bicycle") + agent_client.expect().that_for_any(type="message", text="~Charlie") + + @pytest.mark.asyncio + async def test_summary_includes_age_when_provided( + self, agent_client: AgentClient + ): + """When age is collected, the summary message includes it.""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Car", wait=0.5) + agent_client.clear() + await agent_client.send("Dana", wait=0.5) + agent_client.clear() + await agent_client.send("yes", wait=0.5) # confirm age + agent_client.clear() + await agent_client.send("35", wait=0.5) # provide age + agent_client.clear() + await agent_client.send("skip", wait=0.5) # skip picture + agent_client.expect().that_for_any(type="message", text="~35") + + @pytest.mark.asyncio + async def test_no_picture_message_shown_when_skipped( + self, agent_client: AgentClient + ): + """When no picture is attached, the summary step says 'No profile picture provided.'""" + + await agent_client.send("hi", wait=0.5) + agent_client.clear() + await agent_client.send("Bus", wait=0.5) + agent_client.clear() + await agent_client.send("Frank", wait=0.5) + agent_client.clear() + await agent_client.send("no", wait=0.5) + agent_client.clear() + + await agent_client.send("skip", wait=0.5) + agent_client.expect().that_for_any(type="message", text="~No profile picture") diff --git a/dev/testing/python-sdk-tests/tests/scenarios/__init__.py b/dev/testing/python-sdk-tests/tests/scenarios/__init__.py index dd9b85a0..4a0bb575 100644 --- a/dev/testing/python-sdk-tests/tests/scenarios/__init__.py +++ b/dev/testing/python-sdk-tests/tests/scenarios/__init__.py @@ -1,3 +1,5 @@ +"""Test scenario registry for AgentApplication-based integration tests.""" + from microsoft_agents.testing import ( AiohttpScenario, ScenarioConfig, @@ -10,15 +12,25 @@ "quickstart": init_quickstart, } -def load_scenario(name: str, config: ScenarioConfig | None = None, use_jwt_middleware: bool = False) -> Scenario: +def load_scenario( + name: str, + config: ScenarioConfig | None = None, + use_jwt_middleware: bool = False, +) -> Scenario: + """Load a named scenario by key.""" name = name.lower() if name not in _SCENARIO_INITS: raise ValueError(f"Unknown scenario: {name}") - - return AiohttpScenario(_SCENARIO_INITS[name], config=config, use_jwt_middleware=use_jwt_middleware) + + return AiohttpScenario( + _SCENARIO_INITS[name], + config=config, + use_jwt_middleware=use_jwt_middleware, + ) + __all__ = [ "load_scenario", -] \ No newline at end of file +] diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/channel_adapter.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/channel_adapter.py index 2592d958..f14fc0e2 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/channel_adapter.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/channel_adapter.py @@ -246,7 +246,7 @@ async def run_pipeline( if self.on_turn_error is not None: await self.on_turn_error(context, error) else: - raise error + raise else: # callback to caller on proactive case if callback is not None: diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/connector/user_token_base.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/connector/user_token_base.py index 32c21abe..3ae669ab 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/connector/user_token_base.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/connector/user_token_base.py @@ -19,8 +19,8 @@ async def get_token( self, user_id: str, connection_name: str, - channel_id: str = None, - code: str = None, + channel_id: str | None = None, + code: str | None = None, ) -> TokenResponse: """ Get sign-in URL. @@ -63,8 +63,8 @@ async def get_aad_tokens( self, user_id: str, connection_name: str, - channel_id: str = None, - body: dict = None, + channel_id: str | None = None, + body: dict | None = None, ) -> dict[str, TokenResponse]: """ Gets Azure Active Directory tokens for a user and connection. @@ -79,7 +79,10 @@ async def get_aad_tokens( @abstractmethod async def sign_out( - self, user_id: str, connection_name: str = None, channel_id: str = None + self, + user_id: str, + connection_name: str | None = None, + channel_id: str | None = None, ) -> None: """ Signs the user out from the specified connection. @@ -92,7 +95,7 @@ async def sign_out( @abstractmethod async def get_token_status( - self, user_id: str, channel_id: str = None, include: str = None + self, user_id: str, channel_id: str | None = None, include: str | None = None ) -> list[TokenStatus]: """ Gets token status for the user. @@ -106,7 +109,11 @@ async def get_token_status( @abstractmethod async def exchange_token( - self, user_id: str, connection_name: str, channel_id: str, body: dict = None + self, + user_id: str, + connection_name: str, + channel_id: str, + body: dict | None = None, ) -> TokenResponse: """ Exchanges a token. diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/message_factory.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/message_factory.py index 424a4024..e3270d1c 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/message_factory.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/message_factory.py @@ -17,9 +17,9 @@ def attachment_activity( attachment_layout: AttachmentLayoutTypes, attachments: list[Attachment], - text: str = None, - speak: str = None, - input_hint: InputHints | str = InputHints.accepting_input, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = InputHints.accepting_input, ) -> Activity: message = Activity( type=ActivityTypes.message, @@ -44,8 +44,8 @@ class MessageFactory: @staticmethod def text( text: str, - speak: str = None, - input_hint: InputHints | str = InputHints.accepting_input, + speak: str | None = None, + input_hint: InputHints | str | None = InputHints.accepting_input, ) -> Activity: """ Returns a simple text message. @@ -68,9 +68,9 @@ def text( @staticmethod def suggested_actions( actions: list[CardAction], - text: str = None, - speak: str = None, - input_hint: InputHints | str = InputHints.accepting_input, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = InputHints.accepting_input, ) -> Activity: """ Returns a message that includes a set of suggested actions and optional text. @@ -101,9 +101,9 @@ def suggested_actions( @staticmethod def attachment( attachment: Attachment, - text: str = None, - speak: str = None, - input_hint: InputHints | str = None, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = None, ): """ Returns a single message activity containing an attachment. @@ -129,9 +129,9 @@ def attachment( @staticmethod def list( attachments: list[Attachment], - text: str = None, - speak: str = None, - input_hint: InputHints | str = None, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = None, ) -> Activity: """ Returns a message that will display a set of attachments in list form. @@ -161,9 +161,9 @@ def list( @staticmethod def carousel( attachments: list[Attachment], - text: str = None, - speak: str = None, - input_hint: InputHints | str = None, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = None, ) -> Activity: """ Returns a message that will display a set of attachments using a carousel layout. @@ -194,10 +194,10 @@ def carousel( def content_url( url: str, content_type: str, - name: str = None, - text: str = None, - speak: str = None, - input_hint: InputHints | str = None, + name: str | None = None, + text: str | None = None, + speak: str | None = None, + input_hint: InputHints | str | None = None, ): """ Returns a message that will display a single image or video to a user. diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/middleware_set.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/middleware_set.py index 5f6f5e58..2dec68e1 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/middleware_set.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/middleware_set.py @@ -74,5 +74,5 @@ async def call_next_middleware(): try: return await next_middleware.on_turn(context, call_next_middleware) - except Exception as error: - raise error + except Exception: + raise diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/state/agent_state.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/state/agent_state.py index 02df1a6c..6d62ae06 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/state/agent_state.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/state/agent_state.py @@ -217,7 +217,7 @@ def get_value( else None ) - if not value and default_value_factory is not None: + if value is None and default_value_factory is not None: # If the value is None and a factory is provided, call the factory to get a default value default = default_value_factory() # Store the default value in the cache so modifications to it are tracked @@ -225,7 +225,7 @@ def get_value( self._cached_state.state[property_name] = default return default - if target_cls and value: + if target_cls and value is not None: # Attempt to deserialize the value if it is not None try: return target_cls.from_json_to_store_item(value) diff --git a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/turn_context.py b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/turn_context.py index 46eeba4a..cc89d177 100644 --- a/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/turn_context.py +++ b/libraries/microsoft-agents-hosting-core/microsoft_agents/hosting/core/turn_context.py @@ -330,8 +330,8 @@ async def next_handler(): await handlers[i](context, arg, next_handler) - except Exception as error: - raise error + except Exception: + raise await emit_next(0) # logic does not use parentheses because it's a coroutine diff --git a/libraries/microsoft-agents-hosting-dialogs/LICENSE b/libraries/microsoft-agents-hosting-dialogs/LICENSE new file mode 100644 index 00000000..9e841e7a --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/__init__.py new file mode 100644 index 00000000..0d3485e2 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/__init__.py @@ -0,0 +1,76 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# -------------------------------------------------------------------------- + +__version__ = "0.0.0" + +from .component_dialog import ComponentDialog +from .dialog_container import DialogContainer +from .dialog_context import DialogContext +from .models.dialog_event import DialogEvent +from .models.dialog_events import DialogEvents +from .models.dialog_instance import DialogInstance +from .models.dialog_reason import DialogReason +from .dialog_set import DialogSet +from .dialog_state import DialogState +from .models.dialog_turn_result import DialogTurnResult +from .models.dialog_turn_status import DialogTurnStatus +from .dialog_manager import DialogManager +from .dialog_manager_result import DialogManagerResult +from .dialog import Dialog +from .dialog_component_registration import DialogsComponentRegistration +from .persisted_state_keys import PersistedStateKeys +from .persisted_state import PersistedState +from .waterfall_dialog import WaterfallDialog +from .waterfall_step_context import WaterfallStepContext +from .dialog_extensions import DialogExtensions +from .prompts import * +from .choices import * +from .object_path import ObjectPath +from .models import ( + DialogEvent, + DialogEvents, + DialogInstance, + DialogReason, + DialogTurnResult, + DialogTurnStatus, +) + +__all__ = [ + "ComponentDialog", + "DialogContainer", + "DialogContext", + "DialogEvent", + "DialogEvents", + "DialogInstance", + "DialogReason", + "DialogSet", + "DialogState", + "DialogTurnResult", + "DialogTurnStatus", + "DialogManager", + "DialogManagerResult", + "Dialog", + "DialogsComponentRegistration", + "WaterfallDialog", + "WaterfallStepContext", + "ConfirmPrompt", + "DateTimePrompt", + "DateTimeResolution", + "NumberPrompt", + "OAuthPrompt", + "OAuthPromptSettings", + "PersistedStateKeys", + "PersistedState", + "PromptRecognizerResult", + "PromptValidatorContext", + "Prompt", + "PromptOptions", + "TextPrompt", + "DialogExtensions", + "ObjectPath", + "__version__", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_component_registration.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_component_registration.py new file mode 100644 index 00000000..adc358cd --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_component_registration.py @@ -0,0 +1,30 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + + +class ComponentRegistration: + """ + Simple component registration that allows dialogs and other components + to register memory scopes and path resolvers. + """ + + _components: List = [] + + @classmethod + def add(cls, component: object) -> None: + """ + Register a component. Duplicate types are ignored. + :param component: The component instance to register. + """ + if not any(type(c) == type(component) for c in cls._components): + cls._components.append(component) + + @classmethod + def get_components(cls) -> List: + """ + Gets all registered components. + :return: List of registered component instances. + """ + return list(cls._components) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_telemetry_client.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_telemetry_client.py new file mode 100644 index 00000000..180c271a --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/_telemetry_client.py @@ -0,0 +1,78 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +class AgentTelemetryClient: + """ + Interface for telemetry logging. Override to send telemetry to a custom sink. + """ + + def track_event( + self, + name: str, + properties: dict[str, str] | None = None, + metrics: dict[str, float] | None = None, + ) -> None: + pass + + def track_exception( + self, + exception: Exception, + properties: dict[str, str] | None = None, + measurements: dict[str, float] | None = None, + ) -> None: + pass + + def track_dependency( + self, + name: str, + data: str | None = None, + type_name: str | None = None, + target: str | None = None, + duration: int | None = None, + success: bool = True, + result_code: str | None = None, + properties: dict[str, str] | None = None, + ) -> None: + pass + + def flush(self) -> None: + pass + + +class NullTelemetryClient(AgentTelemetryClient): + """ + No-op telemetry client. All calls are silently discarded. + """ + + def track_event( + self, + name: str, + properties: dict[str, str] | None = None, + metrics: dict[str, float] | None = None, + ) -> None: + pass + + def track_exception( + self, + exception: Exception, + properties: dict[str, str] | None = None, + measurements: dict[str, float] | None = None, + ) -> None: + pass + + def track_dependency( + self, + name: str, + data: str | None = None, + type_name: str | None = None, + target: str | None = None, + duration: int | None = None, + success: bool = True, + result_code: str | None = None, + properties: dict[str, str] | None = None, + ) -> None: + pass + + def flush(self) -> None: + pass diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/__init__.py new file mode 100644 index 00000000..42ef388c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/__init__.py @@ -0,0 +1,38 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# -------------------------------------------------------------------------- + +from .channel import Channel +from .models.choice import Choice +from .models.choice_factory_options import ChoiceFactoryOptions +from .choice_factory import ChoiceFactory +from .choice_recognizer import ChoiceRecognizers +from .find import Find +from .models.find_choices_options import FindChoicesOptions, FindValuesOptions +from .models.found_choice import FoundChoice +from .models.found_value import FoundValue +from .models.list_style import ListStyle +from .models.model_result import ModelResult +from .models.sorted_value import SortedValue +from .models.token import Token +from .tokenizer import Tokenizer + +__all__ = [ + "Channel", + "Choice", + "ChoiceFactory", + "ChoiceFactoryOptions", + "ChoiceRecognizers", + "Find", + "FindChoicesOptions", + "FindValuesOptions", + "FoundChoice", + "ListStyle", + "ModelResult", + "SortedValue", + "Token", + "Tokenizer", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/channel.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/channel.py new file mode 100644 index 00000000..6aeb0b15 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/channel.py @@ -0,0 +1,121 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import Channels + + +class Channel: + """ + Methods for determining channel-specific functionality. + """ + + @staticmethod + def supports_suggested_actions(channel_id: str, button_cnt: int = 100) -> bool: + """Determine if a number of Suggested Actions are supported by a Channel. + + Args: + channel_id (str): The Channel to check the if Suggested Actions are supported in. + button_cnt (int, optional): Defaults to 100. The number of Suggested Actions to check for the Channel. + + Returns: + bool: True if the Channel supports the button_cnt total Suggested Actions, False if the Channel does not + support that number of Suggested Actions. + """ + if isinstance(channel_id, Channels): + channel_id = channel_id.value + + max_actions = { + # https://developers.facebook.com/docs/messenger-platform/send-messages/quick-replies + Channels.facebook.value: 10, + Channels.skype.value: 10, + # https://developers.line.biz/en/reference/messaging-api/#items-object + Channels.line.value: 13, + # https://dev.kik.com/#/docs/messaging#text-response-object + Channels.kik.value: 20, + Channels.telegram.value: 100, + Channels.emulator.value: 100, + Channels.direct_line.value: 100, + Channels.direct_line_speech.value: 100, + Channels.webchat.value: 100, + } + return ( + button_cnt <= max_actions[channel_id] + if channel_id in max_actions + else False + ) + + @staticmethod + def supports_card_actions(channel_id: str, button_cnt: int = 100) -> bool: + """Determine if a number of Card Actions are supported by a Channel. + + Args: + channel_id (str): The Channel to check if the Card Actions are supported in. + button_cnt (int, optional): Defaults to 100. The number of Card Actions to check for the Channel. + + Returns: + bool: True if the Channel supports the button_cnt total Card Actions, False if the Channel does not support + that number of Card Actions. + """ + if isinstance(channel_id, Channels): + channel_id = channel_id.value + + max_actions = { + Channels.facebook.value: 3, + Channels.skype.value: 3, + Channels.ms_teams.value: 3, + Channels.line.value: 99, + Channels.slack.value: 100, + Channels.telegram.value: 100, + Channels.emulator.value: 100, + Channels.direct_line.value: 100, + Channels.direct_line_speech.value: 100, + Channels.webchat.value: 100, + } + return ( + button_cnt <= max_actions[channel_id] + if channel_id in max_actions + else False + ) + + @staticmethod + def has_message_feed(_: str) -> bool: + """Determine if a Channel has a Message Feed. + + Args: + channel_id (str): The Channel to check for Message Feed. + + Returns: + bool: True if the Channel has a Message Feed, False if it does not. + """ + + return True + + @staticmethod + def get_channel_id(turn_context: TurnContext) -> str: + """Get the channel ID from the TurnContext's activity. + + Args: + turn_context (TurnContext): The current turn context. + + Returns: + str: The channel ID, or an empty string if not set. + """ + if turn_context.activity and turn_context.activity.channel_id: + return turn_context.activity.channel_id + return "" + + @staticmethod + def max_action_title_length( # pylint: disable=unused-argument + channel_id: str, + ) -> int: + """Maximum length allowed for Action Titles. + + Args: + channel_id (str): The Channel to determine Maximum Action Title Length. + + Returns: + int: The total number of characters allowed for an Action Title on a specific Channel. + """ + + return 20 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_factory.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_factory.py new file mode 100644 index 00000000..a5fdb608 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_factory.py @@ -0,0 +1,262 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from collections.abc import Iterable + +from microsoft_agents.hosting.core import CardFactory, MessageFactory +from microsoft_agents.activity import ( + ActionTypes, + Activity, + CardAction, + HeroCard, + InputHints, +) + +from . import Channel, Choice, ChoiceFactoryOptions + + +class ChoiceFactory: + """ + Assists with formatting a message activity that contains a list of choices. + """ + + @staticmethod + def for_channel( + channel_id: str, + choices: Iterable[str | Choice], + text: str | None = None, + speak: str | None = None, + options: ChoiceFactoryOptions | None = None, + ) -> Activity: + """ + Creates a message activity that includes a list of choices formatted based on the + capabilities of a given channel. + + Parameters + ---------- + channel_id: A channel ID. + choices: List of choices to render + text: (Optional) Text of the message to send. + speak (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel. + """ + if channel_id is None: + channel_id = "" + + choice_list: list[Choice] = ChoiceFactory._to_choices(choices) + + # Find maximum title length + max_title_length = 0 + for choice in choice_list: + if choice.action is not None and choice.action.title not in (None, ""): + size = len(choice.action.title) + else: + size = len(choice.value) if choice.value is not None else 0 + + max_title_length = max(max_title_length, size) + + # Determine list style + supports_suggested_actions = Channel.supports_suggested_actions( + channel_id, len(choice_list) + ) + supports_card_actions = Channel.supports_card_actions( + channel_id, len(choice_list) + ) + max_action_title_length = Channel.max_action_title_length(channel_id) + long_titles = max_title_length > max_action_title_length + + if not long_titles and not supports_suggested_actions and supports_card_actions: + # SuggestedActions is the preferred approach, but for channels that don't + # support them (e.g. Teams, Cortana) we should use a HeroCard with CardActions + return ChoiceFactory.hero_card(choice_list, text, speak) + if not long_titles and supports_suggested_actions: + # We always prefer showing choices using suggested actions. If the titles are too long, however, + # we'll have to show them as a text list. + return ChoiceFactory.suggested_action(choice_list, text, speak) + if not long_titles and len(choice_list) <= 3: + # If the titles are short and there are 3 or less choices we'll use an inline list. + return ChoiceFactory.inline(choice_list, text, speak, options) + # Show a numbered list. + return ChoiceFactory.list_style(choice_list, text, speak, options) + + @staticmethod + def inline( + choices: Iterable[str | Choice], + text: str | None = None, + speak: str | None = None, + options: ChoiceFactoryOptions | None = None, + ) -> Activity: + """ + Creates a message activity that includes a list of choices formatted as an inline list. + + Parameters + ---------- + choices: The list of choices to render. + text: (Optional) The text of the message to send. + speak: (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel. + options: (Optional) The formatting options to use to tweak rendering of list. + """ + choice_list = ChoiceFactory._to_choices(choices) + + if options is None: + options = ChoiceFactoryOptions() + + opt = ChoiceFactoryOptions( + inline_separator=options.inline_separator or ", ", + inline_or=options.inline_or or " or ", + inline_or_more=options.inline_or_more or ", or ", + include_numbers=( + options.include_numbers if options.include_numbers is not None else True + ), + ) + + # Format list of choices + connector = "" + txt_builder: list[str] = [] + if text is not None: + txt_builder.append(text) + txt_builder.append(" ") + + for index, choice in enumerate(choice_list): + title = ( + choice.action.title + if (choice.action is not None and choice.action.title is not None) + else choice.value + ) + txt_builder.append(connector) + if opt.include_numbers is True: + txt_builder.append("(") + txt_builder.append(f"{index + 1}") + txt_builder.append(") ") + + txt_builder.append(title or "title") + if index == (len(choice_list) - 2): + connector = opt.inline_or if index == 0 else opt.inline_or_more + connector = connector or "" + else: + connector = opt.inline_separator or "" + + # Return activity with choices as an inline list. + return MessageFactory.text( + "".join(txt_builder), speak, InputHints.expecting_input + ) + + @staticmethod + def list_style( + choices: Iterable[str | Choice], + text: str | None = None, + speak: str | None = None, + options: ChoiceFactoryOptions | None = None, + ) -> Activity: + """ + Creates a message activity that includes a list of choices formatted as a numbered or bulleted list. + + Parameters + ---------- + + choices: The list of choices to render. + + text: (Optional) The text of the message to send. + + speak: (Optional) SSML. Text to be spoken by your bot on a speech-enabled channel. + + options: (Optional) The formatting options to use to tweak rendering of list. + """ + choices = ChoiceFactory._to_choices(choices) + if options is None: + options = ChoiceFactoryOptions() + + if options.include_numbers is None: + include_numbers = True + else: + include_numbers = options.include_numbers + + # Format list of choices + connector = "" + txt_builder: list[str] = [] + if text: + txt_builder.append(text) + txt_builder.append("\n\n ") + + for index, choice in enumerate(choices): + title = ( + choice.action.title + if choice.action is not None and choice.action.title is not None + else choice.value + ) + + txt_builder.append(connector) + if include_numbers: + txt_builder.append(f"{index + 1}") + txt_builder.append(". ") + else: + txt_builder.append("- ") + + txt_builder.append(title) + connector = "\n " + + # Return activity with choices as a numbered list. + txt = "".join(txt_builder) + return MessageFactory.text(txt, speak, InputHints.expecting_input) + + @staticmethod + def suggested_action( + choices: Iterable[Choice], text: str | None = None, speak: str | None = None + ) -> Activity: + """ + Creates a message activity that includes a list of choices that have been added as suggested actions. + """ + # Return activity with choices as suggested actions + return MessageFactory.suggested_actions( + ChoiceFactory._extract_actions(choices), + text, + speak, + InputHints.expecting_input, + ) + + @staticmethod + def hero_card( + choices: Iterable[Choice | str], + text: str | None = None, + speak: str | None = None, + ) -> Activity: + """ + Creates a message activity that includes a lsit of coices that have been added as `HeroCard`'s + """ + attachment = CardFactory.hero_card( + HeroCard(text=text or "", buttons=ChoiceFactory._extract_actions(choices)) + ) + + # Return activity with choices as HeroCard with buttons + return MessageFactory.attachment( + attachment, None, speak, InputHints.expecting_input + ) + + @staticmethod + def _to_choices(choices: Iterable[str | Choice]) -> list[Choice]: + """ + Takes a list of strings and returns them as [`Choice`]. + """ + if choices is None: + return [] + return [ + Choice(value=choice) if isinstance(choice, str) else choice + for choice in choices + ] + + @staticmethod + def _extract_actions(choices: Iterable[str | Choice]) -> list[CardAction]: + if choices is None: + choices = [] + choices = ChoiceFactory._to_choices(choices) + card_actions: list[CardAction] = [] + for choice in choices: + if choice.action is not None: + card_action = choice.action + else: + card_action = CardAction( + type=ActionTypes.im_back, value=choice.value, title=choice.value + ) + + card_actions.append(card_action) + + return card_actions diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_recognizer.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_recognizer.py new file mode 100644 index 00000000..1ddcac03 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/choice_recognizer.py @@ -0,0 +1,148 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from collections.abc import Iterable + +from recognizers_number import NumberModel, NumberRecognizer, OrdinalModel +from recognizers_text import Culture + +from typing import cast + + +from .models.choice import Choice +from .find import Find +from .models.find_choices_options import FindChoicesOptions +from .models.found_choice import FoundChoice +from .models.model_result import ModelResult + + +class ChoiceRecognizers: + """Contains methods for matching user input against a list of choices.""" + + @staticmethod + def recognize_choices( + utterance: str, + choices: Iterable[str | Choice], + options: FindChoicesOptions | None = None, + ) -> list[ModelResult]: + """ + Matches user input against a list of choices. + + This is layered above the `Find.find_choices()` function, and adds logic to let the user specify + their choice by index (they can say "one" to pick `choice[0]`) or ordinal position + (they can say "the second one" to pick `choice[1]`.) + The user's utterance is recognized in the following order: + + - By name using `find_choices()` + - By 1's based ordinal position. + - By 1's based index position. + + Parameters + ----------- + + utterance: The input. + + choices: The list of choices. + + options: (Optional) Options to control the recognition strategy. + + Returns + -------- + A list of found choices, sorted by most relevant first. + """ + if utterance is None: + utterance = "" + + # Normalize list of choices + choices_list = [ + Choice(value=choice) if isinstance(choice, str) else choice + for choice in choices + ] + + # Try finding choices by text search first + # - We only want to use a single strategy for returning results to avoid issues where utterances + # like the "the third one" or "the red one" or "the first division book" would miss-recognize as + # a numerical index or ordinal as well. + locale = options.locale if (options and options.locale) else Culture.English + matched = Find.find_choices(utterance, choices_list, options) + if not matched: + matches = [] + + if not options or options.recognize_ordinals: + # Next try finding by ordinal + matches = ChoiceRecognizers._recognize_ordinal(utterance, locale) + for match in matches: + ChoiceRecognizers._match_choice_by_index( + choices_list, matched, match + ) + + if not matches and (not options or options.recognize_numbers): + # Then try by numerical index + matches = ChoiceRecognizers._recognize_number(utterance, locale) + for match in matches: + ChoiceRecognizers._match_choice_by_index( + choices_list, matched, match + ) + + # Sort any found matches by their position within the utterance. + # - The results from find_choices() are already properly sorted so we just need this + # for ordinal & numerical lookups. + matched = sorted(matched, key=lambda model_result: model_result.start) + + return matched + + @staticmethod + def _recognize_ordinal(utterance: str, culture: str) -> list[ModelResult]: + model: OrdinalModel = cast( + OrdinalModel, NumberRecognizer(culture).get_ordinal_model(culture) + ) + + return list( + map(ChoiceRecognizers._found_choice_constructor, model.parse(utterance)) # type: ignore[arg-type] + ) + + @staticmethod + def _match_choice_by_index( + choices: list[Choice], matched: list[ModelResult], match: ModelResult + ): + try: + index: int = int(match.resolution.value) - 1 + if 0 <= index < len(choices): + choice = choices[index] + + matched.append( + ModelResult( + start=match.start, + end=match.end, + type_name="choice", + text=match.text, + resolution=FoundChoice( + value=choice.value, index=index, score=1.0 + ), + ) + ) + except: + # noop here, as in dotnet/node repos + pass + + @staticmethod + def _recognize_number(utterance: str, culture: str) -> list[ModelResult]: + model: NumberModel = cast( + NumberModel, NumberRecognizer(culture).get_number_model(culture) + ) + + return list( + map(ChoiceRecognizers._found_choice_constructor, model.parse(utterance)) # type: ignore[arg-type] + ) + + @staticmethod + def _found_choice_constructor(value_model: ModelResult) -> ModelResult: + return ModelResult( + start=value_model.start, + end=value_model.end, + type_name="choice", + text=value_model.text, + resolution=FoundChoice( + value=value_model.resolution["value"], index=0, score=1.0 + ), + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/find.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/find.py new file mode 100644 index 00000000..291fc40f --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/find.py @@ -0,0 +1,242 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Callable +from collections.abc import Iterable + +from .models.choice import Choice +from .models.find_choices_options import FindChoicesOptions, FindValuesOptions +from .models.found_choice import FoundChoice +from .models.found_value import FoundValue +from .models.model_result import ModelResult +from .models.sorted_value import SortedValue +from .models.token import Token +from .tokenizer import Tokenizer + + +class Find: + """Contains methods for matching user input against a list of choices""" + + @staticmethod + def find_choices( + utterance: str, + choices: Iterable[str | Choice], + options: FindChoicesOptions | None = None, + ) -> list[ModelResult]: + """Matches user input against a list of choices""" + + if not choices: + raise TypeError("Find: choices cannot be None.") + + opt = options or FindChoicesOptions() + + # Normalize list of choices + choices_list = [ + Choice(value=choice) if isinstance(choice, str) else choice + for choice in choices + ] + + # Build up full list of synonyms to search over. + # - Each entry in the list contains the index of the choice it belongs to which will later be + # used to map the search results back to their choice. + synonyms: list[SortedValue] = [] + + for index, choice in enumerate(choices_list): + if not opt.no_value: + synonyms.append(SortedValue(value=choice.value, index=index)) + + if choice.action and choice.action.title and not opt.no_action: + synonyms.append(SortedValue(value=choice.action.title, index=index)) + + if choice.synonyms is not None: + for synonym in choice.synonyms: + synonyms.append(SortedValue(value=synonym, index=index)) + + def found_choice_constructor(value_model: ModelResult) -> ModelResult: + choice = choices_list[value_model.resolution.index] + + return ModelResult( + start=value_model.start, + end=value_model.end, + type_name="choice", + text=value_model.text, + resolution=FoundChoice( + value=choice.value, + index=value_model.resolution.index, + score=value_model.resolution.score, + synonym=value_model.resolution.value, + ), + ) + + # Find synonyms in utterance and map back to their choices_list + return list( + map(found_choice_constructor, Find.find_values(utterance, synonyms, opt)) + ) + + @staticmethod + def find_values( + utterance: str, + values: list[SortedValue], + options: FindValuesOptions | None = None, + ) -> list[ModelResult]: + # Sort values in descending order by length, so that the longest value is searchd over first. + sorted_values = sorted( + values, key=lambda sorted_val: len(sorted_val.value), reverse=True + ) + + # Search for each value within the utterance. + matches: list[ModelResult] = [] + opt = options if options else FindValuesOptions() + tokenizer: Callable[[str, str | None], list[Token]] = ( + opt.tokenizer if opt.tokenizer else Tokenizer.default_tokenizer + ) + tokens = tokenizer(utterance, opt.locale) + max_distance = ( + opt.max_token_distance if opt.max_token_distance is not None else 2 + ) + + for entry in sorted_values: + # Find all matches for a value + # - To match "last one" in "the last time I chose the last one" we need + # to re-search the string starting from the end of the previous match. + # - The start & end position returned for the match are token positions. + start_pos = 0 + searched_tokens = tokenizer(entry.value.strip(), opt.locale) + + while start_pos < len(tokens): + match: ModelResult | None = Find._match_value( + tokens, + max_distance, + opt, + entry.index, + entry.value, + searched_tokens, + start_pos, + ) + + if match is not None: + start_pos = match.end + 1 + matches.append(match) + else: + break + + # Sort matches by score descending + sorted_matches = sorted( + matches, + key=lambda model_result: model_result.resolution.score, + reverse=True, + ) + + # Filter out duplicate matching indexes and overlapping characters + # - The start & end positions are token positions and need to be translated to + # character positions before returning. We also need to populate the "text" + # field as well. + results: list[ModelResult] = [] + found_indexes = set() + used_tokens = set() + + for match in sorted_matches: + # Apply filters. + add = match.resolution.index not in found_indexes + + for i in range(match.start, match.end + 1): + if i in used_tokens: + add = False + break + + # Add to results + if add: + # Update filter info + found_indexes.add(match.resolution.index) + + for i in range(match.start, match.end + 1): + used_tokens.add(i) + + # Translate start & end and populate text field + match.start = tokens[match.start].start + match.end = tokens[match.end].end + match.text = utterance[match.start : match.end + 1] + results.append(match) + + # Return the results sorted by position in the utterance + return sorted(results, key=lambda model_result: model_result.start) + + @staticmethod + def _match_value( + source_tokens: list[Token], + max_distance: int, + options: FindValuesOptions, + index: int, + value: str, + searched_tokens: list[Token], + start_pos: int, + ) -> ModelResult | None: + # Match value to utterance and calculate total deviation. + # - The tokens are matched in order so "second last" will match in + # "the second from last one" but not in "the last from the second one". + # - The total deviation is a count of the number of tokens skipped in the + # match so for the example above the number of tokens matched would be + # 2 and the total deviation would be 1. + matched = 0 + total_deviation = 0 + start = -1 + end = -1 + + for token in searched_tokens: + # Find the position of the token in the utterance. + pos = Find._index_of_token(source_tokens, token, start_pos) + if pos >= 0: + # Calculate the distance between the current token's position and the previous token's distance. + distance = pos - start_pos if matched > 0 else 0 + if distance <= max_distance: + # Update count of tokens matched and move start pointer to search for next token + # after the current token + matched += 1 + total_deviation += distance + start_pos = pos + 1 + + # Update start & end position that will track the span of the utterance that's matched. + if start < 0: + start = pos + + end = pos + + # Calculate score and format result + # - The start & end positions and the results text field will be corrected by the caller. + result: ModelResult | None = None + + if matched > 0 and ( + matched == len(searched_tokens) or options.allow_partial_matches + ): + # Percentage of tokens matched. If matching "second last" in + # "the second form last one" the completeness would be 1.0 since + # all tokens were found. + completeness = matched / len(searched_tokens) + + # Accuracy of the match. The accuracy is reduced by additional tokens + # occuring in the value that weren't in the utterance. So an utterance + # of "second last" matched against a value of "second from last" would + # result in an accuracy of 0.5. + accuracy = float(matched) / (matched + total_deviation) + + # The final score is simply the compeleteness multiplied by the accuracy. + score = completeness * accuracy + + # Format result + result = ModelResult( + text="", + start=start, + end=end, + type_name="value", + resolution=FoundValue(value=value, index=index, score=score), + ) + + return result + + @staticmethod + def _index_of_token(tokens: list[Token], token: Token, start_pos: int) -> int: + for i in range(start_pos, len(tokens)): + if tokens[i].normalized == token.normalized: + return i + + return -1 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/__init__.py new file mode 100644 index 00000000..58a6f988 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/__init__.py @@ -0,0 +1,23 @@ +from .choice_factory_options import ChoiceFactoryOptions +from .choice import Choice +from .find_choices_options import FindChoicesOptions +from .find_values_options import FindValuesOptions +from .found_choice import FoundChoice +from .found_value import FoundValue +from .list_style import ListStyle +from .model_result import ModelResult +from .sorted_value import SortedValue +from .token import Token + +__all__ = [ + "ChoiceFactoryOptions", + "Choice", + "FindChoicesOptions", + "FindValuesOptions", + "FoundChoice", + "FoundValue", + "ListStyle", + "ModelResult", + "SortedValue", + "Token", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice.py new file mode 100644 index 00000000..55f52469 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice.py @@ -0,0 +1,14 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass, field + +from microsoft_agents.activity import CardAction + + +@dataclass +class Choice: + + value: str = "" + action: CardAction | None = None + synonyms: list[str] = field(default_factory=list) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice_factory_options.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice_factory_options.py new file mode 100644 index 00000000..4787977b --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/choice_factory_options.py @@ -0,0 +1,13 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + + +@dataclass +class ChoiceFactoryOptions: + + inline_separator: str | None = None + inline_or: str | None = None + inline_or_more: str | None = None + include_numbers: bool = True diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_choices_options.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_choices_options.py new file mode 100644 index 00000000..645c3fca --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_choices_options.py @@ -0,0 +1,28 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + +from .find_values_options import FindValuesOptions + + +@dataclass +class FindChoicesOptions(FindValuesOptions): + """Contains options to control how input is matched against a list of choices + + no_value: If `True`, the choices `value` field will NOT be search over. Defaults to `False`. + + no_action: If `True`, the choices `action.title` field will NOT be searched over. + Defaults to `False`. + + recognize_numbers: Indicates whether the recognizer should check for Numbers using the + NumberRecognizer's NumberModel. + + recognize_ordinals: Indicates whether the recognizer should check for Ordinal Numbers using + the NumberRecognizer's OrdinalModel. + """ + + no_value: bool = False + no_action: bool = False + recognize_numbers: bool = True + recognize_ordinals: bool = True diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_values_options.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_values_options.py new file mode 100644 index 00000000..daf58a72 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/find_values_options.py @@ -0,0 +1,31 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from collections.abc import Iterable +from dataclasses import dataclass +from typing import Callable + +from .token import Token + + +@dataclass +class FindValuesOptions: + """Contains search options, used to control how choices are recognized in a user's utterance. + + allow_partial_matches: (Optional) If `True`, then only some of the tokens in a value need to exist to be considered + a match. The default value is `False`. + + locale: (Optional) locale/culture code of the utterance. Default is `en-US`. + + max_token_distance: (Optional) maximum tokens allowed between two matched tokens in the utterance. So with + a max distance of 2 the value "second last" would match the utterance "second from the last" + but it wouldn't match "Wait a second. That's not the last one is it?". + The default value is "2". + + tokenizer: (Optional) Tokenizer to use when parsing the utterance and values being recognized. + """ + + allow_partial_matches: bool = False + locale: str = "en-US" + max_token_distance: int = 2 + tokenizer: Callable[[str, str | None], list[Token]] | None = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_choice.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_choice.py new file mode 100644 index 00000000..d7f24c6b --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_choice.py @@ -0,0 +1,22 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + + +@dataclass +class FoundChoice: + """Represents a result from matching user input against a list of choices. + + + value: The value of the choice that was matched. + index: The index of the choice that was matched. + score: The accuracy with which the synonym matched the specified portion of the utterance. + A value of 1.0 would indicate a perfect match. + synonym: The synonym that was matched in case of a synonym match. + """ + + value: str + index: int + score: float + synonym: str | None = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_value.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_value.py new file mode 100644 index 00000000..df5589ef --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/found_value.py @@ -0,0 +1,20 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + + +@dataclass +class FoundValue: + """Represents a result from matching user input against a list of choices + + + value: The value that was matched. + index: The index of the value that was matched. + score: The accuracy with which the synonym matched the specified portion of the utterance. + A value of 1.0 would indicate a perfect match. + """ + + value: str + index: int + score: float diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/list_style.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/list_style.py new file mode 100644 index 00000000..26341285 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/list_style.py @@ -0,0 +1,15 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from enum import Enum + + +class ListStyle(int, Enum): + """Defines the style of list to present choices to the user.""" + + none = 0 + auto = 1 + in_line = 2 + list_style = 3 + suggested_action = 4 + hero_card = 5 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/model_result.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/model_result.py new file mode 100644 index 00000000..b832ec00 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/model_result.py @@ -0,0 +1,16 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass +from typing import Any + + +@dataclass +class ModelResult: + """Contains recognition result information.""" + + text: str + start: int + end: int + type_name: str + resolution: Any diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/sorted_value.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/sorted_value.py new file mode 100644 index 00000000..27bcb66d --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/sorted_value.py @@ -0,0 +1,16 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + + +@dataclass +class SortedValue: + """A value that can be sorted and still refer to its original position with a source array. + + value: the value that will be sorted. + index: the value's original position within its unsorted array. + """ + + value: str + index: int diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/token.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/token.py new file mode 100644 index 00000000..5a9b5270 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/models/token.py @@ -0,0 +1,20 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + + +@dataclass +class Token: + """Represents an individual token, such as a word in an input string. + + start: The index of the first character of the token within the outer input string. + end: The index of the last character of the token within the outer input string. + text: The original text of the token. + normalized: A normalized version of the token. This can include things like lower casing or stemming. + """ + + start: int + end: int + text: str + normalized: str | None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/tokenizer.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/tokenizer.py new file mode 100644 index 00000000..5ec760d0 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/choices/tokenizer.py @@ -0,0 +1,92 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .models.token import Token + + +class Tokenizer: + """Provides a default tokenizer implementation.""" + + @staticmethod + def default_tokenizer( # pylint: disable=unused-argument + text: str, locale: str | None = None + ) -> list[Token]: + """ + Simple tokenizer that breaks on spaces and punctuation. The only normalization is to lowercase. + + Parameter: + --------- + + text: The input text. + + locale: (Optional) Identifies the locale of the input text. + """ + tokens: list[Token] = [] + token: Token | None = None + + # Parse text + length: int = len(text) if text else 0 + i: int = 0 + + while i < length: + # Get both the UNICODE value of the current character and the complete character itself + # which can potentially be multiple segments + code_point = ord(text[i]) + char = chr(code_point) + + # Process current character + if Tokenizer._is_breaking_char(code_point): + # Character is in Unicode Plane 0 and is in an excluded block + Tokenizer._append_token(tokens, token, i - 1) + token = None + elif code_point > 0xFFFF: + # Character is in a Supplementary Unicode Plane. This is where emoji live so + # we're going to just break each character in this range out as its own token + Tokenizer._append_token(tokens, token, i - 1) + token = None + tokens.append(Token(start=i, end=i, text=char, normalized=char)) + elif token is None: + # Start a new token + token = Token(start=i, end=0, text=char, normalized=None) + else: + # Add onto current token + token.text += char + + i += 1 + + Tokenizer._append_token(tokens, token, length - 1) + + return tokens + + @staticmethod + def _is_breaking_char(code_point) -> bool: + return ( + Tokenizer._is_between(code_point, 0x0000, 0x002F) + or Tokenizer._is_between(code_point, 0x003A, 0x0040) + or Tokenizer._is_between(code_point, 0x005B, 0x0060) + or Tokenizer._is_between(code_point, 0x007B, 0x00BF) + or Tokenizer._is_between(code_point, 0x02B9, 0x036F) + or Tokenizer._is_between(code_point, 0x2000, 0x2BFF) + or Tokenizer._is_between(code_point, 0x2E00, 0x2E7F) + ) + + @staticmethod + def _is_between(value: int, from_val: int, to_val: int) -> bool: + """ + Parameters + ----------- + + value: number value + + from: low range + + to: high range + """ + return from_val <= value <= to_val + + @staticmethod + def _append_token(tokens: list[Token], token: Token | None, end: int): + if token is not None: + token.end = end + token.normalized = token.text.lower() + tokens.append(token) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/component_dialog.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/component_dialog.py new file mode 100644 index 00000000..dba3b5b7 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/component_dialog.py @@ -0,0 +1,284 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Any + +from microsoft_agents.hosting.core import TurnContext + +from .dialog import Dialog +from .dialog_context import DialogContext +from .models.dialog_turn_result import DialogTurnResult +from .dialog_state import DialogState +from .models.dialog_turn_status import DialogTurnStatus +from .models.dialog_reason import DialogReason +from .dialog_set import DialogSet +from .models.dialog_instance import DialogInstance + + +class ComponentDialog(Dialog): + """ + A :class:`microsoft_agents.hosting.dialogs.Dialog` that is composed of other dialogs + + :var persisted_dialog state: + :vartype persisted_dialog_state: str + """ + + persisted_dialog_state = "dialogs" + + def __init__(self, dialog_id: str): + """ + Initializes a new instance of the :class:`ComponentDialog` + + :param dialog_id: The ID to assign to the new dialog within the parent dialog set. + :type dialog_id: str + """ + super(ComponentDialog, self).__init__(dialog_id) + + if dialog_id is None: + raise TypeError("ComponentDialog(): dialog_id cannot be None.") + + self._dialogs = DialogSet() + self.initial_dialog_id = None + + # TODO: Add TelemetryClient + + async def begin_dialog( + self, dialog_context: DialogContext, options: Any = None + ) -> DialogTurnResult: + """ + Called when the dialog is started and pushed onto the parent's dialog stack. + + If the task is successful, the result indicates whether the dialog is still + active after the turn has been processed by the dialog. + + :param dialog_context: The :class:`botbuilder.dialogs.DialogContext` for the current turn of the conversation. + :type dialog_context: :class:`botbuilder.dialogs.DialogContext` + :param options: Optional, initial information to pass to the dialog. + :type options: Any + :return: Signals the end of the turn + :rtype: :class:`microsoft_agents.hosting.dialogs.Dialog.end_of_turn` + """ + if dialog_context is None: + raise TypeError("ComponentDialog.begin_dialog(): outer_dc cannot be None.") + + # Start the inner dialog. + dialog_state = DialogState() + assert dialog_context.active_dialog is not None + dialog_context.active_dialog.state[self.persisted_dialog_state] = dialog_state + inner_dc = DialogContext(self._dialogs, dialog_context.context, dialog_state) + inner_dc.parent = dialog_context + turn_result = await self.on_begin_dialog(inner_dc, options) + + # Check for end of inner dialog + if turn_result.status != DialogTurnStatus.Waiting: + # Return result to calling dialog + return await self.end_component(dialog_context, turn_result.result) + + # Just signal waiting + return Dialog.end_of_turn + + async def continue_dialog(self, dialog_context: DialogContext) -> DialogTurnResult: + """ + Called when the dialog is continued, where it is the active dialog and the + user replies with a new activity. + + .. remarks:: + If the task is successful, the result indicates whether the dialog is still + active after the turn has been processed by the dialog. The result may also + contain a return value. + + If this method is *not* overriden the component dialog calls the + :meth:`microsoft_agents.hosting.dialogs.DialogContext.continue_dialog` method on it's inner dialog + context. If the inner dialog stack is empty, the component dialog ends, + and if a :class:`microsoft_agents.hosting.dialogs.DialogTurnResult.result` is available, the component dialog + uses that as it's return value. + + + :param dialog_context: The parent dialog context for the current turn of the conversation. + :type dialog_context: :class:`microsoft_agents.hosting.dialogs.DialogContext` + :return: Signals the end of the turn + :rtype: :class:`microsoft_agents.hosting.dialogs.Dialog.end_of_turn` + """ + if dialog_context is None: + raise TypeError("ComponentDialog.begin_dialog(): outer_dc cannot be None.") + + # Continue execution of inner dialog. + assert dialog_context.active_dialog is not None + dialog_state = dialog_context.active_dialog.state[self.persisted_dialog_state] + inner_dc = DialogContext(self._dialogs, dialog_context.context, dialog_state) + inner_dc.parent = dialog_context + turn_result = await self.on_continue_dialog(inner_dc) + + if turn_result.status != DialogTurnStatus.Waiting: + return await self.end_component(dialog_context, turn_result.result) + + return Dialog.end_of_turn + + async def resume_dialog( + self, dialog_context: DialogContext, reason: DialogReason, result: object = None + ) -> DialogTurnResult: + """ + Called when a child dialog on the parent's dialog stack completed this turn, returning + control to this dialog component. + + .. remarks:: + Containers are typically leaf nodes on the stack but the dev is free to push other dialogs + on top of the stack which will result in the container receiving an unexpected call to + :meth:`ComponentDialog.resume_dialog()` when the pushed on dialog ends. + To avoid the container prematurely ending we need to implement this method and simply + ask our inner dialog stack to re-prompt. + + :param dialog_context: The dialog context for the current turn of the conversation. + :type dialog_context: :class:`microsoft_agents.hosting.dialogs.DialogContext` + :param reason: Reason why the dialog resumed. + :type reason: :class:`microsoft_agents.hosting.dialogs.DialogReason` + :param result: Optional, value returned from the dialog that was called. + :type result: object + :return: Signals the end of the turn + :rtype: :class:`microsoft_agents.hosting.dialogs.Dialog.end_of_turn` + """ + + assert dialog_context.active_dialog is not None + await self.reprompt_dialog(dialog_context.context, dialog_context.active_dialog) + return Dialog.end_of_turn + + async def reprompt_dialog( + self, context: TurnContext, instance: DialogInstance + ) -> None: + """ + Called when the dialog should re-prompt the user for input. + + :param context: The context object for this turn. + :type context: :class:`microsoft_agents.hosting.dialogs.TurnContext` + :param instance: State information for this dialog. + :type instance: :class:`microsoft_agents.hosting.dialogs.DialogInstance` + """ + # Delegate to inner dialog. + dialog_state = instance.state[self.persisted_dialog_state] + inner_dc = DialogContext(self._dialogs, context, dialog_state) + await inner_dc.reprompt_dialog() + + # Notify component + await self.on_reprompt_dialog(context, instance) + + async def end_dialog( + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ) -> None: + """ + Called when the dialog is ending. + + :param context: The context object for this turn. + :type context: :class:`microsoft_agents.hosting.dialogs.TurnContext` + :param instance: State information associated with the instance of this component dialog. + :type instance: :class:`microsoft_agents.hosting.dialogs.DialogInstance` + :param reason: Reason why the dialog ended. + :type reason: :class:`microsoft_agents.hosting.dialogs.DialogReason` + """ + # Forward cancel to inner dialog + if reason == DialogReason.CancelCalled: + dialog_state = instance.state[self.persisted_dialog_state] + inner_dc = DialogContext(self._dialogs, context, dialog_state) + await inner_dc.cancel_all_dialogs() + await self.on_end_dialog(context, instance, reason) + + def add_dialog(self, dialog: Dialog) -> object: + """ + Adds a :class:`Dialog` to the component dialog and returns the updated component. + + :param dialog: The dialog to add. + :return: The updated :class:`ComponentDialog`. + :rtype: :class:`ComponentDialog` + """ + self._dialogs.add(dialog) + if not self.initial_dialog_id: + self.initial_dialog_id = dialog.id + return self + + async def find_dialog(self, dialog_id: str | None) -> Dialog | None: + """ + Finds a dialog by ID. + + :param dialog_id: The dialog to add. + :return: The dialog; or None if there is not a match for the ID. + :rtype: :class:`botbuilder.dialogs.Dialog` + """ + return await self._dialogs.find(dialog_id) + + async def on_begin_dialog( + self, inner_dc: DialogContext, options: object + ) -> DialogTurnResult: + """ + Called when the dialog is started and pushed onto the parent's dialog stack. + + .. remarks:: + If the task is successful, the result indicates whether the dialog is still + active after the turn has been processed by the dialog. + + By default, this calls the :meth:`microsoft_agents.hosting.dialogs.Dialog.begin_dialog()` + method of the component dialog's initial dialog. + + Override this method in a derived class to implement interrupt logic. + + :param inner_dc: The inner dialog context for the current turn of conversation. + :type inner_dc: :class:`microsoft_agents.hosting.dialogs.DialogContext` + :param options: Optional, initial information to pass to the dialog. + :type options: object + """ + assert ( + self.initial_dialog_id is not None + ), "ComponentDialog: initial_dialog_id must be set before begin_dialog is called." + return await inner_dc.begin_dialog(self.initial_dialog_id, options) + + async def on_continue_dialog(self, inner_dc: DialogContext) -> DialogTurnResult: + """ + Called when the dialog is continued, where it is the active dialog and the user replies with a new activity. + + :param inner_dc: The inner dialog context for the current turn of conversation. + :type inner_dc: :class:`botbuilder.dialogs.DialogContext` + """ + return await inner_dc.continue_dialog() + + async def on_end_dialog( # pylint: disable=unused-argument + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ) -> None: + """ + Ends the component dialog in its parent's context. + + :param turn_context: The :class:`botbuilder.core.TurnContext` for the current turn of the conversation. + :type turn_context: :class:`botbuilder.core.TurnContext` + :param instance: State information associated with the inner dialog stack of this component dialog. + :type instance: :class:`botbuilder.dialogs.DialogInstance` + :param reason: Reason why the dialog ended. + :type reason: :class:`botbuilder.dialogs.DialogReason` + """ + return + + async def on_reprompt_dialog( # pylint: disable=unused-argument + self, turn_context: TurnContext, instance: DialogInstance + ) -> None: + """ + :param turn_context: The :class:`botbuilder.core.TurnContext` for the current turn of the conversation. + :type turn_context: :class:`botbuilder.dialogs.DialogInstance` + :param instance: State information associated with the inner dialog stack of this component dialog. + :type instance: :class:`botbuilder.dialogs.DialogInstance` + """ + return + + async def end_component( + self, outer_dc: DialogContext, result: object # pylint: disable=unused-argument + ) -> DialogTurnResult: + """ + Ends the component dialog in its parent's context. + + .. remarks:: + If the task is successful, the result indicates that the dialog ended after the + turn was processed by the dialog. + + :param outer_dc: The parent dialog context for the current turn of conversation. + :type outer_dc: class:`botbuilder.dialogs.DialogContext` + :param result: Optional, value to return from the dialog component to the parent context. + :type result: object + :return: Value to return. + :rtype: :class:`botbuilder.dialogs.DialogTurnResult.result` + """ + return await outer_dc.end_dialog(result) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog.py new file mode 100644 index 00000000..94b9aad4 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog.py @@ -0,0 +1,198 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import TYPE_CHECKING + +from microsoft_agents.hosting.core import TurnContext + +from ._telemetry_client import AgentTelemetryClient, NullTelemetryClient +from .models.dialog_reason import DialogReason +from .models.dialog_event import DialogEvent +from .models.dialog_turn_status import DialogTurnStatus +from .models.dialog_turn_result import DialogTurnResult +from .models.dialog_instance import DialogInstance + +if TYPE_CHECKING: + from .dialog_context import DialogContext + + +class Dialog(ABC): + + def __init__(self, dialog_id: str): + if dialog_id is None or not dialog_id.strip(): + raise TypeError("Dialog(): dialogId cannot be None.") + + self._telemetry_client = NullTelemetryClient() + self._id = dialog_id + + end_of_turn = DialogTurnResult(DialogTurnStatus.Waiting) + """DialogTurnResult indicating the dialog is waiting for new activity.""" + + @property + def id(self) -> str: # pylint: disable=invalid-name + return self._id + + @property + def telemetry_client(self) -> AgentTelemetryClient: + """ + Gets the telemetry client for logging events. + """ + return self._telemetry_client + + @telemetry_client.setter + def telemetry_client(self, value: AgentTelemetryClient) -> None: + """ + Sets the telemetry client for logging events. + """ + if value is None: + self._telemetry_client = NullTelemetryClient() + else: + self._telemetry_client = value + + @abstractmethod + async def begin_dialog( + self, dialog_context: "DialogContext", options: object = None + ): + """ + Method called when a new dialog has been pushed onto the stack and is being activated. + :param dialog_context: The dialog context for the current turn of conversation. + :param options: (Optional) additional argument(s) to pass to the dialog being started. + """ + raise NotImplementedError() + + async def continue_dialog(self, dialog_context: "DialogContext"): + """ + Method called when an instance of the dialog is the "current" dialog and the + user replies with a new activity. The dialog will generally continue to receive the user's + replies until it calls either `end_dialog()` or `begin_dialog()`. + If this method is NOT implemented then the dialog will automatically be ended when the user replies. + :param dialog_context: The dialog context for the current turn of conversation. + :return: + """ + # By default just end the current dialog. + return await dialog_context.end_dialog(None) + + async def resume_dialog( # pylint: disable=unused-argument + self, dialog_context: "DialogContext", reason: DialogReason, result: object + ): + """ + Method called when an instance of the dialog is being returned to from another + dialog that was started by the current instance using `begin_dialog()`. + If this method is NOT implemented then the dialog will be automatically ended with a call + to `end_dialog()`. Any result passed from the called dialog will be passed + to the current dialog's parent. If there are no more parent dialogs on the stack then + processing of the turn will end. + :param dialog_context: The dialog context for the current turn of conversation. + :param reason: Reason why the dialog resumed. + :param result: (Optional) value returned from the dialog that was called. + :return: + """ + # By default just end the current dialog and return result to parent. + return await dialog_context.end_dialog(result) + + async def reprompt_dialog( # pylint: disable=unused-argument + self, context: TurnContext, instance: DialogInstance + ): + """Called when the dialog should re-prompt the user for input. + + Override this method to send a repeat of the most recent prompt activity. + The default implementation is a no-op. + + :param context: The context for the current turn. + :param instance: The dialog instance on the stack. + """ + # No-op by default + return + + async def end_dialog( # pylint: disable=unused-argument + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ): + """Called when the dialog is ending. Override to perform cleanup or send an + EndOfConversation activity. + + The default implementation is a no-op; subclasses should call ``super()`` + only if they need the no-op behaviour to remain in derived chains. + + :param context: The context for the current turn. + :param instance: The dialog instance being ended. + :param reason: Why the dialog is ending (EndCalled, CancelCalled, or ReplaceCalled). + """ + # No-op by default + return + + def get_version(self) -> str: + """Gets a string that uniquely describes this dialog's version. Changing the version + indicates that a stored instance of the dialog may be incompatible with the current + definition. By default this returns the dialog's ID. + + :return: Version string for this dialog. + """ + return self.id + + async def on_dialog_event( + self, dialog_context: "DialogContext", dialog_event: DialogEvent + ) -> bool: + """ + Called when an event has been raised, using `DialogContext.emitEvent()`, by either the current dialog or a + dialog that the current dialog started. + :param dialog_context: The dialog context for the current turn of conversation. + :param dialog_event: The event being raised. + :return: True if the event is handled by the current dialog and bubbling should stop. + """ + # Before bubble + handled = await self._on_pre_bubble_event(dialog_context, dialog_event) + + # Bubble as needed + if (not handled) and dialog_event.bubble and dialog_context.parent: + handled = await dialog_context.parent.emit_event( + dialog_event.name, dialog_event.value, True, False + ) + + # Post bubble + if not handled: + handled = await self._on_post_bubble_event(dialog_context, dialog_event) + + return handled + + async def _on_pre_bubble_event( # pylint: disable=unused-argument + self, dialog_context: "DialogContext", dialog_event: DialogEvent + ) -> bool: + """ + Called before an event is bubbled to its parent. + :param dialog_context: The dialog context for the current turn of conversation. + :param dialog_event: The event being raised. + :return: Whether the event is handled by the current dialog and further processing should stop. + """ + return False + + async def _on_post_bubble_event( # pylint: disable=unused-argument + self, dialog_context: "DialogContext", dialog_event: DialogEvent + ) -> bool: + """ + Called after an event was bubbled to all parents and wasn't handled. + :param dialog_context: The dialog context for the current turn of conversation. + :param dialog_event: The event being raised. + :return: Whether the event is handled by the current dialog and further processing should stop. + """ + return False + + def _on_compute_id(self) -> str: + """ + Computes an unique ID for a dialog. + :return: An unique ID for a dialog + """ + return self.__class__.__name__ + + def _register_source_location( + self, path: str, line_number: int + ): # pylint: disable=unused-argument + """ + Registers a SourceRange in the provided location. + :param path: The path to the source file. + :param line_number: The line number where the source will be located on the file. + """ + if path: + pass diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_component_registration.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_component_registration.py new file mode 100644 index 00000000..bfb29df3 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_component_registration.py @@ -0,0 +1,52 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Iterable + +from microsoft_agents.hosting.dialogs.memory import ( + ComponentMemoryScopesBase, + ComponentPathResolversBase, + PathResolverBase, +) +from microsoft_agents.hosting.dialogs.memory.scopes import ( + TurnMemoryScope, + SettingsMemoryScope, + DialogMemoryScope, + DialogContextMemoryScope, + DialogClassMemoryScope, + ClassMemoryScope, + MemoryScope, + ThisMemoryScope, + ConversationMemoryScope, + UserMemoryScope, +) + +from microsoft_agents.hosting.dialogs.memory.path_resolvers import ( + AtAtPathResolver, + AtPathResolver, + DollarPathResolver, + HashPathResolver, + PercentPathResolver, +) + + +class DialogsComponentRegistration( + ComponentMemoryScopesBase, ComponentPathResolversBase +): + def get_memory_scopes(self) -> Iterable[MemoryScope]: + yield TurnMemoryScope() + yield SettingsMemoryScope() + yield DialogMemoryScope() + yield DialogContextMemoryScope() + yield DialogClassMemoryScope() + yield ClassMemoryScope() + yield ThisMemoryScope() + yield ConversationMemoryScope() + yield UserMemoryScope() + + def get_path_resolvers(self) -> Iterable[PathResolverBase]: + yield AtAtPathResolver() + yield AtPathResolver() + yield DollarPathResolver() + yield HashPathResolver() + yield PercentPathResolver() diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_container.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_container.py new file mode 100644 index 00000000..5855821c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_container.py @@ -0,0 +1,31 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import TYPE_CHECKING + +from .dialog import Dialog +from .dialog_set import DialogSet + +if TYPE_CHECKING: + from .dialog_context import DialogContext + + +class DialogContainer(Dialog, ABC): + + def __init__(self, dialog_id: str): + super().__init__(dialog_id) + self.dialogs = DialogSet() + + @abstractmethod + def create_child_context(self, dialog_context: DialogContext) -> DialogContext: + """ + Creates the inner dialog context for the active child dialog, if there is one. + :param dialog_context: The parent dialog context. + :return: The child dialog context, or None if there is no active child. + """ + raise NotImplementedError( + "DialogContainer.create_child_context(): not implemented." + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_context.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_context.py new file mode 100644 index 00000000..bfd715ae --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_context.py @@ -0,0 +1,426 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from microsoft_agents.hosting.core.turn_context import TurnContext +from microsoft_agents.hosting.dialogs.memory import DialogStateManager + +from .models.dialog_event import DialogEvent +from .models.dialog_events import DialogEvents +from .dialog_set import DialogSet +from .dialog_state import DialogState +from .models.dialog_turn_status import DialogTurnStatus +from .models.dialog_turn_result import DialogTurnResult +from .models.dialog_reason import DialogReason +from .models.dialog_instance import DialogInstance +from .dialog import Dialog + + +class DialogContext: + + def __init__( + self, dialog_set: DialogSet, turn_context: TurnContext, state: DialogState + ): + if dialog_set is None: + raise TypeError("DialogContext(): dialog_set cannot be None.") + # TODO: Circular dependency with dialog_set: Check type. + if turn_context is None: + raise TypeError("DialogContext(): turn_context cannot be None.") + self._turn_context = turn_context + self._dialogs = dialog_set + self._stack = state.dialog_stack + self.services = {} + self.parent: DialogContext | None = None + self.state = DialogStateManager(self) + + @property + def dialogs(self) -> DialogSet: + """Gets the set of dialogs that can be called from this context. + + :param: + :return DialogSet: + """ + return self._dialogs + + @property + def context(self) -> TurnContext: + """Gets the context for the current turn of conversation. + + :param: + :return TurnContext: + """ + return self._turn_context + + @property + def stack(self) -> list[DialogInstance]: + """Gets the current dialog stack. + + :param: + :return list: + """ + return self._stack + + @property + def active_dialog(self) -> DialogInstance | None: + """Gets the instance of the active (top-of-stack) dialog, or None if the stack is empty. + + :return: The active DialogInstance, or None if no dialog is active. + """ + if self._stack: + return self._stack[0] + return None + + @property + def child(self) -> DialogContext | None: + """Gets the DialogContext for the active dialog's inner dialog stack, if the active + dialog is a DialogContainer (e.g. ComponentDialog). Returns None if there is no + active dialog or the active dialog is not a container. + + :return: The child DialogContext, or None. + """ + # pylint: disable=import-outside-toplevel + instance = self.active_dialog + + if instance: + dialog = self.find_dialog_sync(instance.id) + + # This import prevents circular dependency issues + from .dialog_container import DialogContainer + + if isinstance(dialog, DialogContainer): + return dialog.create_child_context(self) + + return None + + async def begin_dialog(self, dialog_id: str, options: object = None): + """ + Pushes a new dialog onto the dialog stack. + :param dialog_id: ID of the dialog to start + :param options: (Optional) additional argument(s) to pass to the dialog being started. + """ + try: + if not dialog_id: + raise TypeError("Dialog(): dialog_id cannot be None.") + # Look up dialog + dialog = await self.find_dialog(dialog_id) + if dialog is None: + raise Exception( + "'DialogContext.begin_dialog(): A dialog with an id of '%s' wasn't found." + " The dialog must be included in the current or parent DialogSet." + " For example, if subclassing a ComponentDialog you can call add_dialog() within your constructor." + % dialog_id + ) + # Push new instance onto stack + instance = DialogInstance() + instance.id = dialog_id + instance.state = {} + + self._stack.insert(0, (instance)) + + # Call dialog's begin_dialog() method + return await dialog.begin_dialog(self, options) + except Exception as err: + self.__set_exception_context_data(err) + raise + + # TODO: Fix options: PromptOptions instead of object + async def prompt(self, dialog_id: str, options) -> DialogTurnResult: + """ + Helper function to simplify formatting the options for calling a prompt dialog. This helper will + take a `PromptOptions` argument and then call. + :param dialog_id: ID of the prompt to start. + :param options: Contains a Prompt, potentially a RetryPrompt and if using ChoicePrompt, Choices. + :return: + """ + try: + if not dialog_id: + raise TypeError("DialogContext.prompt(): dialogId cannot be None.") + + if not options: + raise TypeError("DialogContext.prompt(): options cannot be None.") + + return await self.begin_dialog(dialog_id, options) + except Exception as err: + self.__set_exception_context_data(err) + raise + + async def continue_dialog(self): + """ + Continues execution of the active dialog, if there is one, by passing the context object to + its `Dialog.continue_dialog()` method. You can check `turn_context.responded` after the call completes + to determine if a dialog was run and a reply was sent to the user. + :return: + """ + try: + # Check for a dialog on the stack + if self.active_dialog is not None: + # Look up dialog + dialog = await self.find_dialog(self.active_dialog.id) + if not dialog: + raise Exception( + "DialogContext.continue_dialog(): Can't continue dialog. " + "A dialog with an id of '%s' wasn't found." + % self.active_dialog.id + ) + + # Continue execution of dialog + return await dialog.continue_dialog(self) + + return DialogTurnResult(DialogTurnStatus.Empty) + except Exception as err: + self.__set_exception_context_data(err) + raise + + # TODO: instance is DialogInstance + async def end_dialog(self, result: object = None): + """ + Ends a dialog by popping it off the stack and returns an optional result to the dialog's + parent. The parent dialog is the dialog that started the dialog being ended via a call to + either "begin_dialog" or "prompt". + The parent dialog will have its `Dialog.resume_dialog()` method invoked with any returned + result. If the parent dialog hasn't implemented a `resume_dialog()` method then it will be + automatically ended as well and the result passed to its parent. If there are no more + parent dialogs on the stack then processing of the turn will end. + :param result: (Optional) result to pass to the parent dialogs. + :return: + """ + try: + await self.end_active_dialog(DialogReason.EndCalled) + + # Resume previous dialog + if self.active_dialog is not None: + # Look up dialog + dialog = await self.find_dialog(self.active_dialog.id) + if not dialog: + raise Exception( + "DialogContext.EndDialogAsync(): Can't resume previous dialog." + " A dialog with an id of '%s' wasn't found." + % self.active_dialog.id + ) + + # Return result to previous dialog + return await dialog.resume_dialog(self, DialogReason.EndCalled, result) + + return DialogTurnResult(DialogTurnStatus.Complete, result) + except Exception as err: + self.__set_exception_context_data(err) + raise + + async def cancel_all_dialogs( + self, + cancel_parents: bool | None = None, + event_name: str | None = None, + event_value: object = None, + ): + """ + Deletes any existing dialog stack thus cancelling all dialogs on the stack. + :param cancel_parents: + :param event_name: + :param event_value: + :return: + """ + try: + event_name = event_name or DialogEvents.cancel_dialog + if self.stack or self.parent: + # Cancel all local and parent dialogs while checking for interception + notify = False + dialog_context = self + + while dialog_context: + if dialog_context.stack: + # Check to see if the dialog wants to handle the event + if notify: + event_handled = await dialog_context.emit_event( + event_name, + event_value, + bubble=False, + from_leaf=False, + ) + + if event_handled: + break + + # End the active dialog + await dialog_context.end_active_dialog( + DialogReason.CancelCalled + ) + else: + dialog_context = ( + dialog_context.parent if cancel_parents else None + ) + + notify = True + + return DialogTurnResult(DialogTurnStatus.Cancelled) + + # Stack was empty and no parent + return DialogTurnResult(DialogTurnStatus.Empty) + except Exception as err: + self.__set_exception_context_data(err) + raise + + async def find_dialog(self, dialog_id: str | None) -> Dialog | None: + """ + If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext` + will be searched if there is one. + :param dialog_id: ID of the dialog to search for. + :return: + """ + try: + dialog = await self.dialogs.find(dialog_id) + + if dialog is None and self.parent is not None: + dialog = await self.parent.find_dialog(dialog_id) + return dialog + except Exception as err: + self.__set_exception_context_data(err) + raise + + def find_dialog_sync(self, dialog_id: str | None) -> Dialog | None: + """ + If the dialog cannot be found within the current `DialogSet`, the parent `DialogContext` + will be searched if there is one. + :param dialog_id: ID of the dialog to search for. + :return: + """ + dialog = self.dialogs.find_dialog(dialog_id) + + if dialog is None and self.parent is not None: + dialog = self.parent.find_dialog_sync(dialog_id) + return dialog + + async def replace_dialog( + self, dialog_id: str, options: object = None + ) -> DialogTurnResult: + """ + Ends the active dialog and starts a new dialog in its place. This is particularly useful + for creating loops or redirecting to another dialog. + :param dialog_id: ID of the dialog to search for. + :param options: (Optional) additional argument(s) to pass to the new dialog. + :return: + """ + try: + # End the current dialog and giving the reason. + await self.end_active_dialog(DialogReason.ReplaceCalled) + + # Start replacement dialog + return await self.begin_dialog(dialog_id, options) + except Exception as err: + self.__set_exception_context_data(err) + raise + + async def reprompt_dialog(self): + """ + Calls reprompt on the currently active dialog, if there is one. Used with Prompts that have a reprompt behavior. + :return: + """ + try: + # Check for a dialog on the stack + if self.active_dialog is not None: + # Look up dialog + dialog = await self.find_dialog(self.active_dialog.id) + if not dialog: + raise Exception( + "DialogSet.reprompt_dialog(): Can't find A dialog with an id of '%s'." + % self.active_dialog.id + ) + + # Ask dialog to re-prompt if supported + await dialog.reprompt_dialog(self.context, self.active_dialog) + except Exception as err: + self.__set_exception_context_data(err) + raise + + async def end_active_dialog(self, reason: DialogReason): + """Pops the active dialog off the stack and notifies it of the reason it ended. + + :param reason: The reason the dialog is ending (e.g. EndCalled, CancelCalled). + """ + instance = self.active_dialog + if instance is not None: + # Look up dialog + dialog = await self.find_dialog(instance.id) + if dialog is not None: + # Notify dialog of end + await dialog.end_dialog(self.context, instance, reason) + + # Pop dialog off stack + self._stack.pop(0) + + async def emit_event( + self, + name: str, + value: object = None, + bubble: bool = True, + from_leaf: bool = False, + ) -> bool: + """ + Searches for a dialog with a given ID. + Emits a named event for the current dialog, or someone who started it, to handle. + :param name: Name of the event to raise. + :param value: Value to send along with the event. + :param bubble: Flag to control whether the event should be bubbled to its parent if not handled locally. + Defaults to a value of `True`. + :param from_leaf: Whether the event is emitted from a leaf node. + :param cancellationToken: The cancellation token. + :return: True if the event was handled. + """ + try: + # Initialize event + dialog_event = DialogEvent( + bubble=bubble, + name=name, + value=value, + ) + + dialog_context = self + + # Find starting dialog + if from_leaf: + while True: + child_dc = dialog_context.child + + if child_dc: + dialog_context = child_dc + else: + break + + # Dispatch to active dialog first + instance = dialog_context.active_dialog + + if instance: + dialog = await dialog_context.find_dialog(instance.id) + + if dialog: + return await dialog.on_dialog_event(dialog_context, dialog_event) + + return False + except Exception as err: + self.__set_exception_context_data(err) + raise + + def __set_exception_context_data(self, exception: Exception): + if not hasattr(exception, "data"): + setattr(exception, "data", {}) + + data = getattr(exception, "data") + if not type(self).__name__ in data: + stack = [] + current_dc = self + + while current_dc is not None: + stack = stack + [x.id for x in current_dc.stack] + current_dc = current_dc.parent + + parent_active_id = None + if self.parent is not None and self.parent.active_dialog is not None: + parent_active_id = self.parent.active_dialog.id + + data[type(self).__name__] = { + "active_dialog": ( + None if self.active_dialog is None else self.active_dialog.id + ), + "parent": parent_active_id, + "stack": self.stack, + } diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_extensions.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_extensions.py new file mode 100644 index 00000000..3b83fe5c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_extensions.py @@ -0,0 +1,201 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ClaimsIdentity, + ChannelAdapter, + StatePropertyAccessor, + TurnContext, +) +from microsoft_agents.activity import Activity, ActivityTypes, EndOfConversationCodes + +from microsoft_agents.hosting.dialogs.memory import DialogStateManager +from .dialog import Dialog +from .dialog_context import DialogContext +from .models import DialogTurnResult +from .models.dialog_events import DialogEvents +from .dialog_set import DialogSet +from .models.dialog_turn_status import DialogTurnStatus + + +class DialogExtensions: + @staticmethod + async def run_dialog( + dialog: Dialog, + turn_context: TurnContext, + accessor: StatePropertyAccessor, + ): + """ + Creates a dialog stack and starts a dialog, pushing it onto the stack. + """ + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context: DialogContext = await dialog_set.create_context(turn_context) + + await DialogExtensions._internal_run(turn_context, dialog.id, dialog_context) + + @staticmethod + async def _internal_run( + context: TurnContext, dialog_id: str, dialog_context: DialogContext + ) -> DialogTurnResult: + # map TurnState into root dialog context.services + for key, service in context.turn_state.items(): + dialog_context.services[key] = service + + # get the DialogStateManager configuration + dialog_state_manager = DialogStateManager(dialog_context) + await dialog_state_manager.load_all_scopes() + dialog_context.context.turn_state[dialog_state_manager.__class__.__name__] = ( + dialog_state_manager + ) + + # Loop as long as we are getting valid OnError handled we should continue executing the actions for the turn. + end_of_turn = False + dialog_turn_result: DialogTurnResult = DialogTurnResult(DialogTurnStatus.Empty) + while not end_of_turn: + try: + dialog_turn_result = await DialogExtensions.__inner_run( + context, dialog_id, dialog_context + ) + + # turn successfully completed, break the loop + end_of_turn = True + except Exception as err: + # fire error event, bubbling from the leaf. + handled = await dialog_context.emit_event( + DialogEvents.error, err, bubble=True, from_leaf=True + ) + + if not handled: + # error was NOT handled, throw the exception and end the turn. (This will trigger the + # Adapter.OnError handler and end the entire dialog stack) + raise + + # save all state scopes to their respective AgentState locations. + await dialog_state_manager.save_all_changes() + + # return the result + return dialog_turn_result + + @staticmethod + async def __inner_run( + turn_context: TurnContext, dialog_id: str, dialog_context: DialogContext + ) -> DialogTurnResult: + # Handle EoC and Reprompt event from a parent bot (can be root bot to skill or skill to skill) + if DialogExtensions.__is_from_parent_to_skill(turn_context): + # Handle remote cancellation request from parent. + if turn_context.activity.type == ActivityTypes.end_of_conversation: + if not dialog_context.stack: + # No dialogs to cancel, just return. + return DialogTurnResult(DialogTurnStatus.Empty) + + # Send cancellation message to the dialog to ensure all the parents are canceled + # in the right order. + return await dialog_context.cancel_all_dialogs(True) + + # Handle a reprompt event sent from the parent. + if ( + turn_context.activity.type == ActivityTypes.event + and turn_context.activity.name == DialogEvents.reprompt_dialog + ): + if not dialog_context.stack: + # No dialogs to reprompt, just return. + return DialogTurnResult(DialogTurnStatus.Empty) + + await dialog_context.reprompt_dialog() + return DialogTurnResult(DialogTurnStatus.Waiting) + + # Continue or start the dialog. + result = await dialog_context.continue_dialog() + if result.status == DialogTurnStatus.Empty: + result = await dialog_context.begin_dialog(dialog_id) + + await DialogExtensions._send_state_snapshot_trace(dialog_context) + + # Skills should send EoC when the dialog completes. + if ( + result.status == DialogTurnStatus.Complete + or result.status == DialogTurnStatus.Cancelled + ): + if DialogExtensions.__send_eoc_to_parent(turn_context): + activity = Activity( # type: ignore[call-arg] + type=ActivityTypes.end_of_conversation, + value=result.result, + locale=turn_context.activity.locale, + code=( + EndOfConversationCodes.completed_successfully + if result.status == DialogTurnStatus.Complete + else EndOfConversationCodes.user_cancelled + ), + ) + await turn_context.send_activity(activity) + + return result + + @staticmethod + def __is_from_parent_to_skill(turn_context: TurnContext) -> bool: + """ + Determines if this turn is an incoming request from a parent bot to this skill. + """ + claims_identity = turn_context.turn_state.get( + ChannelAdapter.AGENT_IDENTITY_KEY, None + ) + return ( + isinstance(claims_identity, ClaimsIdentity) + and claims_identity.is_agent_claim() + ) + + @staticmethod + async def _send_state_snapshot_trace(dialog_context: DialogContext): + """ + Helper to send a trace activity with a memory snapshot of the active dialog DC. + """ + claims_identity = dialog_context.context.turn_state.get( + ChannelAdapter.AGENT_IDENTITY_KEY, None + ) + trace_label = ( + "Skill State" + if isinstance(claims_identity, ClaimsIdentity) + and claims_identity.is_agent_claim() + else "Bot State" + ) + # send trace of memory + snapshot = DialogExtensions._get_active_dialog_context( + dialog_context + ).state.get_memory_snapshot() + trace_activity = Activity( # type: ignore[call-arg] + type=ActivityTypes.trace, + name="BotState", + value_type="https://www.botframework.com/schemas/botState", + value=snapshot, + label=trace_label, + ) + await dialog_context.context.send_activity(trace_activity) + + @staticmethod + def __send_eoc_to_parent(turn_context: TurnContext) -> bool: + """ + Determines whether to send an EndOfConversation to the parent bot. + """ + claims_identity = turn_context.turn_state.get( + ChannelAdapter.AGENT_IDENTITY_KEY, None + ) + if ( + isinstance(claims_identity, ClaimsIdentity) + and claims_identity.is_agent_claim() + ): + return True + + return False + + @staticmethod + def _get_active_dialog_context(dialog_context: DialogContext) -> DialogContext: + """ + Recursively walk up the DC stack to find the active DC. + """ + child = dialog_context.child + if not child: + return dialog_context + + return DialogExtensions._get_active_dialog_context(child) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager.py new file mode 100644 index 00000000..c82c7310 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager.py @@ -0,0 +1,189 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from datetime import datetime, timedelta +from threading import Lock +from typing import cast + +from microsoft_agents.hosting.core import ( + ChannelAdapter, + ConversationState, + UserState, + TurnContext, + ClaimsIdentity, +) + +from .dialog import Dialog +from .dialog_context import DialogContext +from .dialog_extensions import DialogExtensions +from .dialog_set import DialogSet +from .dialog_state import DialogState +from .dialog_manager_result import DialogManagerResult +from .models.dialog_turn_status import DialogTurnStatus +from .models.dialog_turn_result import DialogTurnResult + + +class DialogManager: + """ + Class which runs the dialog system. + """ + + def __init__( + self, + root_dialog: Dialog | None = None, + dialog_state_property: str = "DialogState", + ): + """ + Initializes an instance of the DialogManager class. + :param root_dialog: Root dialog to use. + :param dialog_state_property: Alternate name for the dialog_state property. (Default is "DialogState"). + """ + self.last_access = "_lastAccess" + self._root_dialog_id = "" + self._dialog_state_property = dialog_state_property + self._lock = Lock() + + # Gets or sets root dialog to use to start conversation. + self.root_dialog = root_dialog + + # Gets or sets the ConversationState. + self.conversation_state: ConversationState | None = None + + # Gets or sets the UserState. + self.user_state: UserState | None = None + + # Gets InitialTurnState collection to copy into the TurnState on every turn. + self.initial_turn_state = {} + + # Gets or sets global dialogs that you want to have be callable. + self.dialogs = DialogSet() + + # Gets or sets (optional) number of milliseconds to expire the bot's state after. + self.expire_after: int | None = None + + async def on_turn(self, context: TurnContext) -> DialogManagerResult: + """ + Runs dialog system in the context of a TurnContext. + :param context: turn context. + :return: + """ + # Lazy initialize RootDialog so it can refer to assets like LG function templates + if not self._root_dialog_id: + with self._lock: + if not self._root_dialog_id: + if self.root_dialog is None: + raise ValueError("DialogManager: root_dialog cannot be None.") + self._root_dialog_id = self.root_dialog.id + self.dialogs.add(self.root_dialog) + + # Preload TurnState with DM TurnState. + for key, val in self.initial_turn_state.items(): + context.turn_state[key] = val + + # Register DialogManager with TurnState. + context.turn_state[DialogManager.__name__] = self + + # Resolve ConversationState + conversation_state_name = ConversationState.__name__ + if self.conversation_state is None: + if conversation_state_name not in context.turn_state: + raise Exception( + f"Unable to get an instance of {conversation_state_name} from turn_context. " + f"Please ensure ConversationState is available in turn_state." + ) + self.conversation_state = cast( + ConversationState, context.turn_state[conversation_state_name] + ) + else: + context.turn_state[conversation_state_name] = self.conversation_state + + # Resolve UserState (optional) + user_state_name = UserState.__name__ + if self.user_state is None: + self.user_state = cast( + UserState | None, context.turn_state.get(user_state_name, None) + ) + else: + context.turn_state[user_state_name] = self.user_state + + # Create property accessors + last_access_property = self.conversation_state.create_property(self.last_access) + last_access: datetime = cast( + datetime, await last_access_property.get(context, datetime.now) + ) + + # Check for expired conversation + if self.expire_after is not None and ( + datetime.now() - last_access + ) >= timedelta(milliseconds=float(self.expire_after)): + # Clear conversation state + self.conversation_state.clear(context) + + last_access = datetime.now() + await last_access_property.set(context, last_access) + + # Get dialog stack + dialogs_property = self.conversation_state.create_property( + self._dialog_state_property + ) + dialog_state: DialogState = cast( + DialogState, await dialogs_property.get(context, DialogState) + ) + + # Create DialogContext + dialog_context = DialogContext(self.dialogs, context, dialog_state) + + # Call the common dialog "continue/begin" execution pattern shared with the classic RunAsync extension method + turn_result = ( + await DialogExtensions._internal_run( # pylint: disable=protected-access + context, self._root_dialog_id, dialog_context + ) + ) + + # Save ConversationState changes + await self.conversation_state.save(context, False) + + # Save UserState changes if present + if self.user_state is not None: + await self.user_state.save(context, False) + + return DialogManagerResult(turn_result=turn_result) + + @staticmethod + def is_from_parent_to_skill(turn_context: TurnContext) -> bool: + """ + Determines if this turn is a request from a parent bot to this skill. + """ + + claims_identity = turn_context.turn_state.get( + ChannelAdapter.AGENT_IDENTITY_KEY, None + ) + return ( + isinstance(claims_identity, ClaimsIdentity) + and claims_identity.is_agent_claim() + ) + + @staticmethod + def should_send_end_of_conversation_to_parent( + context: TurnContext, turn_result: DialogTurnResult + ) -> bool: + """ + Helper to determine if we should send an EndOfConversation to the parent or not. + """ + if not ( + turn_result.status == DialogTurnStatus.Complete + or turn_result.status == DialogTurnStatus.Cancelled + ): + # The dialog is still going, don't return EoC. + return False + + return DialogManager.is_from_parent_to_skill(context) + + @staticmethod + def get_active_dialog_context(dialog_context: DialogContext) -> DialogContext: + """ + Recursively walk up the DC stack to find the active DC. + """ + return DialogExtensions._get_active_dialog_context( # pylint: disable=protected-access + dialog_context + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager_result.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager_result.py new file mode 100644 index 00000000..a651703f --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_manager_result.py @@ -0,0 +1,17 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass, field + +from microsoft_agents.activity import Activity + +from .models.dialog_turn_result import DialogTurnResult +from .persisted_state import PersistedState + + +@dataclass +class DialogManagerResult: + + turn_result: DialogTurnResult | None = None + activities: list[Activity] = field(default_factory=list) + persisted_state: PersistedState | None = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_set.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_set.py new file mode 100644 index 00000000..0fe84723 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_set.py @@ -0,0 +1,174 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +import inspect +from hashlib import sha256 +from typing import TYPE_CHECKING + +from microsoft_agents.hosting.core import TurnContext, StatePropertyAccessor + +from ._telemetry_client import AgentTelemetryClient, NullTelemetryClient +from .dialog import Dialog +from .dialog_state import DialogState + +if TYPE_CHECKING: + from .dialog_context import DialogContext + + +class DialogSet: + def __init__(self, dialog_state: StatePropertyAccessor | None = None): + # pylint: disable=import-outside-toplevel + if dialog_state is None: + current_frame = inspect.currentframe() + frame = current_frame.f_back if current_frame is not None else None + try: + # try to access the caller's "self" + try: + self_obj = frame.f_locals["self"] if frame is not None else None + if self_obj is None: + raise KeyError + except KeyError: + raise TypeError("DialogSet(): dialog_state cannot be None.") + # Only ComponentDialog / DialogContainer / DialogManager can initialize with None dialog_state + from .component_dialog import ComponentDialog + from .dialog_manager import DialogManager + from .dialog_container import DialogContainer + + if not isinstance( + self_obj, (ComponentDialog, DialogContainer, DialogManager) + ): + raise TypeError("DialogSet(): dialog_state cannot be None.") + finally: + # make sure to clean up the frame at the end to avoid ref cycles + del frame + + self._dialog_state = dialog_state + self.__telemetry_client = NullTelemetryClient() + + self._dialogs: dict[str, Dialog] = {} + self._version: str | None = None + + @property + def telemetry_client(self) -> AgentTelemetryClient: + """ + Gets the telemetry client for logging events. + """ + return self.__telemetry_client + + @telemetry_client.setter + def telemetry_client(self, value: AgentTelemetryClient) -> None: + """ + Sets the telemetry client for all dialogs in this set. + """ + if value is None: + self.__telemetry_client = NullTelemetryClient() + else: + self.__telemetry_client = value + + for dialog in self._dialogs.values(): + dialog.telemetry_client = self.__telemetry_client + self._version = None + + def get_version(self) -> str: + """ + Gets a unique string which represents the combined versions of all dialogs in this dialogset. + Version will change when any of the child dialogs version changes. + """ + if not self._version: + version = "" + for _, dialog in self._dialogs.items(): + aux_version = dialog.get_version() + if aux_version: + version += aux_version + + self._version = sha256(version.encode()).hexdigest() + + return self._version + + def add(self, dialog: Dialog): + """ + Adds a new dialog to the set and returns the added dialog. + :param dialog: The dialog to add. + """ + if dialog is None or not isinstance(dialog, Dialog): + raise TypeError( + "DialogSet.add(): dialog cannot be None and must be a Dialog or derived class." + ) + + if dialog.id in self._dialogs: + raise TypeError( + "DialogSet.add(): A dialog with an id of '%s' already added." + % dialog.id + ) + + self._dialogs[dialog.id] = dialog + self._version = None + + return self + + async def create_context(self, turn_context: TurnContext) -> "DialogContext": + """Creates a DialogContext for this set using the given TurnContext. + + Loads persisted dialog state via the StatePropertyAccessor provided at construction + and wraps it in a new DialogContext. Raises RuntimeError if the set was created + without a StatePropertyAccessor (e.g. from within a ComponentDialog). + + :param turn_context: The current turn context. + :return: A DialogContext backed by the loaded dialog state. + """ + # This import prevents circular dependency issues + # pylint: disable=import-outside-toplevel + from .dialog_context import DialogContext + + if turn_context is None: + raise TypeError("DialogSet.create_context(): turn_context cannot be None.") + + if not self._dialog_state: + raise RuntimeError( + "DialogSet.create_context(): DialogSet created with a null IStatePropertyAccessor." + ) + + from typing import cast as _cast # pylint: disable=import-outside-toplevel + + state: DialogState = _cast( + DialogState, + await self._dialog_state.get(turn_context, lambda: DialogState()), + ) + + return DialogContext(self, turn_context, state) + + async def find(self, dialog_id: str | None) -> Dialog | None: + """ + Finds a dialog that was previously added to the set using add(dialog) + :param dialog_id: ID of the dialog/prompt to look up. + :return: The dialog if found, otherwise null. + """ + if not dialog_id: + raise TypeError("DialogSet.find(): dialog_id cannot be None.") + + if dialog_id in self._dialogs: + return self._dialogs[dialog_id] + + return None + + def find_dialog(self, dialog_id: str | None) -> Dialog | None: + """ + Finds a dialog that was previously added to the set using add(dialog). + Synchronous version of find(). + :param dialog_id: ID of the dialog/prompt to look up. + :return: The dialog if found, otherwise null. + """ + if not dialog_id: + raise TypeError("DialogSet.find_dialog(): dialog_id cannot be None.") + + if dialog_id in self._dialogs: + return self._dialogs[dialog_id] + + return None + + def __str__(self): + if not self._dialogs: + return "dialog set empty!" + return " ".join(map(str, self._dialogs.keys())) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_state.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_state.py new file mode 100644 index 00000000..58dbdd25 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/dialog_state.py @@ -0,0 +1,20 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass, field + +from .models.dialog_instance import DialogInstance + + +@dataclass +class DialogState: + """ + Contains state information for the dialog stack. + """ + + dialog_stack: list[DialogInstance] = field(default_factory=list) + + def __str__(self): + if not self.dialog_stack: + return "dialog stack empty!" + return " ".join(map(str, self.dialog_stack)) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/__init__.py new file mode 100644 index 00000000..a43b4cfb --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/__init__.py @@ -0,0 +1,24 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# -------------------------------------------------------------------------- + +from .dialog_path import DialogPath +from .dialog_state_manager import DialogStateManager +from .dialog_state_manager_configuration import DialogStateManagerConfiguration +from .component_memory_scopes_base import ComponentMemoryScopesBase +from .component_path_resolvers_base import ComponentPathResolversBase +from .path_resolver_base import PathResolverBase +from . import scope_path + +__all__ = [ + "DialogPath", + "DialogStateManager", + "DialogStateManagerConfiguration", + "ComponentMemoryScopesBase", + "ComponentPathResolversBase", + "PathResolverBase", + "scope_path", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_memory_scopes_base.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_memory_scopes_base.py new file mode 100644 index 00000000..061a3491 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_memory_scopes_base.py @@ -0,0 +1,14 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from abc import ABC, abstractmethod +from collections.abc import Iterable + +from .scopes.memory_scope import MemoryScope + + +class ComponentMemoryScopesBase(ABC): + + @abstractmethod + def get_memory_scopes(self) -> Iterable[MemoryScope]: + raise NotImplementedError() diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_path_resolvers_base.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_path_resolvers_base.py new file mode 100644 index 00000000..a9c2644d --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/component_path_resolvers_base.py @@ -0,0 +1,15 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +from abc import ABC, abstractmethod +from collections.abc import Iterable + +from .path_resolver_base import PathResolverBase + + +class ComponentPathResolversBase(ABC): + + @abstractmethod + def get_path_resolvers(self) -> Iterable[PathResolverBase]: + raise NotImplementedError() diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_path.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_path.py new file mode 100644 index 00000000..7cc3f1cc --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_path.py @@ -0,0 +1,33 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +class DialogPath: + # Counter of emitted events. + EVENT_COUNTER = "dialog.eventCounter" + + # Currently expected properties. + EXPECTED_PROPERTIES = "dialog.expectedProperties" + + # Default operation to use for entities where there is no identified operation entity. + DEFAULT_OPERATION = "dialog.defaultOperation" + + # Last surfaced entity ambiguity event. + LAST_EVENT = "dialog.lastEvent" + + # Currently required properties. + REQUIRED_PROPERTIES = "dialog.requiredProperties" + + # Number of retries for the current Ask. + RETRIES = "dialog.retries" + + # Last intent. + LAST_INTENT = "dialog.lastIntent" + + # Last trigger event: defined in FormEvent, ask, clarifyEntity etc.. + LAST_TRIGGER_EVENT = "dialog.lastTriggerEvent" + + @staticmethod + def get_property_name(prop: str) -> str: + """Get the property name without the 'dialog.' prefix, if it exists.""" + return prop.removeprefix("dialog.") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager.py new file mode 100644 index 00000000..f7e3bcdf --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager.py @@ -0,0 +1,563 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ..dialog_context import DialogContext + +import builtins + +from collections.abc import Callable, Iterable, Iterator +from inspect import isawaitable +from traceback import print_tb +from typing import TypeVar, cast + +from .scopes.memory_scope import MemoryScope +from .component_memory_scopes_base import ComponentMemoryScopesBase +from .component_path_resolvers_base import ComponentPathResolversBase +from .dialog_path import DialogPath +from .dialog_state_manager_configuration import DialogStateManagerConfiguration + +# Declare type variable +T = TypeVar("T") # pylint: disable=invalid-name + +BUILTIN_TYPES = list(filter(lambda x: not x.startswith("_"), dir(builtins))) + + +# +# The DialogStateManager manages memory scopes and pathresolvers +# MemoryScopes are named root level objects, which can exist either in the dialogcontext or off of turn state +# PathResolvers allow for shortcut behavior for mapping things like $foo -> dialog.foo. +# +class DialogStateManager: + SEPARATORS = [",", "["] + + def __init__( + self, + dialog_context: "DialogContext", + configuration: DialogStateManagerConfiguration | None = None, + ): + """ + Initializes a new instance of the DialogStateManager class. + :param dialog_context: The dialog context for the current turn of the conversation. + :param configuration: Configuration for the dialog state manager. Default is None. + """ + # pylint: disable=import-outside-toplevel + # These modules are imported at static level to avoid circular dependency problems + from microsoft_agents.hosting.dialogs import ( + DialogsComponentRegistration, + ObjectPath, + ) + from microsoft_agents.hosting.dialogs._component_registration import ( + ComponentRegistration, + ) + + self._object_path_cls = ObjectPath + self._dialog_component_registration_cls = DialogsComponentRegistration + + # Information for tracking when path was last modified. + self.path_tracker = "dialog._tracker.paths" + + self._dialog_context = dialog_context + self._version: int = 0 + + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + from typing import cast as _cast # pylint: disable=import-outside-toplevel + + self._configuration: DialogStateManagerConfiguration | None = ( + configuration + or _cast( + DialogStateManagerConfiguration | None, + dialog_context.context.turn_state.get( + DialogStateManagerConfiguration.__name__, None + ), + ) + ) + if not self._configuration: + self._configuration = DialogStateManagerConfiguration() + + ComponentRegistration.add(self._dialog_component_registration_cls()) + + # get all of the component memory scopes + memory_component: ComponentMemoryScopesBase + for memory_component in filter( + lambda comp: isinstance(comp, ComponentMemoryScopesBase), + ComponentRegistration.get_components(), + ): + for memory_scope in memory_component.get_memory_scopes(): + self._configuration.memory_scopes.append(memory_scope) + + # get all of the component path resolvers + path_component: ComponentPathResolversBase + for path_component in filter( + lambda comp: isinstance(comp, ComponentPathResolversBase), + ComponentRegistration.get_components(), + ): + for path_resolver in path_component.get_path_resolvers(): + self._configuration.path_resolvers.append(path_resolver) + + # cache for any other new dialog_state_manager instances in this turn. + dialog_context.context.turn_state[self._configuration.__class__.__name__] = ( + self._configuration + ) + + def __len__(self) -> int: + """ + Gets the number of memory scopes in the dialog state manager. + """ + return len(self.configuration.memory_scopes) + + @property + def configuration(self) -> DialogStateManagerConfiguration: + """ + Gets or sets the configured path resolvers and memory scopes for the dialog state manager. + """ + assert self._configuration is not None + return self._configuration + + @property + def keys(self) -> Iterable[str]: + """ + Gets a Iterable containing the keys of the memory scopes + """ + return [memory_scope.name for memory_scope in self.configuration.memory_scopes] + + @property + def values(self) -> Iterable[object]: + """ + Gets a Iterable containing the values of the memory scopes. + """ + return [ + memory_scope.get_memory(self._dialog_context) + for memory_scope in self.configuration.memory_scopes + ] + + @property + def is_read_only(self) -> bool: + """ + Gets a value indicating whether the dialog state manager is read-only. + """ + return True + + def __getitem__(self, key): + """ + :param key: + :return The value stored at key's position: + """ + return self.get_value(object, key, default_value=lambda: None) + + def __setitem__(self, key, value): + if self._index_of_any(key, self.SEPARATORS) == -1: + # Root is handled by SetMemory rather than SetValue + scope = self.get_memory_scope(key) + if not scope: + raise IndexError(self._get_bad_scope_message(key)) + scope.set_memory(self._dialog_context, value) + else: + self.set_value(key, value) + + def _get_bad_scope_message(self, path: str) -> str: + return ( + f"'{path}' does not match memory scopes:[" + f"{', '.join((memory_scope.name for memory_scope in self.configuration.memory_scopes))}]" + ) + + @staticmethod + def _index_of_any(string: str, elements_to_search_for) -> int: + for element in elements_to_search_for: + index = string.find(element) + if index != -1: + return index + + return -1 + + def get_memory_scope(self, name: str) -> MemoryScope: + """ + Get MemoryScope by name. + """ + if not name: + raise TypeError(f"Expecting: {str.__name__}, but received None") + + memory_scope = next( + ( + memory_scope + for memory_scope in self.configuration.memory_scopes + if memory_scope.name.lower() == name.lower() + ), + None, + ) + + if not memory_scope: + raise IndexError(self._get_bad_scope_message(name)) + + return memory_scope + + def version(self) -> str: + """ + Version help caller to identify the updates and decide cache or not. + """ + return str(self._version) + + def resolve_memory_scope(self, path: str) -> tuple[MemoryScope, str]: + """ + Will find the MemoryScope for and return the remaining path. + """ + scope = path + sep_index = -1 + dot = path.find(".") + open_square_bracket = path.find("[") + + if dot > 0 and open_square_bracket > 0: + sep_index = min(dot, open_square_bracket) + + elif dot > 0: + sep_index = dot + + elif open_square_bracket > 0: + sep_index = open_square_bracket + + if sep_index > 0: + scope = path[0:sep_index] + memory_scope = self.get_memory_scope(scope) + if memory_scope: + remaining_path = path[sep_index + 1 :] + return memory_scope, remaining_path + + memory_scope = self.get_memory_scope(scope) + if not scope: + raise IndexError(self._get_bad_scope_message(scope)) + return memory_scope, "" + + def transform_path(self, path: str) -> str: + """ + Transform the path using the registered PathTransformers. + """ + for path_resolver in self.configuration.path_resolvers: + path = path_resolver.transform_path(path) + + return path + + @staticmethod + def _is_primitive(type_to_check: type) -> bool: + return type_to_check.__name__ in BUILTIN_TYPES + + def try_get_value( + self, path: str, class_type: type = object + ) -> tuple[bool, object]: + """ + Get the value from memory using path expression (NOTE: This always returns clone of value). + """ + if not path: + raise TypeError(f"Expecting: {str.__name__}, but received None") + return_value = ( + class_type() if DialogStateManager._is_primitive(class_type) else None + ) + path = self.transform_path(path) + + try: + memory_scope, remaining_path = self.resolve_memory_scope(path) + except Exception as error: + print_tb(error.__traceback__) + return False, return_value + + if not memory_scope: + return False, return_value + + if not remaining_path: + memory = memory_scope.get_memory(self._dialog_context) + if not memory: + return False, return_value + + return True, memory + + # TODO: HACK to support .First() retrieval on turn.recognized.entities.foo, replace with Expressions once + # expressions ship + first = ".FIRST()" + try: + i_first = path.upper().rindex(first) + except ValueError: + i_first = -1 + if i_first >= 0: + remaining_path = path[i_first + len(first) :] + path = path[0:i_first] + success, first_value = self._try_get_first_nested_value(path, self) + if success: + if not remaining_path: + return True, first_value + + path_value = self._object_path_cls.try_get_path_value( + first_value, remaining_path + ) + return bool(path_value), path_value + + return False, return_value + + path_value = self._object_path_cls.try_get_path_value(self, path) + return bool(path_value), path_value + + def get_value( + self, + class_type: type, + path_expression: str, + default_value: Callable[[], T] | None = None, + ) -> T | None: + """ + Get the value from memory using path expression (NOTE: This always returns clone of value). + """ + if not path_expression: + raise TypeError(f"Expecting: {str.__name__}, but received None") + + success, value = self.try_get_value(path_expression, class_type) + if success: + return cast(T, value) + + return default_value() if default_value else None + + def get_int_value(self, path_expression: str, default_value: int = 0) -> int: + """ + Get an int value from memory using a path expression. + """ + if not path_expression: + raise TypeError(f"Expecting: {str.__name__}, but received None") + success, value = self.try_get_value(path_expression, int) + if success: + return cast(int, value) + + return default_value + + def get_bool_value(self, path_expression: str, default_value: bool = False) -> bool: + """ + Get a bool value from memory using a path expression. + """ + if not path_expression: + raise TypeError(f"Expecting: {str.__name__}, but received None") + success, value = self.try_get_value(path_expression, bool) + if success: + return cast(bool, value) + + return default_value + + def get_string_value(self, path_expression: str, default_value: str = "") -> str: + """ + Get a string value from memory using a path expression. + """ + if not path_expression: + raise TypeError(f"Expecting: {str.__name__}, but received None") + success, value = self.try_get_value(path_expression, str) + if success: + return cast(str, value) + + return default_value + + def set_value(self, path: str, value: object): + """ + Set memory to value. + """ + if isawaitable(value): + raise Exception(f"{path} = You can't pass an awaitable to set_value") + + if not path: + raise TypeError(f"Expecting: {str.__name__}, but received None") + + path = self.transform_path(path) + if self._track_change(path, value): + self._object_path_cls.set_path_value(self, path, value) + + # Every set will increase version + self._version += 1 + + def remove_value(self, path: str): + """ + Remove memory at the given path. + """ + if not path: + raise TypeError(f"Expecting: {str.__name__}, but received None") + + path = self.transform_path(path) + if self._track_change(path, None): + self._object_path_cls.remove_path_value(self, path) + + def get_memory_snapshot(self) -> dict[str, object]: + """ + Gets all memoryscopes suitable for logging. + """ + result = {} + + for scope in [ + ms for ms in self.configuration.memory_scopes if ms.include_in_snapshot + ]: + memory = scope.get_memory(self._dialog_context) + if memory: + result[scope.name] = memory + + return result + + async def load_all_scopes(self): + """ + Load all of the scopes. + """ + for scope in self.configuration.memory_scopes: + await scope.load(self._dialog_context) + + async def save_all_changes(self): + """ + Save all changes for all scopes. + """ + for scope in self.configuration.memory_scopes: + await scope.save_changes(self._dialog_context) + + async def delete_scopes_memory_async(self, name: str): + """ + Delete the memory for a scope. + """ + name = name.upper() + scope_list = [ + ms for ms in self.configuration.memory_scopes if ms.name.upper() == name + ] + if len(scope_list) > 1: + raise RuntimeError(f"More than 1 scopes found with the name '{name}'") + scope = scope_list[0] if scope_list else None + if scope: + await scope.delete(self._dialog_context) + + def add(self, key: str, value: object): + raise RuntimeError("Not supported") + + def contains_key(self, key: str) -> bool: + scopes_with_key = [ + ms + for ms in self.configuration.memory_scopes + if ms.name.upper() == key.upper() + ] + return bool(scopes_with_key) + + def remove(self, key: str): + raise RuntimeError("Not supported") + + def clear(self, key: str): + raise RuntimeError("Not supported") + + def contains(self, item: tuple[str, object]) -> bool: + raise RuntimeError("Not supported") + + def __contains__(self, item: tuple[str, object]) -> bool: + raise RuntimeError("Not supported") + + def copy_to(self, array: list[tuple[str, object]], array_index: int): + for memory_scope in self.configuration.memory_scopes: + array[array_index] = ( + memory_scope.name, + memory_scope.get_memory(self._dialog_context), + ) + array_index += 1 + + def remove_item(self, item: tuple[str, object]) -> bool: + raise RuntimeError("Not supported") + + def get_enumerator(self) -> Iterator[tuple[str, object]]: + for memory_scope in self.configuration.memory_scopes: + yield (memory_scope.name, memory_scope.get_memory(self._dialog_context)) + + def track_paths(self, paths: Iterable[str]) -> list[str]: + """ + Track when specific paths are changed. + """ + all_paths = [] + for path in paths: + t_path = self.transform_path(path) + + # Track any path that resolves to a constant path + segments = self._object_path_cls.try_resolve_path(self, t_path) + if segments: + n_path = "_".join(segments) + self.set_value(self.path_tracker + "." + n_path, 0) + all_paths.append(n_path) + + return all_paths + + def any_path_changed(self, counter: int, paths: Iterable[str]) -> bool: + """ + Check to see if any path has changed since watermark. + """ + found = False + if paths: + for path in paths: + if self.get_int_value(self.path_tracker + "." + path) > counter: + found = True + break + + return found + + def __iter__(self): + for memory_scope in self.configuration.memory_scopes: + yield (memory_scope.name, memory_scope.get_memory(self._dialog_context)) + + @staticmethod + def _try_get_first_nested_value( + remaining_path: str, memory: object + ) -> tuple[bool, object]: + # pylint: disable=import-outside-toplevel + from microsoft_agents.hosting.dialogs import ObjectPath + + array = ObjectPath.try_get_path_value(memory, remaining_path) + if array and isinstance(array, list): + if isinstance(array[0], list): + first = array[0] + if first: + second = first[0] + return True, second + + return False, None + + return True, array[0] + + return False, None + + def _track_change(self, path: str, value: object) -> bool: + has_path = False + segments = self._object_path_cls.try_resolve_path(self, path) + if segments: + root = segments[1] if len(segments) > 1 else "" + + # Skip _* as first scope, i.e. _adaptive, _tracker, ... + if not root.startswith("_"): + # Convert to a simple path with _ between segments + path_name = "_".join(segments) + tracked_path = f"{self.path_tracker}.{path_name}" + counter = None + + def update(): + nonlocal counter + last_changed = self.try_get_value(tracked_path, int) + if last_changed: + if counter is not None: + counter = self.get_value(int, DialogPath.EVENT_COUNTER) + + self.set_value(tracked_path, counter) + + update() + if not self._is_primitive(type(value)): + # For an object we need to see if any children path are being tracked + def check_children(property: str, instance: object): + nonlocal tracked_path + # Add new child segment + tracked_path += "_" + property.lower() + update() + if not self._is_primitive(type(instance)): + self._object_path_cls.for_each_property( + property, check_children + ) + + # Remove added child segment + tracked_path = tracked_path[: tracked_path.rfind("_")] + + self._object_path_cls.for_each_property(value, check_children) + + has_path = True + + return has_path diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager_configuration.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager_configuration.py new file mode 100644 index 00000000..53aa3d10 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/dialog_state_manager_configuration.py @@ -0,0 +1,11 @@ +from dataclasses import dataclass, field + +from .scopes.memory_scope import MemoryScope +from .path_resolver_base import PathResolverBase + + +@dataclass +class DialogStateManagerConfiguration: + + path_resolvers: list[PathResolverBase] = field(default_factory=list) + memory_scopes: list[MemoryScope] = field(default_factory=list) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolver_base.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolver_base.py new file mode 100644 index 00000000..88e14aea --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolver_base.py @@ -0,0 +1,8 @@ +from abc import ABC, abstractmethod + + +class PathResolverBase(ABC): + + @abstractmethod + def transform_path(self, path: str): + raise NotImplementedError() diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/__init__.py new file mode 100644 index 00000000..b22ac063 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +from .alias_path_resolver import AliasPathResolver +from .at_at_path_resolver import AtAtPathResolver +from .at_path_resolver import AtPathResolver +from .dollar_path_resolver import DollarPathResolver +from .hash_path_resolver import HashPathResolver +from .percent_path_resolver import PercentPathResolver + +__all__ = [ + "AliasPathResolver", + "AtAtPathResolver", + "AtPathResolver", + "DollarPathResolver", + "HashPathResolver", + "PercentPathResolver", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/alias_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/alias_path_resolver.py new file mode 100644 index 00000000..0ee2d419 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/alias_path_resolver.py @@ -0,0 +1,53 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from ..path_resolver_base import PathResolverBase + + +class AliasPathResolver(PathResolverBase): + def __init__(self, alias: str, prefix: str, postfix: str = ""): + """ + Initializes a new instance of the class. + Alias name. + Prefix name. + Postfix name. + """ + if alias is None: + raise TypeError(f"Expecting: alias, but received None") + if prefix is None: + raise TypeError(f"Expecting: prefix, but received None") + + # Gets the alias name. + self.alias = alias.strip() + self._prefix = prefix.strip() + self._postfix = postfix.strip() + + def transform_path(self, path: str): + """ + Transforms the path. + Path to inspect. + Transformed path. + """ + if not path: + raise TypeError(f"Expecting: path, but received None") + + path = path.strip() + if ( + path.startswith(self.alias) + and len(path) > len(self.alias) + and AliasPathResolver._is_path_char(path[len(self.alias)]) + ): + # here we only deals with trailing alias, alias in middle be handled in further breakdown + # $xxx -> path.xxx + return f"{self._prefix}{path[len(self.alias):]}{self._postfix}".rstrip(".") + + return path + + @staticmethod + def _is_path_char(char: str) -> bool: + """ + Verifies if a character is valid for a path. + Character to verify. + true if the character is valid for a path otherwise, false. + """ + return len(char) == 1 and (char.isalpha() or char == "_") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_at_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_at_path_resolver.py new file mode 100644 index 00000000..d440c040 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_at_path_resolver.py @@ -0,0 +1,9 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .alias_path_resolver import AliasPathResolver + + +class AtAtPathResolver(AliasPathResolver): + def __init__(self): + super().__init__(alias="@@", prefix="turn.recognized.entities.") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_path_resolver.py new file mode 100644 index 00000000..f8c26b3e --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/at_path_resolver.py @@ -0,0 +1,44 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .alias_path_resolver import AliasPathResolver + + +class AtPathResolver(AliasPathResolver): + _DELIMITERS = [".", "["] + + def __init__(self): + super().__init__(alias="@", prefix="") + + self._PREFIX = "turn.recognized.entities." # pylint: disable=invalid-name + + def transform_path(self, path: str): + if not path: + raise TypeError(f"Expecting: path, but received None") + + path = path.strip() + if ( + path.startswith("@") + and len(path) > 1 + and AtPathResolver._is_path_char(path[1]) + ): + end = AtPathResolver._index_of_any(path[1:], AtPathResolver._DELIMITERS) + if end == -1: + end = len(path) - 1 + # +1 to offset the leading '@' we skipped in the search + end += 1 + + prop = path[1:end] + suffix = path[end:] + path = f"{self._PREFIX}{prop}.first(){suffix}" + + return path + + @staticmethod + def _index_of_any(string: str, elements_to_search_for) -> int: + for element in elements_to_search_for: + index = string.find(element) + if index != -1: + return index + + return -1 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/dollar_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/dollar_path_resolver.py new file mode 100644 index 00000000..8152d23c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/dollar_path_resolver.py @@ -0,0 +1,9 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .alias_path_resolver import AliasPathResolver + + +class DollarPathResolver(AliasPathResolver): + def __init__(self): + super().__init__(alias="$", prefix="dialog.") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/hash_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/hash_path_resolver.py new file mode 100644 index 00000000..b00376e5 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/hash_path_resolver.py @@ -0,0 +1,9 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .alias_path_resolver import AliasPathResolver + + +class HashPathResolver(AliasPathResolver): + def __init__(self): + super().__init__(alias="#", prefix="turn.recognized.intents.") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/percent_path_resolver.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/percent_path_resolver.py new file mode 100644 index 00000000..dd0fa2e1 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/path_resolvers/percent_path_resolver.py @@ -0,0 +1,9 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .alias_path_resolver import AliasPathResolver + + +class PercentPathResolver(AliasPathResolver): + def __init__(self): + super().__init__(alias="%", prefix="class.") diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scope_path.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scope_path.py new file mode 100644 index 00000000..1a6afa63 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scope_path.py @@ -0,0 +1,38 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +# User memory scope root path. +# This property is deprecated, use ScopePath.User instead. +USER = "user" + +# Conversation memory scope root path. +# This property is deprecated, use ScopePath.Conversation instead.This property is deprecated, use ScopePath.Dialog instead.This property is deprecated, use ScopePath.DialogClass instead.This property is deprecated, use ScopePath.This instead.This property is deprecated, use ScopePath.Class instead. +CLASS = "class" + +# Settings memory scope root path. +# This property is deprecated, use ScopePath.Settings instead. + +SETTINGS = "settings" + +# Turn memory scope root path. +# This property is deprecated, use ScopePath.Turn instead. +TURN = "turn" + +# DialogContext memory scope root path. +DIALOG_CONTEXT = "dialogContext" diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/__init__.py new file mode 100644 index 00000000..00556b6c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/__init__.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# -------------------------------------------------------------------------- +from .bot_state_memory_scope import BotStateMemoryScope +from .class_memory_scope import ClassMemoryScope +from .conversation_memory_scope import ConversationMemoryScope +from .dialog_class_memory_scope import DialogClassMemoryScope +from .dialog_context_memory_scope import DialogContextMemoryScope +from .dialog_memory_scope import DialogMemoryScope +from .memory_scope import MemoryScope +from .settings_memory_scope import SettingsMemoryScope +from .this_memory_scope import ThisMemoryScope +from .turn_memory_scope import TurnMemoryScope +from .user_memory_scope import UserMemoryScope + +__all__ = [ + "BotStateMemoryScope", + "ClassMemoryScope", + "ConversationMemoryScope", + "DialogClassMemoryScope", + "DialogContextMemoryScope", + "DialogMemoryScope", + "MemoryScope", + "SettingsMemoryScope", + "ThisMemoryScope", + "TurnMemoryScope", + "UserMemoryScope", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/bot_state_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/bot_state_memory_scope.py new file mode 100644 index 00000000..c402fa92 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/bot_state_memory_scope.py @@ -0,0 +1,66 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.core import AgentState + +from .memory_scope import MemoryScope + + +class BotStateMemoryScope(MemoryScope): + def __init__(self, agent_state_type: type[AgentState], name: str): + super().__init__(name, include_in_snapshot=True) + self.agent_state_type = agent_state_type + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + # In the new SDK, after AgentState.load() is called, turn_state contains + # a CachedAgentState (not the AgentState itself) at the context_service_key. + # Handle both cases: AgentState (before load) and CachedAgentState (after load). + turn_state_value = dialog_context.context.turn_state.get( + self.agent_state_type.__name__ + ) + if turn_state_value is None: + return None + if isinstance(turn_state_value, AgentState): + cached_state = turn_state_value.get_cached_state(dialog_context.context) + # If get_cached_state() returned AgentState itself (load() skipped turn_state update) + # or None, the state memory is not yet available. + if cached_state is None or isinstance(cached_state, AgentState): + return None + return cached_state.state + # It's a CachedAgentState (stored after load() was called) + return getattr(turn_state_value, "state", None) + + def set_memory(self, dialog_context: "DialogContext", memory: object): + raise RuntimeError("You cannot replace the root AgentState object") + + async def load(self, dialog_context: "DialogContext", force: bool = False): + agent_state: AgentState | None = self._get_agent_state(dialog_context) + + if agent_state: + await agent_state.load(dialog_context.context, force) + + async def save_changes(self, dialog_context: "DialogContext", force: bool = False): + agent_state: AgentState | None = self._get_agent_state(dialog_context) + + if agent_state: + await agent_state.save(dialog_context.context, force) + + def _get_agent_state(self, dialog_context: "DialogContext") -> AgentState | None: + value = dialog_context.context.turn_state.get( + self.agent_state_type.__name__, None + ) + # After AgentState.load(), the turn_state key holds CachedAgentState, not AgentState. + # Return None in that case so callers don't try to call AgentState methods on it. + if isinstance(value, AgentState): + return value + return None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/class_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/class_memory_scope.py new file mode 100644 index 00000000..85a7d95f --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/class_memory_scope.py @@ -0,0 +1,64 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from collections import namedtuple + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class ClassMemoryScope(MemoryScope): + def __init__(self): + super().__init__(scope_path.CLASS, include_in_snapshot=False) + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + # if active dialog is a container dialog then "dialogclass" binds to it. + if dialog_context.active_dialog: + dialog = dialog_context.find_dialog_sync(dialog_context.active_dialog.id) + if dialog: + return ClassMemoryScope._bind_to_dialog_context(dialog, dialog_context) + + return None + + def set_memory(self, dialog_context: "DialogContext", memory: object): + raise Exception( + f"{self.__class__.__name__}.set_memory not supported (read only)" + ) + + @staticmethod + def _bind_to_dialog_context(obj, dialog_context: "DialogContext") -> object: + clone = {} + for prop in dir(obj): + # don't process double underscore attributes + if prop[:1] != "_": + prop_value = getattr(obj, prop) + if not callable(prop_value): + # the only objects + if hasattr(prop_value, "try_get_value"): + clone[prop] = prop_value.try_get_value(dialog_context.state) + elif hasattr(prop_value, "__dict__") and not isinstance( + prop_value, type(prop_value) + ): + clone[prop] = ClassMemoryScope._bind_to_dialog_context( + prop_value, dialog_context + ) + else: + clone[prop] = prop_value + if clone: + ReadOnlyObject = namedtuple( # pylint: disable=invalid-name + "ReadOnlyObject", clone + ) + return ReadOnlyObject(**clone) + + return None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/conversation_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/conversation_memory_scope.py new file mode 100644 index 00000000..3987823e --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/conversation_memory_scope.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ConversationState + +from microsoft_agents.hosting.dialogs.memory import scope_path +from .bot_state_memory_scope import BotStateMemoryScope + + +class ConversationMemoryScope(BotStateMemoryScope): + def __init__(self): + super().__init__(ConversationState, scope_path.CONVERSATION) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_class_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_class_memory_scope.py new file mode 100644 index 00000000..5a1b7fe0 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_class_memory_scope.py @@ -0,0 +1,52 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from copy import deepcopy + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class DialogClassMemoryScope(MemoryScope): + def __init__(self): + # pylint: disable=import-outside-toplevel + super().__init__(scope_path.DIALOG_CLASS, include_in_snapshot=False) + + # This import is to avoid circular dependency issues + from microsoft_agents.hosting.dialogs.dialog_container import DialogContainer + + self._dialog_container_cls = DialogContainer + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + # if active dialog is a container dialog then "dialogclass" binds to it. + if dialog_context.active_dialog: + dialog = dialog_context.find_dialog_sync(dialog_context.active_dialog.id) + if isinstance(dialog, self._dialog_container_cls): + return deepcopy(dialog) + + # Otherwise we always bind to parent, or if there is no parent the active dialog + parent_id = ( + dialog_context.parent.active_dialog.id + if dialog_context.parent and dialog_context.parent.active_dialog + else None + ) + active_id = ( + dialog_context.active_dialog.id if dialog_context.active_dialog else None + ) + return deepcopy(dialog_context.find_dialog_sync(parent_id or active_id)) + + def set_memory(self, dialog_context: "DialogContext", memory: object): + raise Exception( + f"{self.__class__.__name__}.set_memory not supported (read only)" + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_context_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_context_memory_scope.py new file mode 100644 index 00000000..eff7c1ee --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_context_memory_scope.py @@ -0,0 +1,68 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class DialogContextMemoryScope(MemoryScope): + def __init__(self): + # pylint: disable=invalid-name + super().__init__(scope_path.DIALOG_CONTEXT, include_in_snapshot=False) + # Stack name. + self.STACK = "stack" + + # Active dialog name. + self.ACTIVE_DIALOG = "activeDialog" + + # Parent name. + self.PARENT = "parent" + + def get_memory(self, dialog_context: "DialogContext") -> object: + """ + Gets the backing memory for this scope. + """ + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + memory = {} + stack = list([]) + current_dc = dialog_context + + # go to leaf node + while current_dc.child: + current_dc = current_dc.child + + while current_dc: + # (PORTERS NOTE: javascript stack is reversed with top of stack on end) + for item in current_dc.stack: + # filter out ActionScope items because they are internal bookkeeping. + if not item.id.startswith("ActionScope["): + stack.append(item.id) + + current_dc = current_dc.parent + + # top of stack is stack[0]. + memory[self.STACK] = stack + memory[self.ACTIVE_DIALOG] = ( + dialog_context.active_dialog.id if dialog_context.active_dialog else None + ) + memory[self.PARENT] = ( + dialog_context.parent.active_dialog.id + if dialog_context.parent and dialog_context.parent.active_dialog + else None + ) + return memory + + def set_memory(self, dialog_context: "DialogContext", memory: object): + raise Exception( + f"{self.__class__.__name__}.set_memory not supported (read only)" + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_memory_scope.py new file mode 100644 index 00000000..f5d7529a --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/dialog_memory_scope.py @@ -0,0 +1,75 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class DialogMemoryScope(MemoryScope): + def __init__(self): + # pylint: disable=import-outside-toplevel + super().__init__(scope_path.DIALOG) + + # This import is to avoid circular dependency issues + from microsoft_agents.hosting.dialogs.dialog_container import DialogContainer + + self._dialog_container_cls = DialogContainer + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + # if active dialog is a container dialog then "dialog" binds to it. + if dialog_context.active_dialog: + dialog = dialog_context.find_dialog_sync(dialog_context.active_dialog.id) + if isinstance(dialog, self._dialog_container_cls): + return dialog_context.active_dialog.state + + # Otherwise we always bind to parent, or if there is no parent the active dialog + parent_state = ( + dialog_context.parent.active_dialog.state + if dialog_context.parent and dialog_context.parent.active_dialog + else None + ) + dc_state = ( + dialog_context.active_dialog.state if dialog_context.active_dialog else None + ) + return parent_state or dc_state + + def set_memory(self, dialog_context: "DialogContext", memory: object): + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + if memory is None: + raise TypeError(f"Expecting: memory object, but received None") + + # If active dialog is a container dialog then "dialog" binds to it. + # Otherwise the "dialog" will bind to the dialogs parent assuming it is a container. + parent: DialogContext | None = dialog_context + if not self.is_container(parent) and self.is_container(parent.parent): + parent = parent.parent + + # If there's no active dialog then throw an error. + assert parent is not None + if not parent.active_dialog: + raise Exception( + "Cannot set DialogMemoryScope. There is no active dialog or parent dialog in the context" + ) + + parent.active_dialog.state = memory # type: ignore[assignment] + + def is_container(self, dialog_context: "DialogContext | None"): + if dialog_context and dialog_context.active_dialog: + dialog = dialog_context.find_dialog_sync(dialog_context.active_dialog.id) + if isinstance(dialog, self._dialog_container_cls): + return True + + return False diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/memory_scope.py new file mode 100644 index 00000000..a0688707 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/memory_scope.py @@ -0,0 +1,91 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from abc import ABC, abstractmethod + + +class MemoryScope(ABC): + def __init__(self, name: str, include_in_snapshot: bool = True): + # + # Gets or sets name of the scope. + # + # + # Name of the scope. + # + self.include_in_snapshot = include_in_snapshot + # + # Gets or sets a value indicating whether this memory should be included in snapshot. + # + # + # True or false. + # + self.name = name + + # + # Get the backing memory for this scope. + # + # dc. + # memory for the scope. + @abstractmethod + def get_memory( + self, dialog_context: "DialogContext" + ) -> object: # pylint: disable=unused-argument + raise NotImplementedError() + + # + # Changes the backing object for the memory scope. + # + # dc. + # memory. + @abstractmethod + def set_memory( + self, dialog_context: "DialogContext", memory: object + ): # pylint: disable=unused-argument + raise NotImplementedError() + + # + # Populates the state cache for this from the storage layer. + # + # The dialog context object for this turn. + # Optional, true to overwrite any existing state cache + # or false to load state from storage only if the cache doesn't already exist. + # A cancellation token that can be used by other objects + # or threads to receive notice of cancellation. + # A task that represents the work queued to execute. + async def load( + self, dialog_context: "DialogContext", force: bool = False + ): # pylint: disable=unused-argument + return + + # + # Writes the state cache for this to the storage layer. + # + # The dialog context object for this turn. + # Optional, true to save the state cache to storage + # or false to save state to storage only if a property in the cache has changed. + # A cancellation token that can be used by other objects + # or threads to receive notice of cancellation. + # A task that represents the work queued to execute. + async def save_changes( + self, dialog_context: "DialogContext", force: bool = False + ): # pylint: disable=unused-argument + return + + # + # Deletes any state in storage and the cache for this . + # + # The dialog context object for this turn. + # A cancellation token that can be used by other objects + # or threads to receive notice of cancellation. + # A task that represents the work queued to execute. + async def delete( + self, dialog_context: "DialogContext" + ): # pylint: disable=unused-argument + return diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/settings_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/settings_memory_scope.py new file mode 100644 index 00000000..eef060ed --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/settings_memory_scope.py @@ -0,0 +1,38 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class SettingsMemoryScope(MemoryScope): + def __init__(self): + super().__init__(scope_path.SETTINGS) + self._empty_settings = {} + self.include_in_snapshot = False + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + settings: dict | None = dialog_context.context.turn_state.get( # type: ignore[assignment] + scope_path.SETTINGS, None + ) + + if not settings: + settings = self._empty_settings + + return settings + + def set_memory(self, dialog_context: "DialogContext", memory: object): + raise Exception( + f"{self.__class__.__name__}.set_memory not supported (read only)" + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/this_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/this_memory_scope.py new file mode 100644 index 00000000..fdc36f24 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/this_memory_scope.py @@ -0,0 +1,36 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class ThisMemoryScope(MemoryScope): + def __init__(self): + super().__init__(scope_path.THIS) + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + return ( + dialog_context.active_dialog.state if dialog_context.active_dialog else None + ) + + def set_memory(self, dialog_context: "DialogContext", memory: object): + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + if memory is None: + raise TypeError(f"Expecting: object, but received None") + + assert dialog_context.active_dialog is not None + dialog_context.active_dialog.state = memory # type: ignore[assignment] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/turn_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/turn_memory_scope.py new file mode 100644 index 00000000..7115b5fa --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/turn_memory_scope.py @@ -0,0 +1,86 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from __future__ import annotations + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ...dialog_context import DialogContext + +from microsoft_agents.hosting.dialogs.memory import scope_path + +from .memory_scope import MemoryScope + + +class CaseInsensitiveDict(dict): + # pylint: disable=protected-access + + @classmethod + def _k(cls, key): + return key.lower() if isinstance(key, str) else key + + def __init__(self, *args, **kwargs): + super(CaseInsensitiveDict, self).__init__(*args, **kwargs) + self._convert_keys() + + def __getitem__(self, key): + return super(CaseInsensitiveDict, self).__getitem__(self.__class__._k(key)) + + def __setitem__(self, key, value): + super(CaseInsensitiveDict, self).__setitem__(self.__class__._k(key), value) + + def __delitem__(self, key): + return super(CaseInsensitiveDict, self).__delitem__(self.__class__._k(key)) + + def __contains__(self, key): + return super(CaseInsensitiveDict, self).__contains__(self.__class__._k(key)) + + def pop(self, key, *args, **kwargs): + return super(CaseInsensitiveDict, self).pop( + self.__class__._k(key), *args, **kwargs + ) + + def get(self, key, *args, **kwargs): + return super(CaseInsensitiveDict, self).get( + self.__class__._k(key), *args, **kwargs + ) + + def setdefault(self, key, *args, **kwargs): + return super(CaseInsensitiveDict, self).setdefault( + self.__class__._k(key), *args, **kwargs + ) + + def update(self, e=None, **f): + if e is None: + e = {} + super(CaseInsensitiveDict, self).update(self.__class__(e)) + super(CaseInsensitiveDict, self).update(self.__class__(**f)) + + def _convert_keys(self): + for k in list(self.keys()): + val = super(CaseInsensitiveDict, self).pop(k) + self.__setitem__(k, val) + + +class TurnMemoryScope(MemoryScope): + def __init__(self): + super().__init__(scope_path.TURN, False) + + def get_memory(self, dialog_context: "DialogContext") -> object: + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + turn_value = dialog_context.context.turn_state.get(scope_path.TURN, None) + + if turn_value is None: + turn_value = CaseInsensitiveDict() + dialog_context.context.turn_state[scope_path.TURN] = turn_value + + return turn_value + + def set_memory(self, dialog_context: "DialogContext", memory: object): + if not dialog_context: + raise TypeError(f"Expecting: DialogContext, but received None") + + dialog_context.context.turn_state[scope_path.TURN] = memory diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/user_memory_scope.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/user_memory_scope.py new file mode 100644 index 00000000..1c97b739 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/memory/scopes/user_memory_scope.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import UserState + +from microsoft_agents.hosting.dialogs.memory import scope_path +from .bot_state_memory_scope import BotStateMemoryScope + + +class UserMemoryScope(BotStateMemoryScope): + def __init__(self): + super().__init__(UserState, scope_path.USER) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/__init__.py new file mode 100644 index 00000000..5046b6b8 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/__init__.py @@ -0,0 +1,15 @@ +from .dialog_event import DialogEvent +from .dialog_events import DialogEvents +from .dialog_instance import DialogInstance +from .dialog_reason import DialogReason +from .dialog_turn_result import DialogTurnResult +from .dialog_turn_status import DialogTurnStatus + +__all__ = [ + "DialogEvent", + "DialogEvents", + "DialogInstance", + "DialogReason", + "DialogTurnResult", + "DialogTurnStatus", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_event.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_event.py new file mode 100644 index 00000000..79ad38ce --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_event.py @@ -0,0 +1,13 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass +from typing import Any + + +@dataclass +class DialogEvent: + + bubble: bool = False + name: str = "" + value: Any = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_events.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_events.py new file mode 100644 index 00000000..9a5ad7f3 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_events.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +class DialogEvents: + begin_dialog = "beginDialog" + reprompt_dialog = "repromptDialog" + cancel_dialog = "cancelDialog" + error = "error" + activity_received = "activityReceived" + recognize_utterance = "recognizeUtterance" + version_changed = "versionChanged" diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_instance.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_instance.py new file mode 100644 index 00000000..5e5726ee --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_instance.py @@ -0,0 +1,28 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass, field +from typing import Any + + +@dataclass +class DialogInstance: + """ + Tracking information for a dialog on the stack. + """ + + id: str | None = None + state: dict[str, Any] = field(default_factory=dict) + + def __str__(self): + """ + Gets or sets a stack index. + + :return: Returns stack index. + :rtype: str + """ + result = "\ndialog_instance_id: %s\n" % self.id + if self.state is not None: + for key, value in self.state.items(): + result += " {} ({})\n".format(key, str(value)) + return result diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_reason.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_reason.py new file mode 100644 index 00000000..4383ab0d --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_reason.py @@ -0,0 +1,34 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +from enum import Enum + + +class DialogReason(Enum): + """ + Indicates in which a dialog-related method is being called. + + :var BeginCalled: A dialog is being started through a call to :meth:`DialogContext.begin()`. + :vartype BeginCalled: int + :var ContinueCalled: A dialog is being continued through a call to :meth:`DialogContext.continue_dialog()`. + :vartype ContinueCalled: int + :var EndCalled: A dialog ended normally through a call to :meth:`DialogContext.end_dialog() + :vartype EndCalled: int + :var ReplaceCalled: A dialog is ending and replaced through a call to :meth:``DialogContext.replace_dialog()`. + :vartype ReplacedCalled: int + :var CancelCalled: A dialog was cancelled as part of a call to :meth:`DialogContext.cancel_all_dialogs()`. + :vartype CancelCalled: int + :var NextCalled: A preceding step was skipped through a call to :meth:`WaterfallStepContext.next()`. + :vartype NextCalled: int + """ + + BeginCalled = 1 + + ContinueCalled = 2 + + EndCalled = 3 + + ReplaceCalled = 4 + + CancelCalled = 5 + + NextCalled = 6 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_result.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_result.py new file mode 100644 index 00000000..716401d4 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_result.py @@ -0,0 +1,17 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass +from typing import Any + +from .dialog_turn_status import DialogTurnStatus + + +@dataclass +class DialogTurnResult: + """ + Result returned to the caller of one of the various stack manipulation methods. + """ + + status: DialogTurnStatus + result: Any = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_status.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_status.py new file mode 100644 index 00000000..6d8b61e5 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/models/dialog_turn_status.py @@ -0,0 +1,26 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +from enum import Enum + + +class DialogTurnStatus(Enum): + """ + Indicates in which a dialog-related method is being called. + + :var Empty: Indicates that there is currently nothing on the dialog stack. + :vartype Empty: int + :var Waiting: Indicates that the dialog on top is waiting for a response from the user. + :vartype Waiting: int + :var Complete: Indicates that the dialog completed successfully, the result is available, and the stack is empty. + :vartype Complete: int + :var Cancelled: Indicates that the dialog was cancelled and the stack is empty. + :vartype Cancelled: int + """ + + Empty = 1 + + Waiting = 2 + + Complete = 3 + + Cancelled = 4 diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/object_path.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/object_path.py new file mode 100644 index 00000000..0e6a4460 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/object_path.py @@ -0,0 +1,315 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import copy +from typing import Union, Callable + + +class ObjectPath: + """ + Helper methods for working with json objects. + """ + + @staticmethod + def assign(start_object, overlay_object, default: Union[Callable, object] = None): + """ + Creates a new object by overlaying values in start_object with non-null values from overlay_object. + + :param start_object: dict or typed object, the target object to set values on + :param overlay_object: dict or typed object, the item to overlay values form + :param default: Provides a default object if both source and overlay are None + :return: A copy of start_object, with values from overlay_object + """ + if start_object and overlay_object: + merged = copy.deepcopy(start_object) + + def merge(target: dict, source: dict): + key_set = set(target).union(set(source)) + + for key in key_set: + target_value = target.get(key) + source_value = source.get(key) + + # skip empty overlay items + if source_value: + if isinstance(source_value, dict): + # merge dictionaries + if not target_value: + target[key] = copy.deepcopy(source_value) + else: + merge(target_value, source_value) + elif not hasattr(source_value, "__dict__"): + # simple type. just copy it. + target[key] = copy.copy(source_value) + elif not target_value: + # the target doesn't have the value, but + # the overlay does. just copy it. + target[key] = copy.deepcopy(source_value) + else: + # recursive class copy + merge(target_value.__dict__, source_value.__dict__) + + target_dict = merged if isinstance(merged, dict) else merged.__dict__ + overlay_dict = ( + overlay_object + if isinstance(overlay_object, dict) + else overlay_object.__dict__ + ) + merge(target_dict, overlay_dict) + + return merged + + if overlay_object: + return copy.deepcopy(overlay_object) + + if start_object: + return start_object + if default: + return default() if callable(default) else copy.deepcopy(default) + return None + + @staticmethod + def set_path_value(obj, path: str, value: object): + """ + Given an object evaluate a path to set the value. + """ + + segments = ObjectPath.try_resolve_path(obj, path) + if not segments: + return + + current = obj + for i in range(len(segments) - 1): + segment = segments[i] + if ObjectPath.is_int(segment): + index = int(segment) + next_obj = current[index] + if not next_obj and len(current) <= index: + # Expand list to index + current += [None] * ((index + 1) - len(current)) + next_obj = current[index] + else: + next_obj = ObjectPath.__get_object_property(current, segment) + if not next_obj: + # Create object or list based on next segment + next_segment = segments[i + 1] + if not ObjectPath.is_int(next_segment): + ObjectPath.__set_object_segment(current, segment, {}) + else: + ObjectPath.__set_object_segment(current, segment, []) + + next_obj = ObjectPath.__get_object_property(current, segment) + + current = next_obj + + last_segment = segments[-1] + ObjectPath.__set_object_segment(current, last_segment, value) + + @staticmethod + def get_path_value( + obj, path: str, default: Union[Callable, object] = None + ) -> object: + """ + Get the value for a path relative to an object. + """ + + value = ObjectPath.try_get_path_value(obj, path) + if value: + return value + + if default is None: + raise KeyError(f"Key {path} not found") + return default() if callable(default) else copy.deepcopy(default) + + @staticmethod + def has_value(obj, path: str) -> bool: + """ + Does an object have a subpath. + """ + return ObjectPath.try_get_path_value(obj, path) is not None + + @staticmethod + def remove_path_value(obj, path: str): + """ + Remove path from object. + """ + + segments = ObjectPath.try_resolve_path(obj, path) + if not segments: + return + + current = obj + for i in range(len(segments) - 1): + segment = segments[i] + current = ObjectPath.__resolve_segment(current, segment) + if not current: + return + + if current: + last_segment = segments[-1] + if ObjectPath.is_int(last_segment): + current[int(last_segment)] = None # type: ignore[index] + else: + current.pop(last_segment) # type: ignore[union-attr] + + @staticmethod + def try_get_path_value(obj, path: str) -> object: + """ + Get the value for a path relative to an object. + """ + + if not obj: + return None + + if path is None: + return None + + if not path: + return obj + + segments = ObjectPath.try_resolve_path(obj, path) + if not segments: + return None + + result = ObjectPath.__resolve_segments(obj, segments) + if not result: + return None + + return result + + @staticmethod + def __set_object_segment(obj, segment, value): + val = ObjectPath.__get_normalized_value(value) + + if ObjectPath.is_int(segment): + # the target is an list + index = int(segment) + + # size the list if needed + obj += [None] * ((index + 1) - len(obj)) + + obj[index] = val + return + + # the target is a dictionary + obj[segment] = val + + @staticmethod + def __get_normalized_value(value): + return value + + @staticmethod + def try_resolve_path( + obj, property_path: str, evaluate: bool = False + ) -> list | None: + so_far = [] + first = property_path[0] if property_path else " " + if first in ("'", '"'): + if not property_path.endswith(first): + return None + + so_far.append(property_path[1 : len(property_path) - 2]) + elif ObjectPath.is_int(property_path): + so_far.append(int(property_path)) + else: + start = 0 + i = 0 + + def emit(): + nonlocal start, i + segment = property_path[start:i] + if segment: + so_far.append(segment) + start = i + 1 + + while i < len(property_path): + char = property_path[i] + if char in (".", "["): + emit() + + if char == "[": + nesting = 1 + i += 1 + while i < len(property_path): + char = property_path[i] + if char == "[": + nesting += 1 + elif char == "]": + nesting -= 1 + if nesting == 0: + break + i += 1 + + if nesting > 0: + return None + + expr = property_path[start:i] + start = i + 1 + indexer = ObjectPath.try_resolve_path(obj, expr, True) + if not indexer: + return None + + result = indexer[0] + if ObjectPath.is_int(result): + so_far.append(int(result)) + else: + so_far.append(result) + + i += 1 + + emit() + + if evaluate: + result = ObjectPath.__resolve_segments(obj, so_far) + if not result: + return None + + so_far.clear() + so_far.append(result) + + return so_far + + @staticmethod + def for_each_property(obj: object, action: Callable[[str, object], None]): + if isinstance(obj, dict): + for key, value in obj.items(): + action(key, value) + elif hasattr(obj, "__dict__"): + for key, value in vars(obj).items(): + action(key, value) + + @staticmethod + def __resolve_segments(current, segments: list) -> object: + result = current + + for segment in segments: + result = ObjectPath.__resolve_segment(result, segment) + if not result: + return None + + return result + + @staticmethod + def __resolve_segment(current, segment) -> object: + if current: + if ObjectPath.is_int(segment): + current = current[int(segment)] + else: + current = ObjectPath.__get_object_property(current, segment) + + return current + + @staticmethod + def __get_object_property(obj, property_name: str): + # doing a case insensitive search + property_name_lower = property_name.lower() + matching = [obj[key] for key in obj if key.lower() == property_name_lower] + return matching[0] if matching else None + + @staticmethod + def is_int(value: str) -> bool: + try: + int(value) + return True + except ValueError: + return False diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state.py new file mode 100644 index 00000000..010ee3d8 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state.py @@ -0,0 +1,22 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Any + +from .persisted_state_keys import PersistedStateKeys + + +class PersistedState: + def __init__( + self, keys: PersistedStateKeys | None = None, data: dict[str, Any] | None = None + ): + if keys and data: + self.user_state: dict[str, Any] = ( + data[keys.user_state] if keys.user_state in data else {} + ) + self.conversation_state: dict[str, Any] = ( + data[keys.conversation_state] if keys.conversation_state in data else {} + ) + else: + self.user_state: dict[str, Any] = {} + self.conversation_state: dict[str, Any] = {} diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state_keys.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state_keys.py new file mode 100644 index 00000000..e4eede51 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/persisted_state_keys.py @@ -0,0 +1,8 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +class PersistedStateKeys: + def __init__(self): + self.user_state: str | None = None + self.conversation_state: str | None = None diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/__init__.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/__init__.py new file mode 100644 index 00000000..91bd539b --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/__init__.py @@ -0,0 +1,41 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# -------------------------------------------------------------------------- + +from .activity_prompt import ActivityPrompt +from .attachment_prompt import AttachmentPrompt +from .choice_prompt import ChoicePrompt +from .confirm_prompt import ConfirmPrompt +from .datetime_prompt import DateTimePrompt +from .datetime_resolution import DateTimeResolution +from .number_prompt import NumberPrompt +from .oauth_prompt import OAuthPrompt +from .oauth_prompt_settings import OAuthPromptSettings +from .prompt_culture_models import PromptCultureModel, PromptCultureModels +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult +from .prompt_validator_context import PromptValidatorContext +from .prompt import Prompt +from .text_prompt import TextPrompt + +__all__ = [ + "ActivityPrompt", + "AttachmentPrompt", + "ChoicePrompt", + "ConfirmPrompt", + "DateTimePrompt", + "DateTimeResolution", + "NumberPrompt", + "OAuthPrompt", + "OAuthPromptSettings", + "PromptCultureModel", + "PromptCultureModels", + "PromptRecognizerResult", + "PromptValidatorContext", + "Prompt", + "PromptOptions", + "TextPrompt", +] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/activity_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/activity_prompt.py new file mode 100644 index 00000000..1c2b16a2 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/activity_prompt.py @@ -0,0 +1,203 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Any, Callable, cast + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes, InputHints + +from ..dialog import Dialog +from ..dialog_context import DialogContext +from ..models.dialog_instance import DialogInstance +from ..models.dialog_reason import DialogReason +from ..models.dialog_turn_result import DialogTurnResult +from .prompt import Prompt +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult +from .prompt_validator_context import PromptValidatorContext + + +class ActivityPrompt(Dialog): + """ + Waits for an activity to be received. + + This prompt requires a validator be passed in and is useful when waiting for non-message + activities like an event to be received. The validator can ignore received events until the + expected activity is received. + """ + + persisted_options = "options" + persisted_state = "state" + + def __init__( + self, dialog_id: str, validator: Callable[[PromptValidatorContext], Any] + ): + Dialog.__init__(self, dialog_id) + + if validator is None: + raise TypeError("validator was expected but received None") + self._validator = validator + + async def begin_dialog( + self, dialog_context: DialogContext, options: object = None + ) -> DialogTurnResult: + """Starts the prompt by sending the initial prompt activity. + + Initialises persisted state with an attempt count of 0, then calls + :meth:`on_prompt`. + + :param dialog_context: The dialog context for the current turn. + :param options: Must be a :class:`PromptOptions` instance. + :raises TypeError: If ``options`` is not a :class:`PromptOptions`. + :return: :attr:`Dialog.end_of_turn` to wait for the user's response. + """ + if not dialog_context: + raise TypeError("ActivityPrompt.begin_dialog(): dc cannot be None.") + if not isinstance(options, PromptOptions): + raise TypeError( + "ActivityPrompt.begin_dialog(): Prompt options are required for ActivityPrompts." + ) + + # Ensure prompts have input hint set + if options.prompt is not None and not options.prompt.input_hint: + options.prompt.input_hint = InputHints.expecting_input + + if options.retry_prompt is not None and not options.retry_prompt.input_hint: + options.retry_prompt.input_hint = InputHints.expecting_input + + # Initialize prompt state + assert dialog_context.active_dialog is not None + state: dict[str, object] = dialog_context.active_dialog.state + state[self.persisted_options] = options + state[self.persisted_state] = {Prompt.ATTEMPT_COUNT_KEY: 0} + + # Send initial prompt + await self.on_prompt( + dialog_context.context, + cast(dict[str, object], state[self.persisted_state]), + cast(PromptOptions, state[self.persisted_options]), + False, + ) + + return Dialog.end_of_turn + + async def continue_dialog(self, dialog_context: DialogContext) -> DialogTurnResult: + """Processes the next incoming activity through the prompt. + + Increments the persisted attempt count **before** calling the validator, + so :attr:`PromptValidatorContext.attempt_count` is at least 1 on the + first validation call. + + .. note:: + This differs from the base :class:`Prompt` class, where + ``attempt_count`` is never stored in state and is always 0 when the + validator runs. Code that validates both ``ActivityPrompt`` and + ``Prompt`` subclasses should rely on + :attr:`PromptOptions.number_of_attempts` for consistent counting. + + :param dialog_context: The dialog context for the current turn. + :return: :attr:`Dialog.end_of_turn` while waiting for valid input, or + a Complete result once the validator accepts the activity. + """ + if not dialog_context: + raise TypeError( + "ActivityPrompt.continue_dialog(): DialogContext cannot be None." + ) + + # Perform base recognition + instance = dialog_context.active_dialog + assert instance is not None + state: dict[str, object] = cast( + dict[str, object], instance.state[self.persisted_state] + ) + prompt_options: PromptOptions = cast( + PromptOptions, instance.state[self.persisted_options] + ) + recognized: PromptRecognizerResult = await self.on_recognize( + dialog_context.context, state, prompt_options + ) + + # Increment attempt count + state[Prompt.ATTEMPT_COUNT_KEY] = ( + int(cast(int, state.get(Prompt.ATTEMPT_COUNT_KEY, 0))) + 1 + ) + + # Validate the return value + is_valid = False + if self._validator is not None: + prompt_context = PromptValidatorContext( + dialog_context.context, recognized, state, prompt_options + ) + is_valid = await self._validator(prompt_context) + + prompt_options.number_of_attempts += 1 + elif recognized.succeeded: + is_valid = True + + # Return recognized value or re-prompt + if is_valid: + return await dialog_context.end_dialog(recognized.value) + + if ( + dialog_context.context.activity.type == ActivityTypes.message + and not dialog_context.context.responded + ): + await self.on_prompt(dialog_context.context, state, prompt_options, True) + + return Dialog.end_of_turn + + async def resume_dialog( # pylint: disable=unused-argument + self, dialog_context: DialogContext, reason: DialogReason, result: object = None + ): + assert dialog_context.active_dialog is not None + await self.reprompt_dialog(dialog_context.context, dialog_context.active_dialog) + + return Dialog.end_of_turn + + async def reprompt_dialog(self, context: TurnContext, instance: DialogInstance): + state: dict[str, object] = instance.state[self.persisted_state] + options: PromptOptions = instance.state[self.persisted_options] + await self.on_prompt(context, state, options, False) + + async def on_prompt( + self, + context: TurnContext, + state: dict[str, object], # pylint: disable=unused-argument + options: PromptOptions, + is_retry: bool = False, + ): + """Sends the initial or retry prompt activity to the user. + + Always sets ``input_hint`` to ``expecting_input`` before sending. + + :param context: The context for the current turn. + :param state: Persisted prompt state (unused by default implementation). + :param options: Prompt options containing the prompt and optional retry prompt. + :param is_retry: ``True`` when re-prompting after failed validation. + """ + if is_retry and options.retry_prompt: + options.retry_prompt.input_hint = InputHints.expecting_input + await context.send_activity(options.retry_prompt) + elif options.prompt: + options.prompt.input_hint = InputHints.expecting_input + await context.send_activity(options.prompt) + + async def on_recognize( # pylint: disable=unused-argument + self, context: TurnContext, state: dict[str, object], options: PromptOptions + ) -> PromptRecognizerResult: + """Default recognizer: always succeeds and returns the raw incoming activity. + + Override this in a subclass to restrict which activities are considered + valid (e.g. accept only events with a specific name). + + :param context: The context for the current turn. + :param state: Persisted prompt state. + :param options: Prompt options. + :return: A result with ``succeeded=True`` and ``value`` set to the + current :class:`Activity`. + """ + result = PromptRecognizerResult() + result.succeeded = True + result.value = context.activity + + return result diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/attachment_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/attachment_prompt.py new file mode 100644 index 00000000..0fa8920d --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/attachment_prompt.py @@ -0,0 +1,87 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Callable + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes + +from .prompt import Prompt, PromptValidatorContext +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult + + +class AttachmentPrompt(Prompt): + """ + Prompts a user to upload attachments like images. + + By default the prompt will return to the calling dialog an `[Attachment]` + """ + + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], bool] | None = None, + ): + super().__init__(dialog_id, validator) + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + """Sends the initial or retry prompt activity to the user. + + :param turn_context: The context for the current turn. + :param state: Persisted prompt state (unused by AttachmentPrompt). + :param options: Prompt options containing the prompt and optional retry prompt. + :param is_retry: ``True`` when re-prompting after failed validation. + """ + if not turn_context: + raise TypeError("AttachmentPrompt.on_prompt(): TurnContext cannot be None.") + + if not isinstance(options, PromptOptions): + raise TypeError( + "AttachmentPrompt.on_prompt(): PromptOptions are required for Attachment Prompt dialogs." + ) + + if is_retry and options.retry_prompt: + await turn_context.send_activity(options.retry_prompt) + elif options.prompt: + await turn_context.send_activity(options.prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + """Attempts to recognise attachments from the incoming activity. + + Succeeds only when the activity is a message **and** ``activity.attachments`` + is a non-empty list. The full attachment list is returned as the result. + + .. note:: + A message activity with no attachments (e.g. plain text) will fail + recognition and trigger the retry prompt. + + :param turn_context: The context for the current turn. + :param state: Persisted prompt state (unused by AttachmentPrompt). + :param options: Prompt options (unused by AttachmentPrompt). + :return: Recognition result with ``succeeded=True`` and the list of + :class:`Attachment` objects, or ``succeeded=False`` if none were found. + """ + if not turn_context: + raise TypeError("AttachmentPrompt.on_recognize(): context cannot be None.") + + result = PromptRecognizerResult() + + if turn_context.activity.type == ActivityTypes.message: + message = turn_context.activity + if isinstance(message.attachments, list) and message.attachments: + result.succeeded = True + result.value = message.attachments + + return result diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/choice_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/choice_prompt.py new file mode 100644 index 00000000..001dace1 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/choice_prompt.py @@ -0,0 +1,156 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Callable + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import Activity, ActivityTypes + +from ..choices import ( + Choice, + ChoiceFactoryOptions, + ChoiceRecognizers, + FindChoicesOptions, + ListStyle, +) + +from .prompt import Prompt +from .prompt_culture_models import PromptCultureModels +from .prompt_options import PromptOptions +from .prompt_validator_context import PromptValidatorContext +from .prompt_recognizer_result import PromptRecognizerResult + + +class ChoicePrompt(Prompt): + """ + Prompts a user to select from a list of choices. + + By default the prompt will return to the calling dialog a `FoundChoice` object containing the choice that + was selected. + """ + + _default_choice_options: dict[str, ChoiceFactoryOptions] = { + c.locale: ChoiceFactoryOptions( + inline_separator=c.separator, + inline_or=c.inline_or, + inline_or_more=c.inline_or_more, + include_numbers=True, + ) + for c in PromptCultureModels.get_supported_cultures() + } + + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], bool] | None = None, + default_locale: str | None = None, + choice_defaults: dict[str, ChoiceFactoryOptions] | None = None, + ): + super().__init__(dialog_id, validator) + + self.style = ListStyle.auto + self.default_locale = default_locale + self.choice_options: ChoiceFactoryOptions | None = None + self.recognizer_options: FindChoicesOptions | None = None + + if choice_defaults is not None: + self._default_choice_options = choice_defaults + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + if not turn_context: + raise TypeError("ChoicePrompt.on_prompt(): turn_context cannot be None.") + + if not options: + raise TypeError("ChoicePrompt.on_prompt(): options cannot be None.") + + # Determine culture + culture = self._determine_culture(turn_context.activity) + + # Format prompt to send + choices: list[Choice] = options.choices if options.choices else [] + channel_id: str = turn_context.activity.channel_id or "" + choice_options: ChoiceFactoryOptions = ( + self.choice_options + if self.choice_options + else self._default_choice_options[culture] + ) + choice_style = ( + 0 if options.style == 0 else options.style if options.style else self.style + ) + + if is_retry and options.retry_prompt is not None: + prompt = self.append_choices( + options.retry_prompt, channel_id, choices, choice_style, choice_options + ) + else: + prompt = self.append_choices( + options.prompt, channel_id, choices, choice_style, choice_options + ) + + # Send prompt + await turn_context.send_activity(prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + if not turn_context: + raise TypeError("ChoicePrompt.on_recognize(): turn_context cannot be None.") + + choices: list[Choice] = options.choices if (options and options.choices) else [] + result: PromptRecognizerResult = PromptRecognizerResult() + + if turn_context.activity.type == ActivityTypes.message: + activity: Activity = turn_context.activity + utterance: str = activity.text + if not utterance: + return result + opt: FindChoicesOptions = ( + self.recognizer_options + if self.recognizer_options + else FindChoicesOptions() + ) + opt.locale = self._determine_culture(turn_context.activity, opt) + results = ChoiceRecognizers.recognize_choices(utterance, choices, opt) + + if results is not None and results: + result.succeeded = True + result.value = results[0].resolution + + return result + + def _determine_culture( + self, activity: Activity, opt: FindChoicesOptions | None = None + ) -> str: + """Resolves the culture/locale string to use for choice formatting and recognition. + + Resolution order: + 1. ``activity.locale`` (mapped to the nearest supported language) + 2. ``self.default_locale`` set at construction + 3. ``opt.locale`` from the recognizer options (if provided) + 4. English (``en-us``) as the final fallback + + If the resolved locale is not in ``_default_choice_options``, English is used. + + :param activity: The incoming activity (provides ``locale``). + :param opt: Optional recogniser options (provides ``locale`` fallback). + :return: A locale string present in :attr:`_default_choice_options`. + """ + culture = ( + PromptCultureModels.map_to_nearest_language(activity.locale) + or self.default_locale + or (opt.locale if opt else None) + or PromptCultureModels.English.locale + ) + if not culture or not self._default_choice_options.get(culture): + culture = PromptCultureModels.English.locale + + return culture diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/confirm_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/confirm_prompt.py new file mode 100644 index 00000000..433fdd79 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/confirm_prompt.py @@ -0,0 +1,161 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Any, Callable + +from recognizers_choice import recognize_boolean + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes, Activity + +from ..choices import ( + Choice, + ChoiceFactoryOptions, + ChoiceRecognizers, + ListStyle, +) + +from .prompt import Prompt +from .prompt_culture_models import PromptCultureModels +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult +from .prompt_validator_context import PromptValidatorContext + + +class ConfirmPrompt(Prompt): + """Prompts a user to confirm something with a yes/no response. + + The prompt first attempts to recognise a boolean value using the + ``recognizers_choice`` package (e.g. "yes", "no", "true", "false", locale + equivalents). If that fails and the prompt was configured to include + numbered choices (the default), it falls back to matching choice indices + ("1" → yes, "2" → no). + + Returns ``True`` for confirmation, ``False`` for denial. + + Culture/locale detection uses :class:`PromptCultureModels`. Override + ``default_locale`` or ``choice_defaults`` at construction time to customise + the displayed choices and the locale used for recognition. + """ + + _default_choice_options: dict[str, tuple[Choice, Choice, ChoiceFactoryOptions]] = { + c.locale: ( + Choice(c.yes_in_language), + Choice(c.no_in_language), + ChoiceFactoryOptions(c.separator, c.inline_or, c.inline_or_more, True), + ) + for c in PromptCultureModels.get_supported_cultures() + } + + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], Any] | None = None, + default_locale: str | None = None, + choice_defaults: ( + dict[str, tuple[Choice, Choice, ChoiceFactoryOptions]] | None + ) = None, + ): + super().__init__(dialog_id, validator) + if dialog_id is None: + raise TypeError("ConfirmPrompt(): dialog_id cannot be None.") + self.style = ListStyle.auto + self.default_locale = default_locale + self.choice_options = None + self.confirm_choices = None + + if choice_defaults is not None: + self._default_choice_options = choice_defaults + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + if not turn_context: + raise TypeError("ConfirmPrompt.on_prompt(): turn_context cannot be None.") + if not options: + raise TypeError("ConfirmPrompt.on_prompt(): options cannot be None.") + + # Format prompt to send + channel_id = turn_context.activity.channel_id or "" + culture = self._determine_culture(turn_context.activity) + defaults = self._default_choice_options[culture] + choice_opts = ( + self.choice_options if self.choice_options is not None else defaults[2] + ) + confirms = ( + self.confirm_choices + if self.confirm_choices is not None + else (defaults[0], defaults[1]) + ) + choices = [confirms[0], confirms[1]] + if is_retry and options.retry_prompt is not None: + prompt = self.append_choices( + options.retry_prompt, channel_id, choices, self.style, choice_opts + ) + else: + prompt = self.append_choices( + options.prompt, channel_id, choices, self.style, choice_opts + ) + await turn_context.send_activity(prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + if not turn_context: + raise TypeError("ConfirmPrompt.on_prompt(): turn_context cannot be None.") + + result = PromptRecognizerResult() + if turn_context.activity.type == ActivityTypes.message: + # Recognize utterance + utterance = turn_context.activity.text + if not utterance: + return result + culture = self._determine_culture(turn_context.activity) + results = recognize_boolean(utterance, culture) + if results: + first = results[0] + if "value" in first.resolution: + result.succeeded = True + result.value = first.resolution["value"] + else: + # First check whether the prompt was sent to the user with numbers + defaults = self._default_choice_options[culture] + opts = ( + self.choice_options + if self.choice_options is not None + else defaults[2] + ) + + if opts.include_numbers is None or opts.include_numbers: + confirm_choices = ( + self.confirm_choices + if self.confirm_choices is not None + else (defaults[0], defaults[1]) + ) + choices = [confirm_choices[0], confirm_choices[1]] + second_attempt_results = ChoiceRecognizers.recognize_choices( + utterance, choices + ) + if second_attempt_results: + result.succeeded = True + result.value = second_attempt_results[0].resolution.index == 0 + + return result + + def _determine_culture(self, activity: Activity) -> str: + culture = ( + PromptCultureModels.map_to_nearest_language(activity.locale) + or self.default_locale + or PromptCultureModels.English.locale + ) + if not culture or not self._default_choice_options.get(culture): + culture = PromptCultureModels.English.locale + + return culture diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_prompt.py new file mode 100644 index 00000000..22563c2c --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_prompt.py @@ -0,0 +1,90 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Any, Callable, cast + +from recognizers_date_time import recognize_datetime +from recognizers_text import Culture + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes + +from .datetime_resolution import DateTimeResolution +from .prompt import Prompt +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult +from .prompt_validator_context import PromptValidatorContext + + +class DateTimePrompt(Prompt): + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], Any] | None = None, + default_locale: str | None = None, + ): + super(DateTimePrompt, self).__init__(dialog_id, validator) + self.default_locale = default_locale + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + if not turn_context: + raise TypeError("DateTimePrompt.on_prompt(): turn_context cannot be None.") + if not options: + raise TypeError("DateTimePrompt.on_prompt(): options cannot be None.") + + if is_retry and options.retry_prompt is not None: + await turn_context.send_activity(options.retry_prompt) + else: + if options.prompt is not None: + await turn_context.send_activity(options.prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + if not turn_context: + raise TypeError( + "DateTimePrompt.on_recognize(): turn_context cannot be None." + ) + + result = PromptRecognizerResult() + if turn_context.activity.type == ActivityTypes.message: + # Recognize utterance + utterance = turn_context.activity.text + if not utterance: + return result + culture = ( + turn_context.activity.locale or self.default_locale or Culture.English + ) + + results = recognize_datetime(utterance, culture) + if results: + result.succeeded = True + result.value = [] + values = cast(list, results[0].resolution["values"]) + for value in values: + cast(list, result.value).append(self.read_resolution(value)) + + return result + + def read_resolution(self, resolution: dict[str, str]) -> DateTimeResolution: + result = DateTimeResolution() + + if "timex" in resolution: + result.timex = resolution["timex"] + if "value" in resolution: + result.value = resolution["value"] + if "start" in resolution: + result.start = resolution["start"] + if "end" in resolution: + result.end = resolution["end"] + + return result diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_resolution.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_resolution.py new file mode 100644 index 00000000..fa4bf4b5 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/datetime_resolution.py @@ -0,0 +1,16 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + + +class DateTimeResolution: + def __init__( + self, + value: str | None = None, + start: str | None = None, + end: str | None = None, + timex: str | None = None, + ): + self.value = value + self.start = start + self.end = end + self.timex = timex diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/number_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/number_prompt.py new file mode 100644 index 00000000..f4f688d0 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/number_prompt.py @@ -0,0 +1,81 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Callable, cast + +from recognizers_number import recognize_number +from recognizers_text import Culture, ModelResult +from babel.numbers import parse_decimal + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes + +from .prompt import Prompt, PromptValidatorContext +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult + + +class NumberPrompt(Prompt): + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], bool] | None = None, + default_locale: str | None = None, + ): + super(NumberPrompt, self).__init__(dialog_id, validator) + self.default_locale = default_locale + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + if not turn_context: + raise TypeError("NumberPrompt.on_prompt(): turn_context cannot be None.") + if not options: + raise TypeError("NumberPrompt.on_prompt(): options cannot be None.") + + if is_retry and options.retry_prompt is not None: + await turn_context.send_activity(options.retry_prompt) + elif options.prompt is not None: + await turn_context.send_activity(options.prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + if not turn_context: + raise TypeError("NumberPrompt.on_recognize(): turn_context cannot be None.") + + result = PromptRecognizerResult() + if turn_context.activity.type == ActivityTypes.message: + utterance = turn_context.activity.text + if not utterance: + return result + culture = self._get_culture(turn_context) + results: list[ModelResult] = recognize_number(utterance, culture) + + if results: + result.succeeded = True + result.value = parse_decimal( + cast(str, results[0].resolution["value"]), + locale=culture.replace("-", "_"), + ) + + return result + + def _get_culture(self, turn_context: TurnContext): + culture = ( + turn_context.activity.locale + if turn_context.activity.locale + else self.default_locale + ) + + if not culture: + culture = Culture.English + + return culture diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt.py new file mode 100644 index 00000000..aade7e97 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt.py @@ -0,0 +1,569 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import logging +from datetime import datetime, timedelta +from http import HTTPStatus +from typing import cast + +from microsoft_agents.activity import ( + Channels, + Activity, + ActivityTypes, + ActionTypes, + CardAction, + InputHints, + SigninCard, + SignInConstants, + OAuthCard, + TokenResponse, + TokenExchangeInvokeRequest, + TokenExchangeInvokeResponse, + InvokeResponse, +) +from microsoft_agents.hosting.core import ( + CardFactory, + MessageFactory, + TurnContext, + ChannelAdapter, + ClaimsIdentity, + UserTokenClient, + MemoryStorage, +) +from microsoft_agents.hosting.core._oauth import ( + _OAuthFlow, + _FlowStorageClient, + _FlowState, + _FlowStateTag, + _FlowResponse, +) +from opentelemetry import context + +from ..dialog import Dialog +from ..dialog_context import DialogContext +from ..models.dialog_turn_result import DialogTurnResult +from .prompt_options import PromptOptions +from .oauth_prompt_settings import OAuthPromptSettings + +logger = logging.getLogger(__name__) + + +class CallerInfo: + def __init__(self, caller_service_url: str | None = None, scope: str | None = None): + self.caller_service_url = caller_service_url + self.scope = scope + + +class OAuthPrompt(Dialog): + PERSISTED_OPTIONS = "options" + PERSISTED_STATE = "state" + PERSISTED_EXPIRES = "expires" + PERSISTED_CALLER = "caller" + + """ + Creates a new prompt that asks the user to sign in. + """ + + def __init__( + self, + dialog_id: str, + settings: OAuthPromptSettings, + ): + super().__init__(dialog_id) + self._storage = MemoryStorage() # to keep track of the OAuth flow state + + if not settings: + raise TypeError( + "OAuthPrompt.__init__(): OAuthPrompt requires OAuthPromptSettings." + ) + + self._settings = settings + + @staticmethod + def _get_user_token_client(context: TurnContext) -> UserTokenClient: + return context.turn_state.get(context.adapter.USER_TOKEN_CLIENT_KEY) + + def _get_app_id(self, context: TurnContext) -> str: + if ( + hasattr(self._settings, "oauth_app_credentials") + and self._settings.oauth_app_credentials + and hasattr(self._settings.oauth_app_credentials, "app_id") + ): + return self._settings.oauth_app_credentials.app_id + return context._identity.claims.get("aud", "") + + async def _load_flow( + self, context: TurnContext + ) -> tuple[_OAuthFlow, _FlowStorageClient]: + """Loads the OAuth flow. + + A new flow is created in Storage if none exists for the channel, user, and handler + combination. + + :param context: The context object for the current turn. + :type context: TurnContext + :return: A tuple containing the OAuthFlow and FlowStorageClient created from the + context and the specified auth handler. + :rtype: tuple[OAuthFlow, FlowStorageClient] + """ + user_token_client = OAuthPrompt._get_user_token_client(context) + + if ( + not context.activity.channel_id + or not context.activity.from_property + or not context.activity.from_property.id + ): + raise ValueError("Channel ID and User ID are required") + + channel_id = context.activity.channel_id + user_id = context.activity.from_property.id + + ms_app_id = self._get_app_id(context) + + # try to load existing state + flow_storage_client = _FlowStorageClient(channel_id, user_id, self._storage) + logger.info("Loading OAuth flow state from storage") + flow_state: _FlowState | None = await flow_storage_client.read(self._id) + if not flow_state: + logger.info("No existing flow state found, creating new flow state") + flow_state = _FlowState( + channel_id=channel_id, + user_id=user_id, + auth_handler_id=self._id, + connection=self._settings.connection_name, + ms_app_id=ms_app_id, + ) + + timeout = ( + self._settings.timeout + if isinstance(self._settings.timeout, int) + else 900000 + ) + + flow = _OAuthFlow( + flow_state, + user_token_client, + default_flow_duration=timeout, + ) + return flow, flow_storage_client + + async def begin_dialog( + self, dialog_context: DialogContext, options: object = None + ) -> DialogTurnResult: + if dialog_context is None: + raise TypeError( + f"OAuthPrompt.begin_dialog(): Expected DialogContext but got NoneType instead" + ) + + prompt_options = ( + options if isinstance(options, PromptOptions) else None + ) or PromptOptions() + + # Ensure prompts have input hint set + if prompt_options.prompt and not prompt_options.prompt.input_hint: + prompt_options.prompt.input_hint = InputHints.accepting_input + + if prompt_options.retry_prompt and not prompt_options.retry_prompt.input_hint: + prompt_options.retry_prompt.input_hint = InputHints.accepting_input + + # Initialize prompt state + timeout = ( + self._settings.timeout + if isinstance(self._settings.timeout, int) + else 900000 + ) + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + state[OAuthPrompt.PERSISTED_STATE] = {} + state[OAuthPrompt.PERSISTED_OPTIONS] = prompt_options + state[OAuthPrompt.PERSISTED_EXPIRES] = datetime.now() + timedelta( + seconds=timeout / 1000 + ) + state[OAuthPrompt.PERSISTED_CALLER] = OAuthPrompt.__create_caller_info( + dialog_context.context + ) + + flow, flow_storage_client = await self._load_flow(dialog_context.context) + + flow_response: _FlowResponse = await flow.begin_flow( + dialog_context.context.activity + ) + + await flow_storage_client.write(flow_response.flow_state) + + if flow_response.flow_state.tag == _FlowStateTag.COMPLETE: + return await dialog_context.end_dialog(flow_response.token_response) + + await self._send_oauth_card( + dialog_context.context, flow_response, prompt_options.prompt + ) + return Dialog.end_of_turn + + async def continue_dialog(self, dialog_context: DialogContext) -> DialogTurnResult: + + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + + # Check for timeout + expires = state.get(OAuthPrompt.PERSISTED_EXPIRES) + if expires and datetime.now() > expires: + return await dialog_context.end_dialog(None) + + flow_response = await self._continue_flow(dialog_context.context) + + if ( + flow_response is not None + and flow_response.flow_state.tag == _FlowStateTag.COMPLETE + ): + return await dialog_context.end_dialog(flow_response.token_response) + + if ( + dialog_context.context.activity.type == ActivityTypes.message + and self._settings.end_on_invalid_message + ): + return await dialog_context.end_dialog(None) + + if ( + not dialog_context.context.responded + and dialog_context.context.activity.type == ActivityTypes.message + and state[OAuthPrompt.PERSISTED_OPTIONS].retry_prompt is not None + ): + await dialog_context.context.send_activity( + state[OAuthPrompt.PERSISTED_OPTIONS].retry_prompt + ) + + return Dialog.end_of_turn + + async def get_user_token( + self, context: TurnContext, code: str = "" + ) -> TokenResponse: + """ + Gets the user's token. + """ + flow, _ = await self._load_flow(context) + return await flow.get_user_token(code) + + async def sign_out_user(self, context: TurnContext): + """ + Signs out the user. + """ + flow, flow_storage_client = await self._load_flow(context) + await flow.sign_out() + await flow_storage_client.delete( + self._id + ) # Clear flow state from storage after signing out + + @staticmethod + def __create_caller_info(context: TurnContext) -> CallerInfo | None: + bot_identity = cast( + ClaimsIdentity | None, + context.turn_state.get(ChannelAdapter.AGENT_IDENTITY_KEY), + ) + if bot_identity and bot_identity.is_agent_claim(): + return CallerInfo( + caller_service_url=context.activity.service_url, + scope=bot_identity.get_app_id(), + ) + + return None + + async def _send_oauth_card( + self, + context: TurnContext, + flow_response: _FlowResponse, + prompt: Activity | str | None = None, + ): + if not isinstance(prompt, Activity): + prompt = MessageFactory.text(prompt or "", None, InputHints.accepting_input) + else: + prompt.input_hint = prompt.input_hint or InputHints.accepting_input + + prompt.attachments = prompt.attachments or [] + + if OAuthPrompt._channel_suppports_oauth_card(context.activity.channel_id or ""): + if not any( + att.content_type == CardFactory.content_types.oauth_card + for att in prompt.attachments + ): + card_action_type = ActionTypes.signin + sign_in_resource = flow_response.sign_in_resource + link = sign_in_resource.sign_in_link + bot_identity = cast( + ClaimsIdentity | None, + context.turn_state.get(ChannelAdapter.AGENT_IDENTITY_KEY), + ) + + # use the SignInLink when in speech channel or bot is a skill or + # an extra OAuthAppCredentials is being passed in + if ( + (bot_identity and bot_identity.is_agent_claim()) + or not context.activity.service_url.startswith("http") + or ( + hasattr(self._settings, "oauth_app_credentials") + and self._settings.oauth_app_credentials + ) + ): + if context.activity.channel_id == Channels.emulator: + card_action_type = ActionTypes.open_url + elif not OAuthPrompt._channel_requires_sign_in_link( + context.activity.channel_id or "" + ): + link = None + + json_token_ex_resource = ( + sign_in_resource.token_exchange_resource.model_dump() + if sign_in_resource.token_exchange_resource + else None + ) + + json_token_ex_post = ( + sign_in_resource.token_post_resource.model_dump() + if hasattr(sign_in_resource, "token_post_resource") + and sign_in_resource.token_post_resource + else None + ) + + card_action_kwargs = { + "title": self._settings.title, + "type": card_action_type, + "value": link, + } + if self._settings.text: + card_action_kwargs["text"] = self._settings.text + oauth_card_kwargs = { + "connection_name": self._settings.connection_name, + "buttons": [CardAction(**card_action_kwargs)], + "token_exchange_resource": json_token_ex_resource, + } + if self._settings.text: + oauth_card_kwargs["text"] = self._settings.text + if json_token_ex_post: + oauth_card_kwargs["token_post_resource"] = json_token_ex_post + prompt.attachments.append( + CardFactory.oauth_card(OAuthCard(**oauth_card_kwargs)) + ) + else: + if not any( + att.content_type == CardFactory.content_types.signin_card + for att in prompt.attachments + ): + if not hasattr(context.adapter, "get_oauth_sign_in_link"): + raise Exception( + "OAuthPrompt._send_oauth_card(): get_oauth_sign_in_link() not supported by the current adapter" + ) + + link = await context.adapter.get_oauth_sign_in_link( + context, + self._settings.connection_name, + ) + prompt.attachments.append( + CardFactory.signin_card( + SigninCard( + text=self._settings.text or "", + buttons=[ + CardAction( + title=self._settings.title, + value=link, + type=ActionTypes.signin, + ) + ], + ) + ) + ) + + # Send prompt + await context.send_activity(prompt) + + @staticmethod + def _validate_token_exchange_invoke_response( + activity: Activity, + ) -> TokenExchangeInvokeRequest: + activity_value = activity.value + if isinstance(activity_value, dict): + activity_value = TokenExchangeInvokeRequest.model_validate(activity_value) + return cast(TokenExchangeInvokeRequest, activity_value) + + def _validate_continue_flow(self, context: TurnContext) -> Activity | None: + if self._is_token_exchange_request_invoke(context): + activity_value = context.activity.value + if isinstance(activity_value, dict): + activity_value = TokenExchangeInvokeRequest.model_validate( + activity_value + ) + + token_exchange_invoke_request = ( + OAuthPrompt._validate_token_exchange_invoke_response(context.activity) + ) + + if not ( + token_exchange_invoke_request + and self._is_token_exchange_request(token_exchange_invoke_request) + ): + # Received activity is not a token exchange request. + return self._get_token_exchange_invoke_response( + int(HTTPStatus.BAD_REQUEST), + "The bot received an InvokeActivity that is missing a TokenExchangeInvokeRequest value." + " This is required to be sent with the InvokeActivity.", + ) + elif ( + token_exchange_invoke_request.connection_name + != self._settings.connection_name + ): + # Connection name on activity does not match that of setting. + return self._get_token_exchange_invoke_response( + int(HTTPStatus.BAD_REQUEST), + "The bot received an InvokeActivity with a TokenExchangeInvokeRequest containing a" + " ConnectionName that does not match the ConnectionName expected by the bots active" + " OAuthPrompt. Ensure these names match when sending the InvokeActivity.", + ) + + async def _exchange_token( + self, context: TurnContext, input_token_response: TokenResponse | None + ) -> TokenResponse | None: + if not input_token_response: + return input_token_response + + user_id = context.activity.from_property.id + channel_id = ( + context.activity.channel_id.channel if context.activity.channel_id else "" + ) + + user_token_client = OAuthPrompt._get_user_token_client(context) + + return await user_token_client.user_token.exchange_token( + user_id, + self._settings.connection_name, + channel_id, + {"token": input_token_response.token}, + ) + + async def _continue_flow( + self, + context: TurnContext, + ) -> _FlowResponse | None: + + flow_response: _FlowResponse | None = None + + error_response = self._validate_continue_flow(context) + if error_response: + await context.send_activity(error_response) + + # do something here + + if error_response is None: + + flow, flow_storage_client = await self._load_flow(context) + + try: + flow_response = await flow.continue_flow(context.activity) + except Exception: + error_response = Activity( # type: ignore[call-arg] + type=ActivityTypes.invoke_response, + value=InvokeResponse(status=HTTPStatus.INTERNAL_SERVER_ERROR), + ) + + if error_response is None: + assert flow_response is not None + await flow_storage_client.write(flow.flow_state) + + token_response: TokenResponse | None = flow_response.token_response + + if OAuthPrompt._is_teams_verification_invoke(context): + if token_response: + await context.send_activity( + Activity( # type: ignore[call-arg] + type=ActivityTypes.invoke_response, + value=InvokeResponse(status=HTTPStatus.OK), + ) + ) + else: + await context.send_activity( + Activity( # type: ignore[call-arg] + type=ActivityTypes.invoke_response, + value=InvokeResponse(status=HTTPStatus.NOT_FOUND), + ) + ) + elif self._is_token_exchange_request_invoke(context): + + token_exchange_response: TokenResponse | None = None + + token_exchange_response = await self._exchange_token( + context, token_response + ) + + if token_exchange_response: + await context.send_activity( + Activity( # type: ignore[call-arg] + type=ActivityTypes.invoke_response, + value=InvokeResponse(status=HTTPStatus.OK), + ) + ) + else: + await context.send_activity( + self._get_token_exchange_invoke_response( + int(HTTPStatus.PRECONDITION_FAILED), + "The bot is unable to exchange token. Proceed with regular login.", + ) + ) + + return flow_response + + def _get_token_exchange_invoke_response( + self, status: int, failure_detail: str | None + ) -> Activity: + body = {"connectionName": self._settings.connection_name} + if failure_detail: + body["failureDetail"] = failure_detail + return Activity( # type: ignore[call-arg] + type=ActivityTypes.invoke_response, + value=InvokeResponse(status=status, body=body), + ) + + @staticmethod + def _is_token_response_event(context: TurnContext) -> bool: + activity = context.activity + + return ( + activity.type == ActivityTypes.event + and activity.name == SignInConstants.token_response_event_name + ) + + @staticmethod + def _is_teams_verification_invoke(context: TurnContext) -> bool: + activity = context.activity + + return ( + activity.type == ActivityTypes.invoke + and activity.name == SignInConstants.verify_state_operation_name + ) + + @staticmethod + def _channel_suppports_oauth_card(channel_id: str) -> bool: + if channel_id in [ + Channels.cortana, + Channels.skype, + Channels.skype_for_business, + ]: + return False + + return True + + @staticmethod + def _channel_requires_sign_in_link(channel_id: str) -> bool: + if channel_id in [Channels.ms_teams]: + return True + + return False + + @staticmethod + def _is_token_exchange_request_invoke(context: TurnContext) -> bool: + activity = context.activity + + return ( + activity.type == ActivityTypes.invoke + and activity.name == SignInConstants.token_exchange_operation_name + ) + + @staticmethod + def _is_token_exchange_request(obj: TokenExchangeInvokeRequest) -> bool: + return bool(obj.connection_name) and bool(obj.token) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt_settings.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt_settings.py new file mode 100644 index 00000000..8fd2b6c8 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/oauth_prompt_settings.py @@ -0,0 +1,43 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +class OAuthPromptSettings: + def __init__( + self, + connection_name: str, + title: str, + text: str | None = None, + timeout: int | None = None, + oauth_app_credentials=None, + end_on_invalid_message: bool = False, + ): + """ + Settings used to configure an `OAuthPrompt` instance. + Parameters: + connection_name (str): Name of the OAuth connection being used. + title (str): The title of the cards signin button. + text (str): (Optional) additional text included on the signin card. + timeout (int): (Optional) number of milliseconds the prompt will wait for the user to authenticate. + `OAuthPrompt` defaults value to `900,000` ms (15 minutes). + oauth_app_credentials (AppCredentials): (Optional) AppCredentials to use for OAuth. If None, + the Agent credentials are used. + end_on_invalid_message (bool): (Optional) value indicating whether the OAuthPrompt should end upon + receiving an invalid message. Generally the OAuthPrompt will ignore incoming messages from the + user during the auth flow, if they are not related to the auth flow. This flag enables ending the + OAuthPrompt rather than ignoring the user's message. Typically, this flag will be set to 'true', + but is 'false' by default for backwards compatibility. + """ + self.connection_name = connection_name + self.title = title + self.text = text + self.timeout = timeout + self.oauth_app_credentials = oauth_app_credentials + self.end_on_invalid_message = end_on_invalid_message + + @property + def oath_app_credentials(self): + """Backward-compatible alias for the misspelled attribute name.""" + return self.oauth_app_credentials + + @oath_app_credentials.setter + def oath_app_credentials(self, value): + self.oauth_app_credentials = value diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt.py new file mode 100644 index 00000000..e7cff1c6 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt.py @@ -0,0 +1,224 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from abc import abstractmethod +import copy +from typing import Any, Callable, Awaitable, cast + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import InputHints, ActivityTypes, Activity + +from ..choices import ( + Choice, + ChoiceFactory, + ChoiceFactoryOptions, + ListStyle, +) +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult +from .prompt_validator_context import PromptValidatorContext +from ..models.dialog_reason import DialogReason +from ..dialog import Dialog +from ..models.dialog_instance import DialogInstance +from ..models.dialog_turn_result import DialogTurnResult +from ..dialog_context import DialogContext + + +class Prompt(Dialog): + """ + Defines the core behavior of prompt dialogs. Extends the Dialog base class. + """ + + ATTEMPT_COUNT_KEY = "AttemptCount" + persisted_options = "options" + persisted_state = "state" + + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], Any] | None = None, + ): + """ + Creates a new Prompt instance. + """ + super(Prompt, self).__init__(dialog_id) + self._validator = validator + + async def begin_dialog( + self, dialog_context: DialogContext, options: object = None + ) -> DialogTurnResult: + if not dialog_context: + raise TypeError("Prompt(): dc cannot be None.") + if not isinstance(options, PromptOptions): + raise TypeError("Prompt(): Prompt options are required for Prompt dialogs.") + + # Ensure prompts have input hint set + if options.prompt is not None and not options.prompt.input_hint: + options.prompt.input_hint = InputHints.expecting_input + + if options.retry_prompt is not None and not options.retry_prompt.input_hint: + options.retry_prompt.input_hint = InputHints.expecting_input + + # Initialize prompt state + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + state[self.persisted_options] = options + state[self.persisted_state] = {self.ATTEMPT_COUNT_KEY: 0} + + # Send initial prompt + await self.on_prompt( + dialog_context.context, + state[self.persisted_state], + state[self.persisted_options], + False, + ) + + return Dialog.end_of_turn + + async def continue_dialog(self, dialog_context: DialogContext): + if not dialog_context: + raise TypeError("Prompt(): dc cannot be None.") + + # Don't do anything for non-message activities + if dialog_context.context.activity.type != ActivityTypes.message: + return Dialog.end_of_turn + + # Perform base recognition + instance = dialog_context.active_dialog + assert instance is not None + state = cast(dict[str, object], instance.state[self.persisted_state]) + options = cast(PromptOptions, instance.state[self.persisted_options]) + recognized = await self.on_recognize(dialog_context.context, state, options) + + # Validate the return value + is_valid = False + state[self.ATTEMPT_COUNT_KEY] = ( + int(cast(int, state.get(self.ATTEMPT_COUNT_KEY, 0))) + 1 + ) + if self._validator is not None: + prompt_context = PromptValidatorContext( + dialog_context.context, recognized, state, options + ) + is_valid = await self._validator(prompt_context) + if options is None: + options = PromptOptions() + options.number_of_attempts += 1 + else: + if recognized.succeeded: + is_valid = True + + # Return recognized value or re-prompt + if is_valid: + return await dialog_context.end_dialog(recognized.value) + + if not dialog_context.context.responded: + await self.on_prompt(dialog_context.context, state, options, True) + return Dialog.end_of_turn + + async def resume_dialog( + self, dialog_context: DialogContext, reason: DialogReason, result: object + ) -> DialogTurnResult: + assert dialog_context.active_dialog is not None + await self.reprompt_dialog(dialog_context.context, dialog_context.active_dialog) + return Dialog.end_of_turn + + async def reprompt_dialog(self, context: TurnContext, instance: DialogInstance): + state = instance.state[self.persisted_state] + options = instance.state[self.persisted_options] + await self.on_prompt(context, state, options, False) + + @abstractmethod + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + pass + + @abstractmethod + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + pass + + def append_choices( + self, + prompt: Activity | None, + channel_id: str, + choices: list[Choice], + style: ListStyle | int, + options: ChoiceFactoryOptions | None = None, + ) -> Activity: + """ + Composes an output activity containing a set of choices. + """ + # Get base prompt text (if any) + text = prompt.text if prompt is not None and prompt.text else "" + + # Create temporary msg + def inline() -> Activity: + return ChoiceFactory.inline(choices, text, None, options) + + def list_style() -> Activity: + return ChoiceFactory.list_style(choices, text, None, options) + + def suggested_action() -> Activity: + return ChoiceFactory.suggested_action(choices, text) + + def hero_card() -> Activity: + return ChoiceFactory.hero_card(choices, text) + + def list_style_none() -> Activity: + from microsoft_agents.activity import ( + Activity as _Activity, + ActivityTypes as _AT, + ) + + activity = _Activity(type=_AT.message) # type: ignore[call-arg] + activity.text = text + return activity + + def default() -> Activity: + return ChoiceFactory.for_channel(channel_id, choices, text, None, options) + + # Maps to values in ListStyle Enum + switcher = { + 0: list_style_none, + 1: default, + 2: inline, + 3: list_style, + 4: suggested_action, + 5: hero_card, + } + + msg = switcher.get(int(style), default)() + + # Update prompt with text, actions and attachments + if prompt: + # clone the prompt set in the options + prompt = copy.copy(prompt) + + prompt.text = msg.text + + if ( + msg.suggested_actions is not None + and msg.suggested_actions.actions is not None + and msg.suggested_actions.actions + ): + prompt.suggested_actions = msg.suggested_actions + + if msg.attachments: + if prompt.attachments: + prompt.attachments.extend(msg.attachments) + else: + prompt.attachments = msg.attachments + + return prompt + + msg.input_hint = None # type: ignore[assignment] + return msg diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_culture_models.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_culture_models.py new file mode 100644 index 00000000..58d51bb1 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_culture_models.py @@ -0,0 +1,222 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from recognizers_text import Culture + + +class PromptCultureModel: + """ + Culture model used in Choice and Confirm Prompts. + """ + + def __init__( + self, + locale: str, + separator: str, + inline_or: str, + inline_or_more: str, + yes_in_language: str, + no_in_language: str, + ): + """ + + :param locale: Culture Model's Locale. Example: "en-US". + :param separator: Culture Model's Inline Separator. Example: ", ". + :param inline_or: Culture Model's Inline Or. Example: " or ". + :param inline_or_more Culture Model's Inline Or More. Example: ", or ". + :param yes_in_language: Equivalent of "Yes" in Culture Model's Language. Example: "Yes". + :param no_in_language: Equivalent of "No" in Culture Model's Language. Example: "No". + """ + self.locale = locale + self.separator = separator + self.inline_or = inline_or + self.inline_or_more = inline_or_more + self.yes_in_language = yes_in_language + self.no_in_language = no_in_language + + +class PromptCultureModels: + """ + Class container for currently-supported Culture Models in Confirm and Choice Prompt. + """ + + Bulgarian = PromptCultureModel( + # TODO: Replace with Culture.Bulgarian after Recognizers-Text package updates. + locale="bg-bg", + inline_or=" или ", + inline_or_more=", или ", + separator=", ", + no_in_language="Не", + yes_in_language="да", + ) + + Chinese = PromptCultureModel( + locale=Culture.Chinese, + inline_or=" 要么 ", + inline_or_more="， 要么 ", + separator="， ", + no_in_language="不", + yes_in_language="是的", + ) + + Dutch = PromptCultureModel( + locale=Culture.Dutch, + inline_or=" of ", + inline_or_more=", of ", + separator=", ", + no_in_language="Nee", + yes_in_language="Ja", + ) + + English = PromptCultureModel( + locale=Culture.English, + inline_or=" or ", + inline_or_more=", or ", + separator=", ", + no_in_language="No", + yes_in_language="Yes", + ) + + Hindi = PromptCultureModel( + # TODO: Replace with Culture.Hindi after Recognizers-Text package updates. + locale="hi-in", + inline_or=" या ", + inline_or_more=", या ", + separator=", ", + no_in_language="नहीं", + yes_in_language="हां", + ) + + French = PromptCultureModel( + locale=Culture.French, + inline_or=" ou ", + inline_or_more=", ou ", + separator=", ", + no_in_language="Non", + yes_in_language="Oui", + ) + + German = PromptCultureModel( + # TODO: Replace with Culture.German after Recognizers-Text package updates. + locale="de-de", + inline_or=" oder ", + inline_or_more=", oder ", + separator=", ", + no_in_language="Nein", + yes_in_language="Ja", + ) + + Italian = PromptCultureModel( + locale=Culture.Italian, + inline_or=" o ", + inline_or_more=" o ", + separator=", ", + no_in_language="No", + yes_in_language="Si", + ) + + Japanese = PromptCultureModel( + locale=Culture.Japanese, + inline_or=" または ", + inline_or_more="、 または ", + separator="、 ", + no_in_language="いいえ", + yes_in_language="はい", + ) + + Korean = PromptCultureModel( + locale=Culture.Korean, + inline_or=" 또는 ", + inline_or_more=" 또는 ", + separator=", ", + no_in_language="아니", + yes_in_language="예", + ) + + Portuguese = PromptCultureModel( + locale=Culture.Portuguese, + inline_or=" ou ", + inline_or_more=", ou ", + separator=", ", + no_in_language="Não", + yes_in_language="Sim", + ) + + Spanish = PromptCultureModel( + locale=Culture.Spanish, + inline_or=" o ", + inline_or_more=", o ", + separator=", ", + no_in_language="No", + yes_in_language="Sí", + ) + + Swedish = PromptCultureModel( + # TODO: Replace with Culture.Swedish after Recognizers-Text package updates. + locale="sv-se", + inline_or=" eller ", + inline_or_more=" eller ", + separator=", ", + no_in_language="Nej", + yes_in_language="Ja", + ) + + Turkish = PromptCultureModel( + locale=Culture.Turkish, + inline_or=" veya ", + inline_or_more=" veya ", + separator=", ", + no_in_language="Hayır", + yes_in_language="Evet", + ) + + @classmethod + def map_to_nearest_language(cls, culture_code: str) -> str: + """ + Normalize various potential locale strings to a standard. + :param culture_code: Represents locale. Examples: "en-US, en-us, EN". + :return: Normalized locale. + :rtype: str + + .. remarks:: + In our other SDKs, this method is a copy/paste of the ones from the Recognizers-Text library. + However, that doesn't exist in Python. + """ + if culture_code: + culture_code = culture_code.lower() + supported_culture_codes = cls._get_supported_locales() + + if culture_code not in supported_culture_codes: + culture_prefix = culture_code.split("-")[0] + + for supported_culture_code in supported_culture_codes: + if supported_culture_code.startswith(culture_prefix): + culture_code = supported_culture_code + + return culture_code + + @classmethod + def get_supported_cultures(cls) -> list[PromptCultureModel]: + """ + Gets a list of the supported culture models. + """ + return [ + cls.Bulgarian, + cls.Chinese, + cls.Dutch, + cls.English, + cls.French, + cls.German, + cls.Hindi, + cls.Italian, + cls.Japanese, + cls.Korean, + cls.Portuguese, + cls.Spanish, + cls.Swedish, + cls.Turkish, + ] + + @classmethod + def _get_supported_locales(cls) -> list[str]: + return [c.locale for c in cls.get_supported_cultures()] diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_options.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_options.py new file mode 100644 index 00000000..a55b0aaa --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_options.py @@ -0,0 +1,42 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.activity import Activity +from microsoft_agents.hosting.dialogs.choices import Choice, ListStyle + + +class PromptOptions: + """ + Contains settings to pass to a :class:`Prompt` object when the prompt is started. + """ + + def __init__( + self, + prompt: Activity | None = None, + retry_prompt: Activity | None = None, + choices: list[Choice] | None = None, + style: ListStyle | None = None, + validations: object = None, + number_of_attempts: int = 0, + ): + """ + Contains settings to pass to a :class:`Prompt` when the prompt is started. + + :param prompt: The initial prompt activity to send to the user. + :type prompt: :class:`microsoft_agents.activity.Activity` + :param retry_prompt: The activity to send when the user's input fails validation. + :type retry_prompt: :class:`microsoft_agents.activity.Activity` + :param choices: The list of choices presented to the user (used by :class:`ChoicePrompt`). + :type choices: list[:class:`microsoft_agents.hosting.dialogs.choices.Choice`] + :param style: Controls how the choice list is rendered. + :type style: :class:`microsoft_agents.hosting.dialogs.choices.ListStyle` + :param validations: Additional validation data passed through to a custom validator. + :param number_of_attempts: Running count of how many times the prompt has been retried. + :type number_of_attempts: int + """ + self.prompt = prompt + self.retry_prompt = retry_prompt + self.choices = choices + self.style = style + self.validations = validations + self.number_of_attempts = number_of_attempts diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_recognizer_result.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_recognizer_result.py new file mode 100644 index 00000000..d2039b24 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_recognizer_result.py @@ -0,0 +1,11 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +"""Result returned by a prompts recognizer function.""" + + +class PromptRecognizerResult: + def __init__(self, succeeded: bool = False, value: object = None): + """Creates result returned by a prompts recognizer function.""" + self.succeeded = succeeded + self.value = value diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_validator.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_validator.py new file mode 100644 index 00000000..e69de29b diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_validator_context.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_validator_context.py new file mode 100644 index 00000000..7a19231a --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/prompt_validator_context.py @@ -0,0 +1,44 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +from typing import Dict, cast +from microsoft_agents.hosting.core import TurnContext +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult + + +class PromptValidatorContext: + def __init__( + self, + turn_context: TurnContext, + recognized: PromptRecognizerResult, + state: Dict[str, object], + options: PromptOptions, + ): + """Creates contextual information passed to a custom `PromptValidator`. + Parameters + ---------- + turn_context + The context for the current turn of conversation with the user. + recognized + Result returned from the prompts recognizer function. + state + A dictionary of values persisted for each conversational turn while the prompt is active. + options + Original set of options passed to the prompt by the calling dialog. + """ + self.context = turn_context + self.recognized = recognized + self.state = state + self.options = options + + @property + def attempt_count(self) -> int: + """Gets the number of times the validator has been called for this prompt. + + The counter starts at 1 on the first validation call and increments with + each subsequent user reply. + """ + # pylint: disable=import-outside-toplevel + from microsoft_agents.hosting.dialogs.prompts.prompt import Prompt + + return int(cast(int, self.state.get(Prompt.ATTEMPT_COUNT_KEY, 0))) diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/text_prompt.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/text_prompt.py new file mode 100644 index 00000000..950e673d --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/prompts/text_prompt.py @@ -0,0 +1,82 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes + +from .prompt import Prompt +from .prompt_options import PromptOptions +from .prompt_recognizer_result import PromptRecognizerResult + + +class TextPrompt(Prompt): + """Prompts a user to enter any text. + + Succeeds whenever the user sends a message activity whose ``text`` field is + not ``None``. Empty strings are accepted as valid because some channels + send an empty ``text`` alongside attachments. There is no built-in + recognizer: the raw ``activity.text`` string is returned as the result. + + Pass an optional ``validator`` at construction time to apply additional + constraints (e.g. minimum length, allow-list, non-empty enforcement). + + .. note:: + Non-message activities and messages where ``activity.text`` is ``None`` + cause recognition to fail and will trigger the retry prompt if one was + provided. + """ + + async def on_prompt( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + is_retry: bool, + ): + """Sends the initial or retry prompt activity to the user. + + :param turn_context: The context for the current turn. + :param state: Persisted prompt state (unused by TextPrompt). + :param options: Prompt options containing the prompt and optional retry prompt. + :param is_retry: ``True`` when re-prompting after a failed validation. + """ + if not turn_context: + raise TypeError("TextPrompt.on_prompt(): turn_context cannot be None.") + if not options: + raise TypeError("TextPrompt.on_prompt(): options cannot be None.") + + if is_retry and options.retry_prompt is not None: + await turn_context.send_activity(options.retry_prompt) + else: + if options.prompt is not None: + await turn_context.send_activity(options.prompt) + + async def on_recognize( + self, + turn_context: TurnContext, + state: dict[str, object], + options: PromptOptions, + ) -> PromptRecognizerResult: + """Attempts to recognise text from the incoming activity. + + Succeeds only when the activity is a message **and** ``activity.text`` + is not ``None``. Empty strings are considered valid (``succeeded=True`` + with an empty string value), since some channels send empty text with + attachments. + + :param turn_context: The context for the current turn. + :param state: Persisted prompt state (unused by TextPrompt). + :param options: Prompt options (unused by TextPrompt). + :return: Recognition result with ``succeeded=True`` and the raw text when + a message with text is received; ``succeeded=False`` otherwise. + """ + if not turn_context: + raise TypeError("TextPrompt.on_recognize(): turn_context cannot be None.") + + result = PromptRecognizerResult() + if turn_context.activity.type == ActivityTypes.message: + message = turn_context.activity + if message.text is not None: + result.succeeded = True + result.value = message.text + return result diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_dialog.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_dialog.py new file mode 100644 index 00000000..f04a43bd --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_dialog.py @@ -0,0 +1,266 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import uuid +from typing import Callable + +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.activity import ActivityTypes + +from .models.dialog_reason import DialogReason +from .dialog import Dialog +from .models.dialog_turn_result import DialogTurnResult +from .dialog_context import DialogContext +from .models.dialog_instance import DialogInstance +from .waterfall_step_context import WaterfallStepContext + + +class WaterfallDialog(Dialog): + """A dialog composed of a fixed, ordered sequence of steps (a waterfall). + + Each step receives a :class:`WaterfallStepContext` and must either: + + * return :attr:`Dialog.end_of_turn` to wait for user input before proceeding + to the next step, or + * call ``await step.next(result)`` / ``await step.begin_dialog(...)`` / + ``await step.end_dialog(...)`` to advance the flow explicitly. + + Steps are invoked in order. When the last step completes the dialog ends and + its result is returned to the parent (if any). If the waterfall has *no* + steps at all, ``begin_dialog`` completes immediately with ``None`` as the + result. + + Telemetry events emitted: ``WaterfallStart``, ``WaterfallStep``, + ``WaterfallComplete``, and ``WaterfallCancel``. + """ + + PersistedOptions = "options" + StepIndex = "stepIndex" + PersistedValues = "values" + PersistedInstanceId = "instanceId" + + def __init__(self, dialog_id: str, steps: list | None = None): + """Creates a new WaterfallDialog. + + :param dialog_id: Unique ID for this dialog within its parent DialogSet. + :param steps: Optional list of async callables (step functions). Each callable + must accept a single :class:`WaterfallStepContext` and return a + :class:`DialogTurnResult`. Pass ``None`` or omit to start with an empty + waterfall and add steps later with :meth:`add_step`. + :raises TypeError: If ``steps`` is not a list. + """ + super(WaterfallDialog, self).__init__(dialog_id) + if not steps: + self._steps = [] + else: + if not isinstance(steps, list): + raise TypeError("WaterfallDialog(): steps must be list of steps") + self._steps = steps + + def add_step(self, step: Callable): + """ + Adds a new step to the waterfall. + :param step: Step to add + :return: Waterfall dialog for fluent calls to `add_step()`. + """ + if not step: + raise TypeError("WaterfallDialog.add_step(): step cannot be None.") + + self._steps.append(step) + return self + + async def begin_dialog( + self, dialog_context: DialogContext, options: object = None + ) -> DialogTurnResult: + """Starts the waterfall from the first step. + + Initialises persisted state (options, values, step index, instance ID) and + immediately runs step 0. If the waterfall has no steps the dialog ends at + once and returns ``None`` to the parent. + + :param dialog_context: The dialog context for the current turn. + :param options: Optional argument passed through to every step as + :attr:`WaterfallStepContext.options`. + :return: The result of the first step, or a Complete result if there are + no steps. + """ + if not dialog_context: + raise TypeError("WaterfallDialog.begin_dialog(): dc cannot be None.") + + # Initialize waterfall state + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + + instance_id = str(uuid.uuid1()) + state[self.PersistedOptions] = options + state[self.PersistedValues] = {} + state[self.PersistedInstanceId] = instance_id + + properties = {} + properties["DialogId"] = self.id + properties["InstanceId"] = instance_id + self.telemetry_client.track_event("WaterfallStart", properties) + + # Run first step + return await self.run_step(dialog_context, 0, DialogReason.BeginCalled, None) + + async def continue_dialog( # pylint: disable=unused-argument,arguments-differ + self, + dialog_context: DialogContext | None = None, + reason: DialogReason | None = None, + result: object = None, + ) -> DialogTurnResult: + """Continues the waterfall on the next incoming activity. + + Non-message activities are ignored (returns :attr:`Dialog.end_of_turn`). + For message activities the user's text is forwarded as the result of the + previous step via :meth:`resume_dialog`. + + :param dialog_context: The dialog context for the current turn. + :return: The result of resuming the current step. + """ + if not dialog_context: + raise TypeError("WaterfallDialog.continue_dialog(): dc cannot be None.") + + if dialog_context.context.activity.type != ActivityTypes.message: + return Dialog.end_of_turn + + return await self.resume_dialog( + dialog_context, + DialogReason.ContinueCalled, + dialog_context.context.activity.text, + ) + + async def resume_dialog( + self, dialog_context: DialogContext, reason: DialogReason, result: object + ): + """Advances the waterfall to the next step, passing ``result`` as the previous + step's output. + + Called automatically by the dialog system when a child dialog completes or + when :meth:`WaterfallStepContext.next` is called explicitly. + + :param dialog_context: The dialog context for the current turn. + :param reason: Why the dialog is being resumed. + :param result: Value returned by the child dialog or previous step. + :return: The result of running the next step. + """ + if dialog_context is None: + raise TypeError("WaterfallDialog.resume_dialog(): dc cannot be None.") + + # Increment step index and run step + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + + return await self.run_step( + dialog_context, state[self.StepIndex] + 1, reason, result + ) + + async def end_dialog( # pylint: disable=unused-argument + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ) -> None: + """Emits telemetry events when the waterfall is cancelled or completes normally. + + :param context: The context for the current turn (unused by this implementation). + :param instance: The dialog instance being ended. + :param reason: Why the dialog is ending. + """ + if reason is DialogReason.CancelCalled: + index = instance.state[self.StepIndex] + step_name = self.get_step_name(index) + instance_id = str(instance.state[self.PersistedInstanceId]) + properties = { + "DialogId": self.id, + "StepName": step_name, + "InstanceId": instance_id, + } + self.telemetry_client.track_event("WaterfallCancel", properties) + else: + if reason is DialogReason.EndCalled: + instance_id = str(instance.state[self.PersistedInstanceId]) + properties = {"DialogId": self.id, "InstanceId": instance_id} + self.telemetry_client.track_event("WaterfallComplete", properties) + + return + + async def on_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Invokes a single waterfall step and emits a ``WaterfallStep`` telemetry event. + + Override this method to add custom logic before or after each step executes. + + :param step_context: Context for the current step. + :return: The result of the step function. + """ + step_name = self.get_step_name(step_context.index) + assert step_context.active_dialog is not None + instance_id = str(step_context.active_dialog.state[self.PersistedInstanceId]) + properties = { + "DialogId": self.id, + "StepName": step_name, + "InstanceId": instance_id, + } + self.telemetry_client.track_event("WaterfallStep", properties) + result = await self._steps[step_context.index](step_context) + if result is None: + raise TypeError( + f"WaterfallDialog '{self.id}' step '{step_name}' (index {step_context.index}) " + "returned None. Each step must return 'Dialog.end_of_turn' or a DialogTurnResult." + ) + return result + + async def run_step( + self, + dialog_context: DialogContext, + index: int, + reason: DialogReason, + result: object, + ) -> DialogTurnResult: + """Executes a specific step by index, or ends the dialog if the index is past the + last step. + + Saves the step index into persisted state, constructs a + :class:`WaterfallStepContext`, and delegates to :meth:`on_step`. + + :param dialog_context: The dialog context for the current turn. + :param index: Zero-based index of the step to run. + :param reason: The reason this step is being executed. + :param result: Value from the previous step or child dialog. + :return: The step result, or the dialog completion result if all steps are done. + """ + if not dialog_context: + raise TypeError( + "WaterfallDialog.run_steps(): dialog_context cannot be None." + ) + if index < len(self._steps): + # Update persisted step index + assert dialog_context.active_dialog is not None + state = dialog_context.active_dialog.state + state[self.StepIndex] = index + + # Create step context + options = state[self.PersistedOptions] + values = state[self.PersistedValues] + step_context = WaterfallStepContext( + self, dialog_context, options, values, index, reason, result + ) + return await self.on_step(step_context) + + # End of waterfall so just return any result to parent + return await dialog_context.end_dialog(result) + + def get_step_name(self, index: int) -> str: + """Returns a human-readable name for the step at ``index``. + + Uses ``__qualname__`` of the step callable. Falls back to + ``"Step{n}of{total}"`` for anonymous lambdas or callables without a + meaningful qualified name. + + :param index: Zero-based step index. + :return: A descriptive step name suitable for telemetry. + """ + step_name = self._steps[index].__qualname__ + + if not step_name or step_name.endswith(""): + step_name = f"Step{index + 1}of{len(self._steps)}" + + return step_name diff --git a/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_step_context.py b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_step_context.py new file mode 100644 index 00000000..e0312530 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/microsoft_agents/hosting/dialogs/waterfall_step_context.py @@ -0,0 +1,109 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .dialog_context import DialogContext +from .models.dialog_reason import DialogReason +from .models.dialog_turn_result import DialogTurnResult +from .dialog_state import DialogState + + +class WaterfallStepContext(DialogContext): + """Context passed to each step function in a :class:`WaterfallDialog`. + + Inherits from :class:`DialogContext` so step functions can call + :meth:`begin_dialog`, :meth:`prompt`, :meth:`end_dialog`, etc. directly on + the step context. + + In addition to the standard :class:`DialogContext` interface, a step context + provides read-only properties for the current step index, the options passed + to the waterfall, the reason this step is executing, the result from the + previous step (or child dialog), and a shared ``values`` dict that persists + across all steps of the same waterfall instance. + + Call :meth:`next` to skip ahead to the next step without waiting for user + input. Calling :meth:`next` more than once in the same step raises an + exception. + """ + + def __init__( + self, + parent, + dc: DialogContext, + options: object, + values: dict[str, object], + index: int, + reason: DialogReason, + result: object = None, + ): + super(WaterfallStepContext, self).__init__( + dc.dialogs, dc.context, DialogState(dc.stack) + ) + self._wf_parent = parent + self._next_called = False + self._index = index + self._options = options + self._reason = reason + self._result = result + self._values = values + self.parent = dc.parent + + @property + def index(self) -> int: + """Zero-based index of the currently executing step.""" + return self._index + + @property + def options(self) -> object: + """Options originally passed to :meth:`WaterfallDialog.begin_dialog`. + Shared across all steps of the same waterfall run. + """ + return self._options + + @property + def reason(self) -> DialogReason: + """Why this step is executing (e.g. ``BeginCalled``, ``ContinueCalled``, + ``NextCalled``). + """ + return self._reason + + @property + def result(self) -> object: + """The value returned by the previous step or a child dialog that was + started from the previous step. ``None`` for the first step. + """ + return self._result + + @property + def values(self) -> dict[str, object]: + """A dictionary that persists across every step of the same waterfall + instance. Use it to accumulate data collected across multiple steps. + + .. note:: + Values stored here are scoped to the current waterfall run only and + are lost when the waterfall ends. + """ + return self._values + + async def next(self, result: object) -> DialogTurnResult: + """Skips to the next step of the waterfall, passing ``result`` as the + previous step's output. + + This is useful when a step wants to bypass waiting for user input and + advance immediately (e.g. when data was already available). + + :param result: Value to pass to the next step as + :attr:`WaterfallStepContext.result`. + :raises Exception: If called more than once within the same step. + :return: The result of running the next step. + """ + if self._next_called is True: + raise Exception( + "WaterfallStepContext.next(): method already called for dialog and step '%s'[%s]." + % (self._wf_parent.id, self._index) + ) + + # Trigger next step + self._next_called = True + return await self._wf_parent.resume_dialog( + self, DialogReason.NextCalled, result + ) diff --git a/libraries/microsoft-agents-hosting-dialogs/pyproject.toml b/libraries/microsoft-agents-hosting-dialogs/pyproject.toml new file mode 100644 index 00000000..ab948a1b --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/pyproject.toml @@ -0,0 +1,25 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" + +[project] +name = "microsoft-agents-hosting-dialogs" +dynamic = ["version", "dependencies"] +description = "Dialog system for Microsoft Agents (waterfall dialogs, prompts, choices)" +readme = {file = "readme.md", content-type = "text/markdown"} +authors = [{name = "Microsoft Corporation"}] +license = "MIT" +license-files = ["LICENSE"] +requires-python = ">=3.10" +classifiers = [ + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Operating System :: OS Independent", +] + +[project.urls] +"Homepage" = "https://github.com/microsoft/Agents" diff --git a/libraries/microsoft-agents-hosting-dialogs/readme.md b/libraries/microsoft-agents-hosting-dialogs/readme.md new file mode 100644 index 00000000..b2780c70 --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/readme.md @@ -0,0 +1,61 @@ +# Microsoft Agents Hosting - Dialogs + +[![PyPI version](https://img.shields.io/pypi/v/microsoft-agents-hosting-dialogs)](https://pypi.org/project/microsoft-agents-hosting-dialogs/) + +Dialog system for the Microsoft 365 Agents SDK. Provides waterfall dialogs, prompts, choice recognition, and multi-turn conversation management. + +This library is a port of the botbuilder-dialogs library to the new Microsoft 365 Agents SDK. It provides the same dialog primitives (WaterfallDialog, ComponentDialog, DialogSet, DialogContext) and prompts (TextPrompt, NumberPrompt, ChoicePrompt, ConfirmPrompt, DateTimePrompt, OAuthPrompt, etc.) with updated imports and patterns for the new SDK. + +## What is this? + +This library is part of the **Microsoft 365 Agents SDK for Python** - a comprehensive framework for building enterprise-grade conversational AI agents. The dialogs library enables developers to structure multi-turn conversations with reusable, composable dialog primitives. + +## Key Features + +- **WaterfallDialog**: Sequential step-by-step conversation flows +- **ComponentDialog**: Composable, encapsulated dialog components +- **Prompts**: Built-in prompts for text, numbers, choices, confirmations, dates, attachments, and OAuth +- **Choice recognition**: Locale-aware choice matching and recognition +- **Dialog memory**: Scoped memory management (conversation, user, dialog, class, settings) +- **DialogManager**: High-level dialog orchestration with state management + +## Installation + +```bash +pip install microsoft-agents-hosting-dialogs +``` + +## Quick Start + +```python +from microsoft_agents.hosting.dialogs import ( + WaterfallDialog, + WaterfallStepContext, + DialogSet, + DialogTurnStatus, +) +from microsoft_agents.hosting.dialogs.prompts import TextPrompt, PromptOptions +from microsoft_agents.hosting.core import ConversationState, MemoryStorage + +storage = MemoryStorage() +conversation_state = ConversationState(storage) +dialog_state = conversation_state.create_property("DialogState") +dialogs = DialogSet(dialog_state) + +async def step1(step: WaterfallStepContext): + return await step.prompt( + "text_prompt", + PromptOptions(prompt=MessageFactory.text("What is your name?")) + ) + +async def step2(step: WaterfallStepContext): + await step.context.send_activity(f"Hello, {step.result}!") + return await step.end_dialog() + +dialogs.add(TextPrompt("text_prompt")) +dialogs.add(WaterfallDialog("main", [step1, step2])) +``` + +## Release Notes + +See [CHANGELOG.md](https://github.com/microsoft/Agents/blob/main/CHANGELOG.md) for release history. diff --git a/libraries/microsoft-agents-hosting-dialogs/setup.py b/libraries/microsoft-agents-hosting-dialogs/setup.py new file mode 100644 index 00000000..0d630b2a --- /dev/null +++ b/libraries/microsoft-agents-hosting-dialogs/setup.py @@ -0,0 +1,22 @@ +from os import environ, path +from setuptools import setup + +# Try to read from VERSION.txt file first, fall back to environment variable +version_file = path.join(path.dirname(__file__), "VERSION.txt") +if path.exists(version_file): + with open(version_file, "r", encoding="utf-8") as f: + package_version = f.read().strip() +else: + package_version = environ.get("PackageVersion", "0.0.0") + +setup( + version=package_version, + install_requires=[ + f"microsoft-agents-hosting-core=={package_version}", + "recognizers-text-number>=1.0.1a0", + "recognizers-text-choice>=1.0.1a0", + "recognizers-text-date-time>=1.0.1a0", + "babel>=2.9.0", + "emoji<2.0.0", + ], +) diff --git a/scripts/dev_setup.ps1 b/scripts/dev_setup.ps1 index bd603070..0b0e21ed 100644 --- a/scripts/dev_setup.ps1 +++ b/scripts/dev_setup.ps1 @@ -8,6 +8,7 @@ pip install -e ./libraries/microsoft-agents-copilotstudio-client/ --config-setti pip install -e ./libraries/microsoft-agents-hosting-aiohttp/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-hosting-core/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-hosting-teams/ --config-settings editable_mode=compat +pip install -e ./libraries/microsoft-agents-hosting-dialogs/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-storage-blob/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-storage-cosmos/ --config-settings editable_mode=compat diff --git a/scripts/dev_setup.sh b/scripts/dev_setup.sh index 8d08fc20..ebf6e81c 100644 --- a/scripts/dev_setup.sh +++ b/scripts/dev_setup.sh @@ -8,6 +8,7 @@ pip install -e ./libraries/microsoft-agents-copilotstudio-client/ --config-setti pip install -e ./libraries/microsoft-agents-hosting-aiohttp/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-hosting-core/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-hosting-teams/ --config-settings editable_mode=compat +pip install -e ./libraries/microsoft-agents-hosting-dialogs/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-storage-blob/ --config-settings editable_mode=compat pip install -e ./libraries/microsoft-agents-storage-cosmos/ --config-settings editable_mode=compat diff --git a/test_samples/agent_to_agent/agent_1/agent1.py b/test_samples/compat/agent_to_agent/agent_1/agent1.py similarity index 100% rename from test_samples/agent_to_agent/agent_1/agent1.py rename to test_samples/compat/agent_to_agent/agent_1/agent1.py diff --git a/test_samples/agent_to_agent/agent_1/app.py b/test_samples/compat/agent_to_agent/agent_1/app.py similarity index 93% rename from test_samples/agent_to_agent/agent_1/app.py rename to test_samples/compat/agent_to_agent/agent_1/app.py index 6a76c37c..08a9c4ea 100644 --- a/test_samples/agent_to_agent/agent_1/app.py +++ b/test_samples/compat/agent_to_agent/agent_1/app.py @@ -21,8 +21,8 @@ ) from microsoft_agents.authentication.msal import MsalAuth -from agent1 import Agent1 -from config import DefaultConfig +from test_samples.activity_handler.agent_to_agent.agent_1.agent1 import Agent1 +from test_samples.activity_handler.agent_to_agent.agent_1.config import DefaultConfig load_dotenv() diff --git a/test_samples/agent_to_agent/agent_1/config.py b/test_samples/compat/agent_to_agent/agent_1/config.py similarity index 100% rename from test_samples/agent_to_agent/agent_1/config.py rename to test_samples/compat/agent_to_agent/agent_1/config.py diff --git a/test_samples/agent_to_agent/agent_1/env.TEMPLATE b/test_samples/compat/agent_to_agent/agent_1/env.TEMPLATE similarity index 94% rename from test_samples/agent_to_agent/agent_1/env.TEMPLATE rename to test_samples/compat/agent_to_agent/agent_1/env.TEMPLATE index 706e88db..9acdb4ac 100644 --- a/test_samples/agent_to_agent/agent_1/env.TEMPLATE +++ b/test_samples/compat/agent_to_agent/agent_1/env.TEMPLATE @@ -1,5 +1,5 @@ -# Rename to .env -TENANT_ID= -CLIENT_ID= -CLIENT_SECRET= +# Rename to .env +TENANT_ID= +CLIENT_ID= +CLIENT_SECRET= TARGET_APP_ID= \ No newline at end of file diff --git a/test_samples/agent_to_agent/agent_2/agent2.py b/test_samples/compat/agent_to_agent/agent_2/agent2.py similarity index 100% rename from test_samples/agent_to_agent/agent_2/agent2.py rename to test_samples/compat/agent_to_agent/agent_2/agent2.py diff --git a/test_samples/agent_to_agent/agent_2/app.py b/test_samples/compat/agent_to_agent/agent_2/app.py similarity index 90% rename from test_samples/agent_to_agent/agent_2/app.py rename to test_samples/compat/agent_to_agent/agent_2/app.py index 620b5ff2..33b867d9 100644 --- a/test_samples/agent_to_agent/agent_2/app.py +++ b/test_samples/compat/agent_to_agent/agent_2/app.py @@ -13,8 +13,8 @@ from microsoft_agents.hosting.aiohttp import CloudAdapter, jwt_authorization_middleware from microsoft_agents.authentication.msal import MsalAuth -from agent2 import Agent2 -from config import DefaultConfig +from test_samples.activity_handler.agent_to_agent.agent_2.agent2 import Agent2 +from test_samples.activity_handler.agent_to_agent.agent_2.config import DefaultConfig load_dotenv() diff --git a/test_samples/agent_to_agent/agent_2/config.py b/test_samples/compat/agent_to_agent/agent_2/config.py similarity index 100% rename from test_samples/agent_to_agent/agent_2/config.py rename to test_samples/compat/agent_to_agent/agent_2/config.py diff --git a/test_samples/agent_to_agent/agent_2/env.TEMPLATE b/test_samples/compat/agent_to_agent/agent_2/env.TEMPLATE similarity index 94% rename from test_samples/agent_to_agent/agent_2/env.TEMPLATE rename to test_samples/compat/agent_to_agent/agent_2/env.TEMPLATE index bae11cf9..e9f542ca 100644 --- a/test_samples/agent_to_agent/agent_2/env.TEMPLATE +++ b/test_samples/compat/agent_to_agent/agent_2/env.TEMPLATE @@ -1,4 +1,4 @@ -# Rename to .env -TENANT_ID= -CLIENT_ID= +# Rename to .env +TENANT_ID= +CLIENT_ID= CLIENT_SECRET= \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/README.md b/test_samples/compat/dialogs/complex_dialog/README.md new file mode 100644 index 00000000..8e65c48a --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/README.md @@ -0,0 +1 @@ +Port of the [complex-dialog](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/python/43.complex-dialog) Python sample from the BotBuilder-Samples repo. \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/env.TEMPLATE b/test_samples/compat/dialogs/complex_dialog/env.TEMPLATE new file mode 100644 index 00000000..b0bcf971 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/env.TEMPLATE @@ -0,0 +1,5 @@ +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +LOGGING__LOGLEVEL__microsoft_agents.hosting.core=INFO \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/requirements.txt b/test_samples/compat/dialogs/complex_dialog/requirements.txt new file mode 100644 index 00000000..727007a5 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/requirements.txt @@ -0,0 +1,5 @@ +microsoft-agents-hosting-dialogs +microsoft-agents-hosting-core +microsoft-agents-hosting-aiohttp +microsoft-agents-authentication-msal +python-dotenv diff --git a/test_samples/compat/dialogs/complex_dialog/src/__init__.py b/test_samples/compat/dialogs/complex_dialog/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test_samples/compat/dialogs/complex_dialog/src/dialog_agent.py b/test_samples/compat/dialogs/complex_dialog/src/dialog_agent.py new file mode 100644 index 00000000..3801c03f --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/dialog_agent.py @@ -0,0 +1,48 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ActivityHandler, + ConversationState, + UserState, + TurnContext +) +from microsoft_agents.hosting.dialogs import Dialog + +from .dialog_helper import DialogHelper + + +class DialogAgent(ActivityHandler): + + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + if conversation_state is None: + raise Exception( + "[DialogAgent]: Missing parameter. conversation_state is required" + ) + if user_state is None: + raise Exception("[DialogAgent]: Missing parameter. user_state is required") + if dialog is None: + raise Exception("[DialogAgent]: Missing parameter. dialog is required") + + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have occurred during the turn. + await self.conversation_state.save(turn_context, False) + await self.user_state.save(turn_context, False) + + async def on_message_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/dialog_and_welcome_agent.py b/test_samples/compat/dialogs/complex_dialog/src/dialog_and_welcome_agent.py new file mode 100644 index 00000000..1893b0c3 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/dialog_and_welcome_agent.py @@ -0,0 +1,38 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ConversationState, + MessageFactory, + UserState, + TurnContext, +) +from microsoft_agents.hosting.dialogs import Dialog +from microsoft_agents.activity import ChannelAccount + +from .dialog_agent import DialogAgent + + +class DialogAndWelcomeAgent(DialogAgent): + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + super().__init__( + conversation_state, user_state, dialog + ) + + async def on_members_added_activity( + self, members_added: list[ChannelAccount], turn_context: TurnContext + ): + for member in members_added: + # Greet anyone that was not the target (recipient) of this message. + if member.id != turn_context.activity.recipient.id: + await turn_context.send_activity( + MessageFactory.text( + f"Welcome to Complex Dialog Agent {member.name}. This agent provides a complex conversation, with " + f"multiple dialogs. Type anything to get started. " + ) + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/dialog_helper.py b/test_samples/compat/dialogs/complex_dialog/src/dialog_helper.py new file mode 100644 index 00000000..9fc5e204 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/dialog_helper.py @@ -0,0 +1,24 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import StatePropertyAccessor, TurnContext +from microsoft_agents.hosting.dialogs import ( + Dialog, + DialogSet, + DialogTurnStatus +) + + +class DialogHelper: + + @staticmethod + async def run_dialog( + dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor + ): + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/main.py b/test_samples/compat/dialogs/complex_dialog/src/main.py new file mode 100644 index 00000000..f7f51380 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/main.py @@ -0,0 +1,47 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from os import path, environ + +from aiohttp import web +from aiohttp.web import Request, Response +from microsoft_agents.authentication.msal import MsalConnectionManager +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + UserState, +) +from microsoft_agents.hosting.aiohttp import CloudAdapter +from microsoft_agents.activity import load_configuration_from_env +from dotenv import load_dotenv + +from .main_dialog import MainDialog +from .dialog_and_welcome_agent import DialogAndWelcomeAgent + +load_dotenv(path.join(path.dirname(__file__), "..", ".env")) +agents_sdk_config = load_configuration_from_env(dict(environ)) + +STORAGE = MemoryStorage() +CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config) +ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER) + +CONVERSATION_STATE = ConversationState(STORAGE) +USER_STATE = UserState(STORAGE) + +DIALOG = MainDialog(USER_STATE) +AGENT = DialogAndWelcomeAgent(CONVERSATION_STATE, USER_STATE, DIALOG) + +# Listen for incoming requests on /api/messages. +async def messages(req: Request) -> Response: + return await ADAPTER.process(req, AGENT) + + +APP = web.Application() +APP.router.add_post("/api/messages", messages) + +if __name__ == "__main__": + try: + web.run_app(APP, host="localhost", port=3978) + except Exception: + raise + \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/main_dialog.py b/test_samples/compat/dialogs/complex_dialog/src/main_dialog.py new file mode 100644 index 00000000..0e9cc472 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/main_dialog.py @@ -0,0 +1,50 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, +) +from microsoft_agents.hosting.core import MessageFactory, UserState + +from .user_profile import UserProfile +from .top_level_dialog import TopLevelDialog + + +class MainDialog(ComponentDialog): + def __init__(self, user_state: UserState): + super(MainDialog, self).__init__(MainDialog.__name__) + + self.user_state = user_state + + self.add_dialog(TopLevelDialog(TopLevelDialog.__name__)) + self.add_dialog( + WaterfallDialog("WFDialog", [self.initial_step, self.final_step]) + ) + + self.initial_dialog_id = "WFDialog" + + async def initial_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + return await step_context.begin_dialog(TopLevelDialog.__name__) + + async def final_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + user_info: UserProfile = step_context.result + + companies = ( + "no companies" + if len(user_info.companies_to_review) == 0 + else " and ".join(user_info.companies_to_review) + ) + status = f"You are signed up to review {companies}." + + await step_context.context.send_activity(MessageFactory.text(status)) + + # store the UserProfile + accessor = self.user_state.create_property("UserProfile") + await accessor.set(step_context.context, user_info) + + return await step_context.end_dialog() \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/review_selection_dialog.py b/test_samples/compat/dialogs/complex_dialog/src/review_selection_dialog.py new file mode 100644 index 00000000..4ab78b86 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/review_selection_dialog.py @@ -0,0 +1,97 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +from microsoft_agents.hosting.dialogs import ( + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, + ComponentDialog, +) +from microsoft_agents.hosting.dialogs.prompts import ChoicePrompt, PromptOptions +from microsoft_agents.hosting.dialogs.choices import Choice, FoundChoice +from microsoft_agents.hosting.core import MessageFactory + + +class ReviewSelectionDialog(ComponentDialog): + def __init__(self, dialog_id: str | None = None): + super(ReviewSelectionDialog, self).__init__( + dialog_id or ReviewSelectionDialog.__name__ + ) + + self.COMPANIES_SELECTED = "value-companiesSelected" + self.DONE_OPTION = "done" + + self.company_options = [ + "Adatum Corporation", + "Contoso Suites", + "Graphic Design Institute", + "Wide World Importers", + ] + + self.add_dialog(ChoicePrompt(ChoicePrompt.__name__)) + self.add_dialog( + WaterfallDialog( + WaterfallDialog.__name__, [self.selection_step, self.loop_step] + ) + ) + + self.initial_dialog_id = WaterfallDialog.__name__ + + async def selection_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # step_context.options will contains the value passed in begin_dialog or replace_dialog. + # if this value wasn't provided then start with an emtpy selection list. This list will + # eventually be returned to the parent via end_dialog. + selected: list[str] = step_context.options if step_context.options is not None else [] + step_context.values[self.COMPANIES_SELECTED] = selected + + if len(selected) == 0: + message = ( + f"Please choose a company to review, or `{self.DONE_OPTION}` to finish." + ) + else: + message = ( + f"You have selected **{selected[0]}**. You can review an additional company, " + f"or choose `{self.DONE_OPTION}` to finish. " + ) + + # create a list of options to choose, with already selected items removed. + options = self.company_options.copy() + options.append(self.DONE_OPTION) + if len(selected) > 0: + options.remove(selected[0]) + + # prompt with the list of choices + prompt_options = PromptOptions( + prompt=MessageFactory.text(message), + retry_prompt=MessageFactory.text("Please choose an option from the list."), + choices=self._to_choices(options), + ) + return await step_context.prompt(ChoicePrompt.__name__, prompt_options) + + def _to_choices(self, choices: list[str]) -> List[Choice]: + choice_list: List[Choice] = [] + for choice in choices: + choice_list.append(Choice(value=choice)) + return choice_list + + async def loop_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + selected: List[str] = step_context.values[self.COMPANIES_SELECTED] + choice: FoundChoice = step_context.result + done = choice.value == self.DONE_OPTION + + # If they chose a company, add it to the list. + if not done: + selected.append(choice.value) + + # If they're done, exit and return their list. + if done or len(selected) >= 2: + return await step_context.end_dialog(selected) + + # Otherwise, repeat this dialog, passing in the selections from this iteration. + return await step_context.replace_dialog( + self.initial_dialog_id, selected + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/top_level_dialog.py b/test_samples/compat/dialogs/complex_dialog/src/top_level_dialog.py new file mode 100644 index 00000000..bfdc7dbb --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/top_level_dialog.py @@ -0,0 +1,95 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import MessageFactory +from microsoft_agents.hosting.dialogs import ( + WaterfallDialog, + DialogTurnResult, + WaterfallStepContext, + ComponentDialog, +) +from microsoft_agents.hosting.dialogs.prompts import PromptOptions, TextPrompt, NumberPrompt + +from .user_profile import UserProfile +from .review_selection_dialog import ReviewSelectionDialog + + +class TopLevelDialog(ComponentDialog): + def __init__(self, dialog_id: str | None = None): + super(TopLevelDialog, self).__init__(dialog_id or TopLevelDialog.__name__) + + # Key name to store this dialogs state info in the StepContext + self.USER_INFO = "value-userInfo" + + self.add_dialog(TextPrompt(TextPrompt.__name__)) + self.add_dialog(NumberPrompt(NumberPrompt.__name__)) + + self.add_dialog(ReviewSelectionDialog(ReviewSelectionDialog.__name__)) + + self.add_dialog( + WaterfallDialog( + "WFDialog", + [ + self.name_step, + self.age_step, + self.start_selection_step, + self.acknowledgement_step, + ], + ) + ) + + self.initial_dialog_id = "WFDialog" + + async def name_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + # Create an object in which to collect the user's information within the dialog. + step_context.values[self.USER_INFO] = UserProfile() + + # Ask the user to enter their name. + prompt_options = PromptOptions( + prompt=MessageFactory.text("Please enter your name.") + ) + return await step_context.prompt(TextPrompt.__name__, prompt_options) + + async def age_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + # Set the user's name to what they entered in response to the name prompt. + user_profile = step_context.values[self.USER_INFO] + user_profile.name = step_context.result + + # Ask the user to enter their age. + prompt_options = PromptOptions( + prompt=MessageFactory.text("Please enter your age.") + ) + return await step_context.prompt(NumberPrompt.__name__, prompt_options) + + async def start_selection_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # Set the user's age to what they entered in response to the age prompt. + user_profile: UserProfile = step_context.values[self.USER_INFO] + user_profile.age = step_context.result + + if user_profile.age < 25: + # If they are too young, skip the review selection dialog, and pass an empty list to the next step. + await step_context.context.send_activity( + MessageFactory.text("You must be 25 or older to participate.") + ) + + return await step_context.next([]) + + # Otherwise, start the review selection dialog. + return await step_context.begin_dialog(ReviewSelectionDialog.__name__) + + async def acknowledgement_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # Set the user's company selection to what they entered in the review-selection dialog. + user_profile: UserProfile = step_context.values[self.USER_INFO] + user_profile.companies_to_review = step_context.result + + # Thank them for participating. + await step_context.context.send_activity( + MessageFactory.text(f"Thanks for participating, {user_profile.name}.") + ) + + # Exit the dialog, returning the collected user information. + return await step_context.end_dialog(user_profile) \ No newline at end of file diff --git a/test_samples/compat/dialogs/complex_dialog/src/user_profile.py b/test_samples/compat/dialogs/complex_dialog/src/user_profile.py new file mode 100644 index 00000000..6c81e063 --- /dev/null +++ b/test_samples/compat/dialogs/complex_dialog/src/user_profile.py @@ -0,0 +1,11 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass, field + +@dataclass +class UserProfile: + + name: str = "" + age: int = 0 + companies_to_review: list[str] = field(default_factory=list) diff --git a/test_samples/compat/dialogs/custom_dialogs/README.md b/test_samples/compat/dialogs/custom_dialogs/README.md new file mode 100644 index 00000000..975b79e9 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/README.md @@ -0,0 +1 @@ +Port of the [custom-dialogs](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/python/19.custom-dialogs) Python sample from the BotBuilder-Samples repo. \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/env.TEMPLATE b/test_samples/compat/dialogs/custom_dialogs/env.TEMPLATE new file mode 100644 index 00000000..b0bcf971 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/env.TEMPLATE @@ -0,0 +1,5 @@ +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +LOGGING__LOGLEVEL__microsoft_agents.hosting.core=INFO \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/requirements.txt b/test_samples/compat/dialogs/custom_dialogs/requirements.txt new file mode 100644 index 00000000..727007a5 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/requirements.txt @@ -0,0 +1,5 @@ +microsoft-agents-hosting-dialogs +microsoft-agents-hosting-core +microsoft-agents-hosting-aiohttp +microsoft-agents-authentication-msal +python-dotenv diff --git a/test_samples/compat/dialogs/custom_dialogs/src/__init__.py b/test_samples/compat/dialogs/custom_dialogs/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test_samples/compat/dialogs/custom_dialogs/src/agent.py b/test_samples/compat/dialogs/custom_dialogs/src/agent.py new file mode 100644 index 00000000..61ac83a9 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/agent.py @@ -0,0 +1,34 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ActivityHandler, ConversationState, TurnContext, UserState +from microsoft_agents.hosting.dialogs import Dialog + +from .dialog_helper import DialogHelper + + +class DialogAgent(ActivityHandler): + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have occurred during the turn. + await self.conversation_state.save(turn_context) + await self.user_state.save(turn_context) + + async def on_message_activity(self, turn_context: TurnContext): + # Run the Dialog with the new message Activity. + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/src/dialog_helper.py b/test_samples/compat/dialogs/custom_dialogs/src/dialog_helper.py new file mode 100644 index 00000000..154ea39c --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/dialog_helper.py @@ -0,0 +1,19 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import StatePropertyAccessor, TurnContext +from microsoft_agents.hosting.dialogs import Dialog, DialogSet, DialogTurnStatus + + +class DialogHelper: + @staticmethod + async def run_dialog( + dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor + ): + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/src/main.py b/test_samples/compat/dialogs/custom_dialogs/src/main.py new file mode 100644 index 00000000..a84226c7 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/main.py @@ -0,0 +1,47 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from os import path, environ + +from aiohttp import web +from aiohttp.web import Request, Response +from microsoft_agents.authentication.msal import MsalConnectionManager +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + UserState, +) +from microsoft_agents.hosting.aiohttp import CloudAdapter +from microsoft_agents.activity import load_configuration_from_env +from dotenv import load_dotenv + +from .root_dialog import RootDialog +from .agent import DialogAgent + +load_dotenv(path.join(path.dirname(__file__), "..", ".env")) +agents_sdk_config = load_configuration_from_env(dict(environ)) + +STORAGE = MemoryStorage() +CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config) +ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER) + +CONVERSATION_STATE = ConversationState(STORAGE) +USER_STATE = UserState(STORAGE) + +DIALOG = RootDialog(USER_STATE) +AGENT = DialogAgent(CONVERSATION_STATE, USER_STATE, DIALOG) + +# Listen for incoming requests on /api/messages. +async def messages(req: Request) -> Response: + return await ADAPTER.process(req, AGENT) + + +APP = web.Application() +APP.router.add_post("/api/messages", messages) + +if __name__ == "__main__": + try: + web.run_app(APP, host="localhost", port=3978) + except Exception as error: + raise error + \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/src/root_dialog.py b/test_samples/compat/dialogs/custom_dialogs/src/root_dialog.py new file mode 100644 index 00000000..ba5a8317 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/root_dialog.py @@ -0,0 +1,137 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import Dict +from recognizers_text import Culture + +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, + NumberPrompt, + PromptValidatorContext, +) +from microsoft_agents.hosting.dialogs.prompts import TextPrompt +from microsoft_agents.hosting.core import MessageFactory, UserState + +from .slot_filling_dialog import SlotFillingDialog +from .slot_details import SlotDetails + + +class RootDialog(ComponentDialog): + def __init__(self, user_state: UserState): + super(RootDialog, self).__init__(RootDialog.__name__) + + self.user_state_accessor = user_state.create_property("result") + + # Rather than explicitly coding a Waterfall we have only to declare what properties we want collected. + # In this example we will want two text prompts to run, one for the first name and one for the last + fullname_slots = [ + SlotDetails( + name="first", dialog_id="text", prompt="Please enter your first name." + ), + SlotDetails( + name="last", dialog_id="text", prompt="Please enter your last name." + ), + ] + + # This defines an address dialog that collects street, city and zip properties. + address_slots = [ + SlotDetails( + name="street", + dialog_id="text", + prompt="Please enter the street address.", + ), + SlotDetails(name="city", dialog_id="text", prompt="Please enter the city."), + SlotDetails(name="zip", dialog_id="text", prompt="Please enter the zip."), + ] + + # Dialogs can be nested and the slot filling dialog makes use of that. In this example some of the child + # dialogs are slot filling dialogs themselves. + slots = [ + SlotDetails(name="fullname", dialog_id="fullname",), + SlotDetails( + name="age", dialog_id="number", prompt="Please enter your age." + ), + SlotDetails( + name="shoesize", + dialog_id="shoesize", + prompt="Please enter your shoe size.", + retry_prompt="You must enter a size between 0 and 16. Half sizes are acceptable.", + ), + SlotDetails(name="address", dialog_id="address"), + ] + + # Add the various dialogs that will be used to the DialogSet. + self.add_dialog(SlotFillingDialog("address", address_slots)) + self.add_dialog(SlotFillingDialog("fullname", fullname_slots)) + self.add_dialog(TextPrompt("text")) + self.add_dialog(NumberPrompt("number", default_locale=Culture.English)) + self.add_dialog( + NumberPrompt( + "shoesize", + RootDialog.shoe_size_validator, + default_locale=Culture.English, + ) + ) + self.add_dialog(SlotFillingDialog("slot-dialog", slots)) + + # Defines a simple two step Waterfall to test the slot dialog. + self.add_dialog( + WaterfallDialog("waterfall", [self.start_dialog, self.process_result]) + ) + + # The initial child Dialog to run. + self.initial_dialog_id = "waterfall" + + async def start_dialog( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # Start the child dialog. This will run the top slot dialog than will complete when all the properties are + # gathered. + return await step_context.begin_dialog("slot-dialog") + + async def process_result( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # To demonstrate that the slot dialog collected all the properties we will echo them back to the user. + if isinstance(step_context.result, dict) and len(step_context.result) > 0: + fullname: Dict[str, object] = step_context.result["fullname"] + shoe_size: float = step_context.result["shoesize"] + address: dict = step_context.result["address"] + + # store the response on UserState + obj: dict = await self.user_state_accessor.get(step_context.context, dict) + obj["data"] = {} + obj["data"]["fullname"] = f"{fullname.get('first')} {fullname.get('last')}" + obj["data"]["shoesize"] = f"{shoe_size}" + obj["data"][ + "address" + ] = f"{address['street']}, {address['city']}, {address['zip']}" + + # show user the values + await step_context.context.send_activity( + MessageFactory.text(obj["data"]["fullname"]) + ) + await step_context.context.send_activity( + MessageFactory.text(obj["data"]["shoesize"]) + ) + await step_context.context.send_activity( + MessageFactory.text(obj["data"]["address"]) + ) + + return await step_context.end_dialog() + + @staticmethod + async def shoe_size_validator(prompt_context: PromptValidatorContext) -> bool: + if not prompt_context.recognized.succeeded or prompt_context.recognized.value is None: + return False + + shoe_size = round(prompt_context.recognized.value, 1) + + # show sizes can range from 0 to 16, whole or half sizes only + if 0 <= shoe_size <= 16 and (shoe_size * 2) % 1 == 0: + prompt_context.recognized.value = shoe_size + return True + return False \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/src/slot_details.py b/test_samples/compat/dialogs/custom_dialogs/src/slot_details.py new file mode 100644 index 00000000..f9b79b2d --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/slot_details.py @@ -0,0 +1,28 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import MessageFactory +from microsoft_agents.hosting.dialogs import PromptOptions + + +class SlotDetails: + def __init__( + self, + name: str, + dialog_id: str, + options: PromptOptions | None = None, + prompt: str = "", + retry_prompt: str | None = None, + ): + self.name = name + self.dialog_id = dialog_id + self.options = ( + options + if options + else PromptOptions( + prompt=MessageFactory.text(prompt), + retry_prompt=None + if retry_prompt is None + else MessageFactory.text(retry_prompt), + ) + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/custom_dialogs/src/slot_filling_dialog.py b/test_samples/compat/dialogs/custom_dialogs/src/slot_filling_dialog.py new file mode 100644 index 00000000..50320800 --- /dev/null +++ b/test_samples/compat/dialogs/custom_dialogs/src/slot_filling_dialog.py @@ -0,0 +1,100 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List, Dict + +from microsoft_agents.hosting.dialogs import ( + DialogContext, + DialogTurnResult, + Dialog, + DialogInstance, + DialogReason, +) +from microsoft_agents.activity import ActivityTypes + +from .slot_details import SlotDetails + + +class SlotFillingDialog(Dialog): + """ + This is an example of implementing a custom Dialog class. This is similar to the Waterfall dialog in the + framework; however, it is based on a Dictionary rather than a sequential set of functions. The dialog is defined + by a list of 'slots', each slot represents a property we want to gather and the dialog we will be using to + collect it. Often the property is simply an atomic piece of data such as a number or a date. But sometimes the + property is itself a complex object, in which case we can use the slot dialog to collect that compound property. + """ + + def __init__(self, dialog_id: str, slots: List[SlotDetails]): + super(SlotFillingDialog, self).__init__(dialog_id) + + # Custom dialogs might define their own custom state. Similarly to the Waterfall dialog we will have a set of + # values in the ConversationState. However, rather than persisting an index we will persist the last property + # we prompted for. This way when we resume this code following a prompt we will have remembered what property + # we were filling. + self.SLOT_NAME = "slot" + self.PERSISTED_VALUES = "values" + + # The list of slots defines the properties to collect and the dialogs to use to collect them. + self.slots = slots + + async def begin_dialog( + self, dialog_context: "DialogContext", options: object = None + ): + if dialog_context.context.activity.type != ActivityTypes.message: + return await dialog_context.end_dialog({}) + return await self._run_prompt(dialog_context) + + async def continue_dialog(self, dialog_context: "DialogContext"): + if dialog_context.context.activity.type != ActivityTypes.message: + return Dialog.end_of_turn + return await self._run_prompt(dialog_context) + + async def resume_dialog( + self, dialog_context: DialogContext, reason: DialogReason, result: object + ): + slot_name = dialog_context.active_dialog.state[self.SLOT_NAME] + values = self._get_persisted_values(dialog_context.active_dialog) + values[slot_name] = result + + return await self._run_prompt(dialog_context) + + async def _run_prompt(self, dialog_context: DialogContext) -> DialogTurnResult: + """ + This helper function contains the core logic of this dialog. The main idea is to compare the state we have + gathered with the list of slots we have been asked to fill. When we find an empty slot we execute the + corresponding prompt. + :param dialog_context: + :return: + """ + state = self._get_persisted_values(dialog_context.active_dialog) + + # Run through the list of slots until we find one that hasn't been filled yet. + unfilled_slot = None + for slot_detail in self.slots: + if slot_detail.name not in state: + unfilled_slot = slot_detail + break + + # If we have an unfilled slot we will try to fill it + if unfilled_slot: + # The name of the slot we will be prompting to fill. + dialog_context.active_dialog.state[self.SLOT_NAME] = unfilled_slot.name + + # Run the child dialog + return await dialog_context.begin_dialog( + unfilled_slot.dialog_id, unfilled_slot.options + ) + + # No more slots to fill so end the dialog. + return await dialog_context.end_dialog(state) + + def _get_persisted_values( + self, dialog_instance: DialogInstance + ) -> Dict[str, object]: + obj = dialog_instance.state.get(self.PERSISTED_VALUES) + + if obj is None: + obj = {} + dialog_instance.state[self.PERSISTED_VALUES] = obj + + return obj \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/README.md b/test_samples/compat/dialogs/multi_turn/README.md new file mode 100644 index 00000000..c7c19ac1 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/README.md @@ -0,0 +1 @@ +Port of the [multi-turn-prompt](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/python/05.multi-turn-prompt) Python sample from the BotBuilder-Samples repo. \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/env.TEMPLATE b/test_samples/compat/dialogs/multi_turn/env.TEMPLATE new file mode 100644 index 00000000..b0bcf971 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/env.TEMPLATE @@ -0,0 +1,5 @@ +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +LOGGING__LOGLEVEL__microsoft_agents.hosting.core=INFO \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/requirements.txt b/test_samples/compat/dialogs/multi_turn/requirements.txt new file mode 100644 index 00000000..727007a5 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/requirements.txt @@ -0,0 +1,5 @@ +microsoft-agents-hosting-dialogs +microsoft-agents-hosting-core +microsoft-agents-hosting-aiohttp +microsoft-agents-authentication-msal +python-dotenv diff --git a/test_samples/compat/dialogs/multi_turn/src/__init__.py b/test_samples/compat/dialogs/multi_turn/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test_samples/compat/dialogs/multi_turn/src/agent.py b/test_samples/compat/dialogs/multi_turn/src/agent.py new file mode 100644 index 00000000..8ea043ae --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/src/agent.py @@ -0,0 +1,56 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ActivityHandler, + ConversationState, + TurnContext, + UserState, +) +from microsoft_agents.hosting.dialogs import Dialog +from .dialog_helper import DialogHelper + + +class DialogAgent(ActivityHandler): + """ + This Agent implementation can run any type of Dialog. The use of type parameterization is to allows multiple + different agents to be run at different endpoints within the same project. This can be achieved by defining distinct + Controller types each with dependency on distinct Agent types. The ConversationState is used by the Dialog system. The + UserState isn't, however, it might have been used in a Dialog implementation, and the requirement is that all + AgentState objects are saved at the end of a turn. + """ + + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + if conversation_state is None: + raise TypeError( + "[DialogAgent]: Missing parameter. conversation_state is required but None was given" + ) + if user_state is None: + raise TypeError( + "[DialogAgent]: Missing parameter. user_state is required but None was given" + ) + if dialog is None: + raise Exception("[DialogAgent]: Missing parameter. dialog is required") + + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have ocurred during the turn. + await self.conversation_state.save(turn_context) + await self.user_state.save(turn_context) + + async def on_message_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/src/dialog_helper.py b/test_samples/compat/dialogs/multi_turn/src/dialog_helper.py new file mode 100644 index 00000000..92e21dc4 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/src/dialog_helper.py @@ -0,0 +1,23 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import StatePropertyAccessor, TurnContext +from microsoft_agents.hosting.dialogs import ( + Dialog, + DialogSet, + DialogTurnStatus, +) + + +class DialogHelper: + @staticmethod + async def run_dialog( + dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor + ): + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/src/main.py b/test_samples/compat/dialogs/multi_turn/src/main.py new file mode 100644 index 00000000..b054d755 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/src/main.py @@ -0,0 +1,46 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from os import path, environ + +from aiohttp import web +from aiohttp.web import Request, Response +from microsoft_agents.authentication.msal import MsalConnectionManager +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + UserState, +) +from microsoft_agents.hosting.aiohttp import CloudAdapter +from microsoft_agents.activity import load_configuration_from_env +from dotenv import load_dotenv + +from .user_profile_dialog import UserProfileDialog +from .agent import DialogAgent + +load_dotenv(path.join(path.dirname(__file__), "..", ".env")) +agents_sdk_config = load_configuration_from_env(dict(environ)) + +STORAGE = MemoryStorage() +CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config) +ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER) + +CONVERSATION_STATE = ConversationState(STORAGE) +USER_STATE = UserState(STORAGE) + +DIALOG = UserProfileDialog(USER_STATE) +AGENT = DialogAgent(CONVERSATION_STATE, USER_STATE, DIALOG) + +# Listen for incoming requests on /api/messages. +async def messages(req: Request) -> Response: + return await ADAPTER.process(req, AGENT) + + +APP = web.Application() +APP.router.add_post("/api/messages", messages) + +if __name__ == "__main__": + try: + web.run_app(APP, host="localhost", port=3978) + except Exception as error: + raise error \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/src/user_profile.py b/test_samples/compat/dialogs/multi_turn/src/user_profile.py new file mode 100644 index 00000000..e8ca3c65 --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/src/user_profile.py @@ -0,0 +1,17 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from dataclasses import dataclass + +from microsoft_agents.activity import Attachment + +@dataclass +class UserProfile: + """ + This is our application state. Just a regular serializable Python class. + """ + + name: str | None = None + transport: str | None = None + age: int = 0 + picture: Attachment | None = None \ No newline at end of file diff --git a/test_samples/compat/dialogs/multi_turn/src/user_profile_dialog.py b/test_samples/compat/dialogs/multi_turn/src/user_profile_dialog.py new file mode 100644 index 00000000..18d13c5b --- /dev/null +++ b/test_samples/compat/dialogs/multi_turn/src/user_profile_dialog.py @@ -0,0 +1,234 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, +) +from microsoft_agents.hosting.dialogs.prompts import ( + TextPrompt, + NumberPrompt, + ChoicePrompt, + ConfirmPrompt, + AttachmentPrompt, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.hosting.dialogs.choices import Choice +from microsoft_agents.hosting.core import MessageFactory, UserState + +from .user_profile import UserProfile + + +class UserProfileDialog(ComponentDialog): + def __init__(self, user_state: UserState): + super(UserProfileDialog, self).__init__(UserProfileDialog.__name__) + + self.user_profile_accessor = user_state.create_property("UserProfile") + + self.add_dialog( + WaterfallDialog( + WaterfallDialog.__name__, + [ + self.transport_step, + self.name_step, + self.name_confirm_step, + self.age_step, + self.picture_step, + self.summary_step, + self.confirm_step, + ], + ) + ) + self.add_dialog(TextPrompt(TextPrompt.__name__)) + self.add_dialog( + NumberPrompt(NumberPrompt.__name__, UserProfileDialog.age_prompt_validator) + ) + self.add_dialog(ChoicePrompt(ChoicePrompt.__name__)) + self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) + self.add_dialog( + AttachmentPrompt( + AttachmentPrompt.__name__, UserProfileDialog.picture_prompt_validator + ) + ) + + self.initial_dialog_id = WaterfallDialog.__name__ + + async def transport_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + # WaterfallStep always finishes with the end of the Waterfall or with another dialog; + # here it is a Prompt Dialog. Running a prompt here means the next WaterfallStep will + # be run when the users response is received. + return await step_context.prompt( + ChoicePrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Please enter your mode of transport."), + choices=[Choice("Car"), Choice("Bus"), Choice("Bicycle")], + ), + ) + + async def name_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + step_context.values["transport"] = step_context.result.value + + return await step_context.prompt( + TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Please enter your name.")), + ) + + async def name_confirm_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + step_context.values["name"] = step_context.result + + # We can send messages to the user at any point in the WaterfallStep. + await step_context.context.send_activity( + MessageFactory.text(f"Thanks {step_context.result}") + ) + + # WaterfallStep always finishes with the end of the Waterfall or + # with another dialog; here it is a Prompt Dialog. + return await step_context.prompt( + ConfirmPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Would you like to give your age?") + ), + ) + + async def age_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + if step_context.result: + # User said "yes" so we will be prompting for the age. + # WaterfallStep always finishes with the end of the Waterfall or with another dialog, + # here it is a Prompt Dialog. + return await step_context.prompt( + NumberPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Please enter your age."), + retry_prompt=MessageFactory.text( + "The value entered must be greater than 0 and less than 150." + ), + ), + ) + + # User said "no" so we will skip the next step. Give -1 as the age. + return await step_context.next(-1) + + async def picture_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + age = step_context.result + step_context.values["age"] = age + + msg = ( + "No age given." + if step_context.result == -1 + else f"I have your age as {age}." + ) + + # We can send messages to the user at any point in the WaterfallStep. + await step_context.context.send_activity(MessageFactory.text(msg)) + + if step_context.context.activity.channel_id == "msteams": + # This attachment prompt example is not designed to work for Teams attachments, so skip it in this case + await step_context.context.send_activity( + "Skipping attachment prompt in Teams channel..." + ) + return await step_context.next(None) + + # WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt + # Dialog. + prompt_options = PromptOptions( + prompt=MessageFactory.text( + "Please attach a profile picture (or type any message to skip)." + ), + retry_prompt=MessageFactory.text( + "The attachment must be a jpeg/png image file." + ), + ) + return await step_context.prompt(AttachmentPrompt.__name__, prompt_options) + + async def confirm_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + if step_context.result: + # User confirmed — save collected values to user profile state. + user_profile = await self.user_profile_accessor.get( + step_context.context, UserProfile + ) + user_profile.transport = step_context.values["transport"] + user_profile.name = step_context.values["name"] + user_profile.age = step_context.values["age"] + user_profile.picture = step_context.values["picture"] + msg = "Thanks. Your profile was saved successfully." + else: + msg = "Thanks. Your profile will not be kept." + + await step_context.context.send_activity(MessageFactory.text(msg)) + + return await step_context.end_dialog() + + async def summary_step( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + step_context.values["picture"] = ( + None if not step_context.result else step_context.result[0] + ) + + # Display a summary of what was collected before asking for confirmation. + transport = step_context.values["transport"] + name = step_context.values["name"] + age = step_context.values["age"] + picture = step_context.values["picture"] + + msg = f"I have your mode of transport as {transport} and your name as {name}." + if age != -1: + msg += f" And age as {age}." + + await step_context.context.send_activity(MessageFactory.text(msg)) + + if picture: + await step_context.context.send_activity( + MessageFactory.attachment(picture, "This is your profile picture.") + ) + else: + await step_context.context.send_activity("No profile picture provided.") + + # WaterfallStep always finishes with the end of the Waterfall or with another + # dialog, here it is the end. + return await step_context.prompt( + ConfirmPrompt.__name__, + PromptOptions(prompt=MessageFactory.text("Is this ok?")), + ) + + @staticmethod + async def age_prompt_validator(prompt_context: PromptValidatorContext) -> bool: + # This condition is our validation rule. You can also change the value at this point. + return ( + prompt_context.recognized.succeeded + and 0 < prompt_context.recognized.value < 150 + ) + + @staticmethod + async def picture_prompt_validator(prompt_context: PromptValidatorContext) -> bool: + if not prompt_context.recognized.succeeded: + await prompt_context.context.send_activity( + "No attachments received. Proceeding without a profile picture..." + ) + + # We can return true from a validator function even if recognized.succeeded is false. + return True + + attachments = prompt_context.recognized.value + + valid_images = [ + attachment + for attachment in attachments + if attachment.content_type in ["image/jpeg", "image/png"] + ] + + prompt_context.recognized.value = valid_images + + # If none of the attachments are valid images, the retry prompt should be sent. + return len(valid_images) > 0 \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/README.md b/test_samples/compat/dialogs/oauth_prompt/README.md new file mode 100644 index 00000000..0e94a1fa --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/README.md @@ -0,0 +1 @@ +A simple sample that uses the user auth to access Graph. diff --git a/test_samples/compat/dialogs/oauth_prompt/env.TEMPLATE b/test_samples/compat/dialogs/oauth_prompt/env.TEMPLATE new file mode 100644 index 00000000..b0bcf971 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/env.TEMPLATE @@ -0,0 +1,5 @@ +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +LOGGING__LOGLEVEL__microsoft_agents.hosting.core=INFO \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/requirements.txt b/test_samples/compat/dialogs/oauth_prompt/requirements.txt new file mode 100644 index 00000000..727007a5 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/requirements.txt @@ -0,0 +1,5 @@ +microsoft-agents-hosting-dialogs +microsoft-agents-hosting-core +microsoft-agents-hosting-aiohttp +microsoft-agents-authentication-msal +python-dotenv diff --git a/test_samples/compat/dialogs/oauth_prompt/src/__init__.py b/test_samples/compat/dialogs/oauth_prompt/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test_samples/compat/dialogs/oauth_prompt/src/agent.py b/test_samples/compat/dialogs/oauth_prompt/src/agent.py new file mode 100644 index 00000000..be8c1a4b --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/src/agent.py @@ -0,0 +1,63 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ActivityHandler, + ConversationState, + TurnContext, + UserState, +) +from microsoft_agents.hosting.dialogs import Dialog +from .dialog_helper import DialogHelper + + +class DialogAgent(ActivityHandler): + """ + This Agent implementation can run any type of Dialog. The use of type parameterization is to allows multiple + different agents to be run at different endpoints within the same project. This can be achieved by defining distinct + Controller types each with dependency on distinct Agent types. The ConversationState is used by the Dialog system. The + UserState isn't, however, it might have been used in a Dialog implementation, and the requirement is that all + AgentState objects are saved at the end of a turn. + """ + + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + if conversation_state is None: + raise TypeError( + "[DialogAgent]: Missing parameter. conversation_state is required but None was given" + ) + if user_state is None: + raise TypeError( + "[DialogAgent]: Missing parameter. user_state is required but None was given" + ) + if dialog is None: + raise Exception("[DialogAgent]: Missing parameter. dialog is required") + + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have ocurred during the turn. + await self.conversation_state.save(turn_context) + await self.user_state.save(turn_context) + + async def on_message_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) + + async def on_invoke_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/src/create_profile_card.py b/test_samples/compat/dialogs/oauth_prompt/src/create_profile_card.py new file mode 100644 index 00000000..d7839523 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/src/create_profile_card.py @@ -0,0 +1,71 @@ +from microsoft_agents.hosting.core import CardFactory + +def create_profile_card(profile): + return CardFactory.adaptive_card( + { + "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", + "version": "1.5", + "type": "AdaptiveCard", + "body": [ + { + "type": "ColumnSet", + "columns": [ + { + "type": "Column", + "width": "auto", + "items": ( + [ + { + "type": "Image", + "altText": "", + "url": profile.get("imageUri", ""), + "style": "Person", + "size": "Small", + } + ] + if profile.get("imageUri") + else [] + ), + }, + { + "type": "Column", + "width": "auto", + "items": [ + { + "type": "TextBlock", + "weight": "Bolder", + "text": profile["displayName"], + }, + { + "type": "Container", + "spacing": "Small", + "items": [ + { + "type": "TextBlock", + "text": profile["jobTitle"], + "spacing": "Small", + }, + { + "type": "TextBlock", + "text": profile["mail"], + "spacing": "None", + }, + { + "type": "TextBlock", + "text": profile["givenName"], + "spacing": "None", + }, + { + "type": "TextBlock", + "text": profile["surname"], + "spacing": "None", + }, + ], + }, + ], + }, + ], + } + ], + } + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/src/dialog_helper.py b/test_samples/compat/dialogs/oauth_prompt/src/dialog_helper.py new file mode 100644 index 00000000..92e21dc4 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/src/dialog_helper.py @@ -0,0 +1,23 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import StatePropertyAccessor, TurnContext +from microsoft_agents.hosting.dialogs import ( + Dialog, + DialogSet, + DialogTurnStatus, +) + + +class DialogHelper: + @staticmethod + async def run_dialog( + dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor + ): + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/src/main.py b/test_samples/compat/dialogs/oauth_prompt/src/main.py new file mode 100644 index 00000000..4a19fe46 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/src/main.py @@ -0,0 +1,50 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from os import path, environ + +from aiohttp import web +from aiohttp.web import Request, Response +from microsoft_agents.authentication.msal import MsalConnectionManager +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + UserState, +) +from microsoft_agents.hosting.aiohttp import CloudAdapter, jwt_authorization_middleware +from microsoft_agents.activity import load_configuration_from_env +from dotenv import load_dotenv + +from .user_profile_dialog import UserProfileDialog +from .agent import DialogAgent + +load_dotenv(path.join(path.dirname(__file__), "..", ".env")) +agents_sdk_config = load_configuration_from_env(dict(environ)) + +STORAGE = MemoryStorage() +CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config) +ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER) + +CONVERSATION_STATE = ConversationState(STORAGE) +USER_STATE = UserState(STORAGE) + +DIALOG = UserProfileDialog(USER_STATE, "graph-oauth") +AGENT = DialogAgent(CONVERSATION_STATE, USER_STATE, DIALOG) + +# Listen for incoming requests on /api/messages. +async def messages(req: Request) -> Response: + return await ADAPTER.process(req, AGENT) + + +APP = web.Application(middlewares=[jwt_authorization_middleware]) +APP.router.add_post("/api/messages", messages) + +APP["agent_configuration"] = CONNECTION_MANAGER.get_default_connection_configuration() +APP["agent_app"] = AGENT +APP["adapter"] = ADAPTER + +if __name__ == "__main__": + try: + web.run_app(APP, host="localhost", port=3978) + except Exception as error: + raise error \ No newline at end of file diff --git a/test_samples/compat/dialogs/oauth_prompt/src/user_profile_dialog.py b/test_samples/compat/dialogs/oauth_prompt/src/user_profile_dialog.py new file mode 100644 index 00000000..1b281a04 --- /dev/null +++ b/test_samples/compat/dialogs/oauth_prompt/src/user_profile_dialog.py @@ -0,0 +1,108 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import aiohttp + +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, +) +from microsoft_agents.hosting.dialogs.prompts import ( + PromptOptions, + OAuthPrompt, + OAuthPromptSettings +) +from microsoft_agents.hosting.core import MessageFactory, UserState, AccessTokenProviderBase + +from .create_profile_card import create_profile_card + + +class UserProfileDialog(ComponentDialog): + def __init__(self, user_state: UserState, connection_name: str): + super(UserProfileDialog, self).__init__(UserProfileDialog.__name__) + + self.user_profile_accessor = user_state.create_property("UserProfile") + + self.add_dialog( + OAuthPrompt( + OAuthPrompt.__name__, + OAuthPromptSettings( + connection_name=connection_name, + title="Sign In", + text="Please login to your Microsoft account to continue.", + end_on_invalid_message=True, + ) + ) + ) + + self.add_dialog( + WaterfallDialog( + WaterfallDialog.__name__, + [ + self.oauth_step, # Add OAuth as first step + self.profile_step + ], + ) + ) + self.initial_dialog_id = WaterfallDialog.__name__ + + @staticmethod + async def get_user_info(token) -> dict[str, object]: + """ + Get information about the current user from Microsoft Graph API. + """ + async with aiohttp.ClientSession() as session: + headers = { + "Authorization": f"Bearer {token}", + "Content-Type": "application/json", + } + async with session.get( + "https://graph.microsoft.com/v1.0/me", headers=headers + ) as response: + if response.status == 200: + return await response.json() + error_text = await response.text() + raise Exception(f"Error from Graph API: {response.status} - {error_text}") + + async def oauth_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """First step: Authenticate the user with OAuth.""" + return await step_context.prompt( + OAuthPrompt.__name__, # Use the OAuthPrompt we defined + PromptOptions( + prompt=MessageFactory.text("Please sign in to continue.") + ) + ) + + async def profile_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Second step: Get user profile information using OAuth token and display profile card.""" + # Get the token from the OAuth step + token_response = step_context.result + + if token_response: + try: + # Use the token to get user info from Microsoft Graph + user_info = await self.get_user_info(token_response.token) + + # Create and send the profile card + profile_card = create_profile_card(user_info) + card_activity = MessageFactory.attachment(profile_card) + await step_context.context.send_activity(card_activity) + + # Send a text message as well + await step_context.context.send_activity( + MessageFactory.text(f"Hello {user_info.get('displayName', 'User')}! Here's your profile information.") + ) + + except Exception as e: + await step_context.context.send_activity( + MessageFactory.text(f"Sorry, I couldn't retrieve your profile information. Error: {str(e)}") + ) + else: + await step_context.context.send_activity( + MessageFactory.text("Authentication failed. Unable to get your profile.") + ) + + # End the dialog + return await step_context.end_dialog() \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/README.md b/test_samples/compat/dialogs/user_auth/README.md new file mode 100644 index 00000000..113211a3 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/README.md @@ -0,0 +1,3 @@ +Port of the [bot-authentication](https://github.com/microsoft/BotBuilder-Samples/tree/main/samples/python/18.bot-authentication) Python sample from the BotBuilder-Samples repo. + +Note: unlike the original, this sample uses the `on_invoke_activity` hook to pipe incoming activities to the OAuthPrompt. \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/env.TEMPLATE b/test_samples/compat/dialogs/user_auth/env.TEMPLATE new file mode 100644 index 00000000..b0bcf971 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/env.TEMPLATE @@ -0,0 +1,5 @@ +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +LOGGING__LOGLEVEL__microsoft_agents.hosting.core=INFO \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/requirements.txt b/test_samples/compat/dialogs/user_auth/requirements.txt new file mode 100644 index 00000000..727007a5 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/requirements.txt @@ -0,0 +1,5 @@ +microsoft-agents-hosting-dialogs +microsoft-agents-hosting-core +microsoft-agents-hosting-aiohttp +microsoft-agents-authentication-msal +python-dotenv diff --git a/test_samples/compat/dialogs/user_auth/src/__init__.py b/test_samples/compat/dialogs/user_auth/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test_samples/compat/dialogs/user_auth/src/auth_agent.py b/test_samples/compat/dialogs/user_auth/src/auth_agent.py new file mode 100644 index 00000000..a9ebfbab --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/auth_agent.py @@ -0,0 +1,43 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ( + ConversationState, + UserState, + TurnContext, +) +from microsoft_agents.hosting.dialogs import Dialog +from microsoft_agents.activity import ChannelAccount + +from .dialog_helper import DialogHelper +from .dialog_agent import DialogAgent + + +class AuthAgent(DialogAgent): + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + super(AuthAgent, self).__init__(conversation_state, user_state, dialog) + + async def on_members_added_activity( + self, members_added: list[ChannelAccount], turn_context: TurnContext + ): + for member in members_added: + # Greet anyone that was not the target (recipient) of this message. + # To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details. + if member.id != turn_context.activity.recipient.id: + await turn_context.send_activity( + "Welcome to AuthenticationBot. Type anything to get logged in. Type " + "'logout' to sign-out." + ) + + async def on_invoke_activity(self, turn_context: TurnContext): + # Run the Dialog with the new Token Response Event Activity. + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/src/dialog_agent.py b/test_samples/compat/dialogs/user_auth/src/dialog_agent.py new file mode 100644 index 00000000..2a8bc536 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/dialog_agent.py @@ -0,0 +1,41 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import ActivityHandler, ConversationState, UserState, TurnContext +from microsoft_agents.hosting.dialogs import Dialog +from .dialog_helper import DialogHelper + + +class DialogAgent(ActivityHandler): + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + if conversation_state is None: + raise Exception( + "[DialogBot]: Missing parameter. conversation_state is required" + ) + if user_state is None: + raise Exception("[DialogBot]: Missing parameter. user_state is required") + if dialog is None: + raise Exception("[DialogBot]: Missing parameter. dialog is required") + + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have occurred during the turn. + await self.conversation_state.save(turn_context, False) + await self.user_state.save(turn_context, False) + + async def on_message_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/src/dialog_helper.py b/test_samples/compat/dialogs/user_auth/src/dialog_helper.py new file mode 100644 index 00000000..154ea39c --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/dialog_helper.py @@ -0,0 +1,19 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import StatePropertyAccessor, TurnContext +from microsoft_agents.hosting.dialogs import Dialog, DialogSet, DialogTurnStatus + + +class DialogHelper: + @staticmethod + async def run_dialog( + dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor + ): + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/src/logout_dialog.py b/test_samples/compat/dialogs/user_auth/src/logout_dialog.py new file mode 100644 index 00000000..48c2c151 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/logout_dialog.py @@ -0,0 +1,42 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.dialogs import DialogTurnResult, ComponentDialog, DialogContext +from microsoft_agents.activity import ActivityTypes +from microsoft_agents.hosting.core import UserTokenClient + + +class LogoutDialog(ComponentDialog): + def __init__(self, dialog_id: str, connection_name: str): + super(LogoutDialog, self).__init__(dialog_id) + + self.connection_name = connection_name + + async def on_begin_dialog( + self, inner_dc: DialogContext, options: object + ) -> DialogTurnResult: + result = await self._interrupt(inner_dc) + if result: + return result + return await super().on_begin_dialog(inner_dc, options) + + async def on_continue_dialog(self, inner_dc: DialogContext) -> DialogTurnResult: + result = await self._interrupt(inner_dc) + if result: + return result + return await super().on_continue_dialog(inner_dc) + + async def _interrupt(self, inner_dc: DialogContext): + if inner_dc.context.activity.type == ActivityTypes.message: + text = inner_dc.context.activity.text.lower() + if text == "logout": + user_token_client: UserTokenClient = inner_dc.context.turn_state.get( + UserTokenClient.__name__, None + ) + await user_token_client.user_token.sign_out( + inner_dc.context.activity.from_property.id, + self.connection_name, + inner_dc.context.activity.channel_id, + ) + await inner_dc.context.send_activity("You have been signed out.") + return await inner_dc.cancel_all_dialogs() \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/src/main.py b/test_samples/compat/dialogs/user_auth/src/main.py new file mode 100644 index 00000000..2c476d92 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/main.py @@ -0,0 +1,50 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from os import path, environ + +from aiohttp import web +from aiohttp.web import Request, Response +from microsoft_agents.authentication.msal import MsalConnectionManager +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + UserState, +) +from microsoft_agents.hosting.aiohttp import CloudAdapter, jwt_authorization_middleware +from microsoft_agents.activity import load_configuration_from_env +from dotenv import load_dotenv + +from .main_dialog import MainDialog +from .auth_agent import AuthAgent + +load_dotenv(path.join(path.dirname(__file__), "..", ".env")) +agents_sdk_config = load_configuration_from_env(dict(environ)) + +STORAGE = MemoryStorage() +CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config) +ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER) + +CONVERSATION_STATE = ConversationState(STORAGE) +USER_STATE = UserState(STORAGE) + +DIALOG = MainDialog("graph-oauth") +AGENT = AuthAgent(CONVERSATION_STATE, USER_STATE, DIALOG) + +# Listen for incoming requests on /api/messages. +async def messages(req: Request) -> Response: + return await ADAPTER.process(req, AGENT) + + +APP = web.Application(middlewares=[jwt_authorization_middleware]) +APP.router.add_post("/api/messages", messages) + +APP["agent_configuration"] = CONNECTION_MANAGER.get_default_connection_configuration() +APP["agent_app"] = AGENT +APP["adapter"] = ADAPTER + +if __name__ == "__main__": + try: + web.run_app(APP, host="localhost", port=3978) + except Exception as error: + raise error \ No newline at end of file diff --git a/test_samples/compat/dialogs/user_auth/src/main_dialog.py b/test_samples/compat/dialogs/user_auth/src/main_dialog.py new file mode 100644 index 00000000..fa288371 --- /dev/null +++ b/test_samples/compat/dialogs/user_auth/src/main_dialog.py @@ -0,0 +1,94 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from microsoft_agents.hosting.core import MessageFactory +from microsoft_agents.hosting.dialogs import ( + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, + PromptOptions, +) +from microsoft_agents.hosting.dialogs.prompts import OAuthPrompt, OAuthPromptSettings, ConfirmPrompt + +from .logout_dialog import LogoutDialog + + +class MainDialog(LogoutDialog): + def __init__(self, connection_name: str): + super(MainDialog, self).__init__(MainDialog.__name__, connection_name) + + self.add_dialog( + OAuthPrompt( + OAuthPrompt.__name__, + OAuthPromptSettings( + connection_name=connection_name, + text="Please Sign In", + title="Sign In", + timeout=300000, + ), + ) + ) + + self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) + + self.add_dialog( + WaterfallDialog( + "WFDialog", + [ + self.prompt_step, + self.login_step, + self.display_token_phase1, + self.display_token_phase2, + ], + ) + ) + + self.initial_dialog_id = "WFDialog" + + async def prompt_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + return await step_context.begin_dialog(OAuthPrompt.__name__) + + async def login_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + # Get the token from the previous step. Note that we could also have gotten the + # token directly from the prompt itself. There is an example of this in the next method. + if step_context.result: + await step_context.context.send_activity("You are now logged in.") + return await step_context.prompt( + ConfirmPrompt.__name__, + PromptOptions( + prompt=MessageFactory.text("Would you like to view your token?") + ), + ) + + await step_context.context.send_activity( + "Login was not successful please try again." + ) + return await step_context.end_dialog() + + async def display_token_phase1( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + await step_context.context.send_activity("Thank you.") + + if step_context.result: + # Call the prompt again because we need the token. The reasons for this are: + # 1. If the user is already logged in we do not need to store the token locally in the bot and worry + # about refreshing it. We can always just call the prompt again to get the token. + # 2. We never know how long it will take a user to respond. By the time the + # user responds the token may have expired. The user would then be prompted to login again. + # + # There is no reason to store the token locally in the bot because we can always just call + # the OAuth prompt to get the token or get a new token if needed. + return await step_context.begin_dialog(OAuthPrompt.__name__) + + return await step_context.end_dialog() + + async def display_token_phase2( + self, step_context: WaterfallStepContext + ) -> DialogTurnResult: + if step_context.result: + await step_context.context.send_activity( + f"Here is your token {step_context.result.token}" + ) + + return await step_context.end_dialog() \ No newline at end of file diff --git a/test_samples/teams_agent/app.py b/test_samples/compat/teams_agent/app.py similarity index 90% rename from test_samples/teams_agent/app.py rename to test_samples/compat/teams_agent/app.py index 744dc132..a479d439 100644 --- a/test_samples/teams_agent/app.py +++ b/test_samples/compat/teams_agent/app.py @@ -11,10 +11,10 @@ from microsoft_agents.hosting.aiohttp import CloudAdapter, jwt_authorization_decorator from microsoft_agents.hosting.core import Authorization, MemoryStorage, UserState -from teams_handler import TeamsHandler -from teams_sso import TeamsSso -from teams_multi_feature import TeamsMultiFeature -from config import DefaultConfig +from test_samples.activity_handler.teams_agent.teams_handler import TeamsHandler +from test_samples.activity_handler.teams_agent.teams_sso import TeamsSso +from test_samples.activity_handler.teams_agent.teams_multi_feature import TeamsMultiFeature +from test_samples.activity_handler.teams_agent.config import DefaultConfig load_dotenv(path.join(path.dirname(__file__), ".env")) diff --git a/test_samples/teams_agent/cards/AdaptiveCard.json b/test_samples/compat/teams_agent/cards/AdaptiveCard.json similarity index 100% rename from test_samples/teams_agent/cards/AdaptiveCard.json rename to test_samples/compat/teams_agent/cards/AdaptiveCard.json diff --git a/test_samples/teams_agent/cards/AdaptiveCard_TaskModule.json b/test_samples/compat/teams_agent/cards/AdaptiveCard_TaskModule.json similarity index 100% rename from test_samples/teams_agent/cards/AdaptiveCard_TaskModule.json rename to test_samples/compat/teams_agent/cards/AdaptiveCard_TaskModule.json diff --git a/test_samples/teams_agent/cards/RestaurantCard.json b/test_samples/compat/teams_agent/cards/RestaurantCard.json similarity index 100% rename from test_samples/teams_agent/cards/RestaurantCard.json rename to test_samples/compat/teams_agent/cards/RestaurantCard.json diff --git a/test_samples/teams_agent/cards/UserProfileCard.json b/test_samples/compat/teams_agent/cards/UserProfileCard.json similarity index 100% rename from test_samples/teams_agent/cards/UserProfileCard.json rename to test_samples/compat/teams_agent/cards/UserProfileCard.json diff --git a/test_samples/teams_agent/config.py b/test_samples/compat/teams_agent/config.py similarity index 100% rename from test_samples/teams_agent/config.py rename to test_samples/compat/teams_agent/config.py diff --git a/test_samples/teams_agent/env.TEMPLATE b/test_samples/compat/teams_agent/env.TEMPLATE similarity index 98% rename from test_samples/teams_agent/env.TEMPLATE rename to test_samples/compat/teams_agent/env.TEMPLATE index 5c857b7c..06c1ab5f 100644 --- a/test_samples/teams_agent/env.TEMPLATE +++ b/test_samples/compat/teams_agent/env.TEMPLATE @@ -1,7 +1,7 @@ -# Rename to .env -CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id -CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret -CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id - -AGENTAPPLICATION__USERAUTHORIZATION__HANDLERS__GRAPH__SETTINGS__AZUREBOTOAUTHCONNECTIONNAME=connection-name +# Rename to .env +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTID=client-id +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__CLIENTSECRET=client-secret +CONNECTIONS__SERVICE_CONNECTION__SETTINGS__TENANTID=tenant-id + +AGENTAPPLICATION__USERAUTHORIZATION__HANDLERS__GRAPH__SETTINGS__AZUREBOTOAUTHCONNECTIONNAME=connection-name AGENT_TYPE=TeamsSso \ No newline at end of file diff --git a/test_samples/teams_agent/graph_client.py b/test_samples/compat/teams_agent/graph_client.py similarity index 100% rename from test_samples/teams_agent/graph_client.py rename to test_samples/compat/teams_agent/graph_client.py diff --git a/test_samples/teams_agent/helpers/task_module_ids.py b/test_samples/compat/teams_agent/helpers/task_module_ids.py similarity index 100% rename from test_samples/teams_agent/helpers/task_module_ids.py rename to test_samples/compat/teams_agent/helpers/task_module_ids.py diff --git a/test_samples/teams_agent/helpers/task_module_response_factory.py b/test_samples/compat/teams_agent/helpers/task_module_response_factory.py similarity index 100% rename from test_samples/teams_agent/helpers/task_module_response_factory.py rename to test_samples/compat/teams_agent/helpers/task_module_response_factory.py diff --git a/test_samples/teams_agent/helpers/task_module_ui_constants.py b/test_samples/compat/teams_agent/helpers/task_module_ui_constants.py similarity index 100% rename from test_samples/teams_agent/helpers/task_module_ui_constants.py rename to test_samples/compat/teams_agent/helpers/task_module_ui_constants.py diff --git a/test_samples/teams_agent/helpers/ui_settings.py b/test_samples/compat/teams_agent/helpers/ui_settings.py similarity index 100% rename from test_samples/teams_agent/helpers/ui_settings.py rename to test_samples/compat/teams_agent/helpers/ui_settings.py diff --git a/test_samples/teams_agent/pages/customForm.html b/test_samples/compat/teams_agent/pages/customForm.html similarity index 100% rename from test_samples/teams_agent/pages/customForm.html rename to test_samples/compat/teams_agent/pages/customForm.html diff --git a/test_samples/teams_agent/pages/youtube.html b/test_samples/compat/teams_agent/pages/youtube.html similarity index 100% rename from test_samples/teams_agent/pages/youtube.html rename to test_samples/compat/teams_agent/pages/youtube.html diff --git a/test_samples/teams_agent/teams_handler.py b/test_samples/compat/teams_agent/teams_handler.py similarity index 100% rename from test_samples/teams_agent/teams_handler.py rename to test_samples/compat/teams_agent/teams_handler.py diff --git a/test_samples/teams_agent/teams_multi_feature.py b/test_samples/compat/teams_agent/teams_multi_feature.py similarity index 97% rename from test_samples/teams_agent/teams_multi_feature.py rename to test_samples/compat/teams_agent/teams_multi_feature.py index 4d9b5c17..da36b017 100644 --- a/test_samples/teams_agent/teams_multi_feature.py +++ b/test_samples/compat/teams_agent/teams_multi_feature.py @@ -13,10 +13,10 @@ TeamsInfo, ) -from helpers.task_module_response_factory import TaskModuleResponseFactory -from helpers.task_module_ids import TaskModuleIds -from helpers.ui_settings import UISettings -from helpers.task_module_ui_constants import TaskModuleUIConstants +from test_samples.activity_handler.teams_agent.helpers.task_module_response_factory import TaskModuleResponseFactory +from test_samples.activity_handler.teams_agent.helpers.task_module_ids import TaskModuleIds +from test_samples.activity_handler.teams_agent.helpers.ui_settings import UISettings +from test_samples.activity_handler.teams_agent.helpers.task_module_ui_constants import TaskModuleUIConstants class TeamsMultiFeature(TeamsActivityHandler): diff --git a/test_samples/teams_agent/teams_sso.py b/test_samples/compat/teams_agent/teams_sso.py similarity index 97% rename from test_samples/teams_agent/teams_sso.py rename to test_samples/compat/teams_agent/teams_sso.py index be6bb8f2..d46dfbff 100644 --- a/test_samples/teams_agent/teams_sso.py +++ b/test_samples/compat/teams_agent/teams_sso.py @@ -8,7 +8,7 @@ from microsoft_agents.activity import ChannelAccount from microsoft_agents.hosting.teams import TeamsActivityHandler -from graph_client import GraphClient +from test_samples.activity_handler.teams_agent.graph_client import GraphClient class TeamsSso(TeamsActivityHandler): diff --git a/test_samples/weather-agent-open-ai/app.py b/test_samples/compat/weather-agent-open-ai/app.py similarity index 100% rename from test_samples/weather-agent-open-ai/app.py rename to test_samples/compat/weather-agent-open-ai/app.py diff --git a/test_samples/weather-agent-open-ai/config.py b/test_samples/compat/weather-agent-open-ai/config.py similarity index 100% rename from test_samples/weather-agent-open-ai/config.py rename to test_samples/compat/weather-agent-open-ai/config.py diff --git a/test_samples/weather-agent-open-ai/env.TEMPLATE b/test_samples/compat/weather-agent-open-ai/env.TEMPLATE similarity index 95% rename from test_samples/weather-agent-open-ai/env.TEMPLATE rename to test_samples/compat/weather-agent-open-ai/env.TEMPLATE index 0967a373..6ea946f8 100644 --- a/test_samples/weather-agent-open-ai/env.TEMPLATE +++ b/test_samples/compat/weather-agent-open-ai/env.TEMPLATE @@ -1,7 +1,7 @@ -# Rename to .env -TENANT_ID= -CLIENT_ID= -CLIENT_SECRET= -AZURE_OPENAI_API_KEY= -AZURE_OPENAI_API_VERSION= +# Rename to .env +TENANT_ID= +CLIENT_ID= +CLIENT_SECRET= +AZURE_OPENAI_API_KEY= +AZURE_OPENAI_API_VERSION= AZURE_OPENAI_ENDPOINT= \ No newline at end of file diff --git a/test_samples/weather-agent-open-ai/requirements.txt b/test_samples/compat/weather-agent-open-ai/requirements.txt similarity index 100% rename from test_samples/weather-agent-open-ai/requirements.txt rename to test_samples/compat/weather-agent-open-ai/requirements.txt diff --git a/test_samples/weather-agent-open-ai/tools/date_time_tool.py b/test_samples/compat/weather-agent-open-ai/tools/date_time_tool.py similarity index 100% rename from test_samples/weather-agent-open-ai/tools/date_time_tool.py rename to test_samples/compat/weather-agent-open-ai/tools/date_time_tool.py diff --git a/test_samples/weather-agent-open-ai/tools/get_weather_tool.py b/test_samples/compat/weather-agent-open-ai/tools/get_weather_tool.py similarity index 100% rename from test_samples/weather-agent-open-ai/tools/get_weather_tool.py rename to test_samples/compat/weather-agent-open-ai/tools/get_weather_tool.py diff --git a/test_samples/weather-agent-open-ai/weather_agent.py b/test_samples/compat/weather-agent-open-ai/weather_agent.py similarity index 100% rename from test_samples/weather-agent-open-ai/weather_agent.py rename to test_samples/compat/weather-agent-open-ai/weather_agent.py diff --git a/tests/hosting_core/state/test_agent_state.py b/tests/hosting_core/state/test_agent_state.py index c5b2a971..9f4bddbd 100644 --- a/tests/hosting_core/state/test_agent_state.py +++ b/tests/hosting_core/state/test_agent_state.py @@ -490,3 +490,45 @@ async def test_state_property_accessor_error_conditions(self): elif not isinstance(invalid_name, str): with pytest.raises((TypeError, ValueError)): self.user_state.create_property(invalid_name) + + @pytest.mark.asyncio + async def test_get_value_falsy_stored_values_are_not_overwritten(self): + """Falsy stored values (0, False, "", {}, []) must be returned as-is and + must NOT trigger the default_value_factory.""" + await self.user_state.load(self.context) + factory_called = [] + + for falsy_value in [0, False, "", {}, []]: + prop = self.user_state.create_property(f"prop_{falsy_value!r}") + await prop.set(self.context, falsy_value) + + retrieved = await prop.get( + self.context, lambda: factory_called.append(True) or "DEFAULT" + ) + assert ( + retrieved == falsy_value + ), f"Expected {falsy_value!r}, got {retrieved!r}" + + assert ( + not factory_called + ), "default_value_factory should not be called for falsy stored values" + + @pytest.mark.asyncio + async def test_get_value_none_triggers_factory_but_falsy_does_not(self): + """The factory is called when the stored value is None (missing), but not for 0 or False.""" + await self.user_state.load(self.context) + + prop_none = self.user_state.create_property("prop_none") + prop_zero = self.user_state.create_property("prop_zero") + prop_false = self.user_state.create_property("prop_false") + + await prop_zero.set(self.context, 0) + await prop_false.set(self.context, False) + # prop_none is never set — remains None + + assert ( + await prop_none.get(self.context, lambda: "factory_default") + == "factory_default" + ) + assert await prop_zero.get(self.context, lambda: 99) == 0 + assert await prop_false.get(self.context, lambda: True) is False diff --git a/tests/hosting_dialogs/__init__.py b/tests/hosting_dialogs/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/hosting_dialogs/choices/__init__.py b/tests/hosting_dialogs/choices/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/hosting_dialogs/choices/test_channel.py b/tests/hosting_dialogs/choices/test_channel.py new file mode 100644 index 00000000..74fc849c --- /dev/null +++ b/tests/hosting_dialogs/choices/test_channel.py @@ -0,0 +1,89 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List, Tuple + +import pytest + +from microsoft_agents.activity import ( + Activity, + ActivityTypes, + Channels, + ConversationAccount, + ChannelAccount, +) +from microsoft_agents.hosting.core import TurnContext +from microsoft_agents.hosting.dialogs.choices import Channel +from tests._common.testing_objects import MockTestingAdapter + + +class TestChannel: + def test_supports_suggested_actions(self): + actual = Channel.supports_suggested_actions(Channels.facebook, 5) + assert actual + + def test_supports_suggested_actions_many(self): + supports_suggested_actions_data: List[Tuple[str, int, bool]] = [ + (Channels.line, 13, True), + (Channels.line, 14, False), + (Channels.skype, 10, True), + (Channels.skype, 11, False), + (Channels.kik, 20, True), + (Channels.kik, 21, False), + (Channels.emulator, 100, True), + (Channels.emulator, 101, False), + (Channels.direct_line_speech, 100, True), + ] + + for channel, button_cnt, expected in supports_suggested_actions_data: + actual = Channel.supports_suggested_actions(channel, button_cnt) + assert ( + expected == actual + ), f"channel={channel}, button_cnt={button_cnt}: expected {expected}, got {actual}" + + def test_supports_card_actions_many(self): + supports_card_action_data: List[Tuple[str, int, bool]] = [ + (Channels.line, 99, True), + (Channels.line, 100, False), + (Channels.slack, 100, True), + (Channels.skype, 3, True), + (Channels.skype, 5, False), + (Channels.direct_line_speech, 99, True), + ] + + for channel, button_cnt, expected in supports_card_action_data: + actual = Channel.supports_card_actions(channel, button_cnt) + assert ( + expected == actual + ), f"channel={channel}, button_cnt={button_cnt}: expected {expected}, got {actual}" + + def test_supports_suggested_actions_accepts_string_channel_id(self): + assert Channel.supports_suggested_actions("facebook", 5) + assert not Channel.supports_suggested_actions("facebook", 11) + + def test_supports_card_actions_accepts_string_channel_id(self): + assert Channel.supports_card_actions("msteams", 3) + assert not Channel.supports_card_actions("msteams", 4) + + def test_should_return_channel_id_from_context_activity(self): + adapter = MockTestingAdapter(channel_id=Channels.facebook) + test_activity = Activity( + type=ActivityTypes.message, + channel_id=Channels.facebook, + conversation=ConversationAccount(id="test"), + from_property=ChannelAccount(id="user"), + ) + test_context = TurnContext(adapter, test_activity) + channel_id = Channel.get_channel_id(test_context) + assert Channels.facebook == channel_id + + def test_should_return_empty_from_context_activity_missing_channel(self): + adapter = MockTestingAdapter() + test_activity = Activity( + type=ActivityTypes.message, + conversation=ConversationAccount(id="test"), + from_property=ChannelAccount(id="user"), + ) + test_context = TurnContext(adapter, test_activity) + channel_id = Channel.get_channel_id(test_context) + assert "" == channel_id diff --git a/tests/hosting_dialogs/choices/test_choice.py b/tests/hosting_dialogs/choices/test_choice.py new file mode 100644 index 00000000..4b37a3e6 --- /dev/null +++ b/tests/hosting_dialogs/choices/test_choice.py @@ -0,0 +1,29 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +import pytest + +from microsoft_agents.hosting.dialogs.choices import Choice +from microsoft_agents.activity import CardAction + + +class TestChoice: + def test_value_round_trips(self) -> None: + choice = Choice() + expected = "any" + choice.value = expected + assert expected is choice.value + + def test_action_round_trips(self) -> None: + choice = Choice() + expected = CardAction(type="imBack", title="Test Action") + choice.action = expected + assert expected is choice.action + + def test_synonyms_round_trips(self) -> None: + choice = Choice() + expected: List[str] = [] + choice.synonyms = expected + assert expected is choice.synonyms diff --git a/tests/hosting_dialogs/choices/test_choice_factory.py b/tests/hosting_dialogs/choices/test_choice_factory.py new file mode 100644 index 00000000..47e143ff --- /dev/null +++ b/tests/hosting_dialogs/choices/test_choice_factory.py @@ -0,0 +1,237 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +import pytest + +from microsoft_agents.hosting.dialogs.choices import ( + Choice, + ChoiceFactory, + ChoiceFactoryOptions, +) +from microsoft_agents.activity import ( + ActionTypes, + Activity, + ActivityTypes, + Attachment, + AttachmentLayoutTypes, + CardAction, + HeroCard, + InputHints, + SuggestedActions, + Channels, +) + + +class TestChoiceFactory: + color_choices: List[Choice] = [Choice("red"), Choice("green"), Choice("blue")] + choices_with_actions: List[Choice] = [ + Choice( + "ImBack", + action=CardAction( + type=ActionTypes.im_back, title="ImBack Action", value="ImBack Value" + ), + ), + Choice( + "MessageBack", + action=CardAction( + type=ActionTypes.message_back, + title="MessageBack Action", + value="MessageBack Value", + ), + ), + Choice( + "PostBack", + action=CardAction( + type=ActionTypes.post_back, + title="PostBack Action", + value="PostBack Value", + ), + ), + ] + + def test_inline_should_render_choices_inline(self): + activity = ChoiceFactory.inline(TestChoiceFactory.color_choices, "select from:") + assert "select from: (1) red, (2) green, or (3) blue" == activity.text + + def test_should_render_choices_as_a_list(self): + activity = ChoiceFactory.list_style( + TestChoiceFactory.color_choices, "select from:" + ) + assert "select from:\n\n 1. red\n 2. green\n 3. blue" == activity.text + + def test_should_render_unincluded_numbers_choices_as_a_list(self): + activity = ChoiceFactory.list_style( + TestChoiceFactory.color_choices, + "select from:", + options=ChoiceFactoryOptions(include_numbers=False), + ) + assert "select from:\n\n - red\n - green\n - blue" == activity.text + + def test_should_render_choices_as_suggested_actions(self): + expected = Activity( + type=ActivityTypes.message, + text="select from:", + input_hint=InputHints.expecting_input, + suggested_actions=SuggestedActions( + actions=[ + CardAction(type=ActionTypes.im_back, value="red", title="red"), + CardAction(type=ActionTypes.im_back, value="green", title="green"), + CardAction(type=ActionTypes.im_back, value="blue", title="blue"), + ] + ), + ) + + activity = ChoiceFactory.suggested_action( + TestChoiceFactory.color_choices, "select from:" + ) + + assert expected == activity + + def test_should_render_choices_as_hero_card(self): + expected = Activity( + type=ActivityTypes.message, + input_hint=InputHints.expecting_input, + attachment_layout=AttachmentLayoutTypes.list, + attachments=[ + Attachment( + content=HeroCard( + text="select from:", + buttons=[ + CardAction( + type=ActionTypes.im_back, value="red", title="red" + ), + CardAction( + type=ActionTypes.im_back, value="green", title="green" + ), + CardAction( + type=ActionTypes.im_back, value="blue", title="blue" + ), + ], + ), + content_type="application/vnd.microsoft.card.hero", + ) + ], + ) + + activity = ChoiceFactory.hero_card( + TestChoiceFactory.color_choices, "select from:" + ) + + assert expected == activity + + def test_should_automatically_choose_render_style_based_on_channel_type(self): + expected = Activity( + type=ActivityTypes.message, + text="select from:", + input_hint=InputHints.expecting_input, + suggested_actions=SuggestedActions( + actions=[ + CardAction(type=ActionTypes.im_back, value="red", title="red"), + CardAction(type=ActionTypes.im_back, value="green", title="green"), + CardAction(type=ActionTypes.im_back, value="blue", title="blue"), + ] + ), + ) + activity = ChoiceFactory.for_channel( + Channels.emulator, TestChoiceFactory.color_choices, "select from:" + ) + + assert expected == activity + + def test_should_choose_correct_styles_for_teams(self): + expected = Activity( + type=ActivityTypes.message, + input_hint=InputHints.expecting_input, + attachment_layout=AttachmentLayoutTypes.list, + attachments=[ + Attachment( + content=HeroCard( + text="select from:", + buttons=[ + CardAction( + type=ActionTypes.im_back, value="red", title="red" + ), + CardAction( + type=ActionTypes.im_back, value="green", title="green" + ), + CardAction( + type=ActionTypes.im_back, value="blue", title="blue" + ), + ], + ), + content_type="application/vnd.microsoft.card.hero", + ) + ], + ) + activity = ChoiceFactory.for_channel( + Channels.ms_teams, TestChoiceFactory.color_choices, "select from:" + ) + assert expected == activity + + def test_should_include_choice_actions_in_suggested_actions(self): + expected = Activity( + type=ActivityTypes.message, + text="select from:", + input_hint=InputHints.expecting_input, + suggested_actions=SuggestedActions( + actions=[ + CardAction( + type=ActionTypes.im_back, + value="ImBack Value", + title="ImBack Action", + ), + CardAction( + type=ActionTypes.message_back, + value="MessageBack Value", + title="MessageBack Action", + ), + CardAction( + type=ActionTypes.post_back, + value="PostBack Value", + title="PostBack Action", + ), + ] + ), + ) + activity = ChoiceFactory.suggested_action( + TestChoiceFactory.choices_with_actions, "select from:" + ) + assert expected == activity + + def test_should_include_choice_actions_in_hero_cards(self): + expected = Activity( + type=ActivityTypes.message, + input_hint=InputHints.expecting_input, + attachment_layout=AttachmentLayoutTypes.list, + attachments=[ + Attachment( + content=HeroCard( + text="select from:", + buttons=[ + CardAction( + type=ActionTypes.im_back, + value="ImBack Value", + title="ImBack Action", + ), + CardAction( + type=ActionTypes.message_back, + value="MessageBack Value", + title="MessageBack Action", + ), + CardAction( + type=ActionTypes.post_back, + value="PostBack Value", + title="PostBack Action", + ), + ], + ), + content_type="application/vnd.microsoft.card.hero", + ) + ], + ) + activity = ChoiceFactory.hero_card( + TestChoiceFactory.choices_with_actions, "select from:" + ) + assert expected == activity diff --git a/tests/hosting_dialogs/choices/test_choice_factory_options.py b/tests/hosting_dialogs/choices/test_choice_factory_options.py new file mode 100644 index 00000000..2e3563a7 --- /dev/null +++ b/tests/hosting_dialogs/choices/test_choice_factory_options.py @@ -0,0 +1,32 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs.choices import ChoiceFactoryOptions + + +class TestChoiceFactoryOptions: + def test_inline_separator_round_trips(self) -> None: + choice_factor_options = ChoiceFactoryOptions() + expected = ", " + choice_factor_options.inline_separator = expected + assert expected == choice_factor_options.inline_separator + + def test_inline_or_round_trips(self) -> None: + choice_factor_options = ChoiceFactoryOptions() + expected = " or " + choice_factor_options.inline_or = expected + assert expected == choice_factor_options.inline_or + + def test_inline_or_more_round_trips(self) -> None: + choice_factor_options = ChoiceFactoryOptions() + expected = ", or " + choice_factor_options.inline_or_more = expected + assert expected == choice_factor_options.inline_or_more + + def test_include_numbers_round_trips(self) -> None: + choice_factor_options = ChoiceFactoryOptions() + expected = True + choice_factor_options.include_numbers = expected + assert expected == choice_factor_options.include_numbers diff --git a/tests/hosting_dialogs/choices/test_choice_recognizers.py b/tests/hosting_dialogs/choices/test_choice_recognizers.py new file mode 100644 index 00000000..edc63cd2 --- /dev/null +++ b/tests/hosting_dialogs/choices/test_choice_recognizers.py @@ -0,0 +1,198 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +import pytest + +from microsoft_agents.hosting.dialogs.choices import ( + ChoiceRecognizers, + Find, + FindValuesOptions, + SortedValue, +) + + +def assert_result(result, start, end, text): + assert ( + result.start == start + ), f"Invalid ModelResult.start of '{result.start}' for '{text}' result." + assert ( + result.end == end + ), f"Invalid ModelResult.end of '{result.end}' for '{text}' result." + assert ( + result.text == text + ), f"Invalid ModelResult.text of '{result.text}' for '{text}' result." + + +def assert_value(result, value, index, score): + assert ( + result.type_name == "value" + ), f"Invalid ModelResult.type_name of '{result.type_name}' for '{value}' value." + assert result.resolution, f"Missing ModelResult.resolution for '{value}' value." + resolution = result.resolution + assert ( + resolution.value == value + ), f"Invalid resolution.value of '{resolution.value}' for '{value}' value." + assert ( + resolution.index == index + ), f"Invalid resolution.index of '{resolution.index}' for '{value}' value." + assert ( + resolution.score == score + ), f"Invalid resolution.score of '{resolution.score}' for '{value}' value." + + +def assert_choice(result, value, index, score, synonym=None): + assert ( + result.type_name == "choice" + ), f"Invalid ModelResult.type_name of '{result.type_name}' for '{value}' choice." + assert result.resolution, f"Missing ModelResult.resolution for '{value}' choice." + resolution = result.resolution + assert ( + resolution.value == value + ), f"Invalid resolution.value of '{resolution.value}' for '{value}' choice." + assert ( + resolution.index == index + ), f"Invalid resolution.index of '{resolution.index}' for '{value}' choice." + assert ( + resolution.score == score + ), f"Invalid resolution.score of '{resolution.score}' for '{value}' choice." + if synonym: + assert ( + resolution.synonym == synonym + ), f"Invalid resolution.synonym of '{resolution.synonym}' for '{value}' choice." + + +_color_choices: List[str] = ["red", "green", "blue"] +_overlapping_choices: List[str] = ["bread", "bread pudding", "pudding"] + +_color_values: List[SortedValue] = [ + SortedValue(value="red", index=0), + SortedValue(value="green", index=1), + SortedValue(value="blue", index=2), +] + +_overlapping_values: List[SortedValue] = [ + SortedValue(value="bread", index=0), + SortedValue(value="bread pudding", index=1), + SortedValue(value="pudding", index=2), +] + +_similar_values: List[SortedValue] = [ + SortedValue(value="option A", index=0), + SortedValue(value="option B", index=1), + SortedValue(value="option C", index=2), +] + + +class TestChoiceRecognizers: + # Find.find_values + + def test_should_find_a_simple_value_in_a_single_word_utterance(self): + found = Find.find_values("red", _color_values) + assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 0, 2, "red") + assert_value(found[0], "red", 0, 1.0) + + def test_should_find_a_simple_value_in_an_utterance(self): + found = Find.find_values("the red one please.", _color_values) + assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 6, "red") + assert_value(found[0], "red", 0, 1.0) + + def test_should_find_multiple_values_within_an_utterance(self): + found = Find.find_values("the red and blue ones please.", _color_values) + assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 6, "red") + assert_value(found[0], "red", 0, 1.0) + assert_value(found[1], "blue", 2, 1.0) + + def test_should_find_multiple_values_that_overlap(self): + found = Find.find_values( + "the bread pudding and bread please.", _overlapping_values + ) + assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 16, "bread pudding") + assert_value(found[0], "bread pudding", 1, 1.0) + assert_value(found[1], "bread", 0, 1.0) + + def test_should_correctly_disambiguate_between_similar_values(self): + found = Find.find_values( + "option B", _similar_values, FindValuesOptions(allow_partial_matches=True) + ) + assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." + assert_value(found[0], "option B", 1, 1.0) + + def test_should_find_a_single_choice_in_an_utterance(self): + found = Find.find_choices("the red one please.", _color_choices) + assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 6, "red") + assert_choice(found[0], "red", 0, 1.0, "red") + + def test_should_find_multiple_choices_within_an_utterance(self): + found = Find.find_choices("the red and blue ones please.", _color_choices) + assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 6, "red") + assert_choice(found[0], "red", 0, 1.0) + assert_choice(found[1], "blue", 2, 1.0) + + def test_should_find_multiple_choices_that_overlap(self): + found = Find.find_choices( + "the bread pudding and bread please.", _overlapping_choices + ) + assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." + assert_result(found[0], 4, 16, "bread pudding") + assert_choice(found[0], "bread pudding", 1, 1.0) + assert_choice(found[1], "bread", 0, 1.0) + + def test_should_accept_null_utterance_in_find_choices(self): + found = Find.find_choices(None, _color_choices) + assert not found + + # ChoiceRecognizers.recognize_choices + + def test_should_find_a_choice_in_an_utterance_by_name(self): + found = ChoiceRecognizers.recognize_choices( + "the red one please.", _color_choices + ) + assert len(found) == 1 + assert_result(found[0], 4, 6, "red") + assert_choice(found[0], "red", 0, 1.0, "red") + + def test_should_find_a_choice_in_an_utterance_by_ordinal_position(self): + found = ChoiceRecognizers.recognize_choices( + "the first one please.", _color_choices + ) + assert len(found) == 1 + assert_result(found[0], 4, 8, "first") + assert_choice(found[0], "red", 0, 1.0) + + def test_should_find_multiple_choices_in_an_utterance_by_ordinal_position(self): + found = ChoiceRecognizers.recognize_choices( + "the first and third one please", _color_choices + ) + assert len(found) == 2 + assert_choice(found[0], "red", 0, 1.0) + assert_choice(found[1], "blue", 2, 1.0) + + def test_should_find_a_choice_in_an_utterance_by_numerical_index_digit(self): + found = ChoiceRecognizers.recognize_choices("1", _color_choices) + assert len(found) == 1 + assert_result(found[0], 0, 0, "1") + assert_choice(found[0], "red", 0, 1.0) + + def test_should_find_a_choice_in_an_utterance_by_numerical_index_text(self): + found = ChoiceRecognizers.recognize_choices("one", _color_choices) + assert len(found) == 1 + assert_result(found[0], 0, 2, "one") + assert_choice(found[0], "red", 0, 1.0) + + def test_should_find_multiple_choices_in_an_utterance_by_numerical_index(self): + found = ChoiceRecognizers.recognize_choices("option one and 3.", _color_choices) + assert len(found) == 2 + assert_choice(found[0], "red", 0, 1.0) + assert_choice(found[1], "blue", 2, 1.0) + + def test_should_accept_null_utterance_in_recognize_choices(self): + found = ChoiceRecognizers.recognize_choices(None, _color_choices) + assert not found diff --git a/tests/hosting_dialogs/choices/test_choice_tokenizer.py b/tests/hosting_dialogs/choices/test_choice_tokenizer.py new file mode 100644 index 00000000..16d9d38d --- /dev/null +++ b/tests/hosting_dialogs/choices/test_choice_tokenizer.py @@ -0,0 +1,67 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs.choices import Tokenizer + + +def _assert_token(token, start, end, text, normalized=None): + assert ( + token.start == start + ), f"Invalid token.start of '{token.start}' for '{text}' token." + assert token.end == end, f"Invalid token.end of '{token.end}' for '{text}' token." + assert ( + token.text == text + ), f"Invalid token.text of '{token.text}' for '{text}' token." + assert token.normalized == ( + normalized or text.lower() + ), f"Invalid token.normalized of '{token.normalized}' for '{text}' token." + + +class TestChoiceTokenizer: + def test_should_break_on_spaces(self): + tokens = Tokenizer.default_tokenizer("how now brown cow") + assert len(tokens) == 4 + _assert_token(tokens[0], 0, 2, "how") + _assert_token(tokens[1], 4, 6, "now") + _assert_token(tokens[2], 8, 12, "brown") + _assert_token(tokens[3], 14, 16, "cow") + + def test_should_break_on_punctuation(self): + tokens = Tokenizer.default_tokenizer("how-now.brown:cow?") + assert len(tokens) == 4 + _assert_token(tokens[0], 0, 2, "how") + _assert_token(tokens[1], 4, 6, "now") + _assert_token(tokens[2], 8, 12, "brown") + _assert_token(tokens[3], 14, 16, "cow") + + def test_should_tokenize_single_character_tokens(self): + tokens = Tokenizer.default_tokenizer("a b c d") + assert len(tokens) == 4 + _assert_token(tokens[0], 0, 0, "a") + _assert_token(tokens[1], 2, 2, "b") + _assert_token(tokens[2], 4, 4, "c") + _assert_token(tokens[3], 6, 6, "d") + + def test_should_return_a_single_token(self): + tokens = Tokenizer.default_tokenizer("food") + assert len(tokens) == 1 + _assert_token(tokens[0], 0, 3, "food") + + def test_should_return_no_tokens(self): + tokens = Tokenizer.default_tokenizer(".?-()") + assert not tokens + + def test_should_return_a_the_normalized_and_original_text_for_a_token(self): + tokens = Tokenizer.default_tokenizer("fOoD") + assert len(tokens) == 1 + _assert_token(tokens[0], 0, 3, "fOoD", "food") + + def test_should_break_on_emojis(self): + tokens = Tokenizer.default_tokenizer("food 💥👍😀") + assert len(tokens) == 4 + _assert_token(tokens[0], 0, 3, "food") + _assert_token(tokens[1], 5, 5, "💥") + _assert_token(tokens[2], 6, 6, "👍") + _assert_token(tokens[3], 7, 7, "😀") diff --git a/tests/hosting_dialogs/helpers.py b/tests/hosting_dialogs/helpers.py new file mode 100644 index 00000000..b8e93bfc --- /dev/null +++ b/tests/hosting_dialogs/helpers.py @@ -0,0 +1,312 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +""" +Test helpers for dialog tests. Provides a TestAdapter/TestFlow compatibility +layer that wraps MockTestingAdapter with the old botbuilder-style chained +send/assert_reply API. +""" + +from typing import Callable, Union, Awaitable + +from microsoft_agents.activity import ( + Activity, + ActivityTypes, + TokenResponse, + SignInResource, + TokenOrSignInResourceResponse, +) +from microsoft_agents.hosting.core import ChannelAdapter, TurnContext +from microsoft_agents.hosting.core.authorization import ClaimsIdentity +from tests._common.testing_objects import MockTestingAdapter + +AgentCallbackHandler = Callable[["TurnContext"], Awaitable[None]] + + +class _MockUserToken: + """Mock user_token API for dialog tests.""" + + def __init__(self, store: dict, exchange_store: dict, throw_on_exchange: dict): + self._store = store + self._exchange_store = exchange_store + self._throw_on_exchange = throw_on_exchange + + @staticmethod + def _key(connection_name, channel_id, user_id): + return f"{connection_name}:{channel_id}:{user_id}" + + @staticmethod + def _exchange_key(connection_name, channel_id, user_id, item): + return f"{connection_name}:{channel_id}:{user_id}:{item}" + + async def get_token(self, user_id, connection_name, channel_id, code=None): + key = self._key(connection_name, channel_id, user_id) + entry = self._store.get(key) + if entry: + token, stored_code = entry + if stored_code is None or (code is not None and code == stored_code): + return TokenResponse( + connection_name=connection_name, + token=token, + channel_id=channel_id, + ) + return None + + async def sign_out(self, user_id, connection_name, channel_id): + key = self._key(connection_name, channel_id, user_id) + self._store.pop(key, None) + + async def exchange_token(self, user_id, connection_name, channel_id, body=None): + token = (body or {}).get("token") or (body or {}).get("uri") + key = self._exchange_key(connection_name, channel_id, user_id, token or "") + if key in self._throw_on_exchange: + raise Exception("Token exchange not allowed for this item.") + result = self._exchange_store.get(key) + if result: + return TokenResponse( + connection_name=connection_name, + token=result, + channel_id=channel_id, + ) + return None + + async def _get_token_or_sign_in_resource( + self, user_id, connection_name, channel_id, state, *_ + ): + key = self._key(connection_name, channel_id, user_id) + entry = self._store.get(key) + if entry: + token, stored_code = entry + if stored_code is None: + return TokenOrSignInResourceResponse( + token_response=TokenResponse( + connection_name=connection_name, + token=token, + channel_id=channel_id, + ) + ) + return TokenOrSignInResourceResponse( + sign_in_resource=SignInResource( + sign_in_link=f"https://token.botframework.com/oauthcards?state={state or ''}" + ) + ) + + +class _MockAgentSignIn: + """Mock agent_sign_in API for dialog tests.""" + + async def get_sign_in_resource(self, state=None): + return SignInResource( + sign_in_link=f"https://token.botframework.com/oauthcards?state={state or ''}", + ) + + +class DialogUserTokenClient: + """ + A lightweight UserTokenClient mock for dialog tests. + Implements the user_token and agent_sign_in APIs used by _UserTokenAccess. + """ + + def __init__(self): + self._store = {} + self._exchange_store = {} + self._throw_on_exchange = {} + self.user_token = _MockUserToken( + self._store, self._exchange_store, self._throw_on_exchange + ) + self.agent_sign_in = _MockAgentSignIn() + + def add_user_token( + self, + connection_name: str, + channel_id: str, + user_id: str, + token: str, + magic_code: str = None, + ): + key = f"{connection_name}:{channel_id}:{user_id}" + self._store[key] = (token, magic_code) + + def add_exchangeable_token( + self, + connection_name: str, + channel_id: str, + user_id: str, + exchangeable_item: str, + token: str, + ): + key = f"{connection_name}:{channel_id}:{user_id}:{exchangeable_item}" + self._exchange_store[key] = token + + def throw_on_exchange_request( + self, + connection_name: str, + channel_id: str, + user_id: str, + exchangeable_item: str, + ): + key = f"{connection_name}:{channel_id}:{user_id}:{exchangeable_item}" + self._throw_on_exchange[key] = True + + +class TestFlow: + """ + Provides a fluent interface for sending messages and asserting replies + in dialog tests. + """ + + def __init__(self, adapter: "DialogTestAdapter", callback: AgentCallbackHandler): + self._adapter = adapter + self._callback = callback + + async def send(self, msg: Union[str, Activity]) -> "TestFlow": + """Send a message or activity to the agent.""" + import asyncio as _asyncio + + # Small delay to ensure time-based timeouts (e.g. OAuthPrompt timeout=1ms) can fire. + await _asyncio.sleep(0.002) + self._adapter.active_queue.clear() + if isinstance(msg, str): + await self._adapter.send_text_to_agent_async(msg, self._callback) + else: + await self._adapter.process_activity_async(msg, self._callback) + return TestFlow(self._adapter, self._callback) + + async def assert_reply( + self, expected: Union[str, Activity, Callable, None] = None + ) -> "TestFlow": + """Assert the next reply matches the expected text, activity, or callable inspector.""" + import inspect + + reply = self._adapter.get_next_reply() + if expected is not None: + if callable(expected) and not isinstance(expected, (str, Activity)): + # Inspector callable: (activity, description) -> bool (sync or async) + result = expected(reply, None) + if inspect.isawaitable(result): + result = await result + assert ( + result is not False + ), f"Inspector returned False for reply: {reply}" + elif isinstance(expected, str): + assert reply is not None, f"Expected reply '{expected}' but got None" + assert ( + reply.text == expected + ), f"Expected reply text '{expected}' but got '{reply.text}'" + elif isinstance(expected, Activity): + assert reply is not None, "Expected a reply but got None" + if expected.text: + assert ( + reply.text == expected.text + ), f"Expected reply text '{expected.text}' but got '{reply.text}'" + if expected.type: + assert ( + reply.type == expected.type + ), f"Expected activity type '{expected.type}' but got '{reply.type}'" + return TestFlow(self._adapter, self._callback) + + +class DialogTestAdapter(MockTestingAdapter): + """ + A test adapter compatible with the botbuilder TestAdapter API. + Provides send() and assert_reply() methods for fluent test flows. + Also provides a proper UserTokenClient in turn_state for OAuthPrompt tests. + """ + + def __init__(self, callback: AgentCallbackHandler = None, **kwargs): + super().__init__(**kwargs) + self._callback = callback + # Dialog-specific token client that implements the user_token API + self._dialog_token_client = DialogUserTokenClient() + # OAuthPrompt reads claims["aud"] from the identity in turn_state + self.claims_identity = ClaimsIdentity({"aud": "test-app-id"}, True) + + def add_user_token( + self, + connection_name: str, + channel_id: str, + user_id: str, + token: str, + magic_code: str = None, + ): + """Store a user token for retrieval by OAuthPrompt.""" + self._dialog_token_client.add_user_token( + connection_name, channel_id, user_id, token, magic_code + ) + # Also update the base class token client for compatibility + super().add_user_token(connection_name, channel_id, user_id, token, magic_code) + + def add_exchangeable_token( + self, + connection_name: str, + channel_id: str, + user_id: str, + exchangeable_item: str, + token: str, + ): + self._dialog_token_client.add_exchangeable_token( + connection_name, channel_id, user_id, exchangeable_item, token + ) + super().add_exchangeable_token( + connection_name, channel_id, user_id, exchangeable_item, token + ) + + def throw_on_exchange_request( + self, + connection_name: str, + channel_id: str, + user_id: str, + exchangeable_item: str, + ): + self._dialog_token_client.throw_on_exchange_request( + connection_name, channel_id, user_id, exchangeable_item + ) + super().throw_on_exchange_request( + connection_name, channel_id, user_id, exchangeable_item + ) + + def create_turn_context( + self, activity: Activity, identity: ClaimsIdentity = None + ) -> TurnContext: + """ + Creates a turn context with the dialog token client in turn_state + so OAuthPrompt can find it via _UserTokenAccess. + """ + turn_context = super().create_turn_context(activity, identity) + turn_context.turn_state[ChannelAdapter.USER_TOKEN_CLIENT_KEY] = ( + self._dialog_token_client + ) + # OAuthPrompt reads claims["aud"] from this identity + turn_context.turn_state[ChannelAdapter.AGENT_IDENTITY_KEY] = ( + identity or self.claims_identity + ) + return turn_context + + def make_activity(self, text: str = None) -> Activity: + """ + Creates a message activity without setting locale, so that prompts' + default_locale is used when no locale is present in the activity. + This matches botbuilder TestAdapter behavior. + """ + from microsoft_agents.activity import ActivityTypes + + activity = Activity( + type=ActivityTypes.message, + from_property=self.conversation.user, + recipient=self.conversation.agent, + conversation=self.conversation.conversation, + service_url=self.conversation.service_url, + id=str(self._next_id), + text=text, + ) + self._next_id += 1 + return activity + + async def send(self, msg: Union[str, Activity]) -> TestFlow: + """Send a message or activity and return a TestFlow for assertions.""" + self.active_queue.clear() + if isinstance(msg, str): + await self.send_text_to_agent_async(msg, self._callback) + else: + await self.process_activity_async(msg, self._callback) + return TestFlow(self, self._callback) diff --git a/tests/hosting_dialogs/memory/__init__.py b/tests/hosting_dialogs/memory/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/hosting_dialogs/memory/scopes/__init__.py b/tests/hosting_dialogs/memory/scopes/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/hosting_dialogs/memory/scopes/test_memory_scopes.py b/tests/hosting_dialogs/memory/scopes/test_memory_scopes.py new file mode 100644 index 00000000..5eca2f3f --- /dev/null +++ b/tests/hosting_dialogs/memory/scopes/test_memory_scopes.py @@ -0,0 +1,684 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# pylint: disable=pointless-string-statement + +from collections import namedtuple + +import pytest + +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + TurnContext, + UserState, +) +from microsoft_agents.hosting.dialogs import ( + Dialog, + DialogContext, + DialogContainer, + DialogInstance, + DialogSet, + DialogState, + ObjectPath, +) +from microsoft_agents.hosting.dialogs.memory.scopes import ( + ClassMemoryScope, + ConversationMemoryScope, + DialogContextMemoryScope, + DialogMemoryScope, + UserMemoryScope, + SettingsMemoryScope, + ThisMemoryScope, + TurnMemoryScope, +) +from microsoft_agents.activity import ( + Activity, + ActivityTypes, + ChannelAccount, + ConversationAccount, + Channels, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class _TestDialog(Dialog): + def __init__(self, id: str, message: str): + super().__init__(id) + + def aux_try_get_value(state): # pylint: disable=unused-argument + return "resolved value" + + ExpressionObject = namedtuple("ExpressionObject", "try_get_value") + self.message = message + self.expression = ExpressionObject(aux_try_get_value) + + async def begin_dialog(self, dialog_context: DialogContext, options: object = None): + dialog_context.active_dialog.state["is_dialog"] = True + await dialog_context.context.send_activity(self.message) + return Dialog.end_of_turn + + +class _TestContainer(DialogContainer): + def __init__(self, id: str, child: Dialog = None): + super().__init__(id) + self.child_id = None + if child: + self.dialogs.add(child) + self.child_id = child.id + + async def begin_dialog(self, dialog_context: DialogContext, options: object = None): + state = dialog_context.active_dialog.state + state["is_container"] = True + if self.child_id: + state["dialog"] = DialogState() + child_dc = self.create_child_context(dialog_context) + return await child_dc.begin_dialog(self.child_id, options) + + return Dialog.end_of_turn + + async def continue_dialog(self, dialog_context: DialogContext): + child_dc = self.create_child_context(dialog_context) + if child_dc: + return await child_dc.continue_dialog() + + return Dialog.end_of_turn + + def create_child_context(self, dialog_context: DialogContext): + state = dialog_context.active_dialog.state + if state["dialog"] is not None: + child_dc = DialogContext( + self.dialogs, dialog_context.context, state["dialog"] + ) + child_dc.parent = dialog_context + return child_dc + + return None + + +_begin_message = Activity( + text="begin", + type=ActivityTypes.message, + channel_id=Channels.test, + service_url="https://test.com", + from_property=ChannelAccount(id="user"), + recipient=ChannelAccount(id="bot"), + conversation=ConversationAccount(id="convo1"), +) + + +class TestMemoryScopes: + @pytest.mark.asyncio + async def test_class_memory_scope_should_find_registered_dialog(self): + # Create ConversationState with MemoryStorage and register the state as middleware. + conversation_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the dialogs. + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + await dialog_state.set( + context, DialogState(dialog_stack=[DialogInstance(id="test", state={})]) + ) + + dialog_context = await dialogs.create_context(context) + + # Run test + scope = ClassMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory, "memory not returned" + assert memory.message == "test message" + assert memory.expression == "resolved value" + + @pytest.mark.asyncio + async def test_class_memory_scope_should_not_allow_set_memory_call(self): + # Create ConversationState with MemoryStorage and register the state as middleware. + conversation_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the dialogs. + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + await dialog_state.set( + context, DialogState(dialog_stack=[DialogInstance(id="test", state={})]) + ) + + dialog_context = await dialogs.create_context(context) + + # Run test + scope = ClassMemoryScope() + with pytest.raises(Exception) as exc_info: + scope.set_memory(dialog_context, {}) + + assert "not supported" in str(exc_info.value) + + @pytest.mark.asyncio + async def test_class_memory_scope_should_not_allow_load_and_save_changes_calls( + self, + ): + # Create ConversationState with MemoryStorage and register the state as middleware. + conversation_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the dialogs. + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + await dialog_state.set( + context, DialogState(dialog_stack=[DialogInstance(id="test", state={})]) + ) + + dialog_context = await dialogs.create_context(context) + + # Run test + scope = ClassMemoryScope() + await scope.load(dialog_context) + memory = scope.get_memory(dialog_context) + with pytest.raises(AttributeError) as exc_info: + memory.message = "foo" + + assert "can't set attribute" in str(exc_info.value) + await scope.save_changes(dialog_context) + assert dialog.message == "test message" + + def test_class_memory_scope_has_unique_name(self): + """ClassMemoryScope must use 'class', not 'settings', to avoid colliding with SettingsMemoryScope.""" + assert ClassMemoryScope().name == "class" + assert ClassMemoryScope().name != SettingsMemoryScope().name + + @pytest.mark.asyncio + async def test_conversation_memory_scope_should_return_conversation_state(self): + # Create ConversationState with MemoryStorage and register the state as middleware. + conversation_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the dialogs. + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + context.turn_state["ConversationState"] = conversation_state + + dialog_context = await dialogs.create_context(context) + + # Initialize conversation state + foo_cls = namedtuple("TestObject", "foo") + conversation_prop = conversation_state.create_property("conversation") + await conversation_prop.set(context, foo_cls(foo="bar")) + await conversation_state.save(context) + + # Run test + scope = ConversationMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory, "memory not returned" + + # TODO: Make get_path_value take conversation.foo + test_obj = ObjectPath.get_path_value(memory, "conversation") + assert test_obj.foo == "bar" + + @pytest.mark.asyncio + async def test_user_memory_scope_should_not_return_state_if_not_loaded(self): + # Initialize user state + storage = MemoryStorage() + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + user_state = UserState(storage) + context.turn_state["UserState"] = user_state + foo_cls = namedtuple("TestObject", "foo") + user_prop = user_state.create_property("conversation") + await user_prop.set(context, foo_cls(foo="bar")) + await user_state.save(context) + + # Replace context and user_state with new instances + context = TurnContext(adapter, _begin_message) + user_state = UserState(storage) + context.turn_state["UserState"] = user_state + + # Create a DialogState property, DialogSet and register the dialogs. + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + dialog_context = await dialogs.create_context(context) + + # Run test + scope = UserMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory is None, "state returned" + + @pytest.mark.asyncio + async def test_user_memory_scope_should_return_state_once_loaded(self): + # Initialize user state + storage = MemoryStorage() + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + user_state = UserState(storage) + context.turn_state["UserState"] = user_state + foo_cls = namedtuple("TestObject", "foo") + user_prop = user_state.create_property("conversation") + await user_prop.set(context, foo_cls(foo="bar")) + await user_state.save(context) + + # Replace context and conversation_state with instances + context = TurnContext(adapter, _begin_message) + user_state = UserState(storage) + context.turn_state["UserState"] = user_state + + # Create a DialogState property, DialogSet and register the dialogs. + conversation_state = ConversationState(storage) + context.turn_state["ConversationState"] = conversation_state + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + dialog_context = await dialogs.create_context(context) + + # Run test + scope = UserMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory is None, "state returned" + + await scope.load(dialog_context) + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + + # TODO: Make get_path_value take conversation.foo + test_obj = ObjectPath.get_path_value(memory, "conversation") + assert test_obj.foo == "bar" + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_return_containers_state(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = DialogMemoryScope() + await dialog_context.begin_dialog("container") + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory["is_container"] + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_return_parent_containers_state_for_children( + self, + ): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container", _TestDialog("child", "test message")) + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = DialogMemoryScope() + await dialog_context.begin_dialog("container") + child_dc = dialog_context.child + assert child_dc is not None, "No child DC" + memory = scope.get_memory(child_dc) + assert memory is not None, "state not returned" + assert memory["is_container"] + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_return_childs_state_when_no_parent(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = DialogMemoryScope() + await dialog_context.begin_dialog("test") + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory["is_dialog"] + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_overwrite_parents_memory(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container", _TestDialog("child", "test message")) + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = DialogMemoryScope() + await dialog_context.begin_dialog("container") + child_dc = dialog_context.child + assert child_dc is not None, "No child DC" + + foo_cls = namedtuple("TestObject", "foo") + scope.set_memory(child_dc, foo_cls("bar")) + memory = scope.get_memory(child_dc) + assert memory is not None, "state not returned" + assert memory.foo == "bar" + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_overwrite_active_dialogs_memory(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = DialogMemoryScope() + await dialog_context.begin_dialog("container") + foo_cls = namedtuple("TestObject", "foo") + scope.set_memory(dialog_context, foo_cls("bar")) + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory.foo == "bar" + + @pytest.mark.asyncio + async def test_dialog_memory_scope_should_raise_error_if_set_memory_called_without_memory( + self, + ): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + with pytest.raises(Exception): + scope = DialogMemoryScope() + await dialog_context.begin_dialog("container") + scope.set_memory(dialog_context, None) + + @pytest.mark.asyncio + async def test_dialog_memory_scope_accepts_empty_dict(self): + """set_memory() must accept an empty dict — empty dialog state is valid.""" + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialogs.add(_TestContainer("container")) + + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + await dialog_context.begin_dialog("container") + + scope = DialogMemoryScope() + scope.set_memory(dialog_context, {}) + assert scope.get_memory(dialog_context) == {} + + @pytest.mark.skip(reason="Requires test_settings module not available") + @pytest.mark.asyncio + async def test_settings_memory_scope_should_return_content_of_settings(self): + # pylint: disable=import-outside-toplevel + from tests.hosting_dialogs.memory.scopes.test_settings import DefaultConfig + + # Create a DialogState property, DialogSet and register the dialogs. + conversation_state = ConversationState(MemoryStorage()) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state).add(_TestDialog("test", "test message")) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + settings = DefaultConfig() + dialog_context.context.turn_state["settings"] = settings + + # Run test + scope = SettingsMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory is not None + assert memory.STRING == "test" + assert memory.INT == 3 + assert memory.LIST[0] == "zero" + assert memory.LIST[1] == "one" + assert memory.LIST[2] == "two" + assert memory.LIST[3] == "three" + + @pytest.mark.asyncio + async def test_this_memory_scope_should_return_active_dialogs_state(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = ThisMemoryScope() + await dialog_context.begin_dialog("test") + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory["is_dialog"] + + @pytest.mark.asyncio + async def test_this_memory_scope_should_overwrite_active_dialogs_memory(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = ThisMemoryScope() + await dialog_context.begin_dialog("container") + foo_cls = namedtuple("TestObject", "foo") + scope.set_memory(dialog_context, foo_cls("bar")) + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory.foo == "bar" + + @pytest.mark.asyncio + async def test_this_memory_scope_should_raise_error_if_set_memory_called_without_memory( + self, + ): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + with pytest.raises(Exception): + scope = ThisMemoryScope() + await dialog_context.begin_dialog("container") + scope.set_memory(dialog_context, None) + + @pytest.mark.asyncio + async def test_this_memory_scope_accepts_empty_dict(self): + """set_memory() must accept an empty dict — empty dialog state is valid.""" + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialogs.add(_TestContainer("container")) + + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + await dialog_context.begin_dialog("container") + + scope = ThisMemoryScope() + scope.set_memory(dialog_context, {}) + assert scope.get_memory(dialog_context) == {} + + @pytest.mark.asyncio + async def test_this_memory_scope_should_raise_error_if_set_memory_called_without_active_dialog( + self, + ): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + container = _TestContainer("container") + dialogs.add(container) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + with pytest.raises(Exception): + scope = ThisMemoryScope() + foo_cls = namedtuple("TestObject", "foo") + scope.set_memory(dialog_context, foo_cls("bar")) + + @pytest.mark.asyncio + async def test_turn_memory_scope_should_persist_changes_to_turn_state(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = TurnMemoryScope() + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + memory["foo"] = "bar" + memory = scope.get_memory(dialog_context) + assert memory["foo"] == "bar" + + @pytest.mark.asyncio + async def test_turn_memory_scope_should_overwrite_values_in_turn_state(self): + # Create a DialogState property, DialogSet and register the dialogs. + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialog = _TestDialog("test", "test message") + dialogs.add(dialog) + + # Create test context + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + # Run test + scope = TurnMemoryScope() + foo_cls = namedtuple("TestObject", "foo") + scope.set_memory(dialog_context, foo_cls("bar")) + memory = scope.get_memory(dialog_context) + assert memory is not None, "state not returned" + assert memory.foo == "bar" + + @pytest.mark.asyncio + async def test_turn_memory_scope_preserves_empty_dict(self): + """An empty dict stored in turn state must not be replaced with a new CaseInsensitiveDict.""" + storage = MemoryStorage() + conversation_state = ConversationState(storage) + dialog_state = conversation_state.create_property("dialogs") + dialogs = DialogSet(dialog_state) + dialogs.add(_TestDialog("test", "test message")) + + adapter = DialogTestAdapter() + context = TurnContext(adapter, _begin_message) + dialog_context = await dialogs.create_context(context) + + scope = TurnMemoryScope() + empty = {} + scope.set_memory(dialog_context, empty) + + retrieved = scope.get_memory(dialog_context) + assert ( + retrieved is empty + ), "get_memory() must return the stored empty dict, not a new one" + + def test_dialog_context_memory_scope_has_unique_name(self): + """DialogContextMemoryScope must not share its scope name with SettingsMemoryScope.""" + dc_scope = DialogContextMemoryScope() + settings_scope = SettingsMemoryScope() + assert dc_scope.name == "dialogContext" + assert dc_scope.name != settings_scope.name diff --git a/tests/hosting_dialogs/memory/scopes/test_settings.py b/tests/hosting_dialogs/memory/scopes/test_settings.py new file mode 100644 index 00000000..9e21a99a --- /dev/null +++ b/tests/hosting_dialogs/memory/scopes/test_settings.py @@ -0,0 +1,14 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import os + + +class DefaultConfig: + """Bot Configuration""" + + STRING = os.environ.get("STRING", "test") + INT = os.environ.get("INT", 3) + LIST = os.environ.get("LIST", ["zero", "one", "two", "three"]) + NOT_TO_BE_OVERRIDDEN = os.environ.get("NOT_TO_BE_OVERRIDDEN", "one") + TO_BE_OVERRIDDEN = os.environ.get("TO_BE_OVERRIDDEN", "one") diff --git a/tests/hosting_dialogs/memory/test_at_path_resolver.py b/tests/hosting_dialogs/memory/test_at_path_resolver.py new file mode 100644 index 00000000..61b307e2 --- /dev/null +++ b/tests/hosting_dialogs/memory/test_at_path_resolver.py @@ -0,0 +1,44 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs.memory.path_resolvers import AtPathResolver + +_PREFIX = "turn.recognized.entities." + + +class TestAtPathResolver: + def setup_method(self): + self.resolver = AtPathResolver() + + def test_simple_entity_no_suffix(self): + """@foo → turn.recognized.entities.foo.first()""" + assert self.resolver.transform_path("@foo") == f"{_PREFIX}foo.first()" + + def test_entity_with_dot_suffix(self): + """@foo.bar → turn.recognized.entities.foo.first().bar""" + assert self.resolver.transform_path("@foo.bar") == f"{_PREFIX}foo.first().bar" + + def test_entity_with_bracket_suffix(self): + """@foo[0] → turn.recognized.entities.foo.first()[0]""" + assert self.resolver.transform_path("@foo[0]") == f"{_PREFIX}foo.first()[0]" + + def test_entity_with_dot_and_bracket_suffix(self): + """@foo.bar[0] — dot comes before bracket, entity name is still just 'foo'""" + assert ( + self.resolver.transform_path("@foo.bar[0]") + == f"{_PREFIX}foo.first().bar[0]" + ) + + def test_non_at_path_is_returned_unchanged(self): + assert self.resolver.transform_path("turn.foo") == "turn.foo" + assert self.resolver.transform_path("user.name") == "user.name" + + def test_empty_path_raises(self): + with pytest.raises(TypeError): + self.resolver.transform_path("") + + def test_at_sign_only_is_returned_unchanged(self): + """A bare '@' has no subsequent path char so the branch is skipped.""" + assert self.resolver.transform_path("@") == "@" diff --git a/tests/hosting_dialogs/test_activity_prompt.py b/tests/hosting_dialogs/test_activity_prompt.py new file mode 100644 index 00000000..705f87c0 --- /dev/null +++ b/tests/hosting_dialogs/test_activity_prompt.py @@ -0,0 +1,286 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs.prompts import ( + ActivityPrompt, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + TurnContext, + MessageFactory, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus, DialogReason + + +async def validator(prompt_context: PromptValidatorContext): + assert prompt_context.attempt_count > 0 + + activity = prompt_context.recognized.value + + if activity.type == ActivityTypes.event: + if int(activity.value) == 2: + prompt_context.recognized.value = MessageFactory.text(str(activity.value)) + return True + else: + await prompt_context.context.send_activity( + "Please send an 'event'-type Activity with a value of 2." + ) + + return False + + +class SimpleActivityPrompt(ActivityPrompt): + pass + + +class TestActivityPrompt: + def test_activity_prompt_with_empty_id_should_fail(self): + empty_id = "" + with pytest.raises(TypeError): + SimpleActivityPrompt(empty_id, validator) + + def test_activity_prompt_with_none_id_should_fail(self): + none_id = None + with pytest.raises(TypeError): + SimpleActivityPrompt(none_id, validator) + + def test_activity_prompt_with_none_validator_should_fail(self): + none_validator = None + with pytest.raises(TypeError): + SimpleActivityPrompt("EventActivityPrompt", none_validator) + + @pytest.mark.asyncio + async def test_basic_activity_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(SimpleActivityPrompt("EventActivityPrompt", validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ) + ) + await dialog_context.prompt("EventActivityPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + event_activity = Activity(type=ActivityTypes.event, value=2) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please send an event.") + step3 = await step2.send(event_activity) + await step3.assert_reply("2") + + @pytest.mark.asyncio + async def test_retry_activity_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(SimpleActivityPrompt("EventActivityPrompt", validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ) + ) + await dialog_context.prompt("EventActivityPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + event_activity = Activity(type=ActivityTypes.event, value=2) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please send an event.") + step3 = await step2.send("hello again") + step4 = await step3.assert_reply( + "Please send an 'event'-type Activity with a value of 2." + ) + step5 = await step4.send(event_activity) + await step5.assert_reply("2") + + @pytest.mark.asyncio + async def test_activity_prompt_should_return_dialog_end_if_validation_failed(self): + async def aux_validator(prompt_context: PromptValidatorContext): + assert prompt_context, "Validator missing prompt_context" + return False + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(SimpleActivityPrompt("EventActivityPrompt", aux_validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ), + retry_prompt=Activity( + type=ActivityTypes.message, text="event not received." + ), + ) + await dialog_context.prompt("EventActivityPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please send an event.") + step3 = await step2.send("test") + await step3.assert_reply("event not received.") + + @pytest.mark.asyncio + async def test_activity_prompt_resume_dialog_should_return_dialog_end(self): + async def aux_validator(prompt_context: PromptValidatorContext): + assert prompt_context, "Validator missing prompt_context" + return False + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + event_prompt = SimpleActivityPrompt("EventActivityPrompt", aux_validator) + dialogs.add(event_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ) + ) + await dialog_context.prompt("EventActivityPrompt", options) + + second_results = await event_prompt.resume_dialog( + dialog_context, DialogReason.NextCalled + ) + + assert ( + second_results.status == DialogTurnStatus.Waiting + ), "resume_dialog did not returned Dialog.EndOfTurn" + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please send an event.") + await step2.assert_reply("please send an event.") + + @pytest.mark.asyncio + async def test_activity_prompt_onerror_should_return_dialogcontext(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(SimpleActivityPrompt("EventActivityPrompt", validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ) + ) + + try: + await dialog_context.prompt("EventActivityPrompt", options) + await dialog_context.prompt("Non existent id", options) + except Exception as err: + assert ( + err.data["DialogContext"] + is not None # pylint: disable=no-member + ) + assert ( + err.data["DialogContext"][ # pylint: disable=no-member + "active_dialog" + ] + == "EventActivityPrompt" + ) + else: + raise Exception("Should have thrown an error.") + + elif results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + await adapter.send("hello") + + @pytest.mark.asyncio + async def test_activity_replace_dialog_onerror_should_return_dialogcontext(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(SimpleActivityPrompt("EventActivityPrompt", validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please send an event." + ) + ) + + try: + await dialog_context.prompt("EventActivityPrompt", options) + await dialog_context.replace_dialog("Non existent id", options) + except Exception as err: + assert ( + err.data["DialogContext"] + is not None # pylint: disable=no-member + ) + else: + raise Exception("Should have thrown an error.") + + elif results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + await adapter.send("hello") diff --git a/tests/hosting_dialogs/test_attachment_prompt.py b/tests/hosting_dialogs/test_attachment_prompt.py new file mode 100644 index 00000000..6d1e3501 --- /dev/null +++ b/tests/hosting_dialogs/test_attachment_prompt.py @@ -0,0 +1,287 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import copy +import pytest +from microsoft_agents.hosting.dialogs.prompts import ( + AttachmentPrompt, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes, Attachment, InputHints +from microsoft_agents.hosting.core import ( + TurnContext, + ConversationState, + MemoryStorage, + MessageFactory, +) +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestAttachmentPrompt: + def test_attachment_prompt_with_empty_id_should_fail(self): + with pytest.raises(TypeError): + AttachmentPrompt("") + + def test_attachment_prompt_with_none_id_should_fail(self): + with pytest.raises(TypeError): + AttachmentPrompt(None) + + @pytest.mark.asyncio + async def test_basic_attachment_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(AttachmentPrompt("AttachmentPrompt")) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please add an attachment." + ) + ) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please add an attachment.") + step3 = await step2.send(attachment_activity) + await step3.assert_reply("some content") + + @pytest.mark.asyncio + async def test_attachment_prompt_with_input_hint(self): + prompt_activity = Activity( + type=ActivityTypes.message, + text="please add an attachment.", + input_hint=InputHints.accepting_input, + ) + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(AttachmentPrompt("AttachmentPrompt")) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions(prompt=copy.copy(prompt_activity)) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + step1 = await adapter.send("hello") + await step1.assert_reply(prompt_activity) + + @pytest.mark.asyncio + async def test_attachment_prompt_with_validator(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + + async def aux_validator(prompt_context: PromptValidatorContext): + assert prompt_context, "Validator missing prompt_context" + return prompt_context.recognized.succeeded + + dialogs.add(AttachmentPrompt("AttachmentPrompt", aux_validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please add an attachment." + ) + ) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please add an attachment.") + step3 = await step2.send(attachment_activity) + await step3.assert_reply("some content") + + @pytest.mark.asyncio + async def test_retry_attachment_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(AttachmentPrompt("AttachmentPrompt")) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please add an attachment." + ) + ) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please add an attachment.") + step3 = await step2.send("hello again") + step4 = await step3.assert_reply("please add an attachment.") + step5 = await step4.send(attachment_activity) + await step5.assert_reply("some content") + + @pytest.mark.asyncio + async def test_attachment_prompt_with_custom_retry(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + + async def aux_validator(prompt_context: PromptValidatorContext): + assert prompt_context, "Validator missing prompt_context" + return prompt_context.recognized.succeeded + + dialogs.add(AttachmentPrompt("AttachmentPrompt", aux_validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please add an attachment." + ), + retry_prompt=Activity( + type=ActivityTypes.message, text="please try again." + ), + ) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + invalid_activity = Activity(type=ActivityTypes.message, text="invalid") + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please add an attachment.") + step3 = await step2.send(invalid_activity) + step4 = await step3.assert_reply("please try again.") + step5 = await step4.send(attachment_activity) + await step5.assert_reply("some content") + + @pytest.mark.asyncio + async def test_should_send_ignore_retry_prompt_if_validator_replies(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + + async def aux_validator(prompt_context: PromptValidatorContext): + assert prompt_context, "Validator missing prompt_context" + if not prompt_context.recognized.succeeded: + await prompt_context.context.send_activity("Bad input.") + return prompt_context.recognized.succeeded + + dialogs.add(AttachmentPrompt("AttachmentPrompt", aux_validator)) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="please add an attachment." + ), + retry_prompt=Activity( + type=ActivityTypes.message, text="please try again." + ), + ) + await dialog_context.prompt("AttachmentPrompt", options) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + invalid_activity = Activity(type=ActivityTypes.message, text="invalid") + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("please add an attachment.") + step3 = await step2.send(invalid_activity) + step4 = await step3.assert_reply("Bad input.") + step5 = await step4.send(attachment_activity) + await step5.assert_reply("some content") + + @pytest.mark.asyncio + async def test_should_not_send_retry_if_not_specified(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add(AttachmentPrompt("AttachmentPrompt")) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog("AttachmentPrompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete: + attachment = results.result[0] + content = MessageFactory.text(attachment.content) + await turn_context.send_activity(content) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + attachment = Attachment(content="some content", content_type="text/plain") + attachment_activity = Activity( + type=ActivityTypes.message, attachments=[attachment] + ) + + step1 = await adapter.send("hello") + step2 = await step1.send("what?") + step3 = await step2.send(attachment_activity) + await step3.assert_reply("some content") diff --git a/tests/hosting_dialogs/test_choice_prompt.py b/tests/hosting_dialogs/test_choice_prompt.py new file mode 100644 index 00000000..990ab686 --- /dev/null +++ b/tests/hosting_dialogs/test_choice_prompt.py @@ -0,0 +1,991 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +import pytest +from recognizers_text import Culture + +from microsoft_agents.hosting.core import ConversationState, MemoryStorage, TurnContext +from microsoft_agents.hosting.core import CardFactory +from microsoft_agents.hosting.dialogs import ( + DialogSet, + DialogTurnResult, + DialogTurnStatus, + ChoiceRecognizers, + FindChoicesOptions, +) +from microsoft_agents.hosting.dialogs.choices import ( + Choice, + ChoiceFactoryOptions, + ListStyle, +) +from microsoft_agents.hosting.dialogs.prompts import ( + ChoicePrompt, + PromptCultureModel, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes +from tests.hosting_dialogs.helpers import DialogTestAdapter + +_color_choices: List[Choice] = [ + Choice(value="red"), + Choice(value="green"), + Choice(value="blue"), +] + +_answer_message: Activity = Activity(text="red", type=ActivityTypes.message) +_invalid_message: Activity = Activity(text="purple", type=ActivityTypes.message) + + +class TestChoicePrompt: + def test_choice_prompt_with_empty_id_should_fail(self): + empty_id = "" + + with pytest.raises(TypeError): + ChoicePrompt(empty_id) + + def test_choice_prompt_with_none_id_should_fail(self): + none_id = None + + with pytest.raises(TypeError): + ChoicePrompt(none_id) + + @pytest.mark.asyncio + async def test_should_call_choice_prompt_using_dc_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + choice_prompt = ChoicePrompt("ChoicePrompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("ChoicePrompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_call_choice_prompt_with_custom_validator(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt", validator) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_invalid_message) + step4 = await step3.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step5 = await step4.send(_answer_message) + await step5.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_send_custom_retry_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + choice_prompt = ChoicePrompt("prompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please choose red, blue, or green.", + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_invalid_message) + step4 = await step3.assert_reply( + "Please choose red, blue, or green. (1) red, (2) green, or (3) blue" + ) + step5 = await step4.send(_answer_message) + await step5.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_send_ignore_retry_prompt_if_validator_replies(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt", validator) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please choose red, blue, or green.", + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_invalid_message) + step4 = await step3.assert_reply("Bad input.") + step5 = await step4.send(_answer_message) + await step5.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_use_default_locale_when_rendering_choices(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt( + "prompt", validator, default_locale=Culture.Spanish + ) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send(Activity(type=ActivityTypes.message, text="Hello")) + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, o (3) blue" + ) + step3 = await step2.send(_invalid_message) + step4 = await step3.assert_reply("Bad input.") + step5 = await step4.send(Activity(type=ActivityTypes.message, text="red")) + await step5.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_use_context_activity_locale_when_rendering_choices(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt", validator) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity(type=ActivityTypes.message, text="Hello", locale=Culture.Spanish) + ) + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, o (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_use_context_activity_locale_over_default_locale_when_rendering_choices( + self, + ): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt( + "prompt", validator, default_locale=Culture.Spanish + ) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity(type=ActivityTypes.message, text="Hello", locale=Culture.English) + ) + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_default_to_english_locale(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + locales = [None, "", "not-supported"] + + for locale in locales: + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt", validator) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + # Activity.locale uses NonEmptyString which rejects None/""; use model_construct to bypass + send_activity = Activity.model_construct( + type=ActivityTypes.message, text="Hello", locale=locale or None + ) + step1 = await adapter.send(send_activity) + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_recognize_locale_variations_of_correct_locales(self): + def cap_ending(locale: str) -> str: + return f"{locale.split('-')[0]}-{locale.split('-')[1].upper()}" + + def title_ending(locale: str) -> str: + return locale[:3] + locale[3].upper() + locale[4:] + + def cap_two_letter(locale: str) -> str: + return locale.split("-")[0].upper() + + def lower_two_letter(locale: str) -> str: + return locale.split("-")[0].upper() + + async def exec_test_for_locale(valid_locale: str, locale_variations: List): + # Hold the correct answer from when a valid locale is used + expected_answer = None + + def inspector(activity: Activity, description: str): + nonlocal expected_answer + + assert not description + + if valid_locale == test_locale: + expected_answer = activity.text + else: + # Ensure we're actually testing a variation. + assert activity.locale != valid_locale + + assert activity.text == expected_answer + return True + + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + test_locale = None + for test_locale in locale_variations: + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt", validator) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, + text="Please choose a color.", + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity( + type=ActivityTypes.message, text="Hello", locale=test_locale + ) + ) + await step1.assert_reply(inspector) + + locales = [ + "zh-cn", + "nl-nl", + "en-us", + "fr-fr", + "de-de", + "it-it", + "ja-jp", + "ko-kr", + "pt-br", + "es-es", + "tr-tr", + "de-de", + ] + + locale_tests = [] + for locale in locales: + locale_tests.append( + [ + locale, + cap_ending(locale), + title_ending(locale), + cap_two_letter(locale), + lower_two_letter(locale), + ] + ) + + # Test each valid locale + for locale_test in locale_tests: + await exec_test_for_locale(locale_test[0], locale_test) + + @pytest.mark.asyncio + async def test_should_recognize_and_use_custom_locale_dict(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + culture = PromptCultureModel( + locale="custom-locale", + no_in_language="customNo", + yes_in_language="customYes", + separator="customSeparator", + inline_or="customInlineOr", + inline_or_more="customInlineOrMore", + ) + + custom_dict = { + culture.locale: ChoiceFactoryOptions( + inline_or=culture.inline_or, + inline_or_more=culture.inline_or_more, + inline_separator=culture.separator, + include_numbers=True, + ) + } + + choice_prompt = ChoicePrompt("prompt", validator, choice_defaults=custom_dict) + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity(type=ActivityTypes.message, text="Hello", locale=culture.locale) + ) + await step1.assert_reply( + "Please choose a color. (1) redcustomSeparator(2) greencustomInlineOrMore(3) blue" + ) + + @pytest.mark.asyncio + async def test_should_not_render_choices_if_list_style_none_is_specified(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + style=ListStyle.none, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply("Please choose a color.") + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_create_prompt_with_inline_choices_when_specified(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + choice_prompt.style = ListStyle.in_line + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_create_prompt_with_list_choices_when_specified(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + choice_prompt.style = ListStyle.list_style + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color.\n\n 1. red\n 2. green\n 3. blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_create_prompt_with_suggested_action_style_when_specified( + self, + ): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + style=ListStyle.suggested_action, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply("Please choose a color.") + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_create_prompt_with_auto_style_when_specified(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + style=ListStyle.auto, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send(_answer_message) + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_recognize_valid_number_choice(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a color." + ), + choices=_color_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply( + "Please choose a color. (1) red, (2) green, or (3) blue" + ) + step3 = await step2.send("1") + await step3.assert_reply("red") + + @pytest.mark.asyncio + async def test_should_display_choices_on_hero_card(self): + size_choices = ["large", "medium", "small"] + + def assert_expected_activity( + activity: Activity, description + ): # pylint: disable=unused-argument + assert len(activity.attachments) == 1 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.hero_card + ) + assert activity.attachments[0].content.text == "Please choose a size." + return True + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + # Change the ListStyle of the prompt to ListStyle.hero_card. + choice_prompt.style = ListStyle.hero_card + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please choose a size." + ), + choices=size_choices, + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply(assert_expected_activity) + step3 = await step2.send("1") + await step3.assert_reply(size_choices[0]) + + @pytest.mark.asyncio + async def test_should_display_choices_on_hero_card_with_additional_attachment(self): + size_choices = ["large", "medium", "small"] + card = CardFactory.adaptive_card( + { + "type": "AdaptiveCard", + "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", + "version": "1.2", + "body": [], + } + ) + card_activity = Activity(type=ActivityTypes.message, attachments=[card]) + + def assert_expected_activity( + activity: Activity, description + ): # pylint: disable=unused-argument + assert len(activity.attachments) == 2 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.adaptive_card + ) + assert ( + activity.attachments[1].content_type + == CardFactory.content_types.hero_card + ) + return True + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ChoicePrompt("prompt") + # Change the ListStyle of the prompt to ListStyle.hero_card. + choice_prompt.style = ListStyle.hero_card + dialogs.add(choice_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions(prompt=card_activity, choices=size_choices) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + await step1.assert_reply(assert_expected_activity) + + def test_should_not_find_a_choice_in_an_utterance_by_ordinal(self): + found = ChoiceRecognizers.recognize_choices( + "the first one please", + _color_choices, + FindChoicesOptions(recognize_numbers=False, recognize_ordinals=False), + ) + assert not found + + def test_should_not_find_a_choice_in_an_utterance_by_numerical_index(self): + found = ChoiceRecognizers.recognize_choices( + "one", + _color_choices, + FindChoicesOptions(recognize_numbers=False, recognize_ordinals=False), + ) + assert not found + + @pytest.mark.asyncio + async def test_choice_prompt_with_empty_choices_renders_but_errors_on_response( + self, + ): + """ChoicePrompt with an empty choices list renders the prompt without + error, but raises TypeError when the user responds. + + This is because Find.find_choices() treats an empty list the same as + None and raises TypeError: "Find: choices cannot be None." Always + provide at least one Choice when using ChoicePrompt. + """ + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + dialogs.add(ChoicePrompt("ChoicePrompt")) + + turns = [] + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + try: + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Choose one:"), + choices=[], + ) + await dialog_context.prompt("ChoicePrompt", options) + turns.append("prompted") + else: + turns.append("continued") + except TypeError as exc: + turns.append(f"error:{exc}") + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + # First turn: prompt is sent without error + await adapter.send("hello") + assert turns[-1] == "prompted" + + # Second turn: recognition raises because choices is empty + await adapter.send("red") + assert turns[-1].startswith("error:") diff --git a/tests/hosting_dialogs/test_component_dialog.py b/tests/hosting_dialogs/test_component_dialog.py new file mode 100644 index 00000000..2edc46af --- /dev/null +++ b/tests/hosting_dialogs/test_component_dialog.py @@ -0,0 +1,371 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.core import ConversationState, MemoryStorage +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + Dialog, + DialogSet, + DialogTurnResult, + DialogTurnStatus, + WaterfallDialog, + WaterfallStepContext, +) +from microsoft_agents.hosting.dialogs.models.dialog_reason import DialogReason +from microsoft_agents.hosting.dialogs.prompts import NumberPrompt, PromptOptions +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +def _number_prompt_options(text: str) -> PromptOptions: + return PromptOptions(prompt=Activity(type=ActivityTypes.message, text=text)) + + +class TestComponentDialog: + @pytest.mark.asyncio + async def test_begin_dialog_null_dc_raises(self): + dialog = ComponentDialog("dialogId") + with pytest.raises((TypeError, Exception)): + await dialog.begin_dialog(None) + + @pytest.mark.asyncio + async def test_basic_waterfall_with_number_prompt(self): + """A two-step waterfall collects two numbers via NumberPrompt.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def step1(step): + return await step.prompt( + "number", _number_prompt_options("Enter a number.") + ) + + async def step2(step): + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + return await step.prompt( + "number", _number_prompt_options("Enter another number.") + ) + + ds.add(WaterfallDialog("test-waterfall", [step1, step2])) + ds.add(NumberPrompt("number", default_locale="en-us")) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("test-waterfall") + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity( + f"Bot received the number '{int(results.result)}'." + ) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("42") + flow = await flow.assert_reply("Thanks for '42'") + flow = await flow.assert_reply("Enter another number.") + flow = await flow.send("64") + await flow.assert_reply("Bot received the number '64'.") + + @pytest.mark.asyncio + async def test_basic_component_dialog(self): + """ComponentDialog encapsulates its own waterfall and prompt.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + class TestComp(ComponentDialog): + def __init__(self): + super().__init__("TestComponentDialog") + + async def step1(step): + return await step.prompt( + "number", _number_prompt_options("Enter a number.") + ) + + async def step2(step): + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + return await step.prompt( + "number", _number_prompt_options("Enter another number.") + ) + + self.add_dialog(WaterfallDialog("test-waterfall", [step1, step2])) + self.add_dialog(NumberPrompt("number", default_locale="en-us")) + + ds.add(TestComp()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("TestComponentDialog") + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity( + f"Bot received the number '{int(results.result)}'." + ) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("42") + flow = await flow.assert_reply("Thanks for '42'") + flow = await flow.assert_reply("Enter another number.") + flow = await flow.send("64") + await flow.assert_reply("Bot received the number '64'.") + + @pytest.mark.asyncio + async def test_call_dialog_in_parent_component(self): + """A child component can call a dialog registered in its parent.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + child_component = ComponentDialog("childComponent") + + async def child_step1(step): + await step.context.send_activity("Child started.") + return await step.begin_dialog("parentDialog", "test") + + async def child_step2(step): + await step.context.send_activity(f"Child finished. Value: {step.result}") + return await step.end_dialog() + + child_component.add_dialog( + WaterfallDialog("childDialog", [child_step1, child_step2]) + ) + + parent_component = ComponentDialog("parentComponent") + parent_component.add_dialog(child_component) + + async def parent_step(step): + await step.context.send_activity("Parent called.") + return await step.end_dialog(step.options) + + parent_component.add_dialog(WaterfallDialog("parentDialog", [parent_step])) + ds.add(parent_component) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("parentComponent") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("Hi") + flow = await flow.assert_reply("Child started.") + flow = await flow.assert_reply("Parent called.") + await flow.assert_reply("Child finished. Value: test") + + @pytest.mark.asyncio + async def test_call_dialog_defined_in_parent_component(self): + """Child can call parent-registered dialog and receive the return value.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + options = {"value": "test"} + + child_component = ComponentDialog("childComponent") + + async def child_step1(step): + await step.context.send_activity("Child started.") + return await step.begin_dialog("parentDialog", options) + + async def child_step2(step): + assert step.result == "test" + await step.context.send_activity("Child finished.") + return await step.end_dialog() + + child_component.add_dialog( + WaterfallDialog("childDialog", [child_step1, child_step2]) + ) + + parent_component = ComponentDialog("parentComponent") + parent_component.add_dialog(child_component) + + async def parent_step(step): + step_options = step.options + await step.context.send_activity( + f"Parent called with: {step_options['value']}" + ) + return await step.end_dialog(step_options["value"]) + + parent_component.add_dialog(WaterfallDialog("parentDialog", [parent_step])) + ds.add(parent_component) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("parentComponent") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("Hi") + flow = await flow.assert_reply("Child started.") + flow = await flow.assert_reply("Parent called with: test") + await flow.assert_reply("Child finished.") + + @pytest.mark.asyncio + async def test_nested_component_dialog(self): + """Nested ComponentDialogs properly pass control between each other.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + class InnerComp(ComponentDialog): + def __init__(self): + super().__init__("TestComponentDialog") + + async def step1(step): + return await step.prompt( + "number", _number_prompt_options("Enter a number.") + ) + + async def step2(step): + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + return await step.prompt( + "number", _number_prompt_options("Enter another number.") + ) + + self.add_dialog(WaterfallDialog("test-waterfall", [step1, step2])) + self.add_dialog(NumberPrompt("number", default_locale="en-us")) + + class OuterComp(ComponentDialog): + def __init__(self): + super().__init__("TestNestedComponentDialog") + + async def step1(step): + return await step.prompt( + "number", _number_prompt_options("Enter a number.") + ) + + async def step2(step): + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + return await step.prompt( + "number", _number_prompt_options("Enter another number.") + ) + + async def step3(step): + await step.context.send_activity(f"Got '{int(step.result)}'.") + return await step.begin_dialog("TestComponentDialog") + + self.add_dialog( + WaterfallDialog("test-waterfall", [step1, step2, step3]) + ) + self.add_dialog(NumberPrompt("number", default_locale="en-us")) + self.add_dialog(InnerComp()) + + ds.add(OuterComp()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("TestNestedComponentDialog") + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity( + f"Bot received the number '{int(results.result)}'." + ) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("42") + flow = await flow.assert_reply("Thanks for '42'") + flow = await flow.assert_reply("Enter another number.") + flow = await flow.send("64") + flow = await flow.assert_reply("Got '64'.") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("101") + flow = await flow.assert_reply("Thanks for '101'") + flow = await flow.assert_reply("Enter another number.") + flow = await flow.send("5") + await flow.assert_reply("Bot received the number '5'.") + + +class TestComponentDialogOnEndDialogHook: + @pytest.mark.asyncio + async def test_on_end_dialog_called_with_cancel_reason(self): + """on_end_dialog hook receives CancelCalled reason when cancel_all_dialogs() is invoked.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + hook_calls = [] + + class TrackingComp(ComponentDialog): + def __init__(self): + super().__init__("TrackingComp") + + async def waiting_step(step): + return Dialog.end_of_turn + + self.add_dialog(WaterfallDialog("inner-wf", [waiting_step])) + + async def on_end_dialog(self, context, instance, reason): + hook_calls.append(reason) + + ds.add(TrackingComp()) + + turn = [0] + + async def exec(tc): + turn[0] += 1 + dc = await ds.create_context(tc) + if turn[0] == 1: + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("TrackingComp") + else: + # Cancel without continuing so the waterfall doesn't advance + await dc.cancel_all_dialogs() + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + await adapter.send("hi") # starts the dialog, step 0 waits + await adapter.send("cancel") # triggers cancel_all_dialogs directly + + assert DialogReason.CancelCalled in hook_calls + + @pytest.mark.asyncio + async def test_on_end_dialog_called_with_end_reason_on_completion(self): + """on_end_dialog hook receives EndCalled reason when the component finishes normally.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + hook_calls = [] + + class TrackingComp(ComponentDialog): + def __init__(self): + super().__init__("TrackingComp") + + async def ending_step(step): + return await step.end_dialog("done") + + self.add_dialog(WaterfallDialog("inner-wf", [ending_step])) + + async def on_end_dialog(self, context, instance, reason): + hook_calls.append(reason) + + ds.add(TrackingComp()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("TrackingComp") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + await adapter.send("hi") # starts and immediately completes the component + + assert DialogReason.EndCalled in hook_calls diff --git a/tests/hosting_dialogs/test_confirm_prompt.py b/tests/hosting_dialogs/test_confirm_prompt.py new file mode 100644 index 00000000..b15a2030 --- /dev/null +++ b/tests/hosting_dialogs/test_confirm_prompt.py @@ -0,0 +1,493 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from typing import List + +import pytest + +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + TurnContext, + MessageFactory, +) +from microsoft_agents.hosting.dialogs import ( + DialogSet, + DialogTurnResult, + DialogTurnStatus, +) +from microsoft_agents.hosting.dialogs.choices import ( + Choice, + ChoiceFactoryOptions, + ListStyle, +) +from microsoft_agents.hosting.dialogs.prompts import ( + ConfirmPrompt, + PromptCultureModel, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestConfirmPrompt: + def test_confirm_prompt_with_empty_id_should_fail(self): + empty_id = "" + + with pytest.raises(TypeError): + ConfirmPrompt(empty_id) + + def test_confirm_prompt_with_none_id_should_fail(self): + none_id = None + + with pytest.raises(TypeError): + ConfirmPrompt(none_id) + + @pytest.mark.asyncio + async def test_confirm_prompt(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm.") + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Please confirm. (1) Yes or (2) No") + step3 = await step2.send("yes") + await step3.assert_reply("Confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_retry(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm."), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please confirm, say 'yes' or 'no' or something like that.", + ), + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Please confirm. (1) Yes or (2) No") + step3 = await step2.send("lala") + step4 = await step3.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. (1) Yes or (2) No" + ) + step5 = await step4.send("no") + await step5.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_no_options(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + await dialog_context.prompt("ConfirmPrompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply(" (1) Yes or (2) No") + step3 = await step2.send("lala") + step4 = await step3.assert_reply(" (1) Yes or (2) No") + step5 = await step4.send("no") + await step5.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_choice_options_numbers(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + confirm_prompt.choice_options = ChoiceFactoryOptions(include_numbers=True) + confirm_prompt.style = ListStyle.in_line + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm."), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please confirm, say 'yes' or 'no' or something like that.", + ), + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Please confirm. (1) Yes or (2) No") + step3 = await step2.send("lala") + step4 = await step3.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. (1) Yes or (2) No" + ) + step5 = await step4.send("2") + await step5.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_choice_options_multiple_attempts(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + confirm_prompt.choice_options = ChoiceFactoryOptions(include_numbers=True) + confirm_prompt.style = ListStyle.in_line + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm."), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please confirm, say 'yes' or 'no' or something like that.", + ), + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Please confirm. (1) Yes or (2) No") + step3 = await step2.send("lala") + step4 = await step3.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. (1) Yes or (2) No" + ) + step5 = await step4.send("what") + step6 = await step5.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. (1) Yes or (2) No" + ) + step7 = await step6.send("2") + await step7.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_options_no_numbers(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt", default_locale="English") + confirm_prompt.choice_options = ChoiceFactoryOptions( + include_numbers=False, inline_separator="~" + ) + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm."), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please confirm, say 'yes' or 'no' or something like that.", + ), + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Please confirm. Yes or No") + step3 = await step2.send("2") + step4 = await step3.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. Yes or No" + ) + step5 = await step4.send("no") + await step5.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_confirm_prompt_should_default_to_english_locale(self): + locales = [None, "", "not-supported"] + + for locale in locales: + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + confirm_prompt = ConfirmPrompt("ConfirmPrompt") + confirm_prompt.choice_options = ChoiceFactoryOptions(include_numbers=True) + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please confirm." + ), + retry_prompt=Activity( + type=ActivityTypes.message, + text="Please confirm, say 'yes' or 'no' or something like that.", + ), + ) + await dialog_context.prompt("ConfirmPrompt", options) + elif results.status == DialogTurnStatus.Complete: + message_text = "Confirmed" if results.result else "Not confirmed" + await turn_context.send_activity(MessageFactory.text(message_text)) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + # Activity.locale uses NonEmptyString which rejects None/""; use model_construct to bypass + send_activity = Activity.model_construct( + type=ActivityTypes.message, text="Hello", locale=locale or None + ) + step1 = await adapter.send(send_activity) + step2 = await step1.assert_reply("Please confirm. (1) Yes or (2) No") + step3 = await step2.send("lala") + step4 = await step3.assert_reply( + "Please confirm, say 'yes' or 'no' or something like that. (1) Yes or (2) No" + ) + step5 = await step4.send("2") + await step5.assert_reply("Not confirmed") + + @pytest.mark.asyncio + async def test_should_recognize_locale_variations_of_correct_locales(self): + def cap_ending(locale: str) -> str: + return f"{locale.split('-')[0]}-{locale.split('-')[1].upper()}" + + def title_ending(locale: str) -> str: + return locale[:3] + locale[3].upper() + locale[4:] + + def cap_two_letter(locale: str) -> str: + return locale.split("-")[0].upper() + + def lower_two_letter(locale: str) -> str: + return locale.split("-")[0].upper() + + async def exec_test_for_locale(valid_locale: str, locale_variations: List): + # Hold the correct answer from when a valid locale is used + expected_answer = None + + def inspector(activity: Activity, description: str): + nonlocal expected_answer + + assert not description + + if valid_locale == test_locale: + expected_answer = activity.text + else: + # Ensure we're actually testing a variation. + assert activity.locale != valid_locale + + assert activity.text == expected_answer + return True + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please confirm." + ) + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + confirmed = results.result + if confirmed: + await turn_context.send_activity("true") + else: + await turn_context.send_activity("false") + + await convo_state.save(turn_context) + + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + test_locale = None + for test_locale in locale_variations: + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + choice_prompt = ConfirmPrompt("prompt", validator) + dialogs.add(choice_prompt) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity( + type=ActivityTypes.message, text="Hello", locale=test_locale + ) + ) + await step1.assert_reply(inspector) + + locales = [ + "zh-cn", + "nl-nl", + "en-us", + "fr-fr", + "de-de", + "it-it", + "ja-jp", + "ko-kr", + "pt-br", + "es-es", + "tr-tr", + "de-de", + ] + + locale_tests = [] + for locale in locales: + locale_tests.append( + [ + locale, + cap_ending(locale), + title_ending(locale), + cap_two_letter(locale), + lower_two_letter(locale), + ] + ) + + # Test each valid locale + for locale_test in locale_tests: + await exec_test_for_locale(locale_test[0], locale_test) + + @pytest.mark.asyncio + async def test_should_recognize_and_use_custom_locale_dict(self): + async def validator(prompt: PromptValidatorContext) -> bool: + assert prompt + + if not prompt.recognized.succeeded: + await prompt.context.send_activity("Bad input.") + + return prompt.recognized.succeeded + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + culture = PromptCultureModel( + locale="custom-locale", + no_in_language="customNo", + yes_in_language="customYes", + separator="customSeparator", + inline_or="customInlineOr", + inline_or_more="customInlineOrMore", + ) + + custom_dict = { + culture.locale: ( + Choice(culture.yes_in_language), + Choice(culture.no_in_language), + ChoiceFactoryOptions( + culture.separator, culture.inline_or, culture.inline_or_more, True + ), + ) + } + + confirm_prompt = ConfirmPrompt("prompt", validator, choice_defaults=custom_dict) + dialogs.add(confirm_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + + results: DialogTurnResult = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please confirm.") + ) + await dialog_context.prompt("prompt", options) + elif results.status == DialogTurnStatus.Complete: + selected_choice = results.result + await turn_context.send_activity(selected_choice.value) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send( + Activity(type=ActivityTypes.message, text="Hello", locale=culture.locale) + ) + await step1.assert_reply( + "Please confirm. (1) customYescustomInlineOr(2) customNo" + ) diff --git a/tests/hosting_dialogs/test_date_time_prompt.py b/tests/hosting_dialogs/test_date_time_prompt.py new file mode 100644 index 00000000..ef2aeb9d --- /dev/null +++ b/tests/hosting_dialogs/test_date_time_prompt.py @@ -0,0 +1,88 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs.prompts import DateTimePrompt, PromptOptions +from microsoft_agents.hosting.core import ( + MessageFactory, + ConversationState, + MemoryStorage, + TurnContext, +) +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestDatetimePrompt: + @pytest.mark.asyncio + async def test_date_time_prompt(self): + # Create new ConversationState with MemoryStorage and register the state as middleware. + conver_state = ConversationState(MemoryStorage()) + + # Create a DialogState property + dialog_state = conver_state.create_property("dialogState") + + # Create new DialogSet. + dialogs = DialogSet(dialog_state) + + # Create and add DateTime prompt to DialogSet. + date_time_prompt = DateTimePrompt("DateTimePrompt") + dialogs.add(date_time_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + prompt_msg = "What date would you like?" + dialog_context = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions(prompt=MessageFactory.text(prompt_msg)) + await dialog_context.begin_dialog("DateTimePrompt", options) + else: + if results.status == DialogTurnStatus.Complete: + resolution = results.result[0] + reply = MessageFactory.text( + f"Timex: '{resolution.timex}' Value: '{resolution.value}'" + ) + await turn_context.send_activity(reply) + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("What date would you like?") + step3 = await step2.send("5th December 2018 at 9am") + await step3.assert_reply("Timex: '2018-12-05T09' Value: '2018-12-05 09:00:00'") + + @pytest.mark.asyncio + async def test_date_time_prompt_retry_on_invalid_input(self): + """DateTimePrompt sends the retry_prompt when input cannot be recognized, then accepts valid input.""" + conver_state = ConversationState(MemoryStorage()) + dialog_state = conver_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + dialogs.add(DateTimePrompt("DateTimePrompt")) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=MessageFactory.text("What date?"), + retry_prompt=MessageFactory.text("Not a valid date. Try again."), + ) + await dialog_context.begin_dialog("DateTimePrompt", options) + elif results.status == DialogTurnStatus.Complete: + resolution = results.result[0] + await turn_context.send_activity( + MessageFactory.text(f"Timex: '{resolution.timex}'") + ) + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("What date?") + step3 = await step2.send("not a date at all xyz") + step4 = await step3.assert_reply("Not a valid date. Try again.") + step5 = await step4.send("5th December 2018") + await step5.assert_reply("Timex: '2018-12-05'") diff --git a/tests/hosting_dialogs/test_dialog.py b/tests/hosting_dialogs/test_dialog.py new file mode 100644 index 00000000..3bf99d2b --- /dev/null +++ b/tests/hosting_dialogs/test_dialog.py @@ -0,0 +1,81 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from unittest.mock import AsyncMock, MagicMock + +from microsoft_agents.hosting.dialogs import ( + Dialog, + DialogTurnResult, + DialogTurnStatus, + DialogReason, +) + + +class _ConcreteDialog(Dialog): + """Minimal concrete Dialog for testing base class behavior.""" + + async def begin_dialog(self, dialog_context, options=None): + return DialogTurnResult(DialogTurnStatus.Complete) + + +class TestDialog: + def test_null_id_raises(self): + with pytest.raises((TypeError, Exception)): + _ConcreteDialog(None) + + def test_blank_id_raises(self): + with pytest.raises((TypeError, Exception)): + _ConcreteDialog(" ") + + def test_telemetry_client_defaults_non_none(self): + dialog = _ConcreteDialog("A") + assert dialog.telemetry_client is not None + + def test_get_version_returns_id(self): + dialog = _ConcreteDialog("my-dialog") + assert dialog.get_version() == "my-dialog" + + def test_id_property(self): + dialog = _ConcreteDialog("test-id") + assert dialog.id == "test-id" + + @pytest.mark.asyncio + async def test_continue_dialog_calls_end_dialog(self): + """Default continue_dialog calls end_dialog(None) → Complete.""" + dialog = _ConcreteDialog("A") + dc = MagicMock() + dc.end_dialog = AsyncMock( + return_value=DialogTurnResult(DialogTurnStatus.Complete) + ) + + result = await dialog.continue_dialog(dc) + + assert result.status == DialogTurnStatus.Complete + dc.end_dialog.assert_awaited_once_with(None) + + @pytest.mark.asyncio + async def test_resume_dialog_calls_end_dialog_with_result(self): + """Default resume_dialog calls end_dialog(result) → Complete.""" + dialog = _ConcreteDialog("A") + dc = MagicMock() + dc.end_dialog = AsyncMock( + return_value=DialogTurnResult(DialogTurnStatus.Complete, "done") + ) + + result = await dialog.resume_dialog(dc, DialogReason.BeginCalled, "done") + + assert result.status == DialogTurnStatus.Complete + dc.end_dialog.assert_awaited_once_with("done") + + @pytest.mark.asyncio + async def test_reprompt_dialog_is_noop(self): + """Default reprompt_dialog is a no-op (no exception).""" + dialog = _ConcreteDialog("A") + await dialog.reprompt_dialog(MagicMock(), MagicMock()) + + @pytest.mark.asyncio + async def test_end_dialog_is_noop(self): + """Default end_dialog is a no-op (no exception).""" + dialog = _ConcreteDialog("A") + await dialog.end_dialog(MagicMock(), MagicMock(), DialogReason.EndCalled) diff --git a/tests/hosting_dialogs/test_dialog_context.py b/tests/hosting_dialogs/test_dialog_context.py new file mode 100644 index 00000000..288b7d0a --- /dev/null +++ b/tests/hosting_dialogs/test_dialog_context.py @@ -0,0 +1,293 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from unittest.mock import MagicMock + +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + Dialog, + DialogContext, + DialogSet, + DialogState, + DialogTurnStatus, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, +) +from microsoft_agents.hosting.dialogs.models.dialog_instance import DialogInstance +from microsoft_agents.hosting.dialogs.prompts import TextPrompt, PromptOptions +from microsoft_agents.hosting.core import ConversationState, MemoryStorage +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +def _make_dc(): + """Create a minimal DialogContext backed by a MagicMock TurnContext.""" + + class _Stub(ComponentDialog): + def __init__(self): + super().__init__("stub") + + ds = _Stub()._dialogs + mock_tc = MagicMock() + return DialogContext(ds, mock_tc, DialogState()) + + +class TestDialogContext: + def test_null_dialog_set_raises(self): + with pytest.raises(TypeError): + DialogContext(None, MagicMock(), DialogState()) + + def test_null_turn_context_raises(self): + dc = _make_dc() + with pytest.raises(TypeError): + DialogContext(dc.dialogs, None, DialogState()) + + @pytest.mark.asyncio + async def test_begin_dialog_empty_id_raises(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + with pytest.raises(TypeError): + await dc.begin_dialog("") + + await adapter.send_text_to_agent_async("hi", callback) + + @pytest.mark.asyncio + async def test_prompt_empty_id_raises(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + with pytest.raises(TypeError): + await dc.prompt("", MagicMock()) + + await adapter.send_text_to_agent_async("hi", callback) + + @pytest.mark.asyncio + async def test_prompt_none_options_raises(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + with pytest.raises(TypeError): + await dc.prompt("somePrompt", None) + + await adapter.send_text_to_agent_async("hi", callback) + + @pytest.mark.asyncio + async def test_continue_dialog_empty_stack_returns_empty(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + result_holder = {} + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + result = await dc.continue_dialog() + result_holder["status"] = result.status + + await adapter.send_text_to_agent_async("hi", callback) + assert result_holder["status"] == DialogTurnStatus.Empty + + def test_active_dialog_none_on_empty_stack(self): + dc = _make_dc() + assert dc.active_dialog is None + + def test_child_none_when_no_active_dialog(self): + dc = _make_dc() + assert dc.child is None + + def test_find_dialog_sync_returns_none_for_unknown(self): + dc = _make_dc() + assert dc.find_dialog_sync("nonexistent") is None + + @pytest.mark.asyncio + async def test_cancel_all_dialogs_empty_stack_returns_empty(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + result_holder = {} + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + result = await dc.cancel_all_dialogs() + result_holder["status"] = result.status + + await adapter.send_text_to_agent_async("hi", callback) + assert result_holder["status"] == DialogTurnStatus.Empty + + @pytest.mark.asyncio + async def test_begin_dialog_unknown_id_raises(self): + """begin_dialog raises when the dialog ID is not registered.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + with pytest.raises(Exception): + await dc.begin_dialog("does-not-exist") + + await adapter.send_text_to_agent_async("hi", callback) + + @pytest.mark.asyncio + async def test_replace_dialog_ends_active_and_starts_new(self): + """replace_dialog pops the active dialog and starts the replacement.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + completed = {} + + async def step1(step): + await step.context.send_activity("step1") + return Dialog.end_of_turn + + async def step2(step): + await step.context.send_activity("replacement") + return await step.end_dialog() + + ds.add(WaterfallDialog("first", [step1])) + ds.add(WaterfallDialog("second", [step2])) + + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("first") + elif results.status == DialogTurnStatus.Waiting: + await dc.replace_dialog("second") + await convo_state.save(tc) + + step = await adapter.send_text_to_agent_async("hi", callback) + step = await adapter.send_text_to_agent_async("next", callback) + completed["done"] = True + assert completed["done"] + + @pytest.mark.asyncio + async def test_find_dialog_returns_none_for_unknown(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + result_holder = {} + adapter = DialogTestAdapter() + + async def callback(tc): + dc = await ds.create_context(tc) + found = await dc.find_dialog("nonexistent") + result_holder["found"] = found + + await adapter.send_text_to_agent_async("hi", callback) + assert result_holder["found"] is None + + @pytest.mark.asyncio + async def test_reprompt_dialog_resends_prompt_activity(self): + """reprompt_dialog re-sends the original prompt when a TextPrompt is waiting.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + ds.add(TextPrompt("text-prompt")) + + async def start_prompt(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Please enter text." + ) + ) + await dc.prompt("text-prompt", options) + await convo_state.save(tc) + + async def do_reprompt(tc): + dc = await ds.create_context(tc) + await dc.reprompt_dialog() + await convo_state.save(tc) + + adapter = DialogTestAdapter() + + await adapter.send_text_to_agent_async("hi", start_prompt) + first_prompt = adapter.get_next_reply() + assert first_prompt is not None + assert first_prompt.text == "Please enter text." + + adapter.active_queue.clear() + await adapter.send_text_to_agent_async("anything", do_reprompt) + reprompt_reply = adapter.get_next_reply() + assert reprompt_reply is not None + assert reprompt_reply.text == "Please enter text." + + @pytest.mark.asyncio + async def test_emit_event_bubbles_to_parent_dc(self): + """Events emitted with bubble=True propagate from the inner DC to the parent DC's active dialog.""" + from unittest.mock import MagicMock + + captured_events = [] + + class CapturingDialog(WaterfallDialog): + async def _on_pre_bubble_event(self, dc, event): + captured_events.append(event.name) + return True # mark as handled; stop bubbling + + # ComponentDialog subclasses are the only way to get a no-state DialogSet + class _OuterHolder(ComponentDialog): + def __init__(self): + super().__init__("_outer_holder") + + class _InnerHolder(ComponentDialog): + def __init__(self): + super().__init__("_inner_holder") + + # Outer DC: has CapturingDialog active on the stack + outer_ds = _OuterHolder()._dialogs + outer_ds.add(CapturingDialog("capturing", [])) + outer_state = DialogState() + outer_instance = DialogInstance() + outer_instance.id = "capturing" + outer_instance.state = {} + outer_state.dialog_stack.insert(0, outer_instance) + mock_tc = MagicMock() + outer_dc = DialogContext(outer_ds, mock_tc, outer_state) + + # Inner DC: has a plain WaterfallDialog active; parent is outer_dc + inner_ds = _InnerHolder()._dialogs + inner_ds.add(WaterfallDialog("inner-wf", [])) + inner_state = DialogState() + inner_instance = DialogInstance() + inner_instance.id = "inner-wf" + inner_instance.state = {} + inner_state.dialog_stack.insert(0, inner_instance) + inner_dc = DialogContext(inner_ds, mock_tc, inner_state) + inner_dc.parent = outer_dc + + handled = await inner_dc.emit_event("custom.test.event", "payload", bubble=True) + + assert ( + handled + ), "Event should have been caught by the outer dialog's _on_pre_bubble_event" + assert "custom.test.event" in captured_events diff --git a/tests/hosting_dialogs/test_dialog_extensions.py b/tests/hosting_dialogs/test_dialog_extensions.py new file mode 100644 index 00000000..082e49ed --- /dev/null +++ b/tests/hosting_dialogs/test_dialog_extensions.py @@ -0,0 +1,188 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +# pylint: disable=ungrouped-imports +import enum +from typing import List +import uuid + +import pytest + +from microsoft_agents.hosting.core import ClaimsIdentity +from microsoft_agents.hosting.core.authorization import AuthenticationConstants +from microsoft_agents.hosting.core import ( + TurnContext, + MessageFactory, + MemoryStorage, + ConversationState, + UserState, +) +from microsoft_agents.activity import ActivityTypes, Activity, EndOfConversationCodes +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + TextPrompt, + WaterfallDialog, + DialogInstance, + DialogReason, + WaterfallStepContext, + PromptOptions, + Dialog, + DialogExtensions, + DialogEvents, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class SimpleComponentDialog(ComponentDialog): + def __init__(self): + super().__init__("SimpleComponentDialog") + + self.add_dialog(TextPrompt("TextPrompt")) + self.add_dialog( + WaterfallDialog("WaterfallDialog", [self.prompt_for_name, self.final_step]) + ) + + self.initial_dialog_id = "WaterfallDialog" + self.end_reason = DialogReason.BeginCalled + + async def end_dialog( + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ) -> None: + self.end_reason = reason + return await super().end_dialog(context, instance, reason) + + async def prompt_for_name(self, step_context: WaterfallStepContext): + return await step_context.prompt( + "TextPrompt", + PromptOptions( + prompt=MessageFactory.text("Hello, what is your name?"), + retry_prompt=MessageFactory.text("Hello, what is your name again?"), + ), + ) + + async def final_step(self, step_context: WaterfallStepContext): + await step_context.context.send_activity( + f"Hello {step_context.result}, nice to meet you!" + ) + return await step_context.end_dialog(step_context.result) + + +class FlowTestCase(enum.Enum): + root_bot_only = 1 + root_bot_consuming_skill = 2 + middle_skill = 3 + leaf_skill = 4 + + +class TestDialogExtensions: + def setup_method(self): + self.eoc_sent: Activity = None + self.skill_bot_id = str(uuid.uuid4()) + self.parent_bot_id = str(uuid.uuid4()) + + def _create_test_flow( + self, dialog: Dialog, test_case: FlowTestCase + ) -> DialogTestAdapter: + """ + Creates a DialogTestAdapter configured for the given test case. + Returns the adapter (which supports send/assert_reply as a TestFlow entry point). + """ + conversation_id = str(uuid.uuid4()) + storage = MemoryStorage() + convo_state = ConversationState(storage) + + eoc_sent_ref = [None] + self.eoc_sent = None + + async def logic(context: TurnContext): + if test_case != FlowTestCase.root_bot_only: + claims_identity = ClaimsIdentity( + { + AuthenticationConstants.VERSION_CLAIM: "2.0", + AuthenticationConstants.AUDIENCE_CLAIM: self.skill_bot_id, + AuthenticationConstants.AUTHORIZED_PARTY: self.parent_bot_id, + }, + True, + ) + context._identity = claims_identity + + async def capture_eoc( + inner_context: TurnContext, activities: List[Activity], next + ): # pylint: disable=unused-argument + for activity in activities: + if activity.type == ActivityTypes.end_of_conversation: + self.eoc_sent = activity + eoc_sent_ref[0] = activity + break + return await next() + + context.on_send_activities(capture_eoc) + + await DialogExtensions.run_dialog( + dialog, context, convo_state.create_property("DialogState") + ) + + return DialogTestAdapter(logic) + + @pytest.mark.asyncio + async def test_handles_root_bot_only(self): + dialog = SimpleComponentDialog() + adapter = self._create_test_flow(dialog, FlowTestCase.root_bot_only) + + step1 = await adapter.send("Hi") + step2 = await step1.assert_reply("Hello, what is your name?") + step3 = await step2.send("SomeName") + await step3.assert_reply("Hello SomeName, nice to meet you!") + + assert dialog.end_reason == DialogReason.EndCalled + assert ( + self.eoc_sent is None + ), "Root bot should not send EndConversation to channel" + + @pytest.mark.skip( + reason="Requires skill infrastructure (SkillHandler/SkillConversationReference) not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_root_bot_consuming_skill(self): + pass + + @pytest.mark.skip( + reason="Requires skill infrastructure (SkillHandler/SkillConversationReference) not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_middle_skill(self): + pass + + @pytest.mark.skip( + reason="Requires skill infrastructure (SkillHandler/SkillConversationReference) not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_leaf_skill(self): + pass + + @pytest.mark.skip( + reason="Requires skill infrastructure (SkillHandler/SkillConversationReference) not available in new SDK" + ) + @pytest.mark.asyncio + async def test_skill_handles_eoc_from_parent(self): + pass + + @pytest.mark.asyncio + async def test_skill_handles_reprompt_from_parent(self): + """ + Tests that a reprompt event causes the dialog to re-prompt. + This test does not require skill infrastructure. + """ + dialog = SimpleComponentDialog() + adapter = self._create_test_flow(dialog, FlowTestCase.root_bot_only) + + step1 = await adapter.send("Hi") + step2 = await step1.assert_reply("Hello, what is your name?") + await step2.send( + Activity( + type=ActivityTypes.event, + name=DialogEvents.reprompt_dialog, + ) + ) + + assert dialog.end_reason == DialogReason.BeginCalled diff --git a/tests/hosting_dialogs/test_dialog_manager.py b/tests/hosting_dialogs/test_dialog_manager.py new file mode 100644 index 00000000..28af29ed --- /dev/null +++ b/tests/hosting_dialogs/test_dialog_manager.py @@ -0,0 +1,281 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +# pylint: disable=pointless-string-statement + +from enum import Enum +from typing import Callable, List, Tuple + +import pytest + +from microsoft_agents.hosting.core import ( + ConversationState, + MemoryStorage, + MessageFactory, + UserState, + TurnContext, +) +from microsoft_agents.hosting.core import ClaimsIdentity +from microsoft_agents.hosting.core.authorization import AuthenticationConstants +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + Dialog, + DialogContext, + DialogEvents, + DialogInstance, + DialogReason, + TextPrompt, + WaterfallDialog, + DialogManager, + DialogManagerResult, + DialogTurnStatus, + WaterfallStepContext, +) +from microsoft_agents.hosting.dialogs.prompts import PromptOptions +from microsoft_agents.activity import ( + Activity, + ActivityTypes, + ChannelAccount, + ConversationAccount, + EndOfConversationCodes, + InputHints, + Channels, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class SkillFlowTestCase(str, Enum): + # DialogManager is executing on a root bot with no skills (typical standalone bot). + root_bot_only = "RootBotOnly" + + # DialogManager is executing on a root bot handling replies from a skill. + root_bot_consuming_skill = "RootBotConsumingSkill" + + # DialogManager is executing in a skill that is called from a root and calling another skill. + middle_skill = "MiddleSkill" + + # DialogManager is executing in a skill that is called from a parent (a root or another skill) but doesn't call + # another skill. + leaf_skill = "LeafSkill" + + +class SimpleComponentDialog(ComponentDialog): + # An App ID for a parent bot. + parent_bot_id = "00000000-0000-0000-0000-0000000000PARENT" + + # An App ID for a skill bot. + skill_bot_id = "00000000-0000-0000-0000-00000000000SKILL" + + # Captures an EndOfConversation if it was sent to help with assertions. + eoc_sent: Activity = None + + # Property to capture the DialogManager turn results and do assertions. + dm_turn_result: DialogManagerResult = None + + def __init__( + self, id: str = None, prop: str = None + ): # pylint: disable=unused-argument + super().__init__(id or "SimpleComponentDialog") + self.text_prompt = "TextPrompt" + self.waterfall_dialog = "WaterfallDialog" + self.add_dialog(TextPrompt(self.text_prompt)) + self.add_dialog( + WaterfallDialog( + self.waterfall_dialog, + [ + self.prompt_for_name, + self.final_step, + ], + ) + ) + self.initial_dialog_id = self.waterfall_dialog + self.end_reason = None + + @staticmethod + async def create_test_flow( + dialog: Dialog, + test_case: SkillFlowTestCase = SkillFlowTestCase.root_bot_only, + enabled_trace=False, + ) -> DialogTestAdapter: + conversation_id = "testFlowConversationId" + storage = MemoryStorage() + conversation_state = ConversationState(storage) + user_state = UserState(storage) + + activity = Activity( + type=ActivityTypes.message, + channel_id=Channels.test, + service_url="https://test.com", + from_property=ChannelAccount(id="user1", name="User1"), + recipient=ChannelAccount(id="bot", name="Bot"), + conversation=ConversationAccount( + is_group=False, conversation_type=conversation_id, id=conversation_id + ), + ) + + dialog_manager = DialogManager(dialog) + dialog_manager.user_state = user_state + dialog_manager.conversation_state = conversation_state + + async def logic(context: TurnContext): + if test_case != SkillFlowTestCase.root_bot_only: + # Create a skill ClaimsIdentity and put it in turn_state so isSkillClaim() returns True. + claims_identity = ClaimsIdentity({}, False) + claims_identity.claims["ver"] = ( + "2.0" # AuthenticationConstants.VersionClaim + ) + claims_identity.claims["aud"] = ( + SimpleComponentDialog.skill_bot_id + ) # AuthenticationConstants.AudienceClaim + claims_identity.claims["azp"] = ( + SimpleComponentDialog.parent_bot_id + ) # AuthenticationConstants.AuthorizedParty + context._identity = claims_identity + + # Note: SkillHandler.SKILL_CONVERSATION_REFERENCE_KEY based skill routing + # is not available in the new SDK. Skill flow test cases that require it are skipped. + + async def aux( + turn_context: TurnContext, # pylint: disable=unused-argument + activities: List[Activity], + next: Callable, + ): + for activity in activities: + if activity.type == ActivityTypes.end_of_conversation: + SimpleComponentDialog.eoc_sent = activity + break + + return await next() + + # Interceptor to capture the EoC activity if it was sent so we can assert it in the tests. + context.on_send_activities(aux) + + SimpleComponentDialog.dm_turn_result = await dialog_manager.on_turn(context) + + # Manually save state since AutoSaveStateMiddleware is not available + await conversation_state.save(context) + await user_state.save(context) + + adapter = DialogTestAdapter(logic) + if enabled_trace: + adapter.enable_trace = True + + return adapter + + async def on_end_dialog( + self, context: DialogContext, instance: DialogInstance, reason: DialogReason + ): + self.end_reason = reason + return await super().on_end_dialog(context, instance, reason) + + async def prompt_for_name(self, step: WaterfallStepContext): + return await step.prompt( + self.text_prompt, + PromptOptions( + prompt=MessageFactory.text( + "Hello, what is your name?", None, InputHints.expecting_input + ), + retry_prompt=MessageFactory.text( + "Hello, what is your name again?", None, InputHints.expecting_input + ), + ), + ) + + async def final_step(self, step: WaterfallStepContext): + await step.context.send_activity(f"Hello { step.result }, nice to meet you!") + return await step.end_dialog(step.result) + + +class TestDialogManager: + @pytest.mark.asyncio + async def test_handles_root_bot_only(self): + SimpleComponentDialog.dm_turn_result = None + SimpleComponentDialog.eoc_sent = None + dialog = SimpleComponentDialog() + test_flow = await SimpleComponentDialog.create_test_flow( + dialog, SkillFlowTestCase.root_bot_only + ) + step1 = await test_flow.send("Hi") + step2 = await step1.assert_reply("Hello, what is your name?") + step3 = await step2.send("SomeName") + await step3.assert_reply("Hello SomeName, nice to meet you!") + + assert ( + SimpleComponentDialog.dm_turn_result.turn_result.status + == DialogTurnStatus.Complete + ) + assert dialog.end_reason == DialogReason.EndCalled + assert ( + SimpleComponentDialog.eoc_sent is None + ), "Root bot should not send EndConversation to channel" + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_root_bot_consuming_skill(self): + pass + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_middle_skill(self): + pass + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_handles_leaf_skill(self): + pass + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_skill_handles_eoc_from_parent(self): + pass + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_skill_handles_reprompt_from_parent(self): + pass + + @pytest.mark.skip( + reason="Requires SkillHandler/SkillConversationReference skill infrastructure not available in new SDK" + ) + @pytest.mark.asyncio + async def test_skill_should_return_empty_on_reprompt_with_no_dialog(self): + pass + + @pytest.mark.asyncio + async def test_trace_bot_state(self): + SimpleComponentDialog.dm_turn_result = None + dialog = SimpleComponentDialog() + + def assert_is_trace(activity, description): # pylint: disable=unused-argument + assert activity.type == ActivityTypes.trace + return True + + def assert_is_trace_and_label(activity, description): + assert_is_trace(activity, description) + assert activity.label == "Bot State" + return True + + test_flow = await SimpleComponentDialog.create_test_flow( + dialog, SkillFlowTestCase.root_bot_only, True + ) + + step1 = await test_flow.send("Hi") + step2 = await step1.assert_reply("Hello, what is your name?") + step3 = await step2.assert_reply(assert_is_trace_and_label) + step4 = await step3.send("SomeName") + step5 = await step4.assert_reply("Hello SomeName, nice to meet you!") + await step5.assert_reply(assert_is_trace_and_label) + + assert ( + SimpleComponentDialog.dm_turn_result.turn_result.status + == DialogTurnStatus.Complete + ) diff --git a/tests/hosting_dialogs/test_dialog_set.py b/tests/hosting_dialogs/test_dialog_set.py new file mode 100644 index 00000000..ef9fee1e --- /dev/null +++ b/tests/hosting_dialogs/test_dialog_set.py @@ -0,0 +1,137 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from microsoft_agents.hosting.dialogs import DialogSet, ComponentDialog, WaterfallDialog +from microsoft_agents.hosting.core import ConversationState, MemoryStorage +from microsoft_agents.hosting.dialogs._telemetry_client import NullTelemetryClient + + +class MyBotTelemetryClient(NullTelemetryClient): + def __init__(self): + super().__init__() + + +class TestDialogSet: + def test_dialogset_constructor_valid(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + assert dialog_set is not None + + def test_dialogset_constructor_null_property(self): + with pytest.raises(TypeError): + DialogSet(None) + + def test_dialogset_constructor_null_from_componentdialog(self): + ComponentDialog("MyId") + + def test_dialogset_telemetryset(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + + dialog_set.add(WaterfallDialog("A")) + dialog_set.add(WaterfallDialog("B")) + + assert isinstance( + dialog_set.find_dialog("A").telemetry_client, NullTelemetryClient + ) + assert isinstance( + dialog_set.find_dialog("B").telemetry_client, NullTelemetryClient + ) + + dialog_set.telemetry_client = MyBotTelemetryClient() + + assert isinstance( + dialog_set.find_dialog("A").telemetry_client, MyBotTelemetryClient + ) + assert isinstance( + dialog_set.find_dialog("B").telemetry_client, MyBotTelemetryClient + ) + + def test_add_duplicate_dialog_id_raises(self): + """Adding a second dialog with the same ID raises TypeError.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + + dialog_set.add(WaterfallDialog("A")) + with pytest.raises(TypeError): + dialog_set.add(WaterfallDialog("A")) + + def test_add_none_dialog_raises(self): + """Adding None raises TypeError.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + with pytest.raises(TypeError): + dialog_set.add(None) + + def test_get_version_is_stable(self): + """get_version() returns the same hash on repeated calls.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + dialog_set.add(WaterfallDialog("A")) + v1 = dialog_set.get_version() + v2 = dialog_set.get_version() + assert v1 == v2 + + def test_dialogset_nulltelemetryset(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + + dialog_set.add(WaterfallDialog("A")) + dialog_set.add(WaterfallDialog("B")) + + dialog_set.telemetry_client = MyBotTelemetryClient() + dialog_set.telemetry_client = None + + assert not isinstance( + dialog_set.find_dialog("A").telemetry_client, MyBotTelemetryClient + ) + assert not isinstance( + dialog_set.find_dialog("B").telemetry_client, MyBotTelemetryClient + ) + assert isinstance( + dialog_set.find_dialog("A").telemetry_client, NullTelemetryClient + ) + assert isinstance( + dialog_set.find_dialog("B").telemetry_client, NullTelemetryClient + ) + + def test_get_version_is_invalidated_after_add(self): + """get_version() must reflect all dialogs even when add() is called after an earlier get_version().""" + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + + dialog_set.add(WaterfallDialog("A")) + version_before = dialog_set.get_version() + + dialog_set.add(WaterfallDialog("B")) + version_after = dialog_set.get_version() + + assert version_before != version_after, ( + "get_version() returned the same hash after adding a new dialog; " + "the version cache was not invalidated by add()" + ) + + def test_get_version_is_invalidated_after_telemetry_change(self): + """Changing the telemetry client must invalidate the cached version.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state_property = convo_state.create_property("dialogstate") + dialog_set = DialogSet(dialog_state_property) + dialog_set.add(WaterfallDialog("A")) + + version_before = dialog_set.get_version() + dialog_set.telemetry_client = MyBotTelemetryClient() + version_after = dialog_set.get_version() + + # Versions may or may not differ depending on whether telemetry affects + # individual dialog versions, but the cache must at least be recomputed + # (i.e. get_version() must not return the stale pre-change value from cache). + # We verify this by checking the cache was cleared (recomputed == same value is fine). + assert version_after is not None diff --git a/tests/hosting_dialogs/test_number_prompt.py b/tests/hosting_dialogs/test_number_prompt.py new file mode 100644 index 00000000..06f01827 --- /dev/null +++ b/tests/hosting_dialogs/test_number_prompt.py @@ -0,0 +1,378 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +from typing import Callable + +import pytest +from recognizers_text import Culture + +from microsoft_agents.hosting.core import ( + TurnContext, + ConversationState, + MemoryStorage, + MessageFactory, +) +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus, DialogContext +from microsoft_agents.hosting.dialogs.prompts import ( + NumberPrompt, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class NumberPromptMock(NumberPrompt): + def __init__( + self, + dialog_id: str, + validator: Callable[[PromptValidatorContext], bool] = None, + default_locale=None, + ): + super().__init__(dialog_id, validator, default_locale) + + async def on_prompt_null_context(self, options: PromptOptions): + # Should throw TypeError + await self.on_prompt( + turn_context=None, state=None, options=options, is_retry=False + ) + + async def on_prompt_null_options(self, dialog_context: DialogContext): + # Should throw TypeError + await self.on_prompt( + dialog_context.context, state=None, options=None, is_retry=False + ) + + async def on_recognize_null_context(self): + # Should throw TypeError + await self.on_recognize(turn_context=None, state=None, options=None) + + +class TestNumberPrompt: + def test_empty_id_should_fail(self): + empty_id = "" + with pytest.raises(TypeError): + NumberPrompt(empty_id) + + def test_none_id_should_fail(self): + with pytest.raises(TypeError): + NumberPrompt(dialog_id=None) + + @pytest.mark.asyncio + async def test_with_null_turn_context_should_fail(self): + number_prompt_mock = NumberPromptMock("NumberPromptMock") + + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Please send a number.") + ) + + with pytest.raises(TypeError): + await number_prompt_mock.on_prompt_null_context(options) + + @pytest.mark.asyncio + async def test_on_prompt_with_null_options_fails(self): + conver_state = ConversationState(MemoryStorage()) + dialog_state = conver_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + number_prompt_mock = NumberPromptMock( + dialog_id="NumberPromptMock", validator=None, default_locale=Culture.English + ) + dialogs.add(number_prompt_mock) + + with pytest.raises(TypeError): + await number_prompt_mock.on_recognize_null_context() + + @pytest.mark.asyncio + async def test_number_prompt(self): + # Create new ConversationState with MemoryStorage and register the state as middleware. + conver_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the WaterfallDialog. + dialog_state = conver_state.create_property("dialogState") + + dialogs = DialogSet(dialog_state) + + # Create and add number prompt to DialogSet. + number_prompt = NumberPrompt("NumberPrompt", None, Culture.English) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog( + "NumberPrompt", + PromptOptions( + prompt=MessageFactory.text("Enter quantity of cable") + ), + ) + else: + if results.status == DialogTurnStatus.Complete: + number_result = results.result + await turn_context.send_activity( + MessageFactory.text( + f"You asked me for '{number_result}' meters of cable." + ) + ) + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply("Enter quantity of cable") + step3 = await step2.send("Give me twenty meters of cable") + await step3.assert_reply("You asked me for '20' meters of cable.") + + @pytest.mark.asyncio + async def test_number_prompt_retry(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + number_prompt = NumberPrompt( + dialog_id="NumberPrompt", validator=None, default_locale=Culture.English + ) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context: DialogContext = await dialogs.create_context(turn_context) + + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number."), + retry_prompt=Activity( + type=ActivityTypes.message, text="You must enter a number." + ), + ) + await dialog_context.prompt("NumberPrompt", options) + elif results.status == DialogTurnStatus.Complete: + number_result = results.result + await turn_context.send_activity( + MessageFactory.text(f"Bot received the number '{number_result}'.") + ) + + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Enter a number.") + step3 = await step2.send("hello") + step4 = await step3.assert_reply("You must enter a number.") + step5 = await step4.send("64") + await step5.assert_reply("Bot received the number '64'.") + + @pytest.mark.asyncio + async def test_number_uses_locale_specified_in_constructor(self): + # Create new ConversationState with MemoryStorage and register the state as middleware. + conver_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the WaterfallDialog. + dialog_state = conver_state.create_property("dialogState") + + dialogs = DialogSet(dialog_state) + + # Create and add number prompt to DialogSet. + number_prompt = NumberPrompt( + "NumberPrompt", None, default_locale=Culture.Spanish + ) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog( + "NumberPrompt", + PromptOptions( + prompt=MessageFactory.text( + "How much money is in your gaming account?" + ) + ), + ) + else: + if results.status == DialogTurnStatus.Complete: + number_result = results.result + await turn_context.send_activity( + MessageFactory.text( + f"You say you have ${number_result} in your gaming account." + ) + ) + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply("How much money is in your gaming account?") + step3 = await step2.send("I've got $1.200.555,42 in my account.") + await step3.assert_reply("You say you have $1200555.42 in your gaming account.") + + @pytest.mark.asyncio + async def test_number_prompt_validator(self): + # Create new ConversationState with MemoryStorage and register the state as middleware. + conver_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the WaterfallDialog. + dialog_state = conver_state.create_property("dialogState") + + dialogs = DialogSet(dialog_state) + + # Create and add number prompt to DialogSet. + async def validator(prompt_context: PromptValidatorContext): + result = prompt_context.recognized.value + + if 0 < result < 100: + return True + + return False + + number_prompt = NumberPrompt( + "NumberPrompt", validator, default_locale=Culture.English + ) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number."), + retry_prompt=Activity( + type=ActivityTypes.message, + text="You must enter a positive number less than 100.", + ), + ) + await dialog_context.prompt("NumberPrompt", options) + + elif results.status == DialogTurnStatus.Complete: + number_result = int(results.result) + await turn_context.send_activity( + MessageFactory.text(f"Bot received the number '{number_result}'.") + ) + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Enter a number.") + step3 = await step2.send("150") + step4 = await step3.assert_reply( + "You must enter a positive number less than 100." + ) + step5 = await step4.send("64") + await step5.assert_reply("Bot received the number '64'.") + + @pytest.mark.asyncio + async def test_float_number_prompt(self): + # Create new ConversationState with MemoryStorage and register the state as middleware. + conver_state = ConversationState(MemoryStorage()) + + # Create a DialogState property, DialogSet and register the WaterfallDialog. + dialog_state = conver_state.create_property("dialogState") + + dialogs = DialogSet(dialog_state) + + # Create and add number prompt to DialogSet. + number_prompt = NumberPrompt( + "NumberPrompt", validator=None, default_locale=Culture.English + ) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number.") + ) + await dialog_context.prompt("NumberPrompt", options) + + elif results.status == DialogTurnStatus.Complete: + number_result = float(results.result) + await turn_context.send_activity( + MessageFactory.text(f"Bot received the number '{number_result}'.") + ) + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Enter a number.") + step3 = await step2.send("3.14") + await step3.assert_reply("Bot received the number '3.14'.") + + @pytest.mark.asyncio + async def test_number_prompt_uses_locale_specified_in_activity(self): + conver_state = ConversationState(MemoryStorage()) + dialog_state = conver_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + number_prompt = NumberPrompt("NumberPrompt", None, None) + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number.") + ) + await dialog_context.prompt("NumberPrompt", options) + + elif results.status == DialogTurnStatus.Complete: + number_result = float(results.result) + assert 3.14 == number_result + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Enter a number.") + await step2.send( + Activity(type=ActivityTypes.message, text="3,14", locale=Culture.Spanish) + ) + + @pytest.mark.asyncio + async def test_number_prompt_defaults_to_en_us_culture(self): + conver_state = ConversationState(MemoryStorage()) + dialog_state = conver_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + number_prompt = NumberPrompt("NumberPrompt") + dialogs.add(number_prompt) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number.") + ) + await dialog_context.prompt("NumberPrompt", options) + + elif results.status == DialogTurnStatus.Complete: + number_result = float(results.result) + await turn_context.send_activity( + MessageFactory.text(f"Bot received the number '{number_result}'.") + ) + + await conver_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1 = await adapter.send("hello") + step2 = await step1.assert_reply("Enter a number.") + step3 = await step2.send("3.14") + await step3.assert_reply("Bot received the number '3.14'.") diff --git a/tests/hosting_dialogs/test_oauth_prompt.py b/tests/hosting_dialogs/test_oauth_prompt.py new file mode 100644 index 00000000..331abe6a --- /dev/null +++ b/tests/hosting_dialogs/test_oauth_prompt.py @@ -0,0 +1,384 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from microsoft_agents.hosting.dialogs.prompts import OAuthPromptSettings +from microsoft_agents.activity import ( + Activity, + ActivityTypes, + ChannelAccount, + ConversationAccount, + InputHints, + SignInConstants, + TokenResponse, +) +from microsoft_agents.hosting.core import ( + CardFactory, + ConversationState, + MemoryStorage, + TurnContext, +) +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus +from microsoft_agents.hosting.dialogs.prompts import OAuthPrompt, PromptOptions +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +def create_reply(activity): + return Activity( + type=ActivityTypes.message, + from_property=ChannelAccount( + id=activity.recipient.id, name=activity.recipient.name + ), + recipient=ChannelAccount( + id=activity.from_property.id, name=activity.from_property.name + ), + reply_to_id=activity.id, + service_url=activity.service_url, + channel_id=activity.channel_id, + conversation=ConversationAccount( + is_group=activity.conversation.is_group, + id=activity.conversation.id, + name=activity.conversation.name, + ), + ) + + +class TestOAuthPrompt: + @pytest.mark.skip( + reason="tokens/response event path not supported in new OAuthPrompt internals" + ) + @pytest.mark.asyncio + async def test_should_call_oauth_prompt(self): + connection_name = "myConnection" + token = "abc123" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", OAuthPromptSettings(connection_name, "Login", None, 300000) + ) + ) + + async def callback_handler(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.prompt("prompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete: + if results.result.token: + await turn_context.send_activity("Logged in.") + else: + await turn_context.send_activity("Failed") + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(callback_handler) + + async def inspector(activity: Activity, description: str = None): + assert len(activity.attachments) == 1 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.oauth_card + ) + + adapter.add_user_token( + connection_name, activity.channel_id, activity.recipient.id, token + ) + + event_activity = create_reply(activity) + event_activity.type = ActivityTypes.event + event_activity.from_property, event_activity.recipient = ( + event_activity.recipient, + event_activity.from_property, + ) + event_activity.name = "tokens/response" + event_activity.value = TokenResponse( + connection_name=connection_name, token=token + ) + + context = adapter.create_turn_context(event_activity) + await callback_handler(context) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply(inspector) + await step2.assert_reply("Logged in.") + + @pytest.mark.asyncio + async def test_should_call_oauth_prompt_with_code(self): + connection_name = "myConnection" + token = "abc123" + magic_code = "888999" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", OAuthPromptSettings(connection_name, "Login", None, 300000) + ) + ) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.prompt("prompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete: + if results.result.token: + await turn_context.send_activity("Logged in.") + else: + await turn_context.send_activity("Failed") + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + def inspector(activity: Activity, description: str = None): + assert len(activity.attachments) == 1 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.oauth_card + ) + adapter.add_user_token( + connection_name, + activity.channel_id, + activity.recipient.id, + token, + magic_code, + ) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply(inspector) + step3 = await step2.send(magic_code) + await step3.assert_reply("Logged in.") + + @pytest.mark.asyncio + async def test_oauth_prompt_doesnt_detect_code_in_begin_dialog(self): + connection_name = "myConnection" + token = "abc123" + magic_code = "888999" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", OAuthPromptSettings(connection_name, "Login", None, 300000) + ) + ) + + async def exec_test(turn_context: TurnContext): + adapter.add_user_token( + connection_name, + turn_context.activity.channel_id, + turn_context.activity.from_property.id, + token, + magic_code, + ) + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + token_result = await dialog_context.prompt("prompt", PromptOptions()) + if isinstance(token_result.result, TokenResponse): + assert False, "Should not have returned token during begin" + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + def inspector(activity: Activity, description: str = None): + assert len(activity.attachments) == 1 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.oauth_card + ) + + step1 = await adapter.send(magic_code) + await step1.assert_reply(inspector) + + @pytest.mark.asyncio + async def test_should_add_accepting_input_hint_oauth_prompt(self): + connection_name = "myConnection" + called = False + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", OAuthPromptSettings(connection_name, "Login", None, 300000) + ) + ) + + async def callback_handler(turn_context: TurnContext): + nonlocal called + dialog_context = await dialogs.create_context(turn_context) + await dialog_context.continue_dialog() + await dialog_context.prompt( + "prompt", + PromptOptions( + prompt=Activity(type=ActivityTypes.message), + retry_prompt=Activity(type=ActivityTypes.message), + ), + ) + assert ( + dialog_context.active_dialog.state["options"].prompt.input_hint + == InputHints.accepting_input + ) + assert ( + dialog_context.active_dialog.state["options"].retry_prompt.input_hint + == InputHints.accepting_input + ) + await convo_state.save(turn_context) + called = True + + adapter = DialogTestAdapter(callback_handler) + await adapter.send("Hello") + assert called + + @pytest.mark.asyncio + async def test_should_end_oauth_prompt_on_invalid_message_when_end_on_invalid_message( + self, + ): + connection_name = "myConnection" + token = "abc123" + magic_code = "888999" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", + OAuthPromptSettings(connection_name, "Login", None, 300000, None, True), + ) + ) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.prompt("prompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete: + if results.result and results.result.token: + await turn_context.send_activity("Failed") + else: + await turn_context.send_activity("Ended") + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + def inspector(activity: Activity, description: str = None): + assert len(activity.attachments) == 1 + assert ( + activity.attachments[0].content_type + == CardFactory.content_types.oauth_card + ) + adapter.add_user_token( + connection_name, + activity.channel_id, + activity.recipient.id, + token, + magic_code, + ) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply(inspector) + step3 = await step2.send("test invalid message") + await step3.assert_reply("Ended") + + @pytest.mark.asyncio + async def test_should_timeout_oauth_prompt_with_message_activity(self): + activity = Activity(type=ActivityTypes.message, text="any") + await self._run_timeout_test(activity) + + @pytest.mark.asyncio + async def test_should_timeout_oauth_prompt_with_token_response_event_activity(self): + activity = Activity( + type=ActivityTypes.event, name=SignInConstants.token_response_event_name + ) + await self._run_timeout_test(activity) + + @pytest.mark.asyncio + async def test_should_timeout_oauth_prompt_with_verify_state_operation_activity( + self, + ): + activity = Activity( + type=ActivityTypes.invoke, name=SignInConstants.verify_state_operation_name + ) + await self._run_timeout_test(activity) + + @pytest.mark.asyncio + async def test_should_not_timeout_oauth_prompt_with_custom_event_activity(self): + activity = Activity(type=ActivityTypes.event, name="custom event name") + await self._run_timeout_test(activity, False, "Ended", "Failed") + + async def _run_timeout_test( + self, + activity: Activity, + should_succeed: bool = True, + token_response: str = "Failed", + no_token_response: str = "Ended", + ): + connection_name = "myConnection" + token = "abc123" + magic_code = "888999" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialog_state") + dialogs = DialogSet(dialog_state) + dialogs.add( + OAuthPrompt( + "prompt", + OAuthPromptSettings(connection_name, "Login", None, 1), + ) + ) + + async def exec_test(turn_context: TurnContext): + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.prompt("prompt", PromptOptions()) + elif results.status == DialogTurnStatus.Complete or ( + results.status == DialogTurnStatus.Waiting and not should_succeed + ): + if results.result and results.result.token: + await turn_context.send_activity(token_response) + else: + await turn_context.send_activity(no_token_response) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + def inspector(activity_: Activity, description: str = None): + assert len(activity_.attachments) == 1 + assert ( + activity_.attachments[0].content_type + == CardFactory.content_types.oauth_card + ) + adapter.add_user_token( + connection_name, + activity_.channel_id, + activity_.recipient.id, + token, + magic_code, + ) + + step1 = await adapter.send("Hello") + step2 = await step1.assert_reply(inspector) + step3 = await step2.send(activity) + await step3.assert_reply(no_token_response) + + +class TestOAuthPromptSettings: + def test_oauth_app_credentials_stored_correctly(self): + """Constructor param oauth_app_credentials must be accessible as oauth_app_credentials.""" + sentinel = object() + settings = OAuthPromptSettings("conn", "title", oauth_app_credentials=sentinel) + assert settings.oauth_app_credentials is sentinel + + def test_oath_typo_alias_reads_same_value(self): + """oath_app_credentials (typo alias) must return the same value as oauth_app_credentials.""" + sentinel = object() + settings = OAuthPromptSettings("conn", "title", oauth_app_credentials=sentinel) + assert settings.oath_app_credentials is sentinel + + def test_oath_typo_alias_setter_writes_to_canonical(self): + """Writing via the typo alias updates oauth_app_credentials.""" + sentinel = object() + settings = OAuthPromptSettings("conn", "title") + settings.oath_app_credentials = sentinel + assert settings.oauth_app_credentials is sentinel diff --git a/tests/hosting_dialogs/test_object_path.py b/tests/hosting_dialogs/test_object_path.py new file mode 100644 index 00000000..db7ff202 --- /dev/null +++ b/tests/hosting_dialogs/test_object_path.py @@ -0,0 +1,209 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from microsoft_agents.hosting.dialogs import ObjectPath + + +class Location: + def __init__(self, lat: float = None, long: float = None): + self.lat = lat + self.long = long + + +class Options: + def __init__( + self, + first_name: str = None, + last_name: str = None, + age: int = None, + boolean: bool = None, + dictionary: dict = None, + location: Location = None, + ): + self.first_name = first_name + self.last_name = last_name + self.age = age + self.boolean = boolean + self.dictionary = dictionary + self.location = location + + +class TestObjectPath: + def test_typed_only_default(self): + default_options = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + overlay = Options() + result = ObjectPath.assign(default_options, overlay) + assert result.last_name == default_options.last_name + assert result.first_name == default_options.first_name + assert result.age == default_options.age + assert result.boolean == default_options.boolean + assert result.location.lat == default_options.location.lat + assert result.location.long == default_options.location.long + + def test_typed_only_overlay(self): + default_options = Options() + overlay = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + result = ObjectPath.assign(default_options, overlay) + assert result.last_name == overlay.last_name + assert result.first_name == overlay.first_name + assert result.age == overlay.age + assert result.boolean == overlay.boolean + assert result.location.lat == overlay.location.lat + assert result.location.long == overlay.location.long + + def test_typed_full_overlay(self): + default_options = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + dictionary={"one": 1, "two": 2}, + ) + overlay = Options( + last_name="Grant", + first_name="Eddit", + age=32, + location=Location(lat=2.2312312, long=2.234234), + dictionary={"one": 99, "three": 3}, + ) + result = ObjectPath.assign(default_options, overlay) + assert result.last_name == overlay.last_name + assert result.first_name == overlay.first_name + assert result.age == overlay.age + assert result.boolean == overlay.boolean + assert result.location.lat == overlay.location.lat + assert result.location.long == overlay.location.long + assert "one" in result.dictionary + assert result.dictionary["one"] == 99 + assert "two" in result.dictionary + assert "three" in result.dictionary + + def test_typed_partial_overlay(self): + default_options = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + overlay = Options(last_name="Grant") + result = ObjectPath.assign(default_options, overlay) + assert result.last_name == overlay.last_name + assert result.first_name == default_options.first_name + assert result.age == default_options.age + assert result.boolean == default_options.boolean + assert result.location.lat == default_options.location.lat + assert result.location.long == default_options.location.long + + def test_typed_no_target(self): + overlay = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + result = ObjectPath.assign(None, overlay) + assert result.last_name == overlay.last_name + assert result.first_name == overlay.first_name + assert result.age == overlay.age + assert result.boolean == overlay.boolean + assert result.location.lat == overlay.location.lat + assert result.location.long == overlay.location.long + + def test_typed_no_overlay(self): + default_options = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + result = ObjectPath.assign(default_options, None) + assert result.last_name == default_options.last_name + assert result.first_name == default_options.first_name + assert result.age == default_options.age + assert result.boolean == default_options.boolean + assert result.location.lat == default_options.location.lat + assert result.location.long == default_options.location.long + + def test_no_target_or_overlay(self): + result = ObjectPath.assign(None, None, Options) + assert result + + def test_dict_partial_overlay(self): + default_options = { + "last_name": "Smith", + "first_name": "Fred", + "age": 22, + "location": Location(lat=1.2312312, long=3.234234), + } + overlay = {"last_name": "Grant"} + result = ObjectPath.assign(default_options, overlay) + assert result["last_name"] == overlay["last_name"] + assert result["first_name"] == default_options["first_name"] + assert result["age"] == default_options["age"] + assert result["location"].lat == default_options["location"].lat + assert result["location"].long == default_options["location"].long + + def test_dict_to_typed_overlay(self): + default_options = Options( + last_name="Smith", + first_name="Fred", + age=22, + location=Location(lat=1.2312312, long=3.234234), + ) + overlay = {"last_name": "Grant"} + result = ObjectPath.assign(default_options, overlay) + assert result.last_name == overlay["last_name"] + assert result.first_name == default_options.first_name + assert result.age == default_options.age + assert result.boolean == default_options.boolean + assert result.location.lat == default_options.location.lat + assert result.location.long == default_options.location.long + + def test_set_value(self): + test = {} + ObjectPath.set_path_value(test, "x.y.z", 15) + ObjectPath.set_path_value(test, "x.p", "hello") + ObjectPath.set_path_value(test, "foo", {"Bar": 15, "Blat": "yo"}) + ObjectPath.set_path_value(test, "x.a[1]", "yabba") + ObjectPath.set_path_value(test, "x.a[0]", "dabba") + ObjectPath.set_path_value(test, "null", None) + + assert ObjectPath.get_path_value(test, "x.y.z") == 15 + assert ObjectPath.get_path_value(test, "x.p") == "hello" + assert ObjectPath.get_path_value(test, "foo.bar") == 15 + + assert not ObjectPath.try_get_path_value(test, "foo.Blatxxx") + assert ObjectPath.try_get_path_value(test, "x.a[1]") == "yabba" + assert ObjectPath.try_get_path_value(test, "x.a[0]") == "dabba" + + assert not ObjectPath.try_get_path_value(test, "null") + + def test_remove_path_value(self): + test = {} + ObjectPath.set_path_value(test, "x.y.z", 15) + ObjectPath.set_path_value(test, "x.p", "hello") + ObjectPath.set_path_value(test, "foo", {"Bar": 15, "Blat": "yo"}) + ObjectPath.set_path_value(test, "x.a[1]", "yabba") + ObjectPath.set_path_value(test, "x.a[0]", "dabba") + + ObjectPath.remove_path_value(test, "x.y.z") + with pytest.raises(KeyError): + ObjectPath.get_path_value(test, "x.y.z") + + assert ObjectPath.get_path_value(test, "x.y.z", 99) == 99 + + ObjectPath.remove_path_value(test, "x.a[1]") + assert not ObjectPath.try_get_path_value(test, "x.a[1]") + + assert ObjectPath.try_get_path_value(test, "x.a[0]") == "dabba" diff --git a/tests/hosting_dialogs/test_prompt_culture_models.py b/tests/hosting_dialogs/test_prompt_culture_models.py new file mode 100644 index 00000000..138d3a7e --- /dev/null +++ b/tests/hosting_dialogs/test_prompt_culture_models.py @@ -0,0 +1,76 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from microsoft_agents.hosting.dialogs.prompts.prompt_culture_models import ( + PromptCultureModels, +) + +SUPPORTED_CULTURES = [ + PromptCultureModels.Bulgarian, + PromptCultureModels.Chinese, + PromptCultureModels.Dutch, + PromptCultureModels.English, + PromptCultureModels.French, + PromptCultureModels.German, + PromptCultureModels.Hindi, + PromptCultureModels.Italian, + PromptCultureModels.Japanese, + PromptCultureModels.Korean, + PromptCultureModels.Portuguese, + PromptCultureModels.Spanish, + PromptCultureModels.Swedish, + PromptCultureModels.Turkish, +] + + +def _locale_variations(culture): + """Generate (input_variation, expected_locale) tuples for a culture.""" + locale = culture.locale # e.g. "en-us" + parts = locale.split("-") + prefix = parts[0] + suffix = parts[1] if len(parts) > 1 else "" + return [ + (locale, locale), # exact: "en-us" + (f"{prefix}-{suffix.upper()}", locale), # cap ending: "en-US" + (f"{prefix.capitalize()}-{suffix.capitalize()}", locale), # title: "En-Us" + (prefix.upper(), locale), # all-caps two-letter: "EN" + (prefix, locale), # lowercase two-letter: "en" + ] + + +LOCALE_VARIATIONS = [ + variation + for culture in SUPPORTED_CULTURES + for variation in _locale_variations(culture) +] + + +@pytest.mark.parametrize("locale_variation,expected", LOCALE_VARIATIONS) +def test_map_to_nearest_language(locale_variation, expected): + result = PromptCultureModels.map_to_nearest_language(locale_variation) + assert result == expected + + +def test_null_locale_does_not_raise(): + result = PromptCultureModels.map_to_nearest_language(None) + assert result is None + + +def test_get_supported_cultures_returns_all(): + expected_locales = {c.locale for c in SUPPORTED_CULTURES} + actual_locales = {c.locale for c in PromptCultureModels.get_supported_cultures()} + assert expected_locales == actual_locales + + +def test_supported_cultures_have_required_fields(): + for culture in PromptCultureModels.get_supported_cultures(): + assert culture.locale, f"Culture missing locale" + assert culture.separator, f"Culture {culture.locale} missing separator" + assert culture.inline_or, f"Culture {culture.locale} missing inline_or" + assert ( + culture.yes_in_language + ), f"Culture {culture.locale} missing yes_in_language" + assert ( + culture.no_in_language + ), f"Culture {culture.locale} missing no_in_language" diff --git a/tests/hosting_dialogs/test_prompt_validator_context.py b/tests/hosting_dialogs/test_prompt_validator_context.py new file mode 100644 index 00000000..f8536da4 --- /dev/null +++ b/tests/hosting_dialogs/test_prompt_validator_context.py @@ -0,0 +1,104 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus +from microsoft_agents.hosting.core import MemoryStorage, ConversationState +from microsoft_agents.hosting.dialogs.prompts import ( + TextPrompt, + PromptOptions, + PromptValidatorContext, +) +from microsoft_agents.activity import Activity, ActivityTypes +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestPromptValidatorContext: + + @pytest.mark.asyncio + async def test_prompt_validator_context_end(self): + storage = MemoryStorage() + conv = ConversationState(storage) + accessor = conv.create_property("dialogstate") + dialog_set = DialogSet(accessor) + assert dialog_set is not None + + def test_prompt_validator_context_retry_end(self): + storage = MemoryStorage() + conv = ConversationState(storage) + accessor = conv.create_property("dialogstate") + dialog_set = DialogSet(accessor) + assert dialog_set is not None + + @pytest.mark.asyncio + async def test_attempt_count_starts_at_one_on_first_validation(self): + """attempt_count is 1 on the first validator call and increments on each + subsequent user reply (mirrors ActivityPrompt behaviour).""" + observed_attempt_counts = [] + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def validator(pc: PromptValidatorContext) -> bool: + observed_attempt_counts.append(pc.attempt_count) + return bool(pc.recognized.value) + + ds.add(TextPrompt("TextPrompt", validator)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter text."), + retry_prompt=Activity(type=ActivityTypes.message, text="Again."), + ) + await dc.prompt("TextPrompt", options) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + await flow.assert_reply("Enter text.") + await adapter.send("something") + + assert observed_attempt_counts == [1] + + @pytest.mark.asyncio + async def test_attempt_count_increments_across_retries(self): + """attempt_count increments with each user reply, so retry #1 = 2, retry #2 = 3, etc.""" + observed_attempt_counts = [] + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def validator(pc: PromptValidatorContext) -> bool: + observed_attempt_counts.append(pc.attempt_count) + # Only accept the literal word "yes" + return pc.recognized.succeeded and pc.recognized.value == "yes" + + ds.add(TextPrompt("TextPrompt", validator)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Say yes."), + retry_prompt=Activity( + type=ActivityTypes.message, text="Please say yes." + ), + ) + await dc.prompt("TextPrompt", options) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("start") + await flow.assert_reply("Say yes.") + await adapter.send("no") # attempt 1 — rejected + await adapter.send("nope") # attempt 2 — rejected + await adapter.send("yes") # attempt 3 — accepted + + assert observed_attempt_counts == [1, 2, 3] diff --git a/tests/hosting_dialogs/test_replace_dialog.py b/tests/hosting_dialogs/test_replace_dialog.py new file mode 100644 index 00000000..86ebb8ec --- /dev/null +++ b/tests/hosting_dialogs/test_replace_dialog.py @@ -0,0 +1,136 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.core import ConversationState, MemoryStorage, TurnContext +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + DialogSet, + DialogTurnStatus, + WaterfallDialog, +) +from microsoft_agents.hosting.dialogs.models.dialog_instance import DialogInstance +from microsoft_agents.hosting.dialogs.models.dialog_reason import DialogReason +from microsoft_agents.hosting.dialogs.prompts import TextPrompt, PromptOptions +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +def _text_prompt_options(text: str) -> PromptOptions: + return PromptOptions(prompt=Activity(type=ActivityTypes.message, text=text)) + + +class _WaterfallWithEndDialog(WaterfallDialog): + """WaterfallDialog that announces itself when it ends.""" + + async def end_dialog( + self, context: TurnContext, instance: DialogInstance, reason: DialogReason + ): + await context.send_activity("*** WaterfallDialog End ***") + await super().end_dialog(context, instance, reason) + + +class _SecondDialog(ComponentDialog): + def __init__(self): + super().__init__("SecondDialog") + + async def action_four(step): + return await step.prompt("TextPrompt", _text_prompt_options("prompt four")) + + async def action_five(step): + return await step.prompt("TextPrompt", _text_prompt_options("prompt five")) + + async def last_action(step): + return await step.end_dialog() + + self.add_dialog(TextPrompt("TextPrompt")) + self.add_dialog( + WaterfallDialog("WaterfallDialog", [action_four, action_five, last_action]) + ) + self.initial_dialog_id = "WaterfallDialog" + + +class _FirstDialog(ComponentDialog): + def __init__(self): + super().__init__("FirstDialog") + + async def action_one(step): + return await step.prompt("TextPrompt", _text_prompt_options("prompt one")) + + async def action_two(step): + return await step.prompt("TextPrompt", _text_prompt_options("prompt two")) + + async def replace_action(step): + if step.result == "replace": + return await step.replace_dialog("SecondDialog") + return await step.next(None) + + async def action_three(step): + return await step.prompt("TextPrompt", _text_prompt_options("prompt three")) + + async def last_action(step): + return await step.end_dialog() + + self.add_dialog(TextPrompt("TextPrompt")) + self.add_dialog(_SecondDialog()) + self.add_dialog( + _WaterfallWithEndDialog( + "WaterfallWithEndDialog", + [action_one, action_two, replace_action, action_three, last_action], + ) + ) + self.initial_dialog_id = "WaterfallWithEndDialog" + + +class TestReplaceDialog: + @pytest.mark.asyncio + async def test_replace_dialog_no_branch(self): + """Dialog flows through all three prompts without branching.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + ds.add(_FirstDialog()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("FirstDialog") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("prompt one") + flow = await flow.send("hello") + flow = await flow.assert_reply("prompt two") + flow = await flow.send("hello") + flow = await flow.assert_reply("prompt three") + flow = await flow.send("hello") + await flow.assert_reply("*** WaterfallDialog End ***") + + @pytest.mark.asyncio + async def test_replace_dialog_branch(self): + """Sending 'replace' causes replace_dialog to switch to SecondDialog.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + ds.add(_FirstDialog()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("FirstDialog") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("prompt one") + flow = await flow.send("hello") + flow = await flow.assert_reply("prompt two") + flow = await flow.send("replace") + flow = await flow.assert_reply("*** WaterfallDialog End ***") + flow = await flow.assert_reply("prompt four") + flow = await flow.send("hello") + await flow.assert_reply("prompt five") diff --git a/tests/hosting_dialogs/test_text_prompt.py b/tests/hosting_dialogs/test_text_prompt.py new file mode 100644 index 00000000..6103d909 --- /dev/null +++ b/tests/hosting_dialogs/test_text_prompt.py @@ -0,0 +1,195 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest + +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.core import ConversationState, MemoryStorage +from microsoft_agents.hosting.dialogs import DialogSet, DialogTurnStatus +from microsoft_agents.hosting.dialogs.prompts import ( + TextPrompt, + PromptOptions, + PromptValidatorContext, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestTextPrompt: + def test_empty_id_raises(self): + with pytest.raises((TypeError, Exception)): + TextPrompt("") + + def test_null_id_raises(self): + with pytest.raises((TypeError, Exception)): + TextPrompt(None) + + @pytest.mark.asyncio + async def test_basic_text_prompt(self): + """TextPrompt echoes user input back after the prompt.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + ds.add(TextPrompt("TextPrompt")) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter some text.") + ) + await dc.prompt("TextPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity(f"Bot received: {results.result}") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter some text.") + flow = await flow.send("some text") + await flow.assert_reply("Bot received: some text") + + @pytest.mark.asyncio + async def test_text_prompt_with_validator(self): + """A validator can reject short inputs and trigger the retry prompt.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def validator(pc: PromptValidatorContext) -> bool: + return pc.recognized.value is not None and len(pc.recognized.value) > 3 + + ds.add(TextPrompt("TextPrompt", validator)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Enter some text." + ), + retry_prompt=Activity( + type=ActivityTypes.message, text="That's not long enough." + ), + ) + await dc.prompt("TextPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity(f"Bot received: {results.result}") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter some text.") + flow = await flow.send("hi") # Too short — validator rejects + flow = await flow.assert_reply("That's not long enough.") + flow = await flow.send("hello world") # Long enough + await flow.assert_reply("Bot received: hello world") + + @pytest.mark.asyncio + async def test_text_prompt_retry_on_failed_validation(self): + """Without a retry_prompt the original prompt is re-sent on failure.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def validator(pc: PromptValidatorContext) -> bool: + return pc.recognized.value is not None and pc.recognized.value != "bad" + + ds.add(TextPrompt("TextPrompt", validator)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity( + type=ActivityTypes.message, text="Enter something." + ), + ) + await dc.prompt("TextPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity(f"Got: {results.result}") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter something.") + flow = await flow.send("bad") # Rejected by validator + flow = await flow.assert_reply("Enter something.") # Re-prompted + flow = await flow.send("good") + await flow.assert_reply("Got: good") + + @pytest.mark.asyncio + async def test_text_prompt_non_message_activity_does_not_succeed(self): + """A non-message activity (e.g. event) causes recognition to fail. + + The base Prompt.continue_dialog returns end_of_turn immediately for + non-message activities without calling the recognizer or validator. + The dialog remains active (Waiting) and the user is not re-prompted. + """ + from microsoft_agents.activity import ActivityTypes + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + ds.add(TextPrompt("TextPrompt")) + + completed = [] + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter something.") + ) + await dc.prompt("TextPrompt", options) + elif results.status == DialogTurnStatus.Complete: + completed.append(results.result) + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + # Start the prompt + flow = await adapter.send("hello") + await flow.assert_reply("Enter something.") + + # Send a non-message event — dialog must NOT complete + event_activity = Activity(type=ActivityTypes.event, name="custom") + await adapter.process_activity_async(event_activity, exec) + assert len(completed) == 0, "Prompt must not complete on non-message activity" + + @pytest.mark.asyncio + async def test_text_prompt_with_custom_message_validator(self): + """Validator can send its own message and return False.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def validator(pc: PromptValidatorContext) -> bool: + if pc.recognized.value and len(pc.recognized.value) > 5: + return True + await pc.context.send_activity("Please enter more than 5 characters.") + return False + + ds.add(TextPrompt("TextPrompt", validator)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + options = PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter text."), + ) + await dc.prompt("TextPrompt", options) + elif results.status == DialogTurnStatus.Complete: + await tc.send_activity(f"Done: {results.result}") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Enter text.") + flow = await flow.send("hi") + flow = await flow.assert_reply("Please enter more than 5 characters.") + flow = await flow.send("hello world") + await flow.assert_reply("Done: hello world") diff --git a/tests/hosting_dialogs/test_waterfall.py b/tests/hosting_dialogs/test_waterfall.py new file mode 100644 index 00000000..c07d1b5a --- /dev/null +++ b/tests/hosting_dialogs/test_waterfall.py @@ -0,0 +1,314 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from recognizers_text import Culture + +from microsoft_agents.activity import Activity, ActivityTypes +from microsoft_agents.hosting.core import ConversationState, MemoryStorage, TurnContext +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + Dialog, + DialogSet, + WaterfallDialog, + WaterfallStepContext, + DialogTurnResult, + DialogTurnStatus, +) +from microsoft_agents.hosting.dialogs.prompts import ( + NumberPrompt, + DateTimePrompt, + PromptOptions, +) +from tests.hosting_dialogs.helpers import DialogTestAdapter + + +class TestWaterfallDialog: + def test_waterfall_none_name(self): + with pytest.raises((TypeError, Exception)): + WaterfallDialog(None) + + def test_waterfall_add_none_step(self): + waterfall = WaterfallDialog("test") + with pytest.raises((TypeError, Exception)): + waterfall.add_step(None) + + def test_waterfall_with_set_instead_of_array(self): + with pytest.raises((TypeError, Exception)): + WaterfallDialog("a", {1, 2}) + + @pytest.mark.asyncio + async def test_execute_sequence_waterfall_steps(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + async def step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("bot responding.") + return Dialog.end_of_turn + + async def step2(step: WaterfallStepContext) -> DialogTurnResult: + return await step.end_dialog("ending WaterfallDialog.") + + my_dialog = WaterfallDialog("test", [step1, step2]) + dialogs.add(my_dialog) + + async def exec_test(turn_context: TurnContext) -> None: + dialog_context = await dialogs.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog("test") + else: + if results.status == DialogTurnStatus.Complete: + await turn_context.send_activity(results.result) + await convo_state.save(turn_context) + + adapter = DialogTestAdapter(exec_test) + + step1_flow = await adapter.send("begin") + step2_flow = await step1_flow.assert_reply("bot responding.") + step3_flow = await step2_flow.send("continue") + await step3_flow.assert_reply("ending WaterfallDialog.") + + def test_waterfall_callback(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + async def step_callback1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1") + + async def step_callback2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step2") + + async def step_callback3(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step3") + + steps = [step_callback1, step_callback2, step_callback3] + dialogs.add(WaterfallDialog("test", steps)) + assert dialogs is not None + assert len(dialogs._dialogs) == 1 # pylint: disable=protected-access + + def test_waterfall_with_class(self): + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + + class MyWaterfallDialog(WaterfallDialog): + def __init__(self, dialog_id: str): + async def step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1") + return Dialog.end_of_turn + + async def step2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step2") + return Dialog.end_of_turn + + super().__init__(dialog_id, [step1, step2]) + + dialogs.add(MyWaterfallDialog("test")) + assert dialogs is not None + assert len(dialogs._dialogs) == 1 # pylint: disable=protected-access + + @pytest.mark.asyncio + async def test_waterfall_step_parent_is_waterfall_parent(self): + """WaterfallStepContext.parent should be the ComponentDialog containing the waterfall.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + + result_holder = {} + + class WaterfallParentDialog(ComponentDialog): + def __init__(self): + super().__init__("waterfall-parent-test-dialog") + + async def step1(step: WaterfallStepContext) -> DialogTurnResult: + # Parent context should have the component dialog as its active dialog + parent_id = ( + step.parent.active_dialog.id + if step.parent and step.parent.active_dialog + else None + ) + result_holder["parent_id"] = parent_id + await step.context.send_activity("verified") + return Dialog.end_of_turn + + self.add_dialog(WaterfallDialog("test", [step1])) + self.initial_dialog_id = "test" + + ds = DialogSet(dialog_state) + ds.add(WaterfallParentDialog()) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("waterfall-parent-test-dialog") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + await flow.assert_reply("verified") + + assert result_holder.get("parent_id") == "waterfall-parent-test-dialog" + + @pytest.mark.asyncio + async def test_waterfall_prompt(self): + """Waterfall with NumberPrompt: invalid inputs trigger retry, valid inputs advance steps.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + + async def step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1") + return await step.prompt( + "number", + PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number."), + retry_prompt=Activity( + type=ActivityTypes.message, text="It must be a number" + ), + ), + ) + + async def step2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + await step.context.send_activity("step2") + return await step.prompt( + "number", + PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Enter a number."), + retry_prompt=Activity( + type=ActivityTypes.message, text="It must be a number" + ), + ), + ) + + async def step3(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity(f"Thanks for '{int(step.result)}'") + await step.context.send_activity("step3") + return await step.end_dialog() + + ds = DialogSet(dialog_state) + ds.add(WaterfallDialog("test-waterfall", [step1, step2, step3])) + ds.add(NumberPrompt("number", default_locale=Culture.English)) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("test-waterfall") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("step1") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("hello again") + flow = await flow.assert_reply("It must be a number") + flow = await flow.send("42") + flow = await flow.assert_reply("Thanks for '42'") + flow = await flow.assert_reply("step2") + flow = await flow.assert_reply("Enter a number.") + flow = await flow.send("apple") + flow = await flow.assert_reply("It must be a number") + flow = await flow.send("orange") + flow = await flow.assert_reply("It must be a number") + flow = await flow.send("64") + flow = await flow.assert_reply("Thanks for '64'") + await flow.assert_reply("step3") + + @pytest.mark.asyncio + async def test_waterfall_nested(self): + """Nested waterfall dialogs chain correctly when each ends.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + + async def waterfall_a_step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1") + return await step.begin_dialog("test-waterfall-b") + + async def waterfall_a_step2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step2") + return await step.begin_dialog("test-waterfall-c") + + async def waterfall_b_step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1.1") + return Dialog.end_of_turn + + async def waterfall_b_step2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step1.2") + return Dialog.end_of_turn + + async def waterfall_c_step1(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step2.1") + return Dialog.end_of_turn + + async def waterfall_c_step2(step: WaterfallStepContext) -> DialogTurnResult: + await step.context.send_activity("step2.2") + return await step.end_dialog() + + ds = DialogSet(dialog_state) + ds.add( + WaterfallDialog("test-waterfall-a", [waterfall_a_step1, waterfall_a_step2]) + ) + ds.add( + WaterfallDialog("test-waterfall-b", [waterfall_b_step1, waterfall_b_step2]) + ) + ds.add( + WaterfallDialog("test-waterfall-c", [waterfall_c_step1, waterfall_c_step2]) + ) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("test-waterfall-a") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("step1") + flow = await flow.assert_reply("step1.1") + flow = await flow.send("hello") + flow = await flow.assert_reply("step1.2") + flow = await flow.send("hello") + flow = await flow.assert_reply("step2") + flow = await flow.assert_reply("step2.1") + flow = await flow.send("hello") + await flow.assert_reply("step2.2") + + @pytest.mark.asyncio + async def test_waterfall_datetime_prompt_first_invalid_then_valid(self): + """DateTimePrompt re-prompts on invalid input and accepts valid date/time.""" + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + + async def step1(step: WaterfallStepContext) -> DialogTurnResult: + return await step.prompt( + "dateTimePrompt", + PromptOptions( + prompt=Activity(type=ActivityTypes.message, text="Provide a date") + ), + ) + + async def step2(step: WaterfallStepContext) -> DialogTurnResult: + assert step.result is not None + return await step.end_dialog() + + ds = DialogSet(dialog_state) + ds.add(DateTimePrompt("dateTimePrompt", default_locale=Culture.English)) + ds.add(WaterfallDialog("test-dateTimePrompt", [step1, step2])) + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dc.begin_dialog("test-dateTimePrompt") + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + flow = await adapter.send("hello") + flow = await flow.assert_reply("Provide a date") + flow = await flow.send("hello again") + flow = await flow.assert_reply("Provide a date") + await flow.send("Wednesday 4 oclock") diff --git a/tests/hosting_dialogs/test_waterfall_dialog.py b/tests/hosting_dialogs/test_waterfall_dialog.py new file mode 100644 index 00000000..de56539f --- /dev/null +++ b/tests/hosting_dialogs/test_waterfall_dialog.py @@ -0,0 +1,171 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from unittest.mock import MagicMock + +from microsoft_agents.activity import ActivityTypes +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + Dialog, + DialogContext, + DialogReason, + DialogSet, + DialogState, + DialogTurnResult, + DialogTurnStatus, + WaterfallDialog, +) + + +def _make_dc(activity_type="message"): + """Create a minimal DialogContext with the given activity type.""" + + class _Stub(ComponentDialog): + def __init__(self): + super().__init__("stub") + + ds = _Stub()._dialogs + mock_tc = MagicMock() + mock_tc.activity.type = activity_type + return DialogContext(ds, mock_tc, DialogState()) + + +class TestWaterfallDialogValidation: + @pytest.mark.asyncio + async def test_begin_dialog_null_dc_raises(self): + dialog = WaterfallDialog("A", []) + with pytest.raises((TypeError, Exception)): + await dialog.begin_dialog(None) + + @pytest.mark.asyncio + async def test_continue_dialog_null_dc_raises(self): + dialog = WaterfallDialog("A", []) + with pytest.raises((TypeError, Exception)): + await dialog.continue_dialog(None) + + @pytest.mark.asyncio + async def test_continue_dialog_returns_waiting_for_non_message_activity(self): + """WaterfallDialog.continue_dialog returns end_of_turn for non-message activities.""" + dialog = WaterfallDialog("A", []) + dc = _make_dc(activity_type=ActivityTypes.event) + + result = await dialog.continue_dialog(dc) + + # end_of_turn is DialogTurnResult(Waiting) + assert result.status == DialogTurnStatus.Waiting + + @pytest.mark.asyncio + async def test_resume_dialog_null_dc_raises(self): + dialog = WaterfallDialog("A", []) + with pytest.raises((TypeError, Exception)): + await dialog.resume_dialog(None, DialogReason.BeginCalled, "result") + + @pytest.mark.asyncio + async def test_run_step_null_dc_raises(self): + dialog = WaterfallDialog("A", []) + with pytest.raises((TypeError, Exception)): + await dialog.run_step(None, 0, DialogReason.BeginCalled, None) + + def test_none_name_raises(self): + with pytest.raises((TypeError, Exception)): + WaterfallDialog(None, []) + + def test_add_none_step_raises(self): + dialog = WaterfallDialog("A", []) + with pytest.raises((TypeError, Exception)): + dialog.add_step(None) + + def test_steps_must_be_list(self): + with pytest.raises((TypeError, Exception)): + WaterfallDialog("A", {1, 2}) + + @pytest.mark.asyncio + async def test_empty_steps_completes_immediately(self): + """WaterfallDialog with no steps ends immediately with None result.""" + from microsoft_agents.hosting.core import ConversationState, MemoryStorage + from microsoft_agents.hosting.dialogs import DialogSet + from tests.hosting_dialogs.helpers import DialogTestAdapter + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + dialogs = DialogSet(dialog_state) + dialogs.add(WaterfallDialog("empty-waterfall", [])) + + result_holder = {} + + async def exec(tc): + dc = await dialogs.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + results = await dc.begin_dialog("empty-waterfall") + result_holder["status"] = results.status + result_holder["result"] = results.result + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + await adapter.send("hi") + assert result_holder["status"] == DialogTurnStatus.Complete + assert result_holder["result"] is None + + @pytest.mark.asyncio + async def test_continue_dialog_non_message_returns_waiting(self): + """WaterfallDialog.continue_dialog ignores non-message activities.""" + dialog = WaterfallDialog("A", [lambda step: Dialog.end_of_turn]) + dc = _make_dc(activity_type=ActivityTypes.event) + result = await dialog.continue_dialog(dc) + assert result.status == DialogTurnStatus.Waiting + + +class TestWaterfallStepName: + def test_get_step_name_named_function_uses_qualname(self): + """Named step functions expose their __qualname__ as the step name.""" + + async def my_named_step(step): + return Dialog.end_of_turn + + dialog = WaterfallDialog("A", [my_named_step]) + assert "my_named_step" in dialog.get_step_name(0) + + def test_get_step_name_lambda_uses_fallback_format(self): + """Lambda steps fall back to 'Step{n}of{total}' because their __qualname__ ends in ''.""" + dialog = WaterfallDialog("A", [lambda s: None, lambda s: None]) + assert dialog.get_step_name(0) == "Step1of2" + assert dialog.get_step_name(1) == "Step2of2" + + +class TestWaterfallStepNoneReturn: + @pytest.mark.asyncio + async def test_step_returning_none_raises_type_error(self): + """A step returning None raises a clear TypeError instead of a confusing AttributeError.""" + from microsoft_agents.hosting.core import ConversationState, MemoryStorage + from microsoft_agents.hosting.dialogs import DialogSet + from tests.hosting_dialogs.helpers import DialogTestAdapter + + convo_state = ConversationState(MemoryStorage()) + dialog_state = convo_state.create_property("dialogState") + ds = DialogSet(dialog_state) + + async def bad_step(step): + return None # programmer forgot to return Dialog.end_of_turn + + ds.add(WaterfallDialog("bad-waterfall", [bad_step])) + + error_holder = {} + + async def exec(tc): + dc = await ds.create_context(tc) + results = await dc.continue_dialog() + if results.status == DialogTurnStatus.Empty: + try: + await dc.begin_dialog("bad-waterfall") + except TypeError as e: + error_holder["error"] = e + await convo_state.save(tc) + + adapter = DialogTestAdapter(exec) + await adapter.send("hi") + + assert "error" in error_holder, "Expected TypeError but none was raised" + error_msg = str(error_holder["error"]).lower() + assert "none" in error_msg or "step" in error_msg diff --git a/tests/hosting_dialogs/test_waterfall_step_context.py b/tests/hosting_dialogs/test_waterfall_step_context.py new file mode 100644 index 00000000..1f040946 --- /dev/null +++ b/tests/hosting_dialogs/test_waterfall_step_context.py @@ -0,0 +1,94 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import pytest +from unittest.mock import AsyncMock, MagicMock + +from microsoft_agents.hosting.dialogs import ( + ComponentDialog, + DialogContext, + DialogReason, + DialogSet, + DialogState, + DialogTurnResult, + DialogTurnStatus, + WaterfallDialog, +) +from microsoft_agents.hosting.dialogs.waterfall_step_context import WaterfallStepContext + + +def _make_step_context(): + """Create a WaterfallStepContext backed by mock objects.""" + + class _Stub(ComponentDialog): + def __init__(self): + super().__init__("stub") + + ds = _Stub()._dialogs + mock_tc = MagicMock() + dc = DialogContext(ds, mock_tc, DialogState()) + + wf_dialog = WaterfallDialog("wf", []) + wf_dialog.resume_dialog = AsyncMock( + return_value=DialogTurnResult(DialogTurnStatus.Complete) + ) + + return WaterfallStepContext(wf_dialog, dc, None, {}, 0, DialogReason.BeginCalled) + + +class TestWaterfallStepContext: + @pytest.mark.asyncio + async def test_next_called_twice_raises(self): + """Calling next() a second time on the same step context must raise.""" + step_ctx = _make_step_context() + + # First call succeeds + await step_ctx.next(None) + + # Second call raises + with pytest.raises(Exception, match="already called"): + await step_ctx.next(None) + + @pytest.mark.asyncio + async def test_next_calls_resume_on_parent_dialog(self): + """next() delegates to the parent WaterfallDialog's resume_dialog.""" + step_ctx = _make_step_context() + await step_ctx.next("my-result") + step_ctx._wf_parent.resume_dialog.assert_awaited_once() + + def test_step_context_properties(self): + """WaterfallStepContext exposes index, options, reason, result, values.""" + step_ctx = _make_step_context() + assert step_ctx.index == 0 + assert step_ctx.options is None + assert step_ctx.reason == DialogReason.BeginCalled + assert step_ctx.result is None + assert step_ctx.values == {} + + def test_step_context_with_result(self): + class _Stub(ComponentDialog): + def __init__(self): + super().__init__("stub") + + ds = _Stub()._dialogs + dc = DialogContext(ds, MagicMock(), DialogState()) + wf = WaterfallDialog("wf", []) + wf.resume_dialog = AsyncMock( + return_value=DialogTurnResult(DialogTurnStatus.Complete) + ) + + step_ctx = WaterfallStepContext( + wf, + dc, + {"key": "val"}, + {"v": 1}, + 2, + DialogReason.NextCalled, + "previous-result", + ) + + assert step_ctx.index == 2 + assert step_ctx.options == {"key": "val"} + assert step_ctx.values == {"v": 1} + assert step_ctx.result == "previous-result" + assert step_ctx.reason == DialogReason.NextCalled