microsoft-agents-hosting-core 1.9.0.dev3__tar.gz → 1.9.0.dev10__tar.gz

{microsoft_agents_hosting_core-1.9.0.dev3 → microsoft_agents_hosting_core-1.9.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 1.9.0.dev3
+Version: 1.9.0.dev10
 Summary: Core library for Microsoft Agents
 Author: Microsoft Corporation
 License-Expression: MIT
@@ -15,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: microsoft-agents-activity==1.9.0.dev3
+Requires-Dist: microsoft-agents-activity==1.9.0.dev10
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: python-dotenv>=1.1.1

microsoft_agents_hosting_core-1.9.0.dev10/VERSION.txt

@@ -0,0 +1 @@
+1.9.0.dev10

{microsoft_agents_hosting_core-1.9.0.dev3 → microsoft_agents_hosting_core-1.9.0.dev10}/microsoft_agents/hosting/core/_utils/__init__.py

@@ -1,6 +1,4 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
-from ._service_set import _ServiceSet
-
-__all__ = ["_ServiceSet"]
+# intentionally left empty to avoid dependency issues

microsoft_agents_hosting_core-1.9.0.dev10/microsoft_agents/hosting/core/_utils/_turn_context_wrapper.py

@@ -0,0 +1,149 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from abc import ABC
+
+from typing import Awaitable, Callable
+
+from microsoft_agents.activity import (
+    Activity,
+    ResourceResponse,
+    ConversationReference,
+)
+
+from microsoft_agents.hosting.core.turn_context import (
+    TurnContext,
+    OnSendActivitiesHandler,
+    OnUpdateActivityHandler,
+    OnDeleteActivityHandler,
+)
+
+
+class _TurnContextWrapper(TurnContext, ABC):
+    """A base class for wrapping a TurnContext with additional functionality."""
+
+    def __init__(self, context: TurnContext) -> None:
+        """Initialise the turn context from a plain turn context.
+
+        :param context: The base turn context provided by the core runtime.
+        """
+        super().__init__(context)
+
+        self._original = context
+        self._turn_state = context.turn_state
+        self.buffered_reply_activities = context.buffered_reply_activities
+
+    @property
+    def responded(self) -> bool:
+        return self._original.responded
+
+    @responded.setter
+    def responded(self, value: bool):
+        self._original.responded = value
+
+    @property
+    def streaming_response(self):
+        return self._original.streaming_response
+
+    async def send_activity(
+        self,
+        activity_or_text: Activity | str,
+        speak: str | None = None,
+        input_hint: str | None = None,
+    ) -> ResourceResponse:
+        """
+        Send an activity to the conversation.
+
+        :param activity_or_text: The activity to send or a string representing the text of the activity.
+        :param speak: Optional speech text for the activity.
+        :param input_hint: Optional input hint for the activity.
+        :return: A ResourceResponse representing the result of the send operation.
+        """
+        return await self._original.send_activity(
+            activity_or_text, speak=speak, input_hint=input_hint
+        )
+
+    async def send_activities(
+        self, activities: list[Activity]
+    ) -> list[ResourceResponse]:
+        """
+        Send multiple activities to the conversation.
+
+        :param activities: A list of activities to send.
+        :return: A list of ResourceResponse objects representing the result of each send operation.
+        """
+        return await self._original.send_activities(activities)
+
+    async def update_activity(self, activity: Activity):
+        """
+        Replaces an existing activity.
+        :param activity:
+        :return:
+        """
+        return await self._original.update_activity(activity)
+
+    async def delete_activity(self, id_or_reference: str | ConversationReference):
+        """
+        Deletes an existing activity.
+        :param id_or_reference:
+        :return:
+        """
+        return await self._original.delete_activity(id_or_reference)
+
+    def on_send_activities(self, handler: OnSendActivitiesHandler) -> TurnContext:
+        """
+        Registers a handler to be notified of and potentially intercept the sending of activities.
+        :param handler: the handler to register
+        :type handler: OnSendActivitiesHandler
+        :return:
+        """
+        self._original.on_send_activities(handler)
+        return self
+
+    def on_update_activity(self, handler: OnUpdateActivityHandler) -> TurnContext:
+        """
+        Registers a handler to be notified of and potentially intercept an activity being updated.
+        :param handler: the handler to register
+        :type handler: OnUpdateActivityHandler
+        :return:
+        """
+        self._original.on_update_activity(handler)
+        return self
+
+    def on_delete_activity(self, handler: OnDeleteActivityHandler) -> TurnContext:
+        """
+        Registers a handler to be notified of and potentially intercept an activity being deleted.
+        :param handler: the handler to register
+        :type handler: OnDeleteActivityHandler
+        :return:
+        """
+        self._original.on_delete_activity(handler)
+        return self
+
+    async def send_trace_activity(
+        self,
+        name: str,
+        value: object = None,
+        value_type: str | None = None,
+        label: str | None = None,
+    ) -> ResourceResponse:
+        return await self._original.send_trace_activity(
+            name=name, value=value, value_type=value_type, label=label
+        )
+
+    async def _aclose(self) -> None:
+        """
+        Asynchronously close any resources associated with the turn context.
+
+        :return: None
+        """
+        await self._original._aclose()
+
+    def _on_aclose(self, handler: Callable[[TurnContext], Awaitable[None]]) -> None:
+        """
+        Register a handler to be called when the turn context is asynchronously closed.
+
+        :param handler: A callable that takes the turn context and returns an awaitable.
+        :return: None
+        """
+        self._original._on_aclose(handler)

{microsoft_agents_hosting_core-1.9.0.dev3 → microsoft_agents_hosting_core-1.9.0.dev10}/microsoft_agents/hosting/core/app/__init__.py

@@ -45,6 +45,7 @@ __all__ = [
     "InputFileDownloader",
     "Query",
     "Route",
+    "RouteRank",
     "RouteHandler",
     "TypingChannelStrategy",
     "TypingIndicator",

microsoft_agents_hosting_core-1.9.0.dev10/microsoft_agents/hosting/core/app/_selector.py

@@ -0,0 +1,143 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import re
+
+from microsoft_agents.activity import ActivityTypes, ChannelId
+from microsoft_agents.hosting.core import TurnContext
+from ._type_defs import RouteSelector, TextSelector
+from ._utils import _matches_text
+
+
+def _text_selector(
+    select: str | re.Pattern[str] | list[str | re.Pattern[str]],
+) -> RouteSelector:
+    """Creates a route selector that matches the activity text against the selection criteria.
+
+    Strings must match the text exactly; regex patterns must fully match it.
+
+    :param select: A string, regex pattern, or a list of strings/regex patterns to match against.
+    :return: A route selector function that returns True if the activity text matches any of the selection criteria.
+    """
+
+    def __selector(context: TurnContext) -> bool:
+        """Selector function that checks if the given text matches the selection criteria."""
+        return _matches_text(select, context.activity.text or "")
+
+    return __selector
+
+
+def _event_selector(event_selector: TextSelector | None) -> RouteSelector:
+    """Creates a route selector that matches the given event name.
+
+    :param event_selector: The text selector for the event name to match against.
+    :return: A route selector function that matches the specified event name.
+    """
+
+    def __selector(context: TurnContext) -> bool:
+        """Selector function that checks if the given event name matches the selection criteria."""
+        if not context.activity.type == ActivityTypes.event:
+            return False
+        return event_selector is None or _matches_text(
+            event_selector, context.activity.name or ""
+        )
+
+    return __selector
+
+
+def _invoke_event_selector(event_selector: TextSelector | None) -> RouteSelector:
+    """Creates a route selector that matches the given invoke event name.
+
+    :param event_selector: The text selector for the invoke event name to match against.
+    :return: A route selector function that matches the specified invoke event name.
+    """
+
+    def __selector(context: TurnContext) -> bool:
+        """Selector function that checks if the given invoke event name matches the selection criteria."""
+        if not context.activity.type == ActivityTypes.invoke:
+            return False
+        return event_selector is None or _matches_text(
+            event_selector, context.activity.name or ""
+        )
+
+    return __selector
+
+
+def _activity_type_selector(activity_type: str | list[str]) -> RouteSelector:
+    """Creates a route selector that matches the given activity type.
+
+    :param activity_type: The activity type or list of activity types to match against.
+    :return: A route selector function that matches the specified activity type.
+    """
+    if isinstance(activity_type, list):
+        return lambda context: context.activity.type in activity_type
+    return lambda context: context.activity.type == activity_type
+
+
+def _channel_selector(channel_id: str | ChannelId | None) -> RouteSelector:
+    """Creates a route selector that matches the given channel ID.
+
+    :param channel_id: The channel ID to match against.
+    :return: A route selector function that matches the specified channel ID.
+    """
+
+    norm_channel_id = ChannelId(channel_id) if channel_id is not None else None
+
+    if norm_channel_id is None:
+        return lambda context: True
+    else:
+
+        def __selector(context: TurnContext) -> bool:
+            """Selector function that checks if the given channel ID matches the selection criteria."""
+            if context.activity.channel_id is None:
+                return False
+            return norm_channel_id.includes(context.activity.channel_id)
+
+        return __selector
+
+
+def _all_selector(*selectors: RouteSelector) -> RouteSelector:
+    """Combines multiple route selectors into one that only passes if all selectors pass.
+
+    :param selectors: A variable number of route selector functions to combine.
+    :return: A new route selector function that only passes if all provided selectors pass.
+    """
+
+    def selector(context: TurnContext) -> bool:
+        return all(sel(context) for sel in selectors)
+
+    return selector
+
+
+class _SimpleRouteSelector:
+    """A simple route selector that combines multiple selection criteria such as channel ID, activity type, and text pattern."""
+
+    def __init__(
+        self,
+        *,
+        channel_id: str | ChannelId | None = None,
+        activity_type: str | list[str] | None = None,
+        text_pattern: str | re.Pattern[str] | list[str | re.Pattern[str]] | None = None,
+    ) -> None:
+        """Initializes a simple route selector with optional channel ID, activity type, and text pattern.
+
+        :param channel_id: The channel ID to match against, or None to match any channel.
+        :param activity_type: The activity type to match against, or None to match any activity type.
+        :param text_pattern: A text pattern or list of patterns to match against the activity text, or None to match any text.
+        """
+
+        self._selectors = []
+        if channel_id is not None:
+            self._selectors.append(_channel_selector(channel_id))
+        if activity_type is not None:
+            self._selectors.append(_activity_type_selector(activity_type))
+        if text_pattern is not None:
+            self._selectors.append(_text_selector(text_pattern))
+
+    def __call__(self, context: TurnContext) -> bool:
+        """Calls the route selector with the given context.
+
+        :param context: The turn context to evaluate.
+        :return: True if all selectors pass for the given context, False otherwise.
+        """
+        return all(selector(context) for selector in self._selectors)

{microsoft_agents_hosting_core-1.9.0.dev3 → microsoft_agents_hosting_core-1.9.0.dev10}/microsoft_agents/hosting/core/app/_type_defs.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
+import re
 from typing import Callable, TypeVar, Awaitable, Protocol
 
 from ..turn_context import TurnContext
@@ -11,6 +12,7 @@ RouteSelector = Callable[[TurnContext], bool]
 StateT = TypeVar("StateT", bound=TurnState)
 _StateContra = TypeVar("_StateContra", bound=TurnState, contravariant=True)
 _RouteHandlerT = TypeVar("_RouteHandlerT", bound=Callable)
+TextSelector = str | re.Pattern[str] | list[str | re.Pattern[str]]
 
 
 class _RouteDecorator(Protocol[_RouteHandlerT]):

{microsoft_agents_hosting_core-1.9.0.dev3 → microsoft_agents_hosting_core-1.9.0.dev10}/microsoft_agents/hosting/core/app/_utils.py

@@ -1,9 +1,13 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
+import re
+
 from email.message import Message
 from urllib.parse import urlparse
 
+from ._type_defs import TextSelector
+
 _CONTENT_TYPE = "Content-Type"
 
 
@@ -34,3 +38,29 @@ def _basic_url_check(url: str) -> bool:
     return parsed.scheme == "https" or (
         parsed.scheme == "http" and parsed.hostname == "localhost"
     )
+
+
+def _matches_text(select: TextSelector | None = None, text: str | None = None) -> bool:
+    """Checks if the given text matches the specified text selector.
+
+    :param select: The text selector to match against. Can be a string, a compiled regex pattern, or a list of these.
+    :param text: The text to check. Defaults to an empty string if None is provided.
+    :return: True if the text matches the selector, False otherwise.
+    """
+    if select is None:
+        return True
+
+    text = text or ""
+    if isinstance(select, list):
+        for item in select:
+            if isinstance(item, re.Pattern):
+                if re.fullmatch(item, text) is not None:
+                    return True
+            elif text == item:
+                return True
+        return False
+
+    if isinstance(select, re.Pattern):
+        return re.fullmatch(select, text) is not None
+
+    return text == select