durabletask 0.0.0.dev65__tar.gz → 0.0.0.dev67__tar.gz

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/PKG-INFO

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

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/client.py

@@ -6,10 +6,9 @@ import uuid
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Optional, Sequence, TypeVar, Union
+from typing import Any, List, Optional, Sequence, TypeVar, Union
 
 import grpc
-from google.protobuf import wrappers_pb2
 
 from durabletask.entities import EntityInstanceId
 from durabletask.entities.entity_metadata import EntityMetadata
@@ -57,6 +56,39 @@ class OrchestrationState:
                 self.failure_details)
 
 
+@dataclass
+class OrchestrationQuery:
+    created_time_from: Optional[datetime] = None
+    created_time_to: Optional[datetime] = None
+    runtime_status: Optional[List[OrchestrationStatus]] = None
+    # Some backends don't respond well with max_instance_count = None, so we use the integer limit for non-paginated
+    # results instead.
+    max_instance_count: Optional[int] = (1 << 31) - 1
+    fetch_inputs_and_outputs: bool = False
+
+
+@dataclass
+class EntityQuery:
+    instance_id_starts_with: Optional[str] = None
+    last_modified_from: Optional[datetime] = None
+    last_modified_to: Optional[datetime] = None
+    include_state: bool = True
+    include_transient: bool = False
+    page_size: Optional[int] = None
+
+
+@dataclass
+class PurgeInstancesResult:
+    deleted_instance_count: int
+    is_complete: bool
+
+
+@dataclass
+class CleanEntityStorageResult:
+    empty_entities_removed: int
+    orphaned_locks_released: int
+
+
 class OrchestrationFailedError(Exception):
     def __init__(self, message: str, failure_details: task.FailureDetails):
         super().__init__(message)
@@ -73,6 +105,12 @@ def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Op
 
     state = res.orchestrationState
 
+    new_state = parse_orchestration_state(state)
+    new_state.instance_id = instance_id  # Override instance_id with the one from the request, to match old behavior
+    return new_state
+
+
+def parse_orchestration_state(state: pb.OrchestrationState) -> OrchestrationState:
     failure_details = None
     if state.failureDetails.errorMessage != '' or state.failureDetails.errorType != '':
         failure_details = task.FailureDetails(
@@ -81,7 +119,7 @@ def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Op
             state.failureDetails.stackTrace.value if not helpers.is_empty(state.failureDetails.stackTrace) else None)
 
     return OrchestrationState(
-        instance_id,
+        state.instanceId,
         state.name,
         OrchestrationStatus(state.orchestrationStatus),
         state.createdTimestamp.ToDatetime(),
@@ -93,7 +131,6 @@ def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Op
 
 
 class TaskHubGrpcClient:
-
     def __init__(self, *,
                  host_address: Optional[str] = None,
                  metadata: Optional[list[tuple[str, str]]] = None,
@@ -136,7 +173,7 @@ class TaskHubGrpcClient:
         req = pb.CreateInstanceRequest(
             name=name,
             instanceId=instance_id if instance_id else uuid.uuid4().hex,
-            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input is not None else None,
+            input=helpers.get_string_value(shared.to_json(input) if input is not None else None),
             scheduledStartTimestamp=helpers.new_timestamp(start_at) if start_at else None,
             version=helpers.get_string_value(version if version else self.default_version),
             orchestrationIdReusePolicy=reuse_id_policy,
@@ -152,6 +189,42 @@ class TaskHubGrpcClient:
         res: pb.GetInstanceResponse = self._stub.GetInstance(req)
         return new_orchestration_state(req.instanceId, res)
 
+    def get_all_orchestration_states(self,
+                                     orchestration_query: Optional[OrchestrationQuery] = None
+                                     ) -> List[OrchestrationState]:
+        if orchestration_query is None:
+            orchestration_query = OrchestrationQuery()
+        _continuation_token = None
+
+        self._logger.info(f"Querying orchestration instances with query: {orchestration_query}")
+
+        states = []
+
+        while True:
+            req = pb.QueryInstancesRequest(
+                query=pb.InstanceQuery(
+                    runtimeStatus=[status.value for status in orchestration_query.runtime_status] if orchestration_query.runtime_status else None,
+                    createdTimeFrom=helpers.new_timestamp(orchestration_query.created_time_from) if orchestration_query.created_time_from else None,
+                    createdTimeTo=helpers.new_timestamp(orchestration_query.created_time_to) if orchestration_query.created_time_to else None,
+                    maxInstanceCount=orchestration_query.max_instance_count,
+                    fetchInputsAndOutputs=orchestration_query.fetch_inputs_and_outputs,
+                    continuationToken=_continuation_token
+                )
+            )
+            resp: pb.QueryInstancesResponse = self._stub.QueryInstances(req)
+            states += [parse_orchestration_state(res) for res in resp.orchestrationState]
+            # Check the value for continuationToken - none or "0" indicates that there are no more results.
+            if resp.continuationToken and resp.continuationToken.value and resp.continuationToken.value != "0":
+                self._logger.info(f"Received continuation token with value {resp.continuationToken.value}, fetching next list of instances...")
+                if _continuation_token and _continuation_token.value and _continuation_token.value == resp.continuationToken.value:
+                    self._logger.warning(f"Received the same continuation token value {resp.continuationToken.value} again, stopping to avoid infinite loop.")
+                    break
+                _continuation_token = resp.continuationToken
+            else:
+                break
+
+        return states
+
     def wait_for_orchestration_start(self, instance_id: str, *,
                                      fetch_payloads: bool = False,
                                      timeout: int = 60) -> Optional[OrchestrationState]:
@@ -199,7 +272,8 @@ class TaskHubGrpcClient:
         req = pb.RaiseEventRequest(
             instanceId=instance_id,
             name=event_name,
-            input=wrappers_pb2.StringValue(value=shared.to_json(data)) if data is not None else None)
+            input=helpers.get_string_value(shared.to_json(data) if data is not None else None)
+        )
 
         self._logger.info(f"Raising event '{event_name}' for instance '{instance_id}'.")
         self._stub.RaiseEvent(req)
@@ -209,7 +283,7 @@ class TaskHubGrpcClient:
                                 recursive: bool = True):
         req = pb.TerminateRequest(
             instanceId=instance_id,
-            output=wrappers_pb2.StringValue(value=shared.to_json(output)) if output is not None else None,
+            output=helpers.get_string_value(shared.to_json(output) if output is not None else None),
             recursive=recursive)
 
         self._logger.info(f"Terminating instance '{instance_id}'.")
@@ -225,10 +299,31 @@ class TaskHubGrpcClient:
         self._logger.info(f"Resuming instance '{instance_id}'.")
         self._stub.ResumeInstance(req)
 
-    def purge_orchestration(self, instance_id: str, recursive: bool = True):
+    def purge_orchestration(self, instance_id: str, recursive: bool = True) -> PurgeInstancesResult:
         req = pb.PurgeInstancesRequest(instanceId=instance_id, recursive=recursive)
         self._logger.info(f"Purging instance '{instance_id}'.")
-        self._stub.PurgeInstances(req)
+        resp: pb.PurgeInstancesResponse = self._stub.PurgeInstances(req)
+        return PurgeInstancesResult(resp.deletedInstanceCount, resp.isComplete.value)
+
+    def purge_orchestrations_by(self,
+                                created_time_from: Optional[datetime] = None,
+                                created_time_to: Optional[datetime] = None,
+                                runtime_status: Optional[List[OrchestrationStatus]] = None,
+                                recursive: bool = False) -> PurgeInstancesResult:
+        self._logger.info("Purging orchestrations by filter: "
+                          f"created_time_from={created_time_from}, "
+                          f"created_time_to={created_time_to}, "
+                          f"runtime_status={[str(status) for status in runtime_status] if runtime_status else None}, "
+                          f"recursive={recursive}")
+        resp: pb.PurgeInstancesResponse = self._stub.PurgeInstances(pb.PurgeInstancesRequest(
+            purgeInstanceFilter=pb.PurgeInstanceFilter(
+                createdTimeFrom=helpers.new_timestamp(created_time_from) if created_time_from else None,
+                createdTimeTo=helpers.new_timestamp(created_time_to) if created_time_to else None,
+                runtimeStatus=[status.value for status in runtime_status] if runtime_status else None
+            ),
+            recursive=recursive
+        ))
+        return PurgeInstancesResult(resp.deletedInstanceCount, resp.isComplete.value)
 
     def signal_entity(self,
                       entity_instance_id: EntityInstanceId,
@@ -237,7 +332,7 @@ class TaskHubGrpcClient:
         req = pb.SignalEntityRequest(
             instanceId=str(entity_instance_id),
             name=operation_name,
-            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input is not None else None,
+            input=helpers.get_string_value(shared.to_json(input) if input is not None else None),
             requestId=str(uuid.uuid4()),
             scheduledTime=None,
             parentTraceContext=None,
@@ -256,4 +351,69 @@ class TaskHubGrpcClient:
         if not res.exists:
             return None
 
-        return EntityMetadata.from_entity_response(res, include_state)
+        return EntityMetadata.from_entity_metadata(res.entity, include_state)
+
+    def get_all_entities(self,
+                         entity_query: Optional[EntityQuery] = None) -> List[EntityMetadata]:
+        if entity_query is None:
+            entity_query = EntityQuery()
+        _continuation_token = None
+
+        self._logger.info(f"Retrieving entities by filter: {entity_query}")
+
+        entities = []
+
+        while True:
+            query_request = pb.QueryEntitiesRequest(
+                query=pb.EntityQuery(
+                    instanceIdStartsWith=helpers.get_string_value(entity_query.instance_id_starts_with),
+                    lastModifiedFrom=helpers.new_timestamp(entity_query.last_modified_from) if entity_query.last_modified_from else None,
+                    lastModifiedTo=helpers.new_timestamp(entity_query.last_modified_to) if entity_query.last_modified_to else None,
+                    includeState=entity_query.include_state,
+                    includeTransient=entity_query.include_transient,
+                    pageSize=helpers.get_int_value(entity_query.page_size),
+                    continuationToken=_continuation_token
+                )
+            )
+            resp: pb.QueryEntitiesResponse = self._stub.QueryEntities(query_request)
+            entities += [EntityMetadata.from_entity_metadata(entity, query_request.query.includeState) for entity in resp.entities]
+            if resp.continuationToken and resp.continuationToken.value and resp.continuationToken.value != "0":
+                self._logger.info(f"Received continuation token with value {resp.continuationToken.value}, fetching next page of entities...")
+                if _continuation_token and _continuation_token.value and _continuation_token.value == resp.continuationToken.value:
+                    self._logger.warning(f"Received the same continuation token value {resp.continuationToken.value} again, stopping to avoid infinite loop.")
+                    break
+                _continuation_token = resp.continuationToken
+            else:
+                break
+        return entities
+
+    def clean_entity_storage(self,
+                             remove_empty_entities: bool = True,
+                             release_orphaned_locks: bool = True
+                             ) -> CleanEntityStorageResult:
+        self._logger.info("Cleaning entity storage")
+
+        empty_entities_removed = 0
+        orphaned_locks_released = 0
+        _continuation_token = None
+
+        while True:
+            req = pb.CleanEntityStorageRequest(
+                removeEmptyEntities=remove_empty_entities,
+                releaseOrphanedLocks=release_orphaned_locks,
+                continuationToken=_continuation_token
+            )
+            resp: pb.CleanEntityStorageResponse = self._stub.CleanEntityStorage(req)
+            empty_entities_removed += resp.emptyEntitiesRemoved
+            orphaned_locks_released += resp.orphanedLocksReleased
+
+            if resp.continuationToken and resp.continuationToken.value and resp.continuationToken.value != "0":
+                self._logger.info(f"Received continuation token with value {resp.continuationToken.value}, cleaning next page...")
+                if _continuation_token and _continuation_token.value and _continuation_token.value == resp.continuationToken.value:
+                    self._logger.warning(f"Received the same continuation token value {resp.continuationToken.value} again, stopping to avoid infinite loop.")
+                    break
+                _continuation_token = resp.continuationToken
+            else:
+                break
+
+        return CleanEntityStorageResult(empty_entities_removed, orphaned_locks_released)

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/entities/__init__.py

@@ -8,7 +8,9 @@ from durabletask.entities.durable_entity import DurableEntity
 from durabletask.entities.entity_lock import EntityLock
 from durabletask.entities.entity_context import EntityContext
 from durabletask.entities.entity_metadata import EntityMetadata
+from durabletask.entities.entity_operation_failed_exception import EntityOperationFailedException
 
-__all__ = ["EntityInstanceId", "DurableEntity", "EntityLock", "EntityContext", "EntityMetadata"]
+__all__ = ["EntityInstanceId", "DurableEntity", "EntityLock", "EntityContext", "EntityMetadata",
+           "EntityOperationFailedException"]
 
 PACKAGE_NAME = "durabletask.entities"

durabletask-0.0.0.dev67/durabletask/entities/entity_instance_id.py

@@ -0,0 +1,84 @@
+class EntityInstanceId:
+    def __init__(self, entity: str, key: str):
+        EntityInstanceId.validate_entity_name(entity)
+        EntityInstanceId.validate_key(key)
+        self.entity = entity.lower()
+        self.key = key
+
+    def __str__(self) -> str:
+        return f"@{self.entity}@{self.key}"
+
+    def __eq__(self, other):
+        if not isinstance(other, EntityInstanceId):
+            return False
+        return self.entity == other.entity and self.key == other.key
+
+    def __lt__(self, other):
+        if not isinstance(other, EntityInstanceId):
+            return self < other
+        return str(self) < str(other)
+
+    @staticmethod
+    def parse(entity_id: str) -> "EntityInstanceId":
+        """Parse a string representation of an entity ID into an EntityInstanceId object.
+
+        Parameters
+        ----------
+        entity_id : str
+            The string representation of the entity ID, in the format '@entity@key'.
+
+        Returns
+        -------
+        EntityInstanceId
+            The parsed EntityInstanceId object.
+
+        Raises
+        ------
+        ValueError
+            If the input string is not in the correct format.
+        """
+        if not entity_id.startswith("@"):
+            raise ValueError("Entity ID must start with '@'.")
+        try:
+            _, entity, key = entity_id.split("@", 2)
+        except ValueError as ex:
+            raise ValueError(f"Invalid entity ID format: {entity_id}") from ex
+        return EntityInstanceId(entity=entity, key=key)
+
+    @staticmethod
+    def validate_entity_name(name: str) -> None:
+        """Validate that the entity name does not contain invalid characters.
+
+        Parameters
+        ----------
+        name : str
+            The entity name to validate.
+
+        Raises
+        ------
+        ValueError
+            If the name is not a valid entity name.
+        """
+        if not name:
+            raise ValueError("Entity name cannot be empty.")
+        if "@" in name:
+            raise ValueError("Entity name cannot contain '@' symbol.")
+
+    @staticmethod
+    def validate_key(key: str) -> None:
+        """Validate that the entity key does not contain invalid characters.
+
+        Parameters
+        ----------
+        key : str
+            The entity key to validate.
+
+        Raises
+        ------
+        ValueError
+            If the key is not a valid entity key.
+        """
+        if not key:
+            raise ValueError("Entity key cannot be empty.")
+        if "@" in key:
+            raise ValueError("Entity key cannot contain '@' symbol.")

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/entities/entity_metadata.py

@@ -44,18 +44,22 @@ class EntityMetadata:
 
     @staticmethod
     def from_entity_response(entity_response: pb.GetEntityResponse, includes_state: bool):
+        return EntityMetadata.from_entity_metadata(entity_response.entity, includes_state)
+
+    @staticmethod
+    def from_entity_metadata(entity: pb.EntityMetadata, includes_state: bool):
         try:
-            entity_id = EntityInstanceId.parse(entity_response.entity.instanceId)
+            entity_id = EntityInstanceId.parse(entity.instanceId)
         except ValueError:
             raise ValueError("Invalid entity instance ID in entity response.")
         entity_state = None
         if includes_state:
-            entity_state = entity_response.entity.serializedState.value
+            entity_state = entity.serializedState.value
         return EntityMetadata(
             id=entity_id,
-            last_modified=entity_response.entity.lastModifiedTime.ToDatetime(timezone.utc),
-            backlog_queue_size=entity_response.entity.backlogQueueSize,
-            locked_by=entity_response.entity.lockedBy.value,
+            last_modified=entity.lastModifiedTime.ToDatetime(timezone.utc),
+            backlog_queue_size=entity.backlogQueueSize,
+            locked_by=entity.lockedBy.value,
             includes_state=includes_state,
             state=entity_state
         )

durabletask-0.0.0.dev67/durabletask/entities/entity_operation_failed_exception.py

@@ -0,0 +1,15 @@
+from durabletask.internal.orchestrator_service_pb2 import TaskFailureDetails
+from durabletask.entities.entity_instance_id import EntityInstanceId
+
+
+class EntityOperationFailedException(Exception):
+    """Exception raised when an operation on an Entity Function fails."""
+
+    def __init__(self, entity_instance_id: EntityInstanceId, operation_name: str, failure_details: TaskFailureDetails) -> None:
+        super().__init__()
+        self.entity_instance_id = entity_instance_id
+        self.operation_name = operation_name
+        self.failure_details = failure_details
+
+    def __str__(self) -> str:
+        return f"Operation '{self.operation_name}' on entity '{self.entity_instance_id}' failed with error: {self.failure_details.errorMessage}"

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/internal/helpers.py

@@ -184,6 +184,13 @@ def get_string_value(val: Optional[str]) -> Optional[wrappers_pb2.StringValue]:
         return wrappers_pb2.StringValue(value=val)
 
 
+def get_int_value(val: Optional[int]) -> Optional[wrappers_pb2.Int32Value]:
+    if val is None:
+        return None
+    else:
+        return wrappers_pb2.Int32Value(value=val)
+
+
 def get_string_value_or_empty(val: Optional[str]) -> wrappers_pb2.StringValue:
     if val is None:
         return wrappers_pb2.StringValue(value="")

durabletask-0.0.0.dev67/durabletask/internal/json_encode_output_exception.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+
+class JsonEncodeOutputException(Exception):
+    """Custom exception type used to indicate that an orchestration result could not be JSON-encoded."""
+
+    def __init__(self, problem_object: Any):
+        super().__init__()
+        self.problem_object = problem_object
+
+    def __str__(self) -> str:
+        return f"The orchestration result could not be encoded. Object details: {self.problem_object}"

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/internal/shared.py

@@ -103,15 +103,18 @@ class InternalJSONEncoder(json.JSONEncoder):
         return super().encode(obj)
 
     def default(self, obj):
-        if dataclasses.is_dataclass(obj):
+        if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
             # Dataclasses are not serializable by default, so we convert them to a dict and mark them for
-            # automatic deserialization by the receiver
-            d = dataclasses.asdict(obj)  # type: ignore
+            # automatic deserialization by the receiver. We use a shallow field extraction instead of
+            # dataclasses.asdict() so that nested dataclass values are re-processed by the encoder
+            # individually (each receiving their own AUTO_SERIALIZED marker).
+            d = {f.name: getattr(obj, f.name) for f in dataclasses.fields(obj)}
             d[AUTO_SERIALIZED] = True
             return d
         elif isinstance(obj, SimpleNamespace):
-            # Most commonly used for serializing custom objects that were previously serialized using our encoder
-            d = vars(obj)
+            # Most commonly used for serializing custom objects that were previously serialized using our encoder.
+            # Copy the dict to avoid mutating the original object.
+            d = dict(vars(obj))
             d[AUTO_SERIALIZED] = True
             return d
         # This will typically raise a TypeError

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask/worker.py

@@ -19,10 +19,12 @@ from packaging.version import InvalidVersion, parse
 import grpc
 from google.protobuf import empty_pb2
 
+from durabletask.entities.entity_operation_failed_exception import EntityOperationFailedException
 from durabletask.internal import helpers
 from durabletask.internal.entity_state_shim import StateShim
 from durabletask.internal.helpers import new_timestamp
 from durabletask.entities import DurableEntity, EntityLock, EntityInstanceId, EntityContext
+from durabletask.internal.json_encode_output_exception import JsonEncodeOutputException
 from durabletask.internal.orchestration_entity_context import OrchestrationEntityContext
 from durabletask.internal.proto_task_hub_sidecar_service_stub import ProtoTaskHubSidecarServiceStub
 import durabletask.internal.helpers as ph
@@ -141,14 +143,12 @@ class _Registry:
     orchestrators: dict[str, task.Orchestrator]
     activities: dict[str, task.Activity]
     entities: dict[str, task.Entity]
-    entity_instances: dict[str, DurableEntity]
     versioning: Optional[VersioningOptions] = None
 
     def __init__(self):
         self.orchestrators = {}
         self.activities = {}
         self.entities = {}
-        self.entity_instances = {}
 
     def add_orchestrator(self, fn: task.Orchestrator[TInput, TOutput]) -> str:
         if fn is None:
@@ -199,8 +199,8 @@ class _Registry:
         return name
 
     def add_named_entity(self, name: str, fn: task.Entity) -> None:
-        if not name:
-            raise ValueError("A non-empty entity name is required.")
+        name = name.lower()
+        EntityInstanceId.validate_entity_name(name)
         if name in self.entities:
             raise ValueError(f"A '{name}' entity already exists.")
 
@@ -829,7 +829,7 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._pending_actions: dict[int, pb.OrchestratorAction] = {}
         self._pending_tasks: dict[int, task.CompletableTask] = {}
         # Maps entity ID to task ID
-        self._entity_task_id_map: dict[str, tuple[EntityInstanceId, int]] = {}
+        self._entity_task_id_map: dict[str, tuple[EntityInstanceId, str, int]] = {}
         self._entity_lock_task_id_map: dict[str, tuple[EntityInstanceId, int]] = {}
         # Maps criticalSectionId to task ID
         self._entity_lock_id_map: dict[str, int] = {}
@@ -902,7 +902,13 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._result = result
         result_json: Optional[str] = None
         if result is not None:
-            result_json = result if is_result_encoded else shared.to_json(result)
+            try:
+                result_json = result if is_result_encoded else shared.to_json(result)
+            except (ValueError, TypeError):
+                self._is_complete = False
+                self._result = None
+                self.set_failed(JsonEncodeOutputException(result))
+                return
         action = ph.new_complete_orchestration_action(
             self.next_sequence_number(), status, result_json
         )
@@ -1606,7 +1612,7 @@ class _OrchestrationExecutor:
                     raise TypeError("Unexpected sub-orchestration task type")
             elif event.HasField("eventRaised"):
                 if event.eventRaised.name in ctx._entity_task_id_map:
-                    entity_id, task_id = ctx._entity_task_id_map.get(event.eventRaised.name, (None, None))
+                    entity_id, operation, task_id = ctx._entity_task_id_map.get(event.eventRaised.name, (None, None, None))
                     self._handle_entity_event_raised(ctx, event, entity_id, task_id, False)
                 elif event.eventRaised.name in ctx._entity_lock_task_id_map:
                     entity_id, task_id = ctx._entity_lock_task_id_map.get(event.eventRaised.name, (None, None))
@@ -1680,9 +1686,10 @@ class _OrchestrationExecutor:
                     )
                 try:
                     entity_id = EntityInstanceId.parse(event.entityOperationCalled.targetInstanceId.value)
+                    operation = event.entityOperationCalled.operation
                 except ValueError:
                     raise RuntimeError(f"Could not parse entity ID from targetInstanceId '{event.entityOperationCalled.targetInstanceId.value}'")
-                ctx._entity_task_id_map[event.entityOperationCalled.requestId] = (entity_id, entity_call_id)
+                ctx._entity_task_id_map[event.entityOperationCalled.requestId] = (entity_id, operation, entity_call_id)
             elif event.HasField("entityOperationSignaled"):
                 # This history event confirms that the entity signal was successfully scheduled.
                 # Remove the entityOperationSignaled event from the pending action list so we don't schedule it
@@ -1743,7 +1750,7 @@ class _OrchestrationExecutor:
                 ctx.resume()
             elif event.HasField("entityOperationCompleted"):
                 request_id = event.entityOperationCompleted.requestId
-                entity_id, task_id = ctx._entity_task_id_map.pop(request_id, (None, None))
+                entity_id, operation, task_id = ctx._entity_task_id_map.pop(request_id, (None, None, None))
                 if not entity_id:
                     raise RuntimeError(f"Could not parse entity ID from request ID '{request_id}'")
                 if not task_id:
@@ -1762,10 +1769,29 @@ class _OrchestrationExecutor:
                 entity_task.complete(result)
                 ctx.resume()
             elif event.HasField("entityOperationFailed"):
-                if not ctx.is_replaying:
-                    self._logger.info(f"{ctx.instance_id}: Entity operation failed.")
-                    self._logger.info(f"Data: {json.dumps(event.entityOperationFailed)}")
-                pass
+                request_id = event.entityOperationFailed.requestId
+                entity_id, operation, task_id = ctx._entity_task_id_map.pop(request_id, (None, None, None))
+                if not entity_id:
+                    raise RuntimeError(f"Could not parse entity ID from request ID '{request_id}'")
+                if operation is None:
+                    raise RuntimeError(f"Could not parse operation name from request ID '{request_id}'")
+                if not task_id:
+                    raise RuntimeError(f"Could not find matching task ID for entity operation with request ID '{request_id}'")
+                entity_task = ctx._pending_tasks.pop(task_id, None)
+                if not entity_task:
+                    if not ctx.is_replaying:
+                        self._logger.warning(
+                            f"{ctx.instance_id}: Ignoring unexpected entityOperationFailed event with request ID = {request_id}."
+                        )
+                    return
+                failure = EntityOperationFailedException(
+                    entity_id,
+                    operation,
+                    event.entityOperationFailed.failureDetails
+                )
+                ctx._entity_context.recover_lock_after_call(entity_id)
+                entity_task.fail(str(failure), failure)
+                ctx.resume()
             elif event.HasField("orchestratorCompleted"):
                 # Added in Functions only (for some reason) and does not affect orchestrator flow
                 pass
@@ -1777,7 +1803,7 @@ class _OrchestrationExecutor:
                 if action and action.HasField("sendEntityMessage"):
                     if action.sendEntityMessage.HasField("entityOperationCalled"):
                         entity_id, event_id = self._parse_entity_event_sent_input(event)
-                        ctx._entity_task_id_map[event_id] = (entity_id, event.eventId)
+                        ctx._entity_task_id_map[event_id] = (entity_id, action.sendEntityMessage.entityOperationCalled.operation, event.eventId)
                     elif action.sendEntityMessage.HasField("entityLockRequested"):
                         entity_id, event_id = self._parse_entity_event_sent_input(event)
                         ctx._entity_lock_task_id_map[event_id] = (entity_id, event.eventId)
@@ -1913,6 +1939,7 @@ class _EntityExecutor:
     def __init__(self, registry: _Registry, logger: logging.Logger):
         self._registry = registry
         self._logger = logger
+        self._entity_method_cache: dict[tuple[type, str], bool] = {}
 
     def execute(
             self,
@@ -1936,11 +1963,7 @@ class _EntityExecutor:
         ctx = EntityContext(orchestration_id, operation, state, entity_id)
 
         if isinstance(fn, type) and issubclass(fn, DurableEntity):
-            if self._registry.entity_instances.get(str(entity_id), None):
-                entity_instance = self._registry.entity_instances[str(entity_id)]
-            else:
-                entity_instance = fn()
-                self._registry.entity_instances[str(entity_id)] = entity_instance
+            entity_instance = fn()
             if not hasattr(entity_instance, operation):
                 raise AttributeError(f"Entity '{entity_id}' does not have operation '{operation}'")
             method = getattr(entity_instance, operation)
@@ -1948,7 +1971,21 @@ class _EntityExecutor:
                 raise TypeError(f"Entity operation '{operation}' is not callable")
             # Execute the entity method
             entity_instance._initialize_entity_context(ctx)
-            entity_output = method(entity_input)
+            cache_key = (type(entity_instance), operation)
+            has_required_param = self._entity_method_cache.get(cache_key)
+            if has_required_param is None:
+                sig = inspect.signature(method)
+                has_required_param = any(
+                    p.default == inspect.Parameter.empty
+                    for p in sig.parameters.values()
+                    if p.kind not in (inspect.Parameter.VAR_POSITIONAL,
+                                      inspect.Parameter.VAR_KEYWORD)
+                )
+                self._entity_method_cache[cache_key] = has_required_param
+            if has_required_param or entity_input is not None:
+                entity_output = method(entity_input)
+            else:
+                entity_output = method()
         else:
             # Execute the entity function
             entity_output = fn(ctx, entity_input)

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask.egg-info/PKG-INFO

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

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/durabletask.egg-info/SOURCES.txt

@@ -17,10 +17,12 @@ durabletask/entities/entity_context.py
 durabletask/entities/entity_instance_id.py
 durabletask/entities/entity_lock.py
 durabletask/entities/entity_metadata.py
+durabletask/entities/entity_operation_failed_exception.py
 durabletask/internal/entity_state_shim.py
 durabletask/internal/exceptions.py
 durabletask/internal/grpc_interceptor.py
 durabletask/internal/helpers.py
+durabletask/internal/json_encode_output_exception.py
 durabletask/internal/orchestration_entity_context.py
 durabletask/internal/orchestrator_service_pb2.py
 durabletask/internal/orchestrator_service_pb2.pyi

{durabletask-0.0.0.dev65 → durabletask-0.0.0.dev67}/pyproject.toml

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

durabletask-0.0.0.dev65/durabletask/entities/entity_instance_id.py

@@ -1,42 +0,0 @@
-class EntityInstanceId:
-    def __init__(self, entity: str, key: str):
-        self.entity = entity
-        self.key = key
-
-    def __str__(self) -> str:
-        return f"@{self.entity}@{self.key}"
-
-    def __eq__(self, other):
-        if not isinstance(other, EntityInstanceId):
-            return False
-        return self.entity == other.entity and self.key == other.key
-
-    def __lt__(self, other):
-        if not isinstance(other, EntityInstanceId):
-            return self < other
-        return str(self) < str(other)
-
-    @staticmethod
-    def parse(entity_id: str) -> "EntityInstanceId":
-        """Parse a string representation of an entity ID into an EntityInstanceId object.
-
-        Parameters
-        ----------
-        entity_id : str
-            The string representation of the entity ID, in the format '@entity@key'.
-
-        Returns
-        -------
-        EntityInstanceId
-            The parsed EntityInstanceId object.
-
-        Raises
-        ------
-        ValueError
-            If the input string is not in the correct format.
-        """
-        try:
-            _, entity, key = entity_id.split("@", 2)
-            return EntityInstanceId(entity=entity, key=key)
-        except ValueError as ex:
-            raise ValueError(f"Invalid entity ID format: {entity_id}", ex)