durabletask 0.1.0a5__py3-none-any.whl → 0.1.1a1__py3-none-any.whl

durabletask/task.py

@@ -4,9 +4,11 @@
 # See https://peps.python.org/pep-0563/
 from __future__ import annotations
 
+import math
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
-from typing import Any, Callable, Generator, Generic, List, TypeVar, Union
+from typing import (Any, Callable, Generator, Generic, List, Optional, TypeVar,
+                    Union)
 
 import durabletask.internal.helpers as pbh
 import durabletask.internal.orchestrator_service_pb2 as pb
@@ -87,17 +89,18 @@ class OrchestrationContext(ABC):
 
     @abstractmethod
     def call_activity(self, activity: Union[Activity[TInput, TOutput], str], *,
-                      input: Union[TInput, None] = None) -> Task[TOutput]:
+                      input: Optional[TInput] = None,
+                      retry_policy: Optional[RetryPolicy] = None) -> Task[TOutput]:
         """Schedule an activity for execution.
 
         Parameters
         ----------
         activity: Union[Activity[TInput, TOutput], str]
             A reference to the activity function to call.
-        input: Union[TInput, None]
+        input: Optional[TInput]
             The JSON-serializable input (or None) to pass to the activity.
-        return_type: task.Task[TOutput]
-            The JSON-serializable output type to expect from the activity result.
+        retry_policy: Optional[RetryPolicy]
+            The retry policy to use for this activity call.
 
         Returns
         -------
@@ -108,19 +111,22 @@ class OrchestrationContext(ABC):
 
     @abstractmethod
     def call_sub_orchestrator(self, orchestrator: Orchestrator[TInput, TOutput], *,
-                              input: Union[TInput, None] = None,
-                              instance_id: Union[str, None] = None) -> Task[TOutput]:
+                              input: Optional[TInput] = None,
+                              instance_id: Optional[str] = None,
+                              retry_policy: Optional[RetryPolicy] = None) -> Task[TOutput]:
         """Schedule sub-orchestrator function for execution.
 
         Parameters
         ----------
         orchestrator: Orchestrator[TInput, TOutput]
             A reference to the orchestrator function to call.
-        input: Union[TInput, None]
+        input: Optional[TInput]
             The optional JSON-serializable input to pass to the orchestrator function.
-        instance_id: Union[str, None]
+        instance_id: Optional[str]
             A unique ID to use for the sub-orchestration instance. If not specified, a
             random UUID will be used.
+        retry_policy: Optional[RetryPolicy]
+            The retry policy to use for this sub-orchestrator call.
 
         Returns
         -------
@@ -162,7 +168,7 @@ class OrchestrationContext(ABC):
 
 
 class FailureDetails:
-    def __init__(self, message: str, error_type: str, stack_trace: Union[str, None]):
+    def __init__(self, message: str, error_type: str, stack_trace: Optional[str]):
         self._message = message
         self._error_type = error_type
         self._stack_trace = stack_trace
@@ -176,7 +182,7 @@ class FailureDetails:
         return self._error_type
 
     @property
-    def stack_trace(self) -> Union[str, None]:
+    def stack_trace(self) -> Optional[str]:
         return self._stack_trace
 
 
@@ -206,8 +212,8 @@ class OrchestrationStateError(Exception):
 class Task(ABC, Generic[T]):
     """Abstract base class for asynchronous tasks in a durable orchestration."""
     _result: T
-    _exception: Union[TaskFailedError, None]
-    _parent: Union[CompositeTask[T], None]
+    _exception: Optional[TaskFailedError]
+    _parent: Optional[CompositeTask[T]]
 
     def __init__(self) -> None:
         super().__init__()
@@ -261,29 +267,6 @@ class CompositeTask(Task[T]):
     def on_child_completed(self, task: Task[T]):
         pass
 
-
-class CompletableTask(Task[T]):
-
-    def __init__(self):
-        super().__init__()
-
-    def complete(self, result: T):
-        if self._is_complete:
-            raise ValueError('The task has already completed.')
-        self._result = result
-        self._is_complete = True
-        if self._parent is not None:
-            self._parent.on_child_completed(self)
-
-    def fail(self, message: str, details: pb.TaskFailureDetails):
-        if self._is_complete:
-            raise ValueError('The task has already completed.')
-        self._exception = TaskFailedError(message, details)
-        self._is_complete = True
-        if self._parent is not None:
-            self._parent.on_child_completed(self)
-
-
 class WhenAllTask(CompositeTask[List[T]]):
     """A task that completes when all of its child tasks complete."""
 
@@ -313,6 +296,76 @@ class WhenAllTask(CompositeTask[List[T]]):
         return self._completed_tasks
 
 
+class CompletableTask(Task[T]):
+
+    def __init__(self):
+        super().__init__()
+        self._retryable_parent = None
+
+    def complete(self, result: T):
+        if self._is_complete:
+            raise ValueError('The task has already completed.')
+        self._result = result
+        self._is_complete = True
+        if self._parent is not None:
+            self._parent.on_child_completed(self)
+
+    def fail(self, message: str, details: pb.TaskFailureDetails):
+        if self._is_complete:
+            raise ValueError('The task has already completed.')
+        self._exception = TaskFailedError(message, details)
+        self._is_complete = True
+        if self._parent is not None:
+            self._parent.on_child_completed(self)
+
+
+class RetryableTask(CompletableTask[T]):
+    """A task that can be retried according to a retry policy."""
+
+    def __init__(self, retry_policy: RetryPolicy, action: pb.OrchestratorAction,
+                 start_time:datetime, is_sub_orch: bool) -> None:
+        super().__init__()
+        self._action = action
+        self._retry_policy = retry_policy
+        self._attempt_count = 1
+        self._start_time = start_time
+        self._is_sub_orch = is_sub_orch
+
+    def increment_attempt_count(self) -> None:
+        self._attempt_count += 1
+    
+    def compute_next_delay(self) -> Union[timedelta, None]:
+        if self._attempt_count >= self._retry_policy.max_number_of_attempts:
+            return None
+
+        retry_expiration: datetime = datetime.max
+        if self._retry_policy.retry_timeout is not None and self._retry_policy.retry_timeout != datetime.max:
+            retry_expiration = self._start_time + self._retry_policy.retry_timeout
+        
+        if self._retry_policy.backoff_coefficient is None:
+            backoff_coefficient = 1.0
+        else:
+            backoff_coefficient = self._retry_policy.backoff_coefficient
+
+        if datetime.utcnow() < retry_expiration:
+            next_delay_f = math.pow(backoff_coefficient, self._attempt_count - 1) * self._retry_policy.first_retry_interval.total_seconds()
+
+            if self._retry_policy.max_retry_interval is not None:
+                next_delay_f = min(next_delay_f, self._retry_policy.max_retry_interval.total_seconds())
+                return timedelta(seconds=next_delay_f)
+
+        return None
+
+
+class TimerTask(CompletableTask[T]):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def set_retryable_parent(self, retryable_task: RetryableTask):
+        self._retryable_parent = retryable_task
+
+
 class WhenAnyTask(CompositeTask[Task]):
     """A task that completes when any of its child tasks complete."""
 
@@ -376,6 +429,74 @@ Orchestrator = Callable[[OrchestrationContext, TInput], Union[Generator[Task, An
 Activity = Callable[[ActivityContext, TInput], TOutput]
 
 
+class RetryPolicy:
+    """Represents the retry policy for an orchestration or activity function."""
+
+    def __init__(self, *,
+                 first_retry_interval: timedelta,
+                 max_number_of_attempts: int,
+                 backoff_coefficient: Optional[float] = 1.0,
+                 max_retry_interval: Optional[timedelta] = None,
+                 retry_timeout: Optional[timedelta] = None):
+        """Creates a new RetryPolicy instance.
+
+        Parameters
+        ----------
+        first_retry_interval : timedelta
+            The retry interval to use for the first retry attempt.
+        max_number_of_attempts : int
+            The maximum number of retry attempts.
+        backoff_coefficient : Optional[float]
+            The backoff coefficient to use for calculating the next retry interval.
+        max_retry_interval : Optional[timedelta]
+            The maximum retry interval to use for any retry attempt.
+        retry_timeout : Optional[timedelta]
+            The maximum amount of time to spend retrying the operation.
+        """
+        # validate inputs
+        if first_retry_interval < timedelta(seconds=0):
+            raise ValueError('first_retry_interval must be >= 0')
+        if max_number_of_attempts < 1:
+            raise ValueError('max_number_of_attempts must be >= 1')
+        if backoff_coefficient is not None and backoff_coefficient < 1:
+            raise ValueError('backoff_coefficient must be >= 1')
+        if max_retry_interval is not None and max_retry_interval < timedelta(seconds=0):
+            raise ValueError('max_retry_interval must be >= 0')
+        if retry_timeout is not None and retry_timeout < timedelta(seconds=0):
+            raise ValueError('retry_timeout must be >= 0')
+
+        self._first_retry_interval = first_retry_interval
+        self._max_number_of_attempts = max_number_of_attempts
+        self._backoff_coefficient = backoff_coefficient
+        self._max_retry_interval = max_retry_interval
+        self._retry_timeout = retry_timeout
+
+    @property
+    def first_retry_interval(self) -> timedelta:
+        """The retry interval to use for the first retry attempt."""
+        return self._first_retry_interval
+
+    @property
+    def max_number_of_attempts(self) -> int:
+        """The maximum number of retry attempts."""
+        return self._max_number_of_attempts
+
+    @property
+    def backoff_coefficient(self) -> Optional[float]:
+        """The backoff coefficient to use for calculating the next retry interval."""
+        return self._backoff_coefficient
+
+    @property
+    def max_retry_interval(self) -> Optional[timedelta]:
+        """The maximum retry interval to use for any retry attempt."""
+        return self._max_retry_interval
+
+    @property
+    def retry_timeout(self) -> Optional[timedelta]:
+        """The maximum amount of time to spend retrying the operation."""
+        return self._retry_timeout
+
+
 def get_name(fn: Callable) -> str:
     """Returns the name of the provided function"""
     name = fn.__name__

durabletask/worker.py

@@ -6,7 +6,8 @@ import logging
 from datetime import datetime, timedelta
 from threading import Event, Thread
 from types import GeneratorType
-from typing import Any, Dict, Generator, List, Sequence, Tuple, TypeVar, Union
+from typing import (Any, Dict, Generator, List, Optional, Sequence, Tuple,
+                    TypeVar, Union)
 
 import grpc
 from google.protobuf import empty_pb2
@@ -47,7 +48,7 @@ class _Registry:
 
         self.orchestrators[name] = fn
 
-    def get_orchestrator(self, name: str) -> Union[task.Orchestrator, None]:
+    def get_orchestrator(self, name: str) -> Optional[task.Orchestrator]:
         return self.orchestrators.get(name)
 
     def add_activity(self, fn: task.Activity) -> str:
@@ -66,7 +67,7 @@ class _Registry:
 
         self.activities[name] = fn
 
-    def get_activity(self, name: str) -> Union[task.Activity, None]:
+    def get_activity(self, name: str) -> Optional[task.Activity]:
         return self.activities.get(name)
 
 
@@ -81,20 +82,19 @@ class ActivityNotRegisteredError(ValueError):
 
 
 class TaskHubGrpcWorker:
-    _response_stream: Union[grpc.Future, None]
+    _response_stream: Optional[grpc.Future] = None
 
     def __init__(self, *,
-                 host_address: Union[str, None] = None,
-                 metadata: Union[List[Tuple[str, str]], None] = None,
-                 log_handler = None,
-                 log_formatter: Union[logging.Formatter, None] = None,
+                 host_address: Optional[str] = None,
+                 metadata: Optional[List[Tuple[str, str]]] = None,
+                 log_handler=None,
+                 log_formatter: Optional[logging.Formatter] = None,
                  secure_channel: bool = False):
         self._registry = _Registry()
         self._host_address = host_address if host_address else shared.get_default_host_address()
         self._metadata = metadata
         self._logger = shared.get_logger("worker", log_handler, log_formatter)
         self._shutdown = Event()
-        self._response_stream = None
         self._is_running = False
         self._secure_channel = secure_channel
 
@@ -224,8 +224,8 @@ class TaskHubGrpcWorker:
 
 
 class _RuntimeOrchestrationContext(task.OrchestrationContext):
-    _generator: Union[Generator[task.Task, Any, Any], None]
-    _previous_task: Union[task.Task, None]
+    _generator: Optional[Generator[task.Task, Any, Any]]
+    _previous_task: Optional[task.Task]
 
     def __init__(self, instance_id: str):
         self._generator = None
@@ -237,10 +237,10 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._sequence_number = 0
         self._current_utc_datetime = datetime(1000, 1, 1)
         self._instance_id = instance_id
-        self._completion_status: Union[pb.OrchestrationStatus, None] = None
+        self._completion_status: Optional[pb.OrchestrationStatus] = None
         self._received_events: Dict[str, List[Any]] = {}
         self._pending_events: Dict[str, List[task.CompletableTask]] = {}
-        self._new_input: Union[Any, None] = None
+        self._new_input: Optional[Any] = None
         self._save_events = False
 
     def run(self, generator: Generator[task.Task, Any, Any]):
@@ -259,22 +259,20 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         # has reached a completed state. The only time this won't be the
         # case is if the user yielded on a WhenAll task and there are still
         # outstanding child tasks that need to be completed.
-        if self._previous_task is not None:
+        while self._previous_task is not None and self._previous_task.is_complete:
+            next_task = None
             if self._previous_task.is_failed:
-                # Raise the failure as an exception to the generator. The orchestrator can then either
-                # handle the exception or allow it to fail the orchestration.
-                self._generator.throw(self._previous_task.get_exception())
-            elif self._previous_task.is_complete:
-                while True:
-                    # Resume the generator. This will either return a Task or raise StopIteration if it's done.
-                    # CONSIDER: Should we check for possible infinite loops here?
-                    next_task = self._generator.send(self._previous_task.get_result())
-                    if not isinstance(next_task, task.Task):
-                        raise TypeError("The orchestrator generator yielded a non-Task object")
-                    self._previous_task = next_task
-                    # If a completed task was returned, then we can keep running the generator function.
-                    if not self._previous_task.is_complete:
-                        break
+                # Raise the failure as an exception to the generator.
+                # The orchestrator can then either handle the exception or allow it to fail the orchestration.
+                next_task = self._generator.throw(self._previous_task.get_exception())
+            else:
+                # Resume the generator with the previous result.
+                # This will either return a Task or raise StopIteration if it's done.
+                next_task = self._generator.send(self._previous_task.get_result())
+
+            if not isinstance(next_task, task.Task):
+                raise TypeError("The orchestrator generator yielded a non-Task object")
+            self._previous_task = next_task
 
     def set_complete(self, result: Any, status: pb.OrchestrationStatus, is_result_encoded: bool = False):
         if self._is_complete:
@@ -285,7 +283,7 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._pending_actions.clear()  # Cancel any pending actions
 
         self._result = result
-        result_json: Union[str, None] = None
+        result_json: Optional[str] = None
         if result is not None:
             result_json = result if is_result_encoded else shared.to_json(result)
         action = ph.new_complete_orchestration_action(
@@ -318,7 +316,7 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
     def get_actions(self) -> List[pb.OrchestratorAction]:
         if self._completion_status == pb.ORCHESTRATION_STATUS_CONTINUED_AS_NEW:
             # When continuing-as-new, we only return a single completion action.
-            carryover_events: Union[List[pb.HistoryEvent], None] = None
+            carryover_events: Optional[List[pb.HistoryEvent]] = None
             if self._save_events:
                 carryover_events = []
                 # We need to save the current set of pending events so that they can be
@@ -358,43 +356,77 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._current_utc_datetime = value
 
     def create_timer(self, fire_at: Union[datetime, timedelta]) -> task.Task:
+        return self.create_timer_internal(fire_at)
+
+    def create_timer_internal(self, fire_at: Union[datetime, timedelta],
+                              retryable_task: Optional[task.RetryableTask] = None) -> task.Task:
         id = self.next_sequence_number()
         if isinstance(fire_at, timedelta):
             fire_at = self.current_utc_datetime + fire_at
         action = ph.new_create_timer_action(id, fire_at)
         self._pending_actions[id] = action
 
-        timer_task = task.CompletableTask()
+        timer_task = task.TimerTask()
+        if retryable_task is not None:
+            timer_task.set_retryable_parent(retryable_task)
         self._pending_tasks[id] = timer_task
         return timer_task
 
     def call_activity(self, activity: Union[task.Activity[TInput, TOutput], str], *,
-                      input: Union[TInput, None] = None) -> task.Task[TOutput]:
+                      input: Optional[TInput] = None,
+                      retry_policy: Optional[task.RetryPolicy] = None) -> task.Task[TOutput]:
         id = self.next_sequence_number()
-        name = activity if isinstance(activity, str) else task.get_name(activity)
-        encoded_input = shared.to_json(input) if input is not None else None
-        action = ph.new_schedule_task_action(id, name, encoded_input)
-        self._pending_actions[id] = action
 
-        activity_task = task.CompletableTask[TOutput]()
-        self._pending_tasks[id] = activity_task
-        return activity_task
+        self.call_activity_function_helper(id, activity, input=input, retry_policy=retry_policy,
+                                           is_sub_orch=False)
+        return self._pending_tasks.get(id, task.CompletableTask())
 
     def call_sub_orchestrator(self, orchestrator: task.Orchestrator[TInput, TOutput], *,
-                              input: Union[TInput, None] = None,
-                              instance_id: Union[str, None] = None) -> task.Task[TOutput]:
+                              input: Optional[TInput] = None,
+                              instance_id: Optional[str] = None,
+                              retry_policy: Optional[task.RetryPolicy] = None) -> task.Task[TOutput]:
         id = self.next_sequence_number()
-        name = task.get_name(orchestrator)
-        if instance_id is None:
-            # Create a deteministic instance ID based on the parent instance ID
-            instance_id = f"{self.instance_id}:{id:04x}"
-        encoded_input = shared.to_json(input) if input is not None else None
-        action = ph.new_create_sub_orchestration_action(id, name, instance_id, encoded_input)
+        orchestrator_name = task.get_name(orchestrator)
+        self.call_activity_function_helper(id, orchestrator_name, input=input, retry_policy=retry_policy,
+                                           is_sub_orch=True, instance_id=instance_id)
+        return self._pending_tasks.get(id, task.CompletableTask())
+
+    def call_activity_function_helper(self, id: Optional[int],
+                                      activity_function: Union[task.Activity[TInput, TOutput], str], *,
+                                      input: Optional[TInput] = None,
+                                      retry_policy: Optional[task.RetryPolicy] = None,
+                                      is_sub_orch: bool = False,
+                                      instance_id: Optional[str] = None,
+                                      fn_task: Optional[task.CompletableTask[TOutput]] = None):
+        if id is None:
+            id = self.next_sequence_number()
+
+        if fn_task is None:
+            encoded_input = shared.to_json(input) if input is not None else None
+        else:
+            # Here, we don't need to convert the input to JSON because it is already converted.
+            # We just need to take string representation of it.
+            encoded_input = str(input)
+        if not is_sub_orch:
+            name = activity_function if isinstance(activity_function, str) else task.get_name(activity_function)
+            action = ph.new_schedule_task_action(id, name, encoded_input)
+        else:
+            if instance_id is None:
+                # Create a deteministic instance ID based on the parent instance ID
+                instance_id = f"{self.instance_id}:{id:04x}"
+            if not isinstance(activity_function, str):
+                raise ValueError("Orchestrator function name must be a string")
+            action = ph.new_create_sub_orchestration_action(id, activity_function, instance_id, encoded_input)
         self._pending_actions[id] = action
 
-        sub_orch_task = task.CompletableTask[TOutput]()
-        self._pending_tasks[id] = sub_orch_task
-        return sub_orch_task
+        if fn_task is None:
+            if retry_policy is None:
+                fn_task = task.CompletableTask[TOutput]()
+            else:
+                fn_task = task.RetryableTask[TOutput](retry_policy=retry_policy, action=action,
+                                                      start_time=self.current_utc_datetime,
+                                                      is_sub_orch=is_sub_orch)
+        self._pending_tasks[id] = fn_task
 
     def wait_for_external_event(self, name: str) -> task.Task:
         # Check to see if this event has already been received, in which case we
@@ -426,12 +458,11 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
 
 
 class _OrchestrationExecutor:
-    _generator: Union[task.Orchestrator, None]
+    _generator: Optional[task.Orchestrator] = None
 
     def __init__(self, registry: _Registry, logger: logging.Logger):
         self._registry = registry
         self._logger = logger
-        self._generator = None
         self._is_suspended = False
         self._suspended_events: List[pb.HistoryEvent] = []
 
@@ -462,7 +493,7 @@ class _OrchestrationExecutor:
         if not ctx._is_complete:
             task_count = len(ctx._pending_tasks)
             event_count = len(ctx._pending_events)
-            self._logger.info(f"{instance_id}: Waiting for {task_count} task(s) and {event_count} event(s).")
+            self._logger.info(f"{instance_id}: Orchestrator yielded with {task_count} task(s) and {event_count} event(s) outstanding.")
         elif ctx._completion_status and ctx._completion_status is not pb.ORCHESTRATION_STATUS_CONTINUED_AS_NEW:
             completion_status_str = pbh.get_orchestration_status_str(ctx._completion_status)
             self._logger.info(f"{instance_id}: Orchestration completed with status: {completion_status_str}")
@@ -521,12 +552,29 @@ class _OrchestrationExecutor:
                             f"{ctx.instance_id}: Ignoring unexpected timerFired event with ID = {timer_id}.")
                     return
                 timer_task.complete(None)
-                ctx.resume()
+                if timer_task._retryable_parent is not None:
+                    activity_action = timer_task._retryable_parent._action
+
+                    if not timer_task._retryable_parent._is_sub_orch:
+                        cur_task = activity_action.scheduleTask
+                        instance_id = None
+                    else:
+                        cur_task = activity_action.createSubOrchestration
+                        instance_id = cur_task.instanceId
+                    ctx.call_activity_function_helper(id=activity_action.id, activity_function=cur_task.name,
+                                                      input=cur_task.input.value,
+                                                      retry_policy=timer_task._retryable_parent._retry_policy,
+                                                      is_sub_orch=timer_task._retryable_parent._is_sub_orch,
+                                                      instance_id=instance_id,
+                                                      fn_task=timer_task._retryable_parent)
+                else:
+                    ctx.resume()
             elif event.HasField("taskScheduled"):
                 # This history event confirms that the activity execution was successfully scheduled.
                 # Remove the taskScheduled event from the pending action list so we don't schedule it again.
                 task_id = event.eventId
                 action = ctx._pending_actions.pop(task_id, None)
+                activity_task = ctx._pending_tasks.get(task_id, None)
                 if not action:
                     raise _get_non_determinism_error(task_id, task.get_name(ctx.call_activity))
                 elif not action.HasField("scheduleTask"):
@@ -562,10 +610,25 @@ class _OrchestrationExecutor:
                         self._logger.warning(
                             f"{ctx.instance_id}: Ignoring unexpected taskFailed event with ID = {task_id}.")
                     return
-                activity_task.fail(
-                    f"{ctx.instance_id}: Activity task #{task_id} failed: {event.taskFailed.failureDetails.errorMessage}",
-                    event.taskFailed.failureDetails)
-                ctx.resume()
+
+                if isinstance(activity_task, task.RetryableTask):
+                    if activity_task._retry_policy is not None:
+                        next_delay = activity_task.compute_next_delay()
+                        if next_delay is None:
+                            activity_task.fail(
+                                f"{ctx.instance_id}: Activity task #{task_id} failed: {event.taskFailed.failureDetails.errorMessage}",
+                                event.taskFailed.failureDetails)
+                            ctx.resume()
+                        else:
+                            activity_task.increment_attempt_count()
+                            ctx.create_timer_internal(next_delay, activity_task)
+                elif isinstance(activity_task, task.CompletableTask):
+                    activity_task.fail(
+                        f"{ctx.instance_id}: Activity task #{task_id} failed: {event.taskFailed.failureDetails.errorMessage}",
+                        event.taskFailed.failureDetails)
+                    ctx.resume()
+                else:
+                    raise TypeError("Unexpected task type")
             elif event.HasField("subOrchestrationInstanceCreated"):
                 # This history event confirms that the sub-orchestration execution was successfully scheduled.
                 # Remove the subOrchestrationInstanceCreated event from the pending action list so we don't schedule it again.
@@ -606,17 +669,31 @@ class _OrchestrationExecutor:
                         self._logger.warning(
                             f"{ctx.instance_id}: Ignoring unexpected subOrchestrationInstanceFailed event with ID = {task_id}.")
                     return
-                sub_orch_task.fail(
-                    f"Sub-orchestration task #{task_id} failed: {failedEvent.failureDetails.errorMessage}",
-                    failedEvent.failureDetails)
-                ctx.resume()
+                if isinstance(sub_orch_task, task.RetryableTask):
+                    if sub_orch_task._retry_policy is not None:
+                        next_delay = sub_orch_task.compute_next_delay()
+                        if next_delay is None:
+                            sub_orch_task.fail(
+                                f"Sub-orchestration task #{task_id} failed: {failedEvent.failureDetails.errorMessage}",
+                                failedEvent.failureDetails)
+                            ctx.resume()
+                        else:
+                            sub_orch_task.increment_attempt_count()
+                            ctx.create_timer_internal(next_delay, sub_orch_task)
+                elif isinstance(sub_orch_task, task.CompletableTask):
+                    sub_orch_task.fail(
+                        f"Sub-orchestration task #{task_id} failed: {failedEvent.failureDetails.errorMessage}",
+                        failedEvent.failureDetails)
+                    ctx.resume()
+                else:
+                    raise TypeError("Unexpected sub-orchestration task type")
             elif event.HasField("eventRaised"):
                 # event names are case-insensitive
                 event_name = event.eventRaised.name.casefold()
                 if not ctx.is_replaying:
                     self._logger.info(f"{ctx.instance_id} Event raised: {event_name}")
                 task_list = ctx._pending_events.get(event_name, None)
-                decoded_result: Union[Any, None] = None
+                decoded_result: Optional[Any] = None
                 if task_list:
                     event_task = task_list.pop(0)
                     if not ph.is_empty(event.eventRaised.input):
@@ -665,7 +742,7 @@ class _ActivityExecutor:
         self._registry = registry
         self._logger = logger
 
-    def execute(self, orchestration_id: str, name: str, task_id: int, encoded_input: Union[str, None]) -> Union[str, None]:
+    def execute(self, orchestration_id: str, name: str, task_id: int, encoded_input: Optional[str]) -> Optional[str]:
         """Executes an activity function and returns the serialized result, if any."""
         self._logger.debug(f"{orchestration_id}/{task_id}: Executing activity '{name}'...")
         fn = self._registry.get_activity(name)

{durabletask-0.1.0a5.dist-info → durabletask-0.1.1a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: durabletask
-Version: 0.1.0a5
+Version: 0.1.1a1
 Summary: A Durable Task Client SDK for Python
 License: MIT License
         
@@ -207,7 +207,7 @@ git submodule update --init
 Once the submodule is available, the corresponding source code can be regenerated using the following command from the project root:
 
 ```sh
-make proto-gen
+make gen-proto
 ```
 
 ### Running unit tests

durabletask-0.1.1a1.dist-info/RECORD

@@ -0,0 +1,16 @@
+durabletask/__init__.py,sha256=4gNZ89cYaJTCvWQ1wWu3-BwRD98fWWt9k7hgHSETXU4,139
+durabletask/client.py,sha256=UmQv4fYjHmJRju6teJ-7HM0tVjd_Ugty044Dg2s19tI,8872
+durabletask/task.py,sha256=zwnlLLNCeFJmFT7wvpK0MEx-tMxu1_JCYq_OhXYW0S0,17471
+durabletask/worker.py,sha256=FoqWcgP35lzqbbOuQ1pdJ3jMNtvtd7HO-s22OOcRHyA,42926
+durabletask/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+durabletask/internal/grpc_interceptor.py,sha256=bixPtGQ5KPN2CWAzrfR8z9drwEdM_ZaTZ-tn97DC3LU,2878
+durabletask/internal/helpers.py,sha256=m9lnmQcx5zx3s0DC_Lddugr__O_dgWgHAAAByOmvL_c,7340
+durabletask/internal/orchestrator_service_pb2.py,sha256=N4R75_gT7P05fUsPgLpL130wjws49-SI0w6_BaleWOI,29754
+durabletask/internal/orchestrator_service_pb2.pyi,sha256=HRtK9PTpLudEoFPD08-oWom26quwWMkjpkmjIiWC-bQ,46324
+durabletask/internal/orchestrator_service_pb2_grpc.py,sha256=r0UbaHS2EacF3SdiY5QoWEZgp21XPcSje0lFEG23HcI,37544
+durabletask/internal/shared.py,sha256=1IU_sTwrntyJqMUB63yOtjQd0IqKARiTR_0L-AiM-N8,3645
+durabletask-0.1.1a1.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+durabletask-0.1.1a1.dist-info/METADATA,sha256=t9YiZ6gJHW3I36X99Zx6iWRuNhDPYrHoT-VxVx1FxqQ,12930
+durabletask-0.1.1a1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+durabletask-0.1.1a1.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
+durabletask-0.1.1a1.dist-info/RECORD,,