Storing changes commit

Author: andystaples

durabletask-azurefunctions/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## v0.1.0
+
+- Initial implementation

durabletask-azurefunctions/__init__.py

@@ -0,0 +1,10 @@
+"""Constants used to determine the local running context."""
+# Todo: Remove unused constants after module is complete
+DEFAULT_LOCAL_HOST: str = 'localhost:7071'
+DEFAULT_LOCAL_ORIGIN: str = f'http://{DEFAULT_LOCAL_HOST}'
+DATETIME_STRING_FORMAT = '%Y-%m-%dT%H:%M:%S.%fZ'
+HTTP_ACTION_NAME = 'BuiltIn::HttpActivity'
+ORCHESTRATION_TRIGGER = "orchestrationTrigger"
+ACTIVITY_TRIGGER = "activityTrigger"
+ENTITY_TRIGGER = "entityTrigger"
+DURABLE_CLIENT = "durableClient"

durabletask-azurefunctions/durabletask/azurefunctions/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Durable Task SDK for Python entities component"""
+
+import durabletask.azurefunctions.decorators.durable_app as durable_app
+import durabletask.azurefunctions.decorators.metadata as metadata
+
+__all__ = ["durable_app", "metadata"]
+
+PACKAGE_NAME = "durabletask.entities"

durabletask-azurefunctions/durabletask/azurefunctions/constants.py

@@ -0,0 +1,193 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+from .metadata import OrchestrationTrigger, ActivityTrigger, EntityTrigger, \
+    DurableClient
+from typing import Callable, Optional
+from typing import Union
+from azure.functions import FunctionRegister, TriggerApi, BindingApi, AuthLevel, OrchestrationContext
+
+
+class Blueprint(TriggerApi, BindingApi):
+    """Durable Functions (DF) Blueprint container.
+
+    It allows functions to be declared via trigger and binding decorators,
+    but does not automatically index/register these functions.
+
+    To register these functions, utilize the `register_functions` method from any
+    :class:`FunctionRegister` subclass, such as `DFApp`.
+    """
+
+    def __init__(self,
+                 http_auth_level: Union[AuthLevel, str] = AuthLevel.FUNCTION):
+        """Instantiate a Durable Functions app with which to register Functions.
+
+        Parameters
+        ----------
+        http_auth_level: Union[AuthLevel, str]
+            Authorization level required for Function invocation.
+            Defaults to AuthLevel.Function.
+
+        Returns
+        -------
+        DFApp
+            New instance of a Durable Functions app
+        """
+        super().__init__(auth_level=http_auth_level)
+
+    def _configure_orchestrator_callable(self, wrap) -> Callable:
+        """Obtain decorator to construct an Orchestrator class from a user-defined Function.
+
+        In the old programming model, this decorator's logic was unavoidable boilerplate
+        in user-code. Now, this is handled internally by the framework.
+
+        Parameters
+        ----------
+        wrap: Callable
+            The next decorator to be applied.
+
+        Returns
+        -------
+        Callable
+            The function to construct an Orchestrator class from the user-defined Function,
+            wrapped by the next decorator in the sequence.
+        """
+        def decorator(orchestrator_func):
+            # Construct an orchestrator based on the end-user code
+
+            # TODO: Extract this logic (?)
+            def handle(context: OrchestrationContext) -> str:
+                context_body = getattr(context, "body", None)
+                if context_body is None:
+                    context_body = context
+                orchestration_context = context_body
+                # TODO: Run the orchestration using the context
+                return ""
+
+            handle.orchestrator_function = orchestrator_func
+
+            # invoke next decorator, with the Orchestrator as input
+            handle.__name__ = orchestrator_func.__name__
+            return wrap(handle)
+
+        return decorator
+
+    def orchestration_trigger(self, context_name: str,
+                              orchestration: Optional[str] = None):
+        """Register an Orchestrator Function.
+
+        Parameters
+        ----------
+        context_name: str
+            Parameter name of the DurableOrchestrationContext object.
+        orchestration: Optional[str]
+            Name of Orchestrator Function.
+            The value is None by default, in which case the name of the method is used.
+        """
+        @self._configure_orchestrator_callable
+        @self._configure_function_builder
+        def wrap(fb):
+
+            def decorator():
+                fb.add_trigger(
+                    trigger=OrchestrationTrigger(name=context_name,
+                                                 orchestration=orchestration))
+                return fb
+
+            return decorator()
+
+        return wrap
+
+    def activity_trigger(self, input_name: str,
+                         activity: Optional[str] = None):
+        """Register an Activity Function.
+
+        Parameters
+        ----------
+        input_name: str
+            Parameter name of the Activity input.
+        activity: Optional[str]
+            Name of Activity Function.
+            The value is None by default, in which case the name of the method is used.
+        """
+        @self._configure_function_builder
+        def wrap(fb):
+            def decorator():
+                fb.add_trigger(
+                    trigger=ActivityTrigger(name=input_name,
+                                            activity=activity))
+                return fb
+
+            return decorator()
+
+        return wrap
+
+    def entity_trigger(self, context_name: str,
+                       entity_name: Optional[str] = None):
+        """Register an Entity Function.
+
+        Parameters
+        ----------
+        context_name: str
+            Parameter name of the Entity input.
+        entity_name: Optional[str]
+            Name of Entity Function.
+            The value is None by default, in which case the name of the method is used.
+        """
+        @self._configure_function_builder
+        def wrap(fb):
+            def decorator():
+                fb.add_trigger(
+                    trigger=EntityTrigger(name=context_name,
+                                          entity_name=entity_name))
+                return fb
+
+            return decorator()
+
+        return wrap
+
+    def durable_client_input(self,
+                             client_name: str,
+                             task_hub: Optional[str] = None,
+                             connection_name: Optional[str] = None
+                             ):
+        """Register a Durable-client Function.
+
+        Parameters
+        ----------
+        client_name: str
+            Parameter name of durable client.
+        task_hub: Optional[str]
+            Used in scenarios where multiple function apps share the same storage account
+            but need to be isolated from each other. If not specified, the default value
+            from host.json is used.
+            This value must match the value used by the target orchestrator functions.
+        connection_name: Optional[str]
+            The name of an app setting that contains a storage account connection string.
+            The storage account represented by this connection string must be the same one
+            used by the target orchestrator functions. If not specified, the default storage
+            account connection string for the function app is used.
+        """
+
+        @self._configure_function_builder
+        def wrap(fb):
+            def decorator():
+                # self._add_rich_client(fb, client_name, DurableOrchestrationClient)
+
+                fb.add_binding(
+                    binding=DurableClient(name=client_name,
+                                          task_hub=task_hub,
+                                          connection_name=connection_name))
+                return fb
+
+            return decorator()
+
+        return wrap
+
+
+class DFApp(Blueprint, FunctionRegister):
+    """Durable Functions (DF) app.
+
+    Exports the decorators required to declare and index DF Function-types.
+    """
+
+    pass

durabletask-azurefunctions/durabletask/azurefunctions/decorators/__init__.py

@@ -0,0 +1,109 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+from typing import Optional
+
+from durabletask.azurefunctions.constants import ORCHESTRATION_TRIGGER, \
+    ACTIVITY_TRIGGER, ENTITY_TRIGGER, DURABLE_CLIENT
+from azure.functions.decorators.core import Trigger, InputBinding
+
+
+class OrchestrationTrigger(Trigger):
+    """OrchestrationTrigger.
+
+    Trigger representing an Orchestration Function.
+    """
+
+    @staticmethod
+    def get_binding_name() -> str:
+        """Get the name of this trigger, as a string.
+
+        Returns
+        -------
+        str
+            The string representation of this trigger.
+        """
+        return ORCHESTRATION_TRIGGER
+
+    def __init__(self,
+                 name: str,
+                 orchestration: Optional[str] = None,
+                 ) -> None:
+        self.orchestration = orchestration
+        super().__init__(name=name)
+
+
+class ActivityTrigger(Trigger):
+    """ActivityTrigger.
+
+    Trigger representing a Durable Functions Activity.
+    """
+
+    @staticmethod
+    def get_binding_name() -> str:
+        """Get the name of this trigger, as a string.
+
+        Returns
+        -------
+        str
+            The string representation of this trigger.
+        """
+        return ACTIVITY_TRIGGER
+
+    def __init__(self,
+                 name: str,
+                 activity: Optional[str] = None,
+                 ) -> None:
+        self.activity = activity
+        super().__init__(name=name)
+
+
+class EntityTrigger(Trigger):
+    """EntityTrigger.
+
+    Trigger representing an Entity Function.
+    """
+
+    @staticmethod
+    def get_binding_name() -> str:
+        """Get the name of this trigger, as a string.
+
+        Returns
+        -------
+        str
+            The string representation of this trigger.
+        """
+        return ENTITY_TRIGGER
+
+    def __init__(self,
+                 name: str,
+                 entity_name: Optional[str] = None,
+                 ) -> None:
+        self.entity_name = entity_name
+        super().__init__(name=name)
+
+
+class DurableClient(InputBinding):
+    """DurableClient.
+
+    Binding representing a Durable-client object.
+    """
+
+    @staticmethod
+    def get_binding_name() -> str:
+        """Get the name of this Binding, as a string.
+
+        Returns
+        -------
+        str
+            The string representation of this binding.
+        """
+        return DURABLE_CLIENT
+
+    def __init__(self,
+                 name: str,
+                 task_hub: Optional[str] = None,
+                 connection_name: Optional[str] = None
+                 ) -> None:
+        self.task_hub = task_hub
+        self.connection_name = connection_name
+        super().__init__(name=name)

durabletask-azurefunctions/durabletask/azurefunctions/decorators/durable_app.py

@@ -0,0 +1,46 @@
+import abc
+from typing import Any, Optional
+
+from azure.functions import meta
+
+
+class DurableInConverter(meta._BaseConverter, binding=None):
+
+    @classmethod
+    @abc.abstractmethod
+    def check_input_type_annotation(cls, pytype: type) -> bool:
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def decode(cls, data: meta.Datum, *, trigger_metadata) -> Any:
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def has_implicit_output(cls) -> bool:
+        return False
+
+
+class DurableOutConverter(meta._BaseConverter, binding=None):
+
+    @classmethod
+    @abc.abstractmethod
+    def check_output_type_annotation(cls, pytype: type) -> bool:
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def encode(cls, obj: Any, *,
+               expected_type: Optional[type]) -> Optional[meta.Datum]:
+        raise NotImplementedError
+
+# Durable Functions Durable Client Bindings
+
+
+class DurableClientConverter(DurableInConverter,
+                             DurableOutConverter,
+                             binding='durableClient'):
+    @classmethod
+    def has_implicit_output(cls) -> bool:
+        return False

durabletask-azurefunctions/durabletask/azurefunctions/decorators/metadata.py

@@ -0,0 +1,3 @@
+from .DurableClientConverter import DurableClientConverter
+
+__all__ = ["DurableClientConverter"]

durabletask-azurefunctions/durabletask/azurefunctions/internal/DurableClientConverter.py

@@ -0,0 +1,2 @@
+class TempClass:
+    pass