durabletask 0.1.0a5__py3-none-any.whl → 0.2b1__py3-none-any.whl

durabletask/worker.py

@@ -6,7 +6,7 @@ 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, Generator, Optional, Sequence, TypeVar, Union
 
 import grpc
 from google.protobuf import empty_pb2
@@ -17,6 +17,7 @@ import durabletask.internal.orchestrator_service_pb2 as pb
 import durabletask.internal.orchestrator_service_pb2_grpc as stubs
 import durabletask.internal.shared as shared
 from durabletask import task
+from durabletask.internal.grpc_interceptor import DefaultClientInterceptorImpl
 
 TInput = TypeVar('TInput')
 TOutput = TypeVar('TOutput')
@@ -24,8 +25,8 @@ TOutput = TypeVar('TOutput')
 
 class _Registry:
 
-    orchestrators: Dict[str, task.Orchestrator]
-    activities: Dict[str, task.Activity]
+    orchestrators: dict[str, task.Orchestrator]
+    activities: dict[str, task.Activity]
 
     def __init__(self):
         self.orchestrators = {}
@@ -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,23 +82,33 @@ class ActivityNotRegisteredError(ValueError):
 
 
 class TaskHubGrpcWorker:
-    _response_stream: Union[grpc.Future, None]
+    _response_stream: Optional[grpc.Future] = None
+    _interceptors: Optional[list[shared.ClientInterceptor]] = 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,
-                 secure_channel: bool = False):
+                 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,
+                 interceptors: Optional[Sequence[shared.ClientInterceptor]] = None):
         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
 
+        # Determine the interceptors to use
+        if interceptors is not None:
+            self._interceptors = list(interceptors)
+            if metadata:
+                self._interceptors.append(DefaultClientInterceptorImpl(metadata))
+        elif metadata:
+            self._interceptors = [DefaultClientInterceptorImpl(metadata)]
+        else:
+            self._interceptors = None
+
     def __enter__(self):
         return self
 
@@ -118,7 +129,7 @@ class TaskHubGrpcWorker:
 
     def start(self):
         """Starts the worker on a background thread and begins listening for work items."""
-        channel = shared.get_grpc_channel(self._host_address, self._metadata, self._secure_channel)
+        channel = shared.get_grpc_channel(self._host_address, self._secure_channel, self._interceptors)
         stub = stubs.TaskHubSidecarServiceStub(channel)
 
         if self._is_running:
@@ -140,13 +151,15 @@ class TaskHubGrpcWorker:
 
                         # The stream blocks until either a work item is received or the stream is canceled
                         # by another thread (see the stop() method).
-                        for work_item in self._response_stream:
+                        for work_item in self._response_stream:  # type: ignore
                             request_type = work_item.WhichOneof('request')
                             self._logger.debug(f'Received "{request_type}" work item')
                             if work_item.HasField('orchestratorRequest'):
-                                executor.submit(self._execute_orchestrator, work_item.orchestratorRequest, stub)
+                                executor.submit(self._execute_orchestrator, work_item.orchestratorRequest, stub, work_item.completionToken)
                             elif work_item.HasField('activityRequest'):
-                                executor.submit(self._execute_activity, work_item.activityRequest, stub)
+                                executor.submit(self._execute_activity, work_item.activityRequest, stub, work_item.completionToken)
+                            elif work_item.HasField('healthPing'):
+                                pass  # no-op
                             else:
                                 self._logger.warning(f'Unexpected work item type: {request_type}')
 
@@ -185,23 +198,27 @@ class TaskHubGrpcWorker:
         self._logger.info("Worker shutdown completed")
         self._is_running = False
 
-    def _execute_orchestrator(self, req: pb.OrchestratorRequest, stub: stubs.TaskHubSidecarServiceStub):
+    def _execute_orchestrator(self, req: pb.OrchestratorRequest, stub: stubs.TaskHubSidecarServiceStub, completionToken):
         try:
             executor = _OrchestrationExecutor(self._registry, self._logger)
-            actions = executor.execute(req.instanceId, req.pastEvents, req.newEvents)
-            res = pb.OrchestratorResponse(instanceId=req.instanceId, actions=actions)
+            result = executor.execute(req.instanceId, req.pastEvents, req.newEvents)
+            res = pb.OrchestratorResponse(
+                instanceId=req.instanceId,
+                actions=result.actions,
+                customStatus=pbh.get_string_value(result.encoded_custom_status),
+                completionToken=completionToken)
         except Exception as ex:
             self._logger.exception(f"An error occurred while trying to execute instance '{req.instanceId}': {ex}")
             failure_details = pbh.new_failure_details(ex)
             actions = [pbh.new_complete_orchestration_action(-1, pb.ORCHESTRATION_STATUS_FAILED, "", failure_details)]
-            res = pb.OrchestratorResponse(instanceId=req.instanceId, actions=actions)
+            res = pb.OrchestratorResponse(instanceId=req.instanceId, actions=actions, completionToken=completionToken)
 
         try:
             stub.CompleteOrchestratorTask(res)
         except Exception as ex:
             self._logger.exception(f"Failed to deliver orchestrator response for '{req.instanceId}' to sidecar: {ex}")
 
-    def _execute_activity(self, req: pb.ActivityRequest, stub: stubs.TaskHubSidecarServiceStub):
+    def _execute_activity(self, req: pb.ActivityRequest, stub: stubs.TaskHubSidecarServiceStub, completionToken):
         instance_id = req.orchestrationInstance.instanceId
         try:
             executor = _ActivityExecutor(self._registry, self._logger)
@@ -209,12 +226,14 @@ class TaskHubGrpcWorker:
             res = pb.ActivityResponse(
                 instanceId=instance_id,
                 taskId=req.taskId,
-                result=pbh.get_string_value(result))
+                result=pbh.get_string_value(result),
+                completionToken=completionToken)
         except Exception as ex:
             res = pb.ActivityResponse(
                 instanceId=instance_id,
                 taskId=req.taskId,
-                failureDetails=pbh.new_failure_details(ex))
+                failureDetails=pbh.new_failure_details(ex),
+                completionToken=completionToken)
 
         try:
             stub.CompleteActivityTask(res)
@@ -224,24 +243,25 @@ 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
         self._is_replaying = True
         self._is_complete = False
         self._result = None
-        self._pending_actions: Dict[int, pb.OrchestratorAction] = {}
-        self._pending_tasks: Dict[int, task.CompletableTask] = {}
+        self._pending_actions: dict[int, pb.OrchestratorAction] = {}
+        self._pending_tasks: dict[int, task.CompletableTask] = {}
         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._received_events: Dict[str, List[Any]] = {}
-        self._pending_events: Dict[str, List[task.CompletableTask]] = {}
-        self._new_input: Union[Any, 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: Optional[Any] = None
         self._save_events = False
+        self._encoded_custom_status: Optional[str] = None
 
     def run(self, generator: Generator[task.Task, Any, Any]):
         self._generator = generator
@@ -259,22 +279,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 +303,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(
@@ -315,10 +333,10 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._new_input = new_input
         self._save_events = save_events
 
-    def get_actions(self) -> List[pb.OrchestratorAction]:
+    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
@@ -357,44 +375,81 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
     def current_utc_datetime(self, value: datetime):
         self._current_utc_datetime = value
 
+    def set_custom_status(self, custom_status: Any) -> None:
+        self._encoded_custom_status = shared.to_json(custom_status) if custom_status is not None else None
+
     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
@@ -425,17 +480,25 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self.set_continued_as_new(new_input, save_events)
 
 
+class ExecutionResults:
+    actions: list[pb.OrchestratorAction]
+    encoded_custom_status: Optional[str]
+
+    def __init__(self, actions: list[pb.OrchestratorAction], encoded_custom_status: Optional[str]):
+        self.actions = actions
+        self.encoded_custom_status = encoded_custom_status
+
+
 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] = []
+        self._suspended_events: list[pb.HistoryEvent] = []
 
-    def execute(self, instance_id: str, old_events: Sequence[pb.HistoryEvent], new_events: Sequence[pb.HistoryEvent]) -> List[pb.OrchestratorAction]:
+    def execute(self, instance_id: str, old_events: Sequence[pb.HistoryEvent], new_events: Sequence[pb.HistoryEvent]) -> ExecutionResults:
         if not new_events:
             raise task.OrchestrationStateError("The new history event list must have at least one event in it.")
 
@@ -462,7 +525,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}")
@@ -470,7 +533,7 @@ class _OrchestrationExecutor:
         actions = ctx.get_actions()
         if self._logger.level <= logging.DEBUG:
             self._logger.debug(f"{instance_id}: Returning {len(actions)} action(s): {_get_action_summary(actions)}")
-        return actions
+        return ExecutionResults(actions=actions, encoded_custom_status=ctx._encoded_custom_status)
 
     def process_event(self, ctx: _RuntimeOrchestrationContext, event: pb.HistoryEvent) -> None:
         if self._is_suspended and _is_suspendable(event):
@@ -521,12 +584,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 +642,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 +701,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 +774,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)
@@ -740,7 +849,7 @@ def _get_new_event_summary(new_events: Sequence[pb.HistoryEvent]) -> str:
     elif len(new_events) == 1:
         return f"[{new_events[0].WhichOneof('eventType')}]"
     else:
-        counts: Dict[str, int] = {}
+        counts: dict[str, int] = {}
         for event in new_events:
             event_type = event.WhichOneof('eventType')
             counts[event_type] = counts.get(event_type, 0) + 1
@@ -754,7 +863,7 @@ def _get_action_summary(new_actions: Sequence[pb.OrchestratorAction]) -> str:
     elif len(new_actions) == 1:
         return f"[{new_actions[0].WhichOneof('orchestratorActionType')}]"
     else:
-        counts: Dict[str, int] = {}
+        counts: dict[str, int] = {}
         for action in new_actions:
             action_type = action.WhichOneof('orchestratorActionType')
             counts[action_type] = counts.get(action_type, 0) + 1

{durabletask-0.1.0a5.dist-info → durabletask-0.2.0b1.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: durabletask
-Version: 0.1.0a5
+Version: 0.2.0b1
 Summary: A Durable Task Client SDK for Python
-License: MIT License
+License:     MIT License
         
             Copyright (c) Microsoft Corporation.
         
@@ -30,23 +30,21 @@ Keywords: durable,task,workflow
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: grpcio
 
-# Durable Task Client SDK for Python
+# Durable Task SDK for Python
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Build Validation](https://github.com/microsoft/durabletask-python/actions/workflows/pr-validation.yml/badge.svg)](https://github.com/microsoft/durabletask-python/actions/workflows/pr-validation.yml)
 [![PyPI version](https://badge.fury.io/py/durabletask.svg)](https://badge.fury.io/py/durabletask)
 
-This repo contains a Python client SDK for use with the [Durable Task Framework for Go](https://github.com/microsoft/durabletask-go) and [Dapr Workflow](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/). With this SDK, you can define, schedule, and manage durable orchestrations using ordinary Python code.
+This repo contains a Python SDK for use with the [Azure Durable Task Scheduler](https://techcommunity.microsoft.com/blog/appsonazureblog/announcing-limited-early-access-of-the-durable-task-scheduler-for-azure-durable-/4286526) and the [Durable Task Framework for Go](https://github.com/microsoft/durabletask-go). With this SDK, you can define, schedule, and manage durable orchestrations using ordinary Python code.
 
 ⚠️ **This SDK is currently under active development and is not yet ready for production use.** ⚠️
 
-> Note that this project is **not** currently affiliated with the [Durable Functions](https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview) project for Azure Functions. If you are looking for a Python SDK for Durable Functions, please see [this repo](https://github.com/Azure/azure-functions-durable-python).
-
+> Note that this SDK is **not** currently compatible with [Azure Durable Functions](https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview). If you are looking for a Python SDK for Azure Durable Functions, please see [this repo](https://github.com/Azure/azure-functions-durable-python).
 
 ## Supported patterns
 
@@ -171,7 +169,7 @@ Orchestrations can specify retry policies for activities and sub-orchestrations.
 
 ### Prerequisites
 
-- Python 3.8
+- Python 3.9
 - A Durable Task-compatible sidecar, like [Dapr Workflow](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/)
 
 ### Installing the Durable Task Python client SDK
@@ -198,17 +196,12 @@ The following is more information about how to develop this project. Note that d
 
 ### Generating protobufs
 
-Protobuf definitions are stored in the [./submodules/durabletask-proto](./submodules/durabletask-proto) directory, which is a submodule. To update the submodule, run the following command from the project root:
-
 ```sh
-git submodule update --init
+pip3 install -r dev-requirements.txt
+make gen-proto
 ```
 
-Once the submodule is available, the corresponding source code can be regenerated using the following command from the project root:
-
-```sh
-make proto-gen
-```
+This will download the `orchestrator_service.proto` from the `microsoft/durabletask-protobuf` repo and compile it using `grpcio-tools`. The version of the source proto file that was downloaded can be found in the file `durabletask/internal/PROTO_SOURCE_COMMIT_HASH`.
 
 ### Running unit tests
 

durabletask-0.2.0b1.dist-info/RECORD

@@ -0,0 +1,14 @@
+durabletask/__init__.py,sha256=4gNZ89cYaJTCvWQ1wWu3-BwRD98fWWt9k7hgHSETXU4,139
+durabletask/client.py,sha256=vAm7BtVHeeWFVoiwvOGcrhrkand43oBCCVNnzbNfH6I,10011
+durabletask/task.py,sha256=Brxt-cFqFaIjU07UFLCQoRv7ioycOLcJQbRh9Je_UW4,17722
+durabletask/worker.py,sha256=YPW0XIp0z7UPh9afFaygcS3uR4jgD4FcI2KCXPp0_6M,44583
+durabletask/internal/grpc_interceptor.py,sha256=KGl8GGIbNdiEnWVLwQwkOemWvIlcEO0dh-_Tg20h5XA,2834
+durabletask/internal/helpers.py,sha256=G4nEhLnRUE1VbFHkOMX277_6LSsMH9lTh9sXUD0GdHM,7289
+durabletask/internal/orchestrator_service_pb2.py,sha256=nkADgSglhimtNjAuISJdBz1bwA8xYm1cEQdL9ZifsmU,33993
+durabletask/internal/orchestrator_service_pb2.pyi,sha256=99AIPzz4AdXrkQrN2MHkHkW9zKqmH4puSwvg9ze5IjA,50517
+durabletask/internal/orchestrator_service_pb2_grpc.py,sha256=mZXK0QtvaRr6cjm8gi9y-DjMNR2Xg2Adu79WsR22pQc,41146
+durabletask/internal/shared.py,sha256=dKRGU8z1EQM4_YA6zkKeKfiaWbiZ6-B8lP-wHy7Q_jI,4379
+durabletask-0.2.0b1.dist-info/METADATA,sha256=Mh020ccP2tO01EibjaX_Y3jg4wUAAvqBUpnPqqC41Ek,12869
+durabletask-0.2.0b1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+durabletask-0.2.0b1.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
+durabletask-0.2.0b1.dist-info/RECORD,,

{durabletask-0.1.0a5.dist-info → durabletask-0.2.0b1.dist-info}/WHEEL

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

durabletask-0.1.0a5.dist-info/LICENSE

@@ -1,21 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE