durabletask 1.4.0__tar.gz → 1.4.0.dev31__tar.gz

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.4.0
+Version: 1.4.0.dev31
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/durabletask/client.py

@@ -6,14 +6,16 @@ import uuid
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Any, List, Optional, Sequence, TypeVar, Union
+from typing import Any, Generic, List, Optional, Sequence, TypeVar, Union
 
 import grpc
 import grpc.aio
 
+import durabletask.history as history
 from durabletask.entities import EntityInstanceId
 from durabletask.entities.entity_metadata import EntityMetadata
 import durabletask.internal.helpers as helpers
+import durabletask.internal.history_helpers as history_helpers
 import durabletask.internal.orchestrator_service_pb2 as pb
 import durabletask.internal.orchestrator_service_pb2_grpc as stubs
 import durabletask.internal.shared as shared
@@ -37,6 +39,7 @@ from durabletask.payload.store import PayloadStore
 
 TInput = TypeVar('TInput')
 TOutput = TypeVar('TOutput')
+TItem = TypeVar('TItem')
 
 
 class OrchestrationStatus(Enum):
@@ -99,6 +102,12 @@ class PurgeInstancesResult:
     is_complete: bool
 
 
+@dataclass
+class Page(Generic[TItem]):
+    items: List[TItem]
+    continuation_token: Optional[str]
+
+
 @dataclass
 class CleanEntityStorageResult:
     empty_entities_removed: int
@@ -218,6 +227,44 @@ class TaskHubGrpcClient:
             payload_helpers.deexternalize_payloads(res, self._payload_store)
         return new_orchestration_state(req.instanceId, res)
 
+    def get_orchestration_history(self,
+                                  instance_id: str, *,
+                                  execution_id: Optional[str] = None,
+                                  for_work_item_processing: bool = False) -> List[history.HistoryEvent]:
+        req = pb.StreamInstanceHistoryRequest(
+            instanceId=instance_id,
+            executionId=helpers.get_string_value(execution_id),
+            forWorkItemProcessing=for_work_item_processing,
+        )
+        self._logger.info(f"Retrieving history for instance '{instance_id}'.")
+        stream = self._stub.StreamInstanceHistory(req)
+        return history_helpers.collect_history_events(stream, self._payload_store)
+
+    def list_instance_ids(self,
+                          runtime_status: Optional[List[OrchestrationStatus]] = None,
+                          completed_time_from: Optional[datetime] = None,
+                          completed_time_to: Optional[datetime] = None,
+                          page_size: Optional[int] = None,
+                          continuation_token: Optional[str] = None) -> Page[str]:
+        req = pb.ListInstanceIdsRequest(
+            runtimeStatus=[status.value for status in runtime_status] if runtime_status else [],
+            completedTimeFrom=helpers.new_timestamp(completed_time_from) if completed_time_from else None,
+            completedTimeTo=helpers.new_timestamp(completed_time_to) if completed_time_to else None,
+            pageSize=page_size or 0,
+            lastInstanceKey=helpers.get_string_value(continuation_token),
+        )
+        self._logger.info(
+            "Listing terminal instance IDs with filters: "
+            f"runtime_status={[str(status) for status in runtime_status] if runtime_status else None}, "
+            f"completed_time_from={completed_time_from}, "
+            f"completed_time_to={completed_time_to}, "
+            f"page_size={page_size}, "
+            f"continuation_token={continuation_token}"
+        )
+        resp: pb.ListInstanceIdsResponse = self._stub.ListInstanceIds(req)
+        next_token = resp.lastInstanceKey.value if resp.HasField("lastInstanceKey") else None
+        return Page(items=list(resp.instanceIds), continuation_token=next_token)
+
     def get_all_orchestration_states(self,
                                      orchestration_query: Optional[OrchestrationQuery] = None
                                      ) -> List[OrchestrationState]:
@@ -502,6 +549,44 @@ class AsyncTaskHubGrpcClient:
             await payload_helpers.deexternalize_payloads_async(res, self._payload_store)
         return new_orchestration_state(req.instanceId, res)
 
+    async def get_orchestration_history(self,
+                                        instance_id: str, *,
+                                        execution_id: Optional[str] = None,
+                                        for_work_item_processing: bool = False) -> List[history.HistoryEvent]:
+        req = pb.StreamInstanceHistoryRequest(
+            instanceId=instance_id,
+            executionId=helpers.get_string_value(execution_id),
+            forWorkItemProcessing=for_work_item_processing,
+        )
+        self._logger.info(f"Retrieving history for instance '{instance_id}'.")
+        stream = self._stub.StreamInstanceHistory(req)
+        return await history_helpers.collect_history_events_async(stream, self._payload_store)
+
+    async def list_instance_ids(self,
+                                runtime_status: Optional[List[OrchestrationStatus]] = None,
+                                completed_time_from: Optional[datetime] = None,
+                                completed_time_to: Optional[datetime] = None,
+                                page_size: Optional[int] = None,
+                                continuation_token: Optional[str] = None) -> Page[str]:
+        req = pb.ListInstanceIdsRequest(
+            runtimeStatus=[status.value for status in runtime_status] if runtime_status else [],
+            completedTimeFrom=helpers.new_timestamp(completed_time_from) if completed_time_from else None,
+            completedTimeTo=helpers.new_timestamp(completed_time_to) if completed_time_to else None,
+            pageSize=page_size or 0,
+            lastInstanceKey=helpers.get_string_value(continuation_token),
+        )
+        self._logger.info(
+            "Listing terminal instance IDs with filters: "
+            f"runtime_status={[str(status) for status in runtime_status] if runtime_status else None}, "
+            f"completed_time_from={completed_time_from}, "
+            f"completed_time_to={completed_time_to}, "
+            f"page_size={page_size}, "
+            f"continuation_token={continuation_token}"
+        )
+        resp: pb.ListInstanceIdsResponse = await self._stub.ListInstanceIds(req)
+        next_token = resp.lastInstanceKey.value if resp.HasField("lastInstanceKey") else None
+        return Page(items=list(resp.instanceIds), continuation_token=next_token)
+
     async def get_all_orchestration_states(self,
                                            orchestration_query: Optional[OrchestrationQuery] = None
                                            ) -> List[OrchestrationState]:

durabletask-1.4.0.dev31/durabletask/history.py

@@ -0,0 +1,535 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from google.protobuf import json_format
+from google.protobuf.message import Message
+
+from durabletask import task
+import durabletask.internal.orchestrator_service_pb2 as pb
+
+
+@dataclass(slots=True)
+class OrchestrationInstance:
+    instance_id: str
+    execution_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ParentInstanceInfo:
+    task_scheduled_id: int
+    name: Optional[str] = None
+    version: Optional[str] = None
+    orchestration_instance: Optional[OrchestrationInstance] = None
+
+
+@dataclass(slots=True)
+class TraceContext:
+    trace_parent: str
+    span_id: str
+    trace_state: Optional[str] = None
+
+
+@dataclass(slots=True)
+class HistoryEvent:
+    event_id: int
+    timestamp: datetime
+
+    def to_dict(self) -> dict[str, Any]:
+        return _to_serializable(asdict(self))
+
+
+@dataclass(slots=True)
+class ExecutionStartedEvent(HistoryEvent):
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    orchestration_instance: Optional[OrchestrationInstance] = None
+    parent_instance: Optional[ParentInstanceInfo] = None
+    scheduled_start_timestamp: Optional[datetime] = None
+    parent_trace_context: Optional[TraceContext] = None
+    orchestration_span_id: Optional[str] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class ExecutionCompletedEvent(HistoryEvent):
+    orchestration_status: int
+    result: Optional[str] = None
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class ExecutionTerminatedEvent(HistoryEvent):
+    input: Optional[str] = None
+    recurse: bool = False
+
+
+@dataclass(slots=True)
+class TaskScheduledEvent(HistoryEvent):
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class TaskCompletedEvent(HistoryEvent):
+    task_scheduled_id: int
+    result: Optional[str] = None
+
+
+@dataclass(slots=True)
+class TaskFailedEvent(HistoryEvent):
+    task_scheduled_id: int
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceCreatedEvent(HistoryEvent):
+    instance_id: str
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceCompletedEvent(HistoryEvent):
+    task_scheduled_id: int
+    result: Optional[str] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceFailedEvent(HistoryEvent):
+    task_scheduled_id: int
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class TimerCreatedEvent(HistoryEvent):
+    fire_at: datetime
+
+
+@dataclass(slots=True)
+class TimerFiredEvent(HistoryEvent):
+    fire_at: datetime
+    timer_id: int
+
+
+@dataclass(slots=True)
+class OrchestratorStartedEvent(HistoryEvent):
+    pass
+
+
+@dataclass(slots=True)
+class OrchestratorCompletedEvent(HistoryEvent):
+    pass
+
+
+@dataclass(slots=True)
+class EventSentEvent(HistoryEvent):
+    instance_id: str
+    name: str
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EventRaisedEvent(HistoryEvent):
+    name: str
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class GenericEvent(HistoryEvent):
+    data: Optional[str] = None
+
+
+@dataclass(slots=True)
+class HistoryStateEvent(HistoryEvent):
+    orchestration_state: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ContinueAsNewEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionSuspendedEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionResumedEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationSignaledEvent(HistoryEvent):
+    request_id: str
+    operation: str
+    scheduled_time: Optional[datetime] = None
+    input: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationCalledEvent(HistoryEvent):
+    request_id: str
+    operation: str
+    scheduled_time: Optional[datetime] = None
+    input: Optional[str] = None
+    parent_instance_id: Optional[str] = None
+    parent_execution_id: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationCompletedEvent(HistoryEvent):
+    request_id: str
+    output: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationFailedEvent(HistoryEvent):
+    request_id: str
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class EntityLockRequestedEvent(HistoryEvent):
+    critical_section_id: str
+    lock_set: list[str]
+    position: int
+    parent_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityLockGrantedEvent(HistoryEvent):
+    critical_section_id: str
+
+
+@dataclass(slots=True)
+class EntityUnlockSentEvent(HistoryEvent):
+    critical_section_id: str
+    parent_instance_id: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionRewoundEvent(HistoryEvent):
+    reason: Optional[str] = None
+    parent_execution_id: Optional[str] = None
+    instance_id: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    name: Optional[str] = None
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_instance: Optional[ParentInstanceInfo] = None
+    tags: Optional[dict[str, str]] = None
+
+
+def _from_protobuf(event: pb.HistoryEvent) -> HistoryEvent:
+    event_type = event.WhichOneof('eventType')
+    if event_type is None:
+        raise ValueError('History event does not have an eventType set')
+    converter = _EVENT_CONVERTERS.get(event_type)
+    if converter is None:
+        raise ValueError(f'Unsupported history event type: {event_type}')
+    return converter(event)
+
+
+def to_dict(event: HistoryEvent) -> dict[str, Any]:
+    return event.to_dict()
+
+
+def _base_kwargs(event: pb.HistoryEvent) -> dict[str, Any]:
+    return {
+        'event_id': event.eventId,
+        'timestamp': event.timestamp.ToDatetime(timezone.utc),
+    }
+
+
+def _string_value(msg: Message, field_name: str) -> Optional[str]:
+    if msg.HasField(field_name):
+        return getattr(msg, field_name).value
+    return None
+
+
+def _timestamp_value(msg: Message, field_name: str) -> Optional[datetime]:
+    if msg.HasField(field_name):
+        return getattr(msg, field_name).ToDatetime(timezone.utc)
+    return None
+
+
+def _failure_details(msg: Message, field_name: str) -> Optional[task.FailureDetails]:
+    if not msg.HasField(field_name):
+        return None
+    details = getattr(msg, field_name)
+    return task.FailureDetails(
+        details.errorMessage,
+        details.errorType,
+        details.stackTrace.value if details.HasField('stackTrace') else None,
+    )
+
+
+def _trace_context(msg: Message, field_name: str) -> Optional[TraceContext]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    return TraceContext(
+        trace_parent=value.traceParent,
+        span_id=value.spanID,
+        trace_state=value.traceState.value if value.HasField('traceState') else None,
+    )
+
+
+def _orchestration_instance(msg: Message, field_name: str) -> Optional[OrchestrationInstance]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    return OrchestrationInstance(
+        instance_id=value.instanceId,
+        execution_id=value.executionId.value if value.HasField('executionId') else None,
+    )
+
+
+def _parent_instance(msg: Message, field_name: str) -> Optional[ParentInstanceInfo]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    orchestration_instance = None
+    if value.HasField('orchestrationInstance'):
+        orchestration_instance = OrchestrationInstance(
+            instance_id=value.orchestrationInstance.instanceId,
+            execution_id=value.orchestrationInstance.executionId.value
+            if value.orchestrationInstance.HasField('executionId') else None,
+        )
+    return ParentInstanceInfo(
+        task_scheduled_id=value.taskScheduledId,
+        name=value.name.value if value.HasField('name') else None,
+        version=value.version.value if value.HasField('version') else None,
+        orchestration_instance=orchestration_instance,
+    )
+
+
+def _message_to_dict(msg: Message) -> dict[str, Any]:
+    return json_format.MessageToDict(msg, preserving_proto_field_name=True)
+
+
+def _to_serializable(value: Any) -> Any:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, list):
+        return [_to_serializable(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _to_serializable(item) for key, item in value.items()}
+    return value
+
+
+_EVENT_CONVERTERS: dict[str, Any] = {
+    'executionStarted': lambda event: ExecutionStartedEvent(
+        **_base_kwargs(event),
+        name=event.executionStarted.name,
+        version=_string_value(event.executionStarted, 'version'),
+        input=_string_value(event.executionStarted, 'input'),
+        orchestration_instance=_orchestration_instance(event.executionStarted, 'orchestrationInstance'),
+        parent_instance=_parent_instance(event.executionStarted, 'parentInstance'),
+        scheduled_start_timestamp=_timestamp_value(event.executionStarted, 'scheduledStartTimestamp'),
+        parent_trace_context=_trace_context(event.executionStarted, 'parentTraceContext'),
+        orchestration_span_id=_string_value(event.executionStarted, 'orchestrationSpanID'),
+        tags=dict(event.executionStarted.tags) if event.executionStarted.tags else None,
+    ),
+    'executionCompleted': lambda event: ExecutionCompletedEvent(
+        **_base_kwargs(event),
+        orchestration_status=event.executionCompleted.orchestrationStatus,
+        result=_string_value(event.executionCompleted, 'result'),
+        failure_details=_failure_details(event.executionCompleted, 'failureDetails'),
+    ),
+    'executionTerminated': lambda event: ExecutionTerminatedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionTerminated, 'input'),
+        recurse=event.executionTerminated.recurse,
+    ),
+    'taskScheduled': lambda event: TaskScheduledEvent(
+        **_base_kwargs(event),
+        name=event.taskScheduled.name,
+        version=_string_value(event.taskScheduled, 'version'),
+        input=_string_value(event.taskScheduled, 'input'),
+        parent_trace_context=_trace_context(event.taskScheduled, 'parentTraceContext'),
+        tags=dict(event.taskScheduled.tags) if event.taskScheduled.tags else None,
+    ),
+    'taskCompleted': lambda event: TaskCompletedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.taskCompleted.taskScheduledId,
+        result=_string_value(event.taskCompleted, 'result'),
+    ),
+    'taskFailed': lambda event: TaskFailedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.taskFailed.taskScheduledId,
+        failure_details=_failure_details(event.taskFailed, 'failureDetails'),
+    ),
+    'subOrchestrationInstanceCreated': lambda event: SubOrchestrationInstanceCreatedEvent(
+        **_base_kwargs(event),
+        instance_id=event.subOrchestrationInstanceCreated.instanceId,
+        name=event.subOrchestrationInstanceCreated.name,
+        version=_string_value(event.subOrchestrationInstanceCreated, 'version'),
+        input=_string_value(event.subOrchestrationInstanceCreated, 'input'),
+        parent_trace_context=_trace_context(event.subOrchestrationInstanceCreated, 'parentTraceContext'),
+        tags=dict(event.subOrchestrationInstanceCreated.tags) if event.subOrchestrationInstanceCreated.tags else None,
+    ),
+    'subOrchestrationInstanceCompleted': lambda event: SubOrchestrationInstanceCompletedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.subOrchestrationInstanceCompleted.taskScheduledId,
+        result=_string_value(event.subOrchestrationInstanceCompleted, 'result'),
+    ),
+    'subOrchestrationInstanceFailed': lambda event: SubOrchestrationInstanceFailedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.subOrchestrationInstanceFailed.taskScheduledId,
+        failure_details=_failure_details(event.subOrchestrationInstanceFailed, 'failureDetails'),
+    ),
+    'timerCreated': lambda event: TimerCreatedEvent(
+        **_base_kwargs(event),
+        fire_at=event.timerCreated.fireAt.ToDatetime(timezone.utc),
+    ),
+    'timerFired': lambda event: TimerFiredEvent(
+        **_base_kwargs(event),
+        fire_at=event.timerFired.fireAt.ToDatetime(timezone.utc),
+        timer_id=event.timerFired.timerId,
+    ),
+    'orchestratorStarted': lambda event: OrchestratorStartedEvent(**_base_kwargs(event)),
+    'orchestratorCompleted': lambda event: OrchestratorCompletedEvent(**_base_kwargs(event)),
+    'eventSent': lambda event: EventSentEvent(
+        **_base_kwargs(event),
+        instance_id=event.eventSent.instanceId,
+        name=event.eventSent.name,
+        input=_string_value(event.eventSent, 'input'),
+    ),
+    'eventRaised': lambda event: EventRaisedEvent(
+        **_base_kwargs(event),
+        name=event.eventRaised.name,
+        input=_string_value(event.eventRaised, 'input'),
+    ),
+    'genericEvent': lambda event: GenericEvent(
+        **_base_kwargs(event),
+        data=_string_value(event.genericEvent, 'data'),
+    ),
+    'historyState': lambda event: HistoryStateEvent(
+        **_base_kwargs(event),
+        orchestration_state=_message_to_dict(event.historyState.orchestrationState),
+    ),
+    'continueAsNew': lambda event: ContinueAsNewEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.continueAsNew, 'input'),
+    ),
+    'executionSuspended': lambda event: ExecutionSuspendedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionSuspended, 'input'),
+    ),
+    'executionResumed': lambda event: ExecutionResumedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionResumed, 'input'),
+    ),
+    'entityOperationSignaled': lambda event: EntityOperationSignaledEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationSignaled.requestId,
+        operation=event.entityOperationSignaled.operation,
+        scheduled_time=_timestamp_value(event.entityOperationSignaled, 'scheduledTime'),
+        input=_string_value(event.entityOperationSignaled, 'input'),
+        target_instance_id=_string_value(event.entityOperationSignaled, 'targetInstanceId'),
+    ),
+    'entityOperationCalled': lambda event: EntityOperationCalledEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationCalled.requestId,
+        operation=event.entityOperationCalled.operation,
+        scheduled_time=_timestamp_value(event.entityOperationCalled, 'scheduledTime'),
+        input=_string_value(event.entityOperationCalled, 'input'),
+        parent_instance_id=_string_value(event.entityOperationCalled, 'parentInstanceId'),
+        parent_execution_id=_string_value(event.entityOperationCalled, 'parentExecutionId'),
+        target_instance_id=_string_value(event.entityOperationCalled, 'targetInstanceId'),
+    ),
+    'entityOperationCompleted': lambda event: EntityOperationCompletedEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationCompleted.requestId,
+        output=_string_value(event.entityOperationCompleted, 'output'),
+    ),
+    'entityOperationFailed': lambda event: EntityOperationFailedEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationFailed.requestId,
+        failure_details=_failure_details(event.entityOperationFailed, 'failureDetails'),
+    ),
+    'entityLockRequested': lambda event: EntityLockRequestedEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityLockRequested.criticalSectionId,
+        lock_set=list(event.entityLockRequested.lockSet),
+        position=event.entityLockRequested.position,
+        parent_instance_id=_string_value(event.entityLockRequested, 'parentInstanceId'),
+    ),
+    'entityLockGranted': lambda event: EntityLockGrantedEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityLockGranted.criticalSectionId,
+    ),
+    'entityUnlockSent': lambda event: EntityUnlockSentEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityUnlockSent.criticalSectionId,
+        parent_instance_id=_string_value(event.entityUnlockSent, 'parentInstanceId'),
+        target_instance_id=_string_value(event.entityUnlockSent, 'targetInstanceId'),
+    ),
+    'executionRewound': lambda event: ExecutionRewoundEvent(
+        **_base_kwargs(event),
+        reason=_string_value(event.executionRewound, 'reason'),
+        parent_execution_id=_string_value(event.executionRewound, 'parentExecutionId'),
+        instance_id=_string_value(event.executionRewound, 'instanceId'),
+        parent_trace_context=_trace_context(event.executionRewound, 'parentTraceContext'),
+        name=_string_value(event.executionRewound, 'name'),
+        version=_string_value(event.executionRewound, 'version'),
+        input=_string_value(event.executionRewound, 'input'),
+        parent_instance=_parent_instance(event.executionRewound, 'parentInstance'),
+        tags=dict(event.executionRewound.tags) if event.executionRewound.tags else None,
+    ),
+}
+
+
+__all__ = [
+    'ContinueAsNewEvent',
+    'EntityLockGrantedEvent',
+    'EntityLockRequestedEvent',
+    'EntityOperationCalledEvent',
+    'EntityOperationCompletedEvent',
+    'EntityOperationFailedEvent',
+    'EntityOperationSignaledEvent',
+    'EntityUnlockSentEvent',
+    'EventRaisedEvent',
+    'EventSentEvent',
+    'ExecutionCompletedEvent',
+    'ExecutionResumedEvent',
+    'ExecutionRewoundEvent',
+    'ExecutionStartedEvent',
+    'ExecutionSuspendedEvent',
+    'ExecutionTerminatedEvent',
+    'GenericEvent',
+    'HistoryEvent',
+    'HistoryStateEvent',
+    'OrchestrationInstance',
+    'OrchestratorCompletedEvent',
+    'OrchestratorStartedEvent',
+    'ParentInstanceInfo',
+    'SubOrchestrationInstanceCompletedEvent',
+    'SubOrchestrationInstanceCreatedEvent',
+    'SubOrchestrationInstanceFailedEvent',
+    'TaskCompletedEvent',
+    'TaskFailedEvent',
+    'TaskScheduledEvent',
+    'TimerCreatedEvent',
+    'TimerFiredEvent',
+    'TraceContext',
+    'to_dict',
+]

durabletask-1.4.0.dev31/durabletask/internal/history_helpers.py

@@ -0,0 +1,68 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import AsyncIterable, Iterable, Optional
+
+import durabletask.history as history
+import durabletask.internal.orchestrator_service_pb2 as pb
+from durabletask.payload import helpers as payload_helpers
+from durabletask.payload.store import PayloadStore
+
+
+def collect_history_events(
+    chunks: Iterable[pb.HistoryChunk],
+    payload_store: Optional[PayloadStore] = None,
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for chunk in chunks:
+        events.extend(_clone_and_convert_events(chunk.events, payload_store))
+    return events
+
+
+async def collect_history_events_async(
+    chunks: AsyncIterable[pb.HistoryChunk],
+    payload_store: Optional[PayloadStore] = None,
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    async for chunk in chunks:
+        events.extend(await _clone_and_convert_events_async(chunk.events, payload_store))
+    return events
+
+
+def history_event_to_dict(event: history.HistoryEvent) -> dict:
+    return history.to_dict(event)
+
+
+def _clone_and_convert_events(
+    source_events: Iterable[pb.HistoryEvent],
+    payload_store: Optional[PayloadStore],
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for source_event in source_events:
+        event = source_event
+        if payload_store is not None:
+            # deexternalize_payloads mutates messages in-place, so clone to avoid
+            # mutating protobuf instances owned by gRPC/deserializer internals.
+            event = pb.HistoryEvent()
+            event.CopyFrom(source_event)
+            payload_helpers.deexternalize_payloads(event, payload_store)
+        events.append(history._from_protobuf(event))
+    return events
+
+
+async def _clone_and_convert_events_async(
+    source_events: Iterable[pb.HistoryEvent],
+    payload_store: Optional[PayloadStore],
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for source_event in source_events:
+        event = source_event
+        if payload_store is not None:
+            # Async deexternalization mutates messages in-place, so clone first.
+            event = pb.HistoryEvent()
+            event.CopyFrom(source_event)
+            await payload_helpers.deexternalize_payloads_async(event, payload_store)
+        events.append(history._from_protobuf(event))
+    return events

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/durabletask/testing/in_memory_backend.py

@@ -10,6 +10,7 @@ unit testing and integration testing scenarios where a sidecar process
 or external storage is not desired.
 """
 
+import bisect
 import logging
 import threading
 import time
@@ -41,6 +42,7 @@ class OrchestrationInstance:
     custom_status: Optional[str] = None
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     last_updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    completed_at: Optional[datetime] = None
     failure_details: Optional[pb.TaskFailureDetails] = None
     history: list[pb.HistoryEvent] = field(default_factory=list)
     pending_events: list[pb.HistoryEvent] = field(default_factory=list)
@@ -97,6 +99,10 @@ class StateWaiter:
     result: Optional[OrchestrationInstance] = None
 
 
+_DEFAULT_PAGE_SIZE = 100
+_TOKEN_SEP = '|'
+
+
 class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
     """
     In-memory backend for durable orchestrations suitable for testing.
@@ -238,6 +244,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
                 input=request.input.value if request.input else None,
                 created_at=now,
                 last_updated_at=now,
+                completed_at=None,
                 completion_token=self._next_completion_token,
                 tags=dict(request.tags) if request.tags else None,
             )
@@ -453,6 +460,48 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             f"Restarted instance '{request.instanceId}' as '{new_instance_id}'")
         return pb.RestartInstanceResponse(instanceId=new_instance_id)
 
+    def ListInstanceIds(self, request: pb.ListInstanceIdsRequest, context):
+        """Lists terminal orchestration instance IDs with completion-time pagination."""
+        with self._lock:
+            matching = []
+            for instance in self._instances.values():
+                if not self._is_terminal_status(instance.status):
+                    continue
+                if request.runtimeStatus and instance.status not in request.runtimeStatus:
+                    continue
+                if instance.completed_at is None:
+                    continue
+                if request.HasField("completedTimeFrom") and instance.completed_at < request.completedTimeFrom.ToDatetime(timezone.utc):
+                    continue
+                if request.HasField("completedTimeTo") and instance.completed_at >= request.completedTimeTo.ToDatetime(timezone.utc):
+                    continue
+                matching.append(instance)
+
+            matching.sort(key=lambda i: (i.completed_at, i.instance_id))
+            sort_keys = [(i.completed_at, i.instance_id) for i in matching]
+
+            start_index = 0
+            if request.HasField("lastInstanceKey") and request.lastInstanceKey.value:
+                token = request.lastInstanceKey.value
+                sep_idx = token.index(_TOKEN_SEP)
+                token_ts = datetime.fromisoformat(token[:sep_idx]).replace(tzinfo=timezone.utc)
+                token_id = token[sep_idx + 1:]
+                # bisect_right positions us just after the cursor entry
+                start_index = bisect.bisect_right(sort_keys, (token_ts, token_id))
+
+            page_size = request.pageSize if request.pageSize > 0 else _DEFAULT_PAGE_SIZE
+            page = matching[start_index:start_index + page_size]
+            next_token = None
+            if start_index + page_size < len(matching) and page:
+                last = page[-1]
+                encoded = f"{last.completed_at.isoformat()}{_TOKEN_SEP}{last.instance_id}"
+                next_token = wrappers_pb2.StringValue(value=encoded)
+
+        return pb.ListInstanceIdsResponse(
+            instanceIds=[instance.instance_id for instance in page],
+            lastInstanceKey=next_token,
+        )
+
     @staticmethod
     def _parse_work_item_filters(request: pb.GetWorkItemsRequest):
         """Extract filters from the request.
@@ -1084,8 +1133,18 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
         )
 
     def StreamInstanceHistory(self, request: pb.StreamInstanceHistoryRequest, context):
-        """Streams instance history (not implemented)."""
-        context.abort(grpc.StatusCode.UNIMPLEMENTED, "StreamInstanceHistory not implemented")
+        """Streams orchestration history for an instance."""
+        with self._lock:
+            instance = self._instances.get(request.instanceId)
+            if instance is None:
+                context.abort(grpc.StatusCode.NOT_FOUND,
+                              f"Orchestration instance '{request.instanceId}' not found")
+                return
+            history = [self._clone_history_event(event) for event in instance.history]
+
+        chunk_size = 100
+        for offset in range(0, len(history), chunk_size):
+            yield pb.HistoryChunk(events=history[offset:offset + chunk_size])
 
     def CreateTaskHub(self, request: pb.CreateTaskHubRequest, context):
         """Creates task hub resources (no-op for in-memory)."""
@@ -1178,6 +1237,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             input=encoded_input,
             created_at=now,
             last_updated_at=now,
+            completed_at=None,
             completion_token=self._next_completion_token,
         )
         self._next_completion_token += 1
@@ -1239,6 +1299,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             orchestrationStatus=instance.status,
             createdTimestamp=created_ts,
             lastUpdatedTimestamp=updated_ts,
+            completedTimestamp=helpers.new_timestamp(instance.completed_at) if instance.completed_at else None,
             input=wrappers_pb2.StringValue(value=instance.input) if include_payloads and instance.input else None,
             output=wrappers_pb2.StringValue(value=instance.output) if include_payloads and instance.output else None,
             customStatus=wrappers_pb2.StringValue(value=instance.custom_status) if instance.custom_status else None,
@@ -1319,6 +1380,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
         instance.status = status
         instance.output = complete_action.result.value if complete_action.result else None
         instance.failure_details = complete_action.failureDetails if complete_action.failureDetails else None
+        instance.completed_at = datetime.now(timezone.utc) if self._is_terminal_status(status) else None
 
         if status == pb.ORCHESTRATION_STATUS_CONTINUED_AS_NEW:
             # Handle continue-as-new
@@ -1336,6 +1398,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             instance.output = None
             instance.failure_details = None
             instance.status = pb.ORCHESTRATION_STATUS_PENDING
+            instance.completed_at = None
 
             # Save any events that arrived during the in-flight dispatch so
             # they can be appended AFTER the new execution started events.
@@ -1357,6 +1420,12 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
 
             self._enqueue_orchestration(instance.instance_id)
 
+    @staticmethod
+    def _clone_history_event(event: pb.HistoryEvent) -> pb.HistoryEvent:
+        cloned_event = pb.HistoryEvent()
+        cloned_event.CopyFrom(event)
+        return cloned_event
+
     def _process_schedule_task_action(self, instance: OrchestrationInstance,
                                       action: pb.OrchestratorAction):
         """Processes a schedule task action."""

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/durabletask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.4.0
+Version: 1.4.0.dev31
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/durabletask.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 durabletask/__init__.py
 durabletask/client.py
+durabletask/history.py
 durabletask/py.typed
 durabletask/task.py
 durabletask/worker.py
@@ -27,6 +28,7 @@ durabletask/internal/entity_state_shim.py
 durabletask/internal/exceptions.py
 durabletask/internal/grpc_interceptor.py
 durabletask/internal/helpers.py
+durabletask/internal/history_helpers.py
 durabletask/internal/json_encode_output_exception.py
 durabletask/internal/orchestration_entity_context.py
 durabletask/internal/orchestrator_service_pb2.py

{durabletask-1.4.0 → durabletask-1.4.0.dev31}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durabletask"
-version = "1.4.0"
+version = "1.4.0.dev31"
 description = "A Durable Task Client SDK for Python"
 keywords = [
     "durable",