azure-functions-durable 1.2.10__py3-none-any.whl → 1.3.1__py3-none-any.whl

azure/durable_functions/decorators/durable_app.py

@@ -198,6 +198,17 @@ class Blueprint(TriggerApi, BindingApi, SettingsApi):
             # Invoke user code with rich DF Client binding
             return await user_code(*args, **kwargs)
 
+        # Todo: This feels awkward - however, there are two reasons that I can't naively implement
+        # this in the same way as entities and orchestrators:
+        # 1. We intentionally wrap this exported signature with @wraps, to preserve the original
+        #    signature of the user code. This means that we can't just assign a new object to the
+        #    fb._function._func, as that would overwrite the original signature.
+        # 2. I have not yet fully tested the behavior of overriding __call__ on an object with an
+        #    async method.
+        # Here we lose type hinting and auto-documentation - not great. Need to find a better way
+        # to do this.
+        df_client_middleware.client_function = fb._function._func
+
         user_code_with_rich_client = df_client_middleware
         fb._function._func = user_code_with_rich_client
 

azure/durable_functions/entity.py

@@ -1,6 +1,6 @@
 from .models import DurableEntityContext
 from .models.entities import OperationResult, EntityState
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Callable, Any, List, Dict
 
 
@@ -49,7 +49,7 @@ class Entity:
         for operation_data in batch:
             result: Any = None
             is_error: bool = False
-            start_time: datetime = datetime.now()
+            start_time: datetime = datetime.now(timezone.utc)
 
             try:
                 # populate context
@@ -74,6 +74,7 @@ class Entity:
             operation_result = OperationResult(
                 is_error=is_error,
                 duration=duration,
+                execution_start_time_ms=int(start_time.timestamp() * 1000),
                 result=result
             )
             response.results.append(operation_result)
@@ -104,6 +105,9 @@ class Entity:
                 context_body = context
             ctx, batch = DurableEntityContext.from_json(context_body)
             return Entity(fn).handle(ctx, batch)
+
+        handle.entity_function = fn
+
         return handle
 
     def _elapsed_milliseconds_since(self, start_time: datetime) -> int:
@@ -119,7 +123,7 @@ class Entity:
         int
             The time, in millseconds, from start_time to now
         """
-        end_time = datetime.now()
+        end_time = datetime.now(timezone.utc)
         time_diff = end_time - start_time
         elapsed_time = int(time_diff.total_seconds() * 1000)
         return elapsed_time

azure/durable_functions/models/DurableOrchestrationClient.py

@@ -4,6 +4,7 @@ from typing import List, Any, Optional, Dict, Union
 from time import time
 from asyncio import sleep
 from urllib.parse import urlparse, quote
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
 import azure.functions as func
 
@@ -71,8 +72,13 @@ class DurableOrchestrationClient:
         request_url = self._get_start_new_url(
             instance_id=instance_id, orchestration_function_name=orchestration_function_name)
 
+        trace_parent, trace_state = DurableOrchestrationClient._get_current_activity_context()
+
         response: List[Any] = await self._post_async_request(
-            request_url, self._get_json_input(client_input))
+            request_url,
+            self._get_json_input(client_input),
+            trace_parent,
+            trace_state)
 
         status_code: int = response[0]
         if status_code <= 202 and response[1]:
@@ -545,9 +551,14 @@ class DurableOrchestrationClient:
                                        entity_Id=entityId)
 
         request_url = options.to_url(self._orchestration_bindings.rpc_base_url)
+
+        trace_parent, trace_state = DurableOrchestrationClient._get_current_activity_context()
+
         response = await self._post_async_request(
             request_url,
-            json.dumps(operation_input) if operation_input else None)
+            json.dumps(operation_input) if operation_input else None,
+            trace_parent,
+            trace_state)
 
         switch_statement = {
             202: lambda: None  # signal accepted
@@ -779,3 +790,23 @@ class DurableOrchestrationClient:
         error_message = has_error_message()
         if error_message:
             raise Exception(error_message)
+
+    """Gets the current trace activity traceparent and tracestate
+
+    Returns
+    -------
+    tuple[str, str]
+        A tuple containing the (traceparent, tracestate)
+    """
+    @staticmethod
+    def _get_current_activity_context() -> tuple[str, str]:
+        carrier = {}
+
+        # Inject the current trace context into the carrier
+        TraceContextTextMapPropagator().inject(carrier)
+
+        # Extract the traceparent and optionally the tracestate
+        trace_parent = carrier.get("traceparent")
+        trace_state = carrier.get("tracestate")
+
+        return trace_parent, trace_state

azure/durable_functions/models/DurableOrchestrationContext.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from azure.durable_functions.models.actions.SignalEntityAction import SignalEntityAction
 from azure.durable_functions.models.actions.CallEntityAction import CallEntityAction
-from azure.durable_functions.models.Task import TaskBase, TimerTask
+from azure.durable_functions.models.Task import LongTimerTask, TaskBase, TimerTask
 from azure.durable_functions.models.actions.CallHttpAction import CallHttpAction
 from azure.durable_functions.models.DurableHttpRequest import DurableHttpRequest
 from azure.durable_functions.models.actions.CallSubOrchestratorWithRetryAction import \
@@ -26,6 +26,8 @@ from typing import DefaultDict, List, Any, Dict, Optional, Tuple, Union, Callabl
 from uuid import UUID, uuid5, NAMESPACE_URL, NAMESPACE_OID
 from datetime import timezone
 
+from azure.durable_functions.models.utils.json_utils import parse_timespan_attrib
+
 from .RetryOptions import RetryOptions
 from .FunctionContext import FunctionContext
 from .history import HistoryEvent, HistoryEventType
@@ -48,11 +50,22 @@ class DurableOrchestrationContext:
     # parameter names are as defined by JSON schema and do not conform to PEP8 naming conventions
     def __init__(self,
                  history: List[Dict[Any, Any]], instanceId: str, isReplaying: bool,
-                 parentInstanceId: str, input: Any = None, upperSchemaVersion: int = 0, **kwargs):
+                 parentInstanceId: str, input: Any = None, upperSchemaVersion: int = 0,
+                 maximumShortTimerDuration: str = None,
+                 longRunningTimerIntervalDuration: str = None, upperSchemaVersionNew: int = None,
+                 **kwargs):
         self._histories: List[HistoryEvent] = [HistoryEvent(**he) for he in history]
         self._instance_id: str = instanceId
         self._is_replaying: bool = isReplaying
         self._parent_instance_id: str = parentInstanceId
+        self._maximum_short_timer_duration: datetime.timedelta = None
+        if maximumShortTimerDuration is not None:
+            max_short_duration = parse_timespan_attrib(maximumShortTimerDuration)
+            self._maximum_short_timer_duration = max_short_duration
+        self._long_timer_interval_duration: datetime.timedelta = None
+        if longRunningTimerIntervalDuration is not None:
+            long_interval_duration = parse_timespan_attrib(longRunningTimerIntervalDuration)
+            self._long_timer_interval_duration = long_interval_duration
         self._custom_status: Any = None
         self._new_uuid_counter: int = 0
         self._sub_orchestrator_counter: int = 0
@@ -66,6 +79,13 @@ class DurableOrchestrationContext:
         self._function_context: FunctionContext = FunctionContext(**kwargs)
         self._sequence_number = 0
         self._replay_schema = ReplaySchema(upperSchemaVersion)
+        if (upperSchemaVersionNew is not None
+                and upperSchemaVersionNew > self._replay_schema.value):
+            valid_schema_values = [enum_member.value for enum_member in ReplaySchema]
+            if upperSchemaVersionNew in valid_schema_values:
+                self._replay_schema = ReplaySchema(upperSchemaVersionNew)
+            else:
+                self._replay_schema = ReplaySchema(max(valid_schema_values))
 
         self._action_payload_v1: List[List[Action]] = []
         self._action_payload_v2: List[Action] = []
@@ -532,10 +552,10 @@ class DurableOrchestrationContext:
             The action to append
         """
         new_action: Union[List[Action], Action]
-        if self._replay_schema is ReplaySchema.V2:
-            new_action = action
-        else:
+        if self._replay_schema is ReplaySchema.V1:
             new_action = [action]
+        else:
+            new_action = action
         self._add_to_actions(new_action)
         self._sequence_number += 1
 
@@ -580,6 +600,23 @@ class DurableOrchestrationContext:
         TaskBase
             A Durable Timer Task that schedules the timer to wake up the activity
         """
+        if self._replay_schema.value >= ReplaySchema.V3.value:
+            if not self._maximum_short_timer_duration or not self._long_timer_interval_duration:
+                raise Exception(
+                    "A framework-internal error was detected: "
+                    "replay schema version >= V3 is being used, "
+                    "but one or more of the properties `maximumShortTimerDuration`"
+                    "and `longRunningTimerIntervalDuration` are not defined. "
+                    "This is likely an issue with the Durable Functions Extension. "
+                    "Please report this bug here: "
+                    "https://github.com/Azure/azure-functions-durable-python/issues\n"
+                    f"maximumShortTimerDuration: {self._maximum_short_timer_duration}\n"
+                    f"longRunningTimerIntervalDuration: {self._long_timer_interval_duration}"
+                )
+            if fire_at > self.current_utc_datetime + self._maximum_short_timer_duration:
+                action = CreateTimerAction(fire_at)
+                return LongTimerTask(None, action, self)
+
         action = CreateTimerAction(fire_at)
         task = self._generate_task(action, task_constructor=TimerTask)
         return task
@@ -656,7 +693,8 @@ class DurableOrchestrationContext:
 
         if self._replay_schema is ReplaySchema.V1 and isinstance(action_repr, list):
             self._action_payload_v1.append(action_repr)
-        elif self._replay_schema is ReplaySchema.V2 and isinstance(action_repr, Action):
+        elif (self._replay_schema.value >= ReplaySchema.V2.value
+              and isinstance(action_repr, Action)):
             self._action_payload_v2.append(action_repr)
         else:
             raise Exception(f"DF-internal exception: ActionRepr of signature {type(action_repr)}"
@@ -684,7 +722,8 @@ class DurableOrchestrationContext:
                 task.id = self._sequence_number
                 self._sequence_number += 1
                 self.open_tasks[task.id] = task
-            elif task.id != -1:
+            elif task.id != -1 and self.open_tasks[task.id] != task:
+                # Case when returning task_any with multiple external events having the same ID
                 self.open_tasks[task.id].append(task)
 
             if task.id in self.deferred_tasks:

azure/durable_functions/models/ReplaySchema.py

@@ -6,3 +6,4 @@ class ReplaySchema(Enum):
 
     V1 = 0
     V2 = 1
+    V3 = 2

azure/durable_functions/models/Task.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from azure.durable_functions.models.actions.NoOpAction import NoOpAction
 from azure.durable_functions.models.actions.CompoundAction import CompoundAction
 from azure.durable_functions.models.RetryOptions import RetryOptions
@@ -170,7 +171,7 @@ class CompoundTask(TaskBase):
                     child_actions.append(action_repr)
         if compound_action_constructor is None:
             self.action_repr = child_actions
-        else:  # replay_schema is ReplaySchema.V2
+        else:  # replay_schema >= ReplaySchema.V2
             self.action_repr = compound_action_constructor(child_actions)
         self._first_error: Optional[Exception] = None
         self.pending_tasks: Set[TaskBase] = set(tasks)
@@ -292,7 +293,7 @@ class WhenAllTask(CompoundTask):
             The ReplaySchema, which determines the inner action payload representation
         """
         compound_action_constructor = None
-        if replay_schema is ReplaySchema.V2:
+        if replay_schema.value >= ReplaySchema.V2.value:
             compound_action_constructor = WhenAllAction
         super().__init__(task, compound_action_constructor)
 
@@ -317,6 +318,119 @@ class WhenAllTask(CompoundTask):
                 self.set_value(is_error=True, value=self._first_error)
 
 
+class LongTimerTask(WhenAllTask):
+    """A Timer Task for intervals longer than supported by the storage backend."""
+
+    def __init__(self, id_, action: CreateTimerAction, orchestration_context):
+        """Initialize a LongTimerTask.
+
+        Parameters
+        ----------
+        id_ : int
+            An ID for the task
+        action : CreateTimerAction
+            The action this task represents
+        orchestration_context: DurableOrchestrationContext
+            The orchestration context this task was created in
+        """
+        current_time = orchestration_context.current_utc_datetime
+        final_fire_time = action.fire_at
+        duration_until_fire = final_fire_time - current_time
+
+        if duration_until_fire > orchestration_context._maximum_short_timer_duration:
+            next_fire_time = current_time + orchestration_context._long_timer_interval_duration
+        else:
+            next_fire_time = final_fire_time
+
+        next_timer_action = CreateTimerAction(next_fire_time)
+        next_timer_task = TimerTask(None, next_timer_action)
+        super().__init__([next_timer_task], orchestration_context._replay_schema)
+
+        self.id = id_
+        self.action = action
+        self._orchestration_context = orchestration_context
+        self._max_short_timer_duration = self._orchestration_context._maximum_short_timer_duration
+        self._long_timer_interval = self._orchestration_context._long_timer_interval_duration
+
+    def is_canceled(self) -> bool:
+        """Check if the LongTimer is cancelled.
+
+        Returns
+        -------
+        bool
+            Returns whether the timer has been cancelled or not
+        """
+        return self.action.is_cancelled
+
+    def cancel(self):
+        """Cancel a timer.
+
+        Raises
+        ------
+        ValueError
+            Raises an error if the task is already completed and an attempt is made to cancel it
+        """
+        if (self.result):
+            raise Exception("Cannot cancel a completed task.")
+        self.action.is_cancelled = True
+
+    def try_set_value(self, child: TimerTask):
+        """Transition this LongTimer Task to a terminal state and set its value.
+
+        If the LongTimer has not yet reached the designated completion time, starts a new
+        TimerTask for the next interval and does not close.
+
+        Parameters
+        ----------
+        child : TimerTask
+            A timer sub-task that just completed
+        """
+        current_time = self._orchestration_context.current_utc_datetime
+        final_fire_time = self.action.fire_at
+        if final_fire_time > current_time:
+            next_timer = self.get_next_timer_task(final_fire_time, current_time)
+            self.add_new_child(next_timer)
+        return super().try_set_value(child)
+
+    def get_next_timer_task(self, final_fire_time: datetime, current_time: datetime) -> TimerTask:
+        """Create a TimerTask to represent the next interval of the LongTimer.
+
+        Parameters
+        ----------
+        final_fire_time : datetime.datetime
+            The final firing time of the LongTimer
+        current_time : datetime.datetime
+            The current time
+
+        Returns
+        -------
+        TimerTask
+            A TimerTask representing the next interval of the LongTimer
+        """
+        duration_until_fire = final_fire_time - current_time
+        if duration_until_fire > self._max_short_timer_duration:
+            next_fire_time = current_time + self._long_timer_interval
+        else:
+            next_fire_time = final_fire_time
+        return TimerTask(None, CreateTimerAction(next_fire_time))
+
+    def add_new_child(self, child_timer: TimerTask):
+        """Add the TimerTask to this task's children.
+
+        Also register the TimerTask with the orchestration context.
+
+        Parameters
+        ----------
+        child_timer : TimerTask
+            The newly created TimerTask to add
+        """
+        child_timer.parent = self
+        self.pending_tasks.add(child_timer)
+        self._orchestration_context._add_to_open_tasks(child_timer)
+        self._orchestration_context._add_to_actions(child_timer.action_repr)
+        child_timer._set_is_scheduled(True)
+
+
 class WhenAnyTask(CompoundTask):
     """A Task representing `when_any` scenarios."""
 
@@ -331,7 +445,7 @@ class WhenAnyTask(CompoundTask):
             The ReplaySchema, which determines the inner action payload representation
         """
         compound_action_constructor = None
-        if replay_schema is ReplaySchema.V2:
+        if replay_schema.value >= ReplaySchema.V2.value:
             compound_action_constructor = WhenAnyAction
         super().__init__(task, compound_action_constructor)
 

azure/durable_functions/models/TaskOrchestrationExecutor.py

@@ -245,14 +245,14 @@ class TaskOrchestrationExecutor:
 
         self.current_task = new_task
         if not (new_task is None):
+            if not (self.current_task._is_scheduled):
+                # new task is received. it needs to be resolved to a value
+                self.context._add_to_actions(self.current_task.action_repr)
+                self._mark_as_scheduled(self.current_task)
             if not (new_task.state is TaskState.RUNNING):
                 # user yielded the same task multiple times, continue executing code
                 # until a new/not-previously-yielded task is encountered
                 self.resume_user_code()
-            elif not (self.current_task._is_scheduled):
-                # new task is received. it needs to be resolved to a value
-                self.context._add_to_actions(self.current_task.action_repr)
-                self._mark_as_scheduled(self.current_task)
 
     def _mark_as_scheduled(self, task: TaskBase):
         if isinstance(task, CompoundTask):
@@ -286,12 +286,18 @@ class TaskOrchestrationExecutor:
                 self.output = None
                 self.exception = e
 
+        exception_str = None
+        if self.exception is not None:
+            exception_str = str(self.exception)
+            if not exception_str:
+                exception_str = str(type(self.exception))
+
         state = OrchestratorState(
             is_done=self.orchestration_invocation_succeeded,
             actions=self.context._actions,
             output=self.output,
             replay_schema=self.context._replay_schema,
-            error=None if self.exception is None else str(self.exception),
+            error=exception_str,
             custom_status=self.context.custom_status
         )
 

azure/durable_functions/models/__init__.py

@@ -9,6 +9,7 @@ from .RetryOptions import RetryOptions
 from .DurableHttpRequest import DurableHttpRequest
 from .TokenSource import ManagedIdentityTokenSource
 from .DurableEntityContext import DurableEntityContext
+from .Task import TaskBase
 
 __all__ = [
     'DurableOrchestrationBindings',
@@ -20,5 +21,6 @@ __all__ = [
     'OrchestratorState',
     'OrchestrationRuntimeStatus',
     'PurgeHistoryResult',
-    'RetryOptions'
+    'RetryOptions',
+    'TaskBase'
 ]

azure/durable_functions/models/entities/OperationResult.py

@@ -12,6 +12,7 @@ class OperationResult:
     def __init__(self,
                  is_error: bool,
                  duration: int,
+                 execution_start_time_ms: int,
                  result: Optional[str] = None):
         """Instantiate an OperationResult.
 
@@ -21,11 +22,15 @@ class OperationResult:
             Whether or not the operation resulted in an exception.
         duration: int
             How long the operation took, in milliseconds.
+        start_time: int
+            The start time of this operation's execution, in milliseconds,
+            since January 1st 1970 midnight in UTC.
         result: Optional[str]
             The operation result. Defaults to None.
         """
         self._is_error: bool = is_error
         self._duration: int = duration
+        self._execution_start_time_ms: int = execution_start_time_ms
         self._result: Optional[str] = result
 
     @property
@@ -50,6 +55,18 @@ class OperationResult:
         """
         return self._duration
 
+    @property
+    def execution_start_time_ms(self) -> int:
+        """Get the start time of this operation.
+
+        Returns
+        -------
+        int:
+            The start time of this operation's execution, in milliseconds,
+            since January 1st 1970 midnight in UTC.
+        """
+        return self._execution_start_time_ms
+
     @property
     def result(self) -> Any:
         """Get the operation's result.
@@ -72,5 +89,6 @@ class OperationResult:
         to_json: Dict[str, Any] = {}
         to_json["isError"] = self.is_error
         to_json["duration"] = self.duration
+        to_json["startTime"] = self.execution_start_time_ms
         to_json["result"] = json.dumps(self.result, default=_serialize_custom_object)
         return to_json

azure/durable_functions/models/utils/http_utils.py

@@ -3,7 +3,10 @@ from typing import Any, List, Union
 import aiohttp
 
 
-async def post_async_request(url: str, data: Any = None) -> List[Union[int, Any]]:
+async def post_async_request(url: str,
+                             data: Any = None,
+                             trace_parent: str = None,
+                             trace_state: str = None) -> List[Union[int, Any]]:
     """Post request with the data provided to the url provided.
 
     Parameters
@@ -12,6 +15,10 @@ async def post_async_request(url: str, data: Any = None) -> List[Union[int, Any]
         url to make the post to
     data: Any
         object to post
+    trace_parent: str
+        traceparent header to send with the request
+    trace_state: str
+        tracestate header to send with the request
 
     Returns
     -------
@@ -19,8 +26,12 @@ async def post_async_request(url: str, data: Any = None) -> List[Union[int, Any]
         Tuple with the Response status code and the data returned from the request
     """
     async with aiohttp.ClientSession() as session:
-        async with session.post(url,
-                                json=data) as response:
+        headers = {}
+        if trace_parent:
+            headers["traceparent"] = trace_parent
+        if trace_state:
+            headers["tracestate"] = trace_state
+        async with session.post(url, json=data, headers=headers) as response:
             # We disable aiohttp's input type validation
             # as the server may respond with alternative
             # data encodings. This is potentially unsafe.

azure/durable_functions/models/utils/json_utils.py

@@ -1,3 +1,5 @@
+import datetime
+import re
 from typing import Dict, Any
 
 from ...constants import DATETIME_STRING_FORMAT
@@ -37,6 +39,44 @@ def add_datetime_attrib(json_dict: Dict[str, Any], object_,
             getattr(object_, attribute_name).strftime(DATETIME_STRING_FORMAT)
 
 
+# When we recieve properties from WebJobs extension originally parsed as
+#   TimeSpan objects through Newtonsoft, the format complies with the constant
+#   format specifier for TimeSpan in .NET.
+#   Python offers no convenient way to parse these back into timedeltas,
+#   so we use this regex method instead
+def parse_timespan_attrib(from_str: str) -> datetime.timedelta:
+    """Convert a string representing TimeSpan.ToString("c") in .NET to a python timedelta.
+
+    Parameters
+    ----------
+    from_str: The string format of the TimeSpan to convert
+
+    Returns
+    -------
+    timespan.timedelta
+        The TimeSpan expressed as a Python datetime.timedelta
+
+    """
+    match = re.match(r"^(?P<negative>-)?(?:(?P<days>[0-9]*)\.)?"
+                     r"(?P<hours>[0-9]{2}):(?P<minutes>[0-9]{2})"
+                     r":(?P<seconds>[0-9]{2})(?:\.(?P<ticks>[0-9]{7}))?$",
+                     from_str)
+    if match:
+        groups = match.groupdict()
+        span = datetime.timedelta(
+            days=int(groups['days'] or "0"),
+            hours=int(groups['hours']),
+            minutes=int(groups['minutes']),
+            seconds=int(groups['seconds']),
+            microseconds=int(groups['ticks'] or "0") // 10)
+
+        if groups['negative'] == '-':
+            span = -span
+        return span
+    else:
+        raise Exception(f"Format of TimeSpan failed attempted conversion to timedelta: {from_str}")
+
+
 def add_json_attrib(json_dict: Dict[str, Any], object_,
                     attribute_name: str, alt_name: str = None):
     """Add the results of the to_json() function call of the attribute from the object to the dict.

azure/durable_functions/orchestrator.py

@@ -68,4 +68,6 @@ class Orchestrator:
                 context_body = context
             return Orchestrator(fn).handle(DurableOrchestrationContext.from_json(context_body))
 
+        handle.orchestrator_function = fn
+
         return handle

azure/durable_functions/testing/OrchestratorGeneratorWrapper.py

@@ -0,0 +1,42 @@
+from typing import Generator, Any, Union
+
+from azure.durable_functions.models import TaskBase
+
+
+def orchestrator_generator_wrapper(
+        generator: Generator[TaskBase, Any, Any]) -> Generator[Union[TaskBase, Any], None, None]:
+    """Wrap a user-defined orchestrator function in a way that simulates the Durable replay logic.
+
+    Parameters
+    ----------
+    generator: Generator[TaskBase, Any, Any]
+        Generator orchestrator as defined in the user function app. This generator is expected
+        to yield a series of TaskBase objects and receive the results of these tasks until
+        returning the result of the orchestrator.
+
+    Returns
+    -------
+    Generator[Union[TaskBase, Any], None, None]
+        A simplified version of the orchestrator which takes no inputs. This generator will
+        yield back the TaskBase objects that are yielded from the user orchestrator as well
+        as the final result of the orchestrator. Exception handling is also simulated here
+        in the same way as replay, where tasks returning exceptions are thrown back into the
+        orchestrator.
+    """
+    previous = next(generator)
+    yield previous
+    while True:
+        try:
+            previous_result = None
+            try:
+                previous_result = previous.result
+            except Exception as e:
+                # Simulated activity exceptions, timer interrupted exceptions,
+                # or anytime a task would throw.
+                previous = generator.throw(e)
+            else:
+                previous = generator.send(previous_result)
+            yield previous
+        except StopIteration as e:
+            yield e.value
+            return

azure/durable_functions/testing/__init__.py

@@ -0,0 +1,6 @@
+"""Unit testing utilities for Azure Durable functions."""
+from .OrchestratorGeneratorWrapper import orchestrator_generator_wrapper
+
+__all__ = [
+    'orchestrator_generator_wrapper'
+]

{azure_functions_durable-1.2.10.dist-info → azure_functions_durable-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-functions-durable
-Version: 1.2.10
+Version: 1.3.1
 Summary: Durable Functions For Python
 Home-page: https://github.com/Azure/azure-functions-durable-python
 Author: Azure Functions team at Microsoft Corp.
@@ -16,13 +16,16 @@ Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Environment :: Web Environment
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.6,<4
+Requires-Python: >=3.9,<4
 Description-Content-Type: text/markdown
-Requires-Dist: azure-functions >=1.12.0
-Requires-Dist: aiohttp >=3.6.2
-Requires-Dist: requests ==2.*
-Requires-Dist: python-dateutil >=2.8.0
-Requires-Dist: furl >=2.1.0
+License-File: LICENSE
+Requires-Dist: azure-functions>=1.12.0
+Requires-Dist: aiohttp>=3.12.9
+Requires-Dist: requests==2.*
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: furl>=2.1.0
+Requires-Dist: opentelemetry-api>=1.32.1
+Requires-Dist: opentelemetry-sdk>=1.32.1
 
 |Branch|Status|
 |---|---|

{azure_functions_durable-1.2.10.dist-info → azure_functions_durable-1.3.1.dist-info}/RECORD

@@ -1,28 +1,28 @@
 azure/durable_functions/__init__.py,sha256=Syz9yrT8sHREVyxqvwjg8_c_h8yMTyuBHcDMsuQs1YM,2910
 azure/durable_functions/constants.py,sha256=JtknDhaVihMeo-ygY9QNofiO2KEqnQvopdfZ6Qatnik,414
-azure/durable_functions/entity.py,sha256=jlJrkms0YnMX1XjQd4ycstderj-JjY-fGwfmdRRqxIQ,4497
-azure/durable_functions/orchestrator.py,sha256=t4lQZbCR3DK48VwfGyroQANl7E8cWGNRGb0lRtLPYNc,2509
+azure/durable_functions/entity.py,sha256=mUUzb1BZiDrUJjvxOTlnVURnKPyDGPJ3mXXMN0DKT7M,4649
+azure/durable_functions/orchestrator.py,sha256=SZni90Aweq0OZykHyMblfJpUndJ2woJmySarcsDiIK4,2554
 azure/durable_functions/decorators/__init__.py,sha256=wEubgP2rUUISwidZWgKx6mmzEeGKsSnpGmetjIUi1nw,150
-azure/durable_functions/decorators/durable_app.py,sha256=h4Mvcqoy03iy-vp5lIfd5qaC72xysMnQlTd3WPPl2V8,9354
+azure/durable_functions/decorators/durable_app.py,sha256=8K4gevZVYcDvifxXVuvTt8YzF8jx63c1PwdBBk1Vt0g,10114
 azure/durable_functions/decorators/metadata.py,sha256=p91rdCe6OSRYJaKAXnrfR0QCV3PoHK7aGy1m6WAnPIE,2828
 azure/durable_functions/models/DurableEntityContext.py,sha256=cyZmjjZu18oV9S4A2NpnXfjd1JQxPxp9EMmAR424UK0,5830
 azure/durable_functions/models/DurableHttpRequest.py,sha256=a5kgRdg4eA0sgyDcpmQWc0dbwP-o3BwWW2Ive0BYO_Q,2021
 azure/durable_functions/models/DurableOrchestrationBindings.py,sha256=_hp61WjN3bQYCqYFQuvUaDdRu7C14fPg7lFbaA9TRe4,2408
-azure/durable_functions/models/DurableOrchestrationClient.py,sha256=AX4IDga52jcNEsW4h5OP34w63jxTpoQHNzrnXpo1xCA,31995
-azure/durable_functions/models/DurableOrchestrationContext.py,sha256=FG8EMpowxWoDE7IuuhXmftWoYGyvAKptSZ6GiC-nALY,29274
+azure/durable_functions/models/DurableOrchestrationClient.py,sha256=kQBqeKugvi2mi-7dDbCxlu67r20doEhDknlchYxcLBE,33018
+azure/durable_functions/models/DurableOrchestrationContext.py,sha256=mbA1Do_1NP_uuqhCUoEsegqBtlNugUB0_tdVWQ1PRoI,31849
 azure/durable_functions/models/DurableOrchestrationStatus.py,sha256=BXWz9L7np4Q9k6z4NsfLX97i2U2IFh94TVeRSV2BjM4,6049
 azure/durable_functions/models/EntityStateResponse.py,sha256=f48W8gmlb-D5iJw3eDyUMYVwHpmIxP6k6a7o2TRHwII,674
 azure/durable_functions/models/FunctionContext.py,sha256=4gHTmIo8DZN-bZLM-hyjoQFlv-AbsfLMT1_X4WxWxqY,274
 azure/durable_functions/models/OrchestrationRuntimeStatus.py,sha256=lCT31d85B9dHA12n7Twdd9gQ-ISCtt-bkEwi3TXVHoE,969
 azure/durable_functions/models/OrchestratorState.py,sha256=xgoEz8Ya8V5kFO997GiS70IVS2EXhDcMZwoclVaseu0,4073
 azure/durable_functions/models/PurgeHistoryResult.py,sha256=C_Ppdk7TEn0fuYZ971u3I_GHQBUqPuLqCrVyvp6YRsY,1092
-azure/durable_functions/models/ReplaySchema.py,sha256=ge-uRkqpeBC3AY3o0XV9DqlaFkgOIGMe87EjOAg1d9w,158
+azure/durable_functions/models/ReplaySchema.py,sha256=85YZD-QWgMQSfZsRQlfQfLPzK9FMITcWK241Vofw6pU,170
 azure/durable_functions/models/RetryOptions.py,sha256=-rmv3mQmzQ_2utFy1d-ontqpcgP139B8MQroanfN54w,1988
 azure/durable_functions/models/RpcManagementOptions.py,sha256=aEOWx_xUWl4Rwb2-7kpyml8rzTX9Vl4s71LkqYPLnHw,3482
-azure/durable_functions/models/Task.py,sha256=Md3TetTwYMvIrmo-QkFt6tGigl3nXxcK9y3wcwpMvzg,15199
-azure/durable_functions/models/TaskOrchestrationExecutor.py,sha256=l8JNCa8vuQKTP1pTKQWhotZigVPlsg9yUIs39KtzRiA,15914
+azure/durable_functions/models/Task.py,sha256=e548_wfJkYY_UCpJkwqVVM65tyP6jchox_YNsf8SslM,19559
+azure/durable_functions/models/TaskOrchestrationExecutor.py,sha256=PBbS3aEKn1JCFhvjR9oz4-WmIW_9vh6-ILzImxVN7zw,16085
 azure/durable_functions/models/TokenSource.py,sha256=9uLxiOV8lcDj--3tD0XxcQnigk9AozjdOoJyskctErU,1822
-azure/durable_functions/models/__init__.py,sha256=HSlC2dw7UZPlODbTMNvujntBb7P2Ch3JNwu3nJMNSo4,954
+azure/durable_functions/models/__init__.py,sha256=L7ynxb_mBGCvV1iEAfpJU9_b-8ubKIEJKaZa2aoqjek,999
 azure/durable_functions/models/actions/Action.py,sha256=0jp-SP_12YmZWWctOXmwl48Ozw3dMMq5-crUAkK8Qk0,598
 azure/durable_functions/models/actions/ActionType.py,sha256=FAQh_EPcFru7rOPYWKpYFBSbZpFEQc2-jsrapRJvFG0,507
 azure/durable_functions/models/actions/CallActivityAction.py,sha256=G9O9JML-Z0_A_WWB4iTbDkvE3iNRtNkES2iNsUQ2SVc,1496
@@ -41,7 +41,7 @@ azure/durable_functions/models/actions/WhenAllAction.py,sha256=xfcvSsJ3zsRL6IbpM
 azure/durable_functions/models/actions/WhenAnyAction.py,sha256=VyKu2iv5ML2862nu4d_ZG0Cbm50546MnhJ6RZyxghso,478
 azure/durable_functions/models/actions/__init__.py,sha256=q3dRJc1r7q6-IYjOGM5LJqoBPp2PkE4argVJ2SUjne4,861
 azure/durable_functions/models/entities/EntityState.py,sha256=lVmkM18z7xExdt1wO1IFJc5MYliVBO3k0fiPyIcu97o,2257
-azure/durable_functions/models/entities/OperationResult.py,sha256=qcXdSruJtapn_7bpXe-LH11e9F4kDsl-XWjSMYDtKV8,2081
+azure/durable_functions/models/entities/OperationResult.py,sha256=RHGoCcLeAiMtDiZH5aYW-s4-IDuVtXArlxhktf49kWs,2766
 azure/durable_functions/models/entities/RequestMessage.py,sha256=y2BG1-HQuPbN91qOh_XrFainFp27YbSk9dotA2ePOPA,1742
 azure/durable_functions/models/entities/ResponseMessage.py,sha256=GC6HnD3mkIfkGptpazq4yOGJfciL2kkVxbcv1R80B7I,1588
 azure/durable_functions/models/entities/Signal.py,sha256=TjyvkG9kzxyjyRGz1bItxt1MI-QN2QS2YK3e7rFP41g,1313
@@ -51,13 +51,15 @@ azure/durable_functions/models/history/HistoryEventType.py,sha256=NdCQQrqvWFw5Gi
 azure/durable_functions/models/history/__init__.py,sha256=otJhZJN9OeGtWrW3lKbk2C1Nyf6I2wJfwuXpCZ2oxYM,237
 azure/durable_functions/models/utils/__init__.py,sha256=dQ6-HRUPsCtDIqGjRJ3TA6NXSYXzhw5yLA2OP-zkm-s,221
 azure/durable_functions/models/utils/entity_utils.py,sha256=TqNTtRC8VuKFtqWLq9oEAloioV-FyinjgRYVKkCldHo,2881
-azure/durable_functions/models/utils/http_utils.py,sha256=p171W9032iBqqiZEfjo0F-sTrGn8C1qJngaXnqfYcKk,2103
-azure/durable_functions/models/utils/json_utils.py,sha256=dejxw7msjConjCT4wWX104th-7Z4RXX36YmO_TJNRUA,2323
+azure/durable_functions/models/utils/http_utils.py,sha256=AoCWjCapd_984J_4296iJ8cNJWEG8GIdhRttBPt0HnA,2551
+azure/durable_functions/models/utils/json_utils.py,sha256=zUn62pm3dQw054ZlK7F4uRP-UELjQC8EmZBU1WncHMg,3811
+azure/durable_functions/testing/OrchestratorGeneratorWrapper.py,sha256=cjh-HAq5rVNCoR0pIbfGrqy6cKSf4S1KMQxrBMWU1-s,1728
+azure/durable_functions/testing/__init__.py,sha256=NLbltPtoPXK-0iMTwcKTKPjQlAWrEq55oDYmrhYz6vg,189
 tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/models/test_DecoratorMetadata.py,sha256=0PeUDszF_gAJZMZR-K-Ro7c3I1D960amOLtbT88L_dk,3918
 tests/models/test_Decorators.py,sha256=y2dhoSlP74J5uAVBDY2JfFkSA-AhyagVBZO5tGi6KaQ,2925
 tests/models/test_DurableOrchestrationBindings.py,sha256=pjuoKlpEc6KAIL-Nq2taoqW0HYWXoupgUxcsPwc1Psg,2961
-tests/models/test_DurableOrchestrationClient.py,sha256=Z17gzBoXEPozUiClAnlFsdA2dUgd7M-tyjtBuhqnmyE,31740
+tests/models/test_DurableOrchestrationClient.py,sha256=7htzuMMfkRU9Hf-9Gr-rYHpJXJdpnAp0WheAFpMKHNo,31791
 tests/models/test_DurableOrchestrationContext.py,sha256=7fWdnvpSEces0VM4Xm11uLZmshXqGl7wtYo8ELixypc,3930
 tests/models/test_DurableOrchestrationStatus.py,sha256=fnUZxrHGy771OoaD5TInELhaG836aB8XqtMdNjnEFp8,2485
 tests/models/test_OrchestrationState.py,sha256=L-k8ScrqoDIZEqIUORbxXA7yCuMbVAUPr-7VmyuQkUc,1272
@@ -68,7 +70,7 @@ tests/orchestrator/orchestrator_test_utils.py,sha256=ldgQGGuOVALcI98enRU08nF_VJd
 tests/orchestrator/test_call_http.py,sha256=CvemeCayrQLjmjl3lpB1fk_CpV-DRPgfxLgD4iNgStQ,9103
 tests/orchestrator/test_continue_as_new.py,sha256=k9mS8tHE1GX9uogCgrrgXJynydxExrlAlGIpC4ojNP0,2575
 tests/orchestrator/test_create_timer.py,sha256=HPaJrYYmyvWqBFqmu2jatLK911DA8knfF88GMRWMhJY,5576
-tests/orchestrator/test_entity.py,sha256=ruOtyJcx0-sjINJT9MRjxDfdAZ6SuI_682zUybDpCRk,13857
+tests/orchestrator/test_entity.py,sha256=fcHhh1kcLDv9GXnChMUsFwYWiRiBRXKLlFp823pooWs,13922
 tests/orchestrator/test_external_event.py,sha256=DfeOFCdt2haxTwVQ1_lQtwkrdhb3EVlXsavVGo8HrmE,2534
 tests/orchestrator/test_fan_out_fan_in.py,sha256=8pNPA2remGz8GLThqINAuYi5FVIMNdE1Ya5zqhXHDKc,7218
 tests/orchestrator/test_is_replaying_flag.py,sha256=se8GOmI_5EP7jae8gdWFFSBEIfWbpgaQstyJwje5sdY,4386
@@ -84,6 +86,7 @@ tests/orchestrator/models/OrchestrationInstance.py,sha256=CQ3qyNumjksuFNMujbESsv
 tests/orchestrator/schemas/OrchetrationStateSchema.py,sha256=EyTsDUZ3K-9mVljLIlg8f_h2zsK228E0PMvvtyEWw24,2718
 tests/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tasks/tasks_test_utils.py,sha256=Ymc5GESJpzybBq3n2mT4IABDRNTVCerAZrlMilv0Pdk,737
+tests/tasks/test_long_timers.py,sha256=KDN0AM4R1Jqaf3L1i7xUXEUIyPUzP6PFRplmD2IamlI,3494
 tests/tasks/test_new_uuid.py,sha256=iaQcF5iPZdU3e1SiKSiP6vQrQeMFehUp354ShMRHE7s,1419
 tests/test_utils/ContextBuilder.py,sha256=l1dDeI1FXdTaiUYwcYNPOtYiivh2c2xUfoOo_AcXgL0,7459
 tests/test_utils/EntityContextBuilder.py,sha256=Gjh0ERX6ND5RZ3blCmix8z0RrmfOVfoY0xm8LuUoZGo,1939
@@ -93,8 +96,8 @@ tests/test_utils/json_utils.py,sha256=B0q3COMya7TGxbH-7sD_0ypWDSuaF4fpD4QV_oJPgG
 tests/test_utils/testClasses.py,sha256=U_u5qKxC9U81SzjLo7ejjPjEn_cE5qjaqoq8edGD6l8,1521
 tests/utils/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 tests/utils/test_entity_utils.py,sha256=kdk5_DV_-bFu_5q2mw9o1yjyzh8Lcxv1jo1Q7is_ukA,748
-azure_functions_durable-1.2.10.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
-azure_functions_durable-1.2.10.dist-info/METADATA,sha256=h2nOeG_Lz2fnQNOxegbZfGR7xrxplZw_5Kc5XnkPChM,3421
-azure_functions_durable-1.2.10.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-azure_functions_durable-1.2.10.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
-azure_functions_durable-1.2.10.dist-info/RECORD,,
+azure_functions_durable-1.3.1.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
+azure_functions_durable-1.3.1.dist-info/METADATA,sha256=8XrQVf_FGsfHF1Nz1Uot4pmFUrVZqpF6tCaPoQohxTc,3523
+azure_functions_durable-1.3.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+azure_functions_durable-1.3.1.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
+azure_functions_durable-1.3.1.dist-info/RECORD,,

{azure_functions_durable-1.2.10.dist-info → azure_functions_durable-1.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/models/test_DurableOrchestrationClient.py

@@ -67,7 +67,7 @@ class MockRequest:
         assert url == self._expected_url
         return self._response
 
-    async def post(self, url: str, data: Any = None):
+    async def post(self, url: str, data: Any = None, trace_parent: str = None, trace_state: str = None):
         assert url == self._expected_url
         return self._response
 

tests/orchestrator/test_entity.py

@@ -209,9 +209,11 @@ def apply_operation(entity_state: EntityState, result: Any, state: Any, is_error
     # We cannot control duration, so default it to zero and avoid checking for it
     # in later asserts
     duration = 0
+    start_time = 0
     operation_result = OperationResult(
         is_error=is_error,
         duration=duration,
+        execution_start_time_ms=start_time,
         result=result
     )
     entity_state._results.append(operation_result)

tests/tasks/test_long_timers.py

@@ -0,0 +1,70 @@
+import datetime
+
+import pytest
+from azure.durable_functions.models.DurableOrchestrationContext import DurableOrchestrationContext
+from azure.durable_functions.models.Task import LongTimerTask, TaskState, TimerTask
+from azure.durable_functions.models.actions.CreateTimerAction import CreateTimerAction
+
+
+@pytest.fixture
+def starting_context_v3():
+    context = DurableOrchestrationContext.from_json(
+        '{"history":[{"EventType":12,"EventId":-1,"IsPlayed":false,'
+        '"Timestamp":"'
+        f'{datetime.datetime.now(datetime.timezone.utc).isoformat()}'
+        '"}, {"OrchestrationInstance":{'
+        '"InstanceId":"48d0f95957504c2fa579e810a390b938", '
+        '"ExecutionId":"fd183ee02e4b4fd18c95b773cfb5452b"},"EventType":0,'
+        '"ParentInstance":null, '
+        '"Name":"DurableOrchestratorTrigger","Version":"","Input":"null",'
+        '"Tags":null,"EventId":-1,"IsPlayed":false, '
+        '"Timestamp":"'
+        f'{datetime.datetime.now(datetime.timezone.utc).isoformat()}'
+        '"}],"input":null,'
+        '"instanceId":"48d0f95957504c2fa579e810a390b938", '
+        '"upperSchemaVersion": 2, '
+        '"upperSchemaVersionNew": 3, '
+        '"isReplaying":false,"parentInstanceId":null, '
+        '"maximumShortTimerDuration":"0.16:00:00", '
+        '"longRunningTimerIntervalDuration":"0.08:00:00" } ')
+    return context
+
+
+def test_durable_context_creates_correct_timer(starting_context_v3):
+    timer = starting_context_v3.create_timer(datetime.datetime.now(datetime.timezone.utc) +
+                                             datetime.timedelta(minutes=30))
+    assert isinstance(timer, TimerTask)
+
+    timer2 = starting_context_v3.create_timer(datetime.datetime.now(datetime.timezone.utc) +
+                                              datetime.timedelta(days=1))
+    assert isinstance(timer2, LongTimerTask)
+
+def test_long_timer_fires_appropriately(starting_context_v3):
+    starting_time = starting_context_v3.current_utc_datetime
+    final_fire_time = starting_time + datetime.timedelta(hours=20)
+    long_timer_action = CreateTimerAction(final_fire_time)
+    long_timer = LongTimerTask(None, long_timer_action, starting_context_v3)
+    assert long_timer.action.fire_at == final_fire_time
+    assert long_timer.action == long_timer_action
+
+    # Check the first "inner" timer and simulate firing it
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == starting_time + datetime.timedelta(hours=8)
+    # This happens when the task is reconstructed during replay, doing it manually for the test
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
+
+    assert long_timer.state == TaskState.RUNNING
+
+    # Check the scond "inner" timer and simulate firing it. This one should be set to the final
+    # fire time, the remaining time (12 hours) is less than the max long timer duration (16 hours)
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == final_fire_time
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
+
+    # Ensure the LongTimerTask finished
+    assert len(long_timer.pending_tasks) == 0
+    assert long_timer.state == TaskState.SUCCEEDED