microsoft-agents-hosting-dialogs 0.10.0.dev2__py3-none-any.whl

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

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)

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",
+]

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

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"

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

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

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

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

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

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] = {}

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

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",
+]