azure-functions-durable 1.2.10__tar.gz → 1.3.1__tar.gz

{azure-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/.github/workflows/durable_python_action.yml

@@ -12,10 +12,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v1
-    - name: Set up Python 3.6.x
+    - name: Set up Python 3.9.x
       uses: actions/setup-python@v1
       with:
-        python-version: 3.6.x
+        python-version: 3.9.x
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

azure-functions-durable-1.3.1/.github/workflows/validate.yml

@@ -0,0 +1,60 @@
+name: Validate
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+    branches:
+      - main
+      - dev
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Run Linter
+        run: |
+          cd azure
+          flake8 . --count --show-source --statistics
+      - name: Run tests
+        run: |
+          pytest --ignore=samples-v2
+  
+  test-samples:
+    strategy:
+      matrix:
+        app_name: [blueprint, fan_in_fan_out, function_chaining]
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./samples-v2/${{ matrix.app_name }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -r ../../requirements.txt
+          pip install ../.. --no-cache-dir --upgrade --no-deps --force-reinstall
+      - name: Run tests
+        run: |
+          python -m pytest

{azure-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/CODEOWNERS

@@ -9,4 +9,4 @@
 # For all file changes, github would automatically include the following people in the PRs.
 #
 
-* @davidmrdavid
+* @nytian @cgillum @bachuv @andystaples

{azure-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/CONTRIBUTING.md

@@ -24,7 +24,7 @@ Thank you for taking the time to contribute to Durable Functions in [Python](htt
     - MacOS (or) Windows10 Ubuntu WSL
 - Language Runtimes
     - .NET Core 2.0
-    - \>= Python 3.6.x
+    - \>= Python 3.9.x
 
 Note: Some ML libraries may not be compatible with newer Python versions. Make sure the library is compatible with the Python version.
 
@@ -123,16 +123,30 @@ pip install -e $REPOSITORY_ROOT/
 ```
 where REPOSITORY_ROOT is the root folder of the azure-functions-durable-python repository 
 
-7. Set breakpoints and click Run -> Start Debugging in VS Code. This should internally start the Azure Function using `func host start` command.
+7. Set breakpoints and click Run -> Start Debugging in VS Code. This should internally start the Azure Function using `func host start` command. If the breakpoints are not getting hit, check to make sure that you have set `justMyCode: false` in the function app's .vscode/launch.json.
+
+```
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      ...
+      "justMyCode": false
+      ...
+    }
+  ]
+}
+```
 
 ### Debugging end-to-end
 
 If you want to debug into the Durable Task or any of the .NET bits, follow instructions below:
 
-1. Open the Azure Storage Explorer and connect to the local storage emulator or the storage account you are using.
-2. Make sure the Durable Python debugging is setup already and the debugger has started the `func` process.
-3. In the VSCode editor for DurableTask, click Debug -> .NET Core Attach Process and search for `func host start` process and attach to it.
-4. Add a breakpoint in both editors and continue debugging.
+1. If you would like to debug a custom local WebJobs extension package then create the custom package, place it in a local directory, and then run `func extensions install --package Microsoft.Azure.WebJobs.Extensions.DurableTask --version <VERSION>`. If you update the version while debugging and the new version doesn't get picked up, then try running `func extensions install` to get the new changes.
+2. Open the Azure Storage Explorer and connect to the local storage emulator or the storage account you are using.
+3. Make sure the Durable Python debugging is setup already and the debugger has started the `func` process.
+4. In the VSCode editor for DurableTask, click Debug -> .NET Core Attach Process, search for `func host start` process and attach to it. If you are using Visual Studio, click Debug -> Attach to Process, search for the `func` process and attach to it.
+5. Add a breakpoint in both editors and continue debugging.
 
 ## Testing changes locally (Windows)
 

azure-functions-durable-1.3.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: azure-functions-durable
+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.
+Author-email: azurefunctions@microsoft.com
+License: MIT
+Keywords: azure functions azurefunctions python serverless workflows durablefunctions
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Environment :: Web Environment
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.9,<4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+|Branch|Status|
+|---|---|
+|main|[![Build Status](https://azfunc.visualstudio.com/Azure%20Functions/_apis/build/status/Azure.azure-functions-durable-python?branchName=main)](https://azfunc.visualstudio.com/Azure%20Functions/_build/latest?definitionId=58&branchName=main)|
+|dev|[![Build Status](https://azfunc.visualstudio.com/Azure%20Functions/_apis/build/status/Azure.azure-functions-durable-python?branchName=dev)](https://azfunc.visualstudio.com/Azure%20Functions/_build/latest?definitionId=58&branchName=dev)|
+
+# Durable Functions for Python
+
+ [Durable Functions](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview) is an extension of [Azure Functions](https://docs.microsoft.com/en-us/azure/azure-functions/functions-overview) that lets you write stateful functions in a serverless compute environment. The extension lets you define stateful workflows by writing orchestrator functions and stateful entities by writing entity functions using the Azure Functions programming model. Behind the scenes, the extension manages state, checkpoints, and restarts for you, allowing you to focus on your business logic.
+
+ 🐍  Find us on PyPi [here](https://pypi.org/project/azure-functions-durable/) 🐍   
+
+
+You can find more information at the following links:
+
+* [Azure Functions overview](https://docs.microsoft.com/en-us/azure/azure-functions/functions-overview)
+* [Azure Functions Python developers guide](https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference-python)
+* [Durable Functions overview](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview?tabs=python)
+* [Core concepts and features overview](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-types-features-overview).
+
+> Durable Functions expects certain programming constraints to be followed. Please read the documentation linked above for more information.
+
+## Getting Started
+
+Follow these instructions to get started with Durable Functions in Python:
+
+**🚀 [Python Durable Functions quickstart](https://docs.microsoft.com/azure/azure-functions/durable/quickstart-python-vscode)**
+
+## Tooling
+
+* Python Durable Functions requires [Azure Functions Core Tools](https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local) version 3.0.2630 or higher.
+
+

{azure-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/azure/durable_functions/models/ReplaySchema.py

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

{azure-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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-functions-durable-1.2.10 → azure-functions-durable-1.3.1}/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'
 ]