durabletask 0.0.0.dev63__tar.gz → 0.0.0.dev64__tar.gz

{durabletask-0.0.0.dev63 → durabletask-0.0.0.dev64}/PKG-INFO

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

{durabletask-0.0.0.dev63 → durabletask-0.0.0.dev64}/durabletask/client.py

@@ -6,9 +6,10 @@ import uuid
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, List, Optional, Sequence, TypeVar, Union
+from typing import Any, Optional, Sequence, TypeVar, Union
 
 import grpc
+from google.protobuf import wrappers_pb2
 
 from durabletask.entities import EntityInstanceId
 from durabletask.entities.entity_metadata import EntityMetadata
@@ -56,39 +57,6 @@ 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)
@@ -105,12 +73,6 @@ 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(
@@ -119,7 +81,7 @@ def parse_orchestration_state(state: pb.OrchestrationState) -> OrchestrationStat
             state.failureDetails.stackTrace.value if not helpers.is_empty(state.failureDetails.stackTrace) else None)
 
     return OrchestrationState(
-        state.instanceId,
+        instance_id,
         state.name,
         OrchestrationStatus(state.orchestrationStatus),
         state.createdTimestamp.ToDatetime(),
@@ -131,6 +93,7 @@ def parse_orchestration_state(state: pb.OrchestrationState) -> OrchestrationStat
 
 
 class TaskHubGrpcClient:
+
     def __init__(self, *,
                  host_address: Optional[str] = None,
                  metadata: Optional[list[tuple[str, str]]] = None,
@@ -173,7 +136,7 @@ class TaskHubGrpcClient:
         req = pb.CreateInstanceRequest(
             name=name,
             instanceId=instance_id if instance_id else uuid.uuid4().hex,
-            input=helpers.get_string_value(shared.to_json(input) if input is not None else None),
+            input=wrappers_pb2.StringValue(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,
@@ -189,42 +152,6 @@ 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]:
@@ -272,8 +199,7 @@ class TaskHubGrpcClient:
         req = pb.RaiseEventRequest(
             instanceId=instance_id,
             name=event_name,
-            input=helpers.get_string_value(shared.to_json(data) if data is not None else None)
-        )
+            input=wrappers_pb2.StringValue(value=shared.to_json(data)) if data else None)
 
         self._logger.info(f"Raising event '{event_name}' for instance '{instance_id}'.")
         self._stub.RaiseEvent(req)
@@ -283,7 +209,7 @@ class TaskHubGrpcClient:
                                 recursive: bool = True):
         req = pb.TerminateRequest(
             instanceId=instance_id,
-            output=helpers.get_string_value(shared.to_json(output) if output is not None else None),
+            output=wrappers_pb2.StringValue(value=shared.to_json(output)) if output else None,
             recursive=recursive)
 
         self._logger.info(f"Terminating instance '{instance_id}'.")
@@ -299,51 +225,10 @@ class TaskHubGrpcClient:
         self._logger.info(f"Resuming instance '{instance_id}'.")
         self._stub.ResumeInstance(req)
 
-    def restart_orchestration(self, instance_id: str, *,
-                              restart_with_new_instance_id: bool = False) -> str:
-        """Restarts an existing orchestration instance.
-
-        Args:
-            instance_id: The ID of the orchestration instance to restart.
-            restart_with_new_instance_id: If True, the restarted orchestration will use a new instance ID.
-                If False (default), the restarted orchestration will reuse the same instance ID.
-
-        Returns:
-            The instance ID of the restarted orchestration.
-        """
-        req = pb.RestartInstanceRequest(
-            instanceId=instance_id,
-            restartWithNewInstanceId=restart_with_new_instance_id)
-
-        self._logger.info(f"Restarting instance '{instance_id}'.")
-        res: pb.RestartInstanceResponse = self._stub.RestartInstance(req)
-        return res.instanceId
-
-    def purge_orchestration(self, instance_id: str, recursive: bool = True) -> PurgeInstancesResult:
+    def purge_orchestration(self, instance_id: str, recursive: bool = True):
         req = pb.PurgeInstancesRequest(instanceId=instance_id, recursive=recursive)
         self._logger.info(f"Purging instance '{instance_id}'.")
-        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)
+        self._stub.PurgeInstances(req)
 
     def signal_entity(self,
                       entity_instance_id: EntityInstanceId,
@@ -352,7 +237,7 @@ class TaskHubGrpcClient:
         req = pb.SignalEntityRequest(
             instanceId=str(entity_instance_id),
             name=operation_name,
-            input=helpers.get_string_value(shared.to_json(input) if input is not None else None),
+            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input else None,
             requestId=str(uuid.uuid4()),
             scheduledTime=None,
             parentTraceContext=None,
@@ -371,69 +256,4 @@ class TaskHubGrpcClient:
         if not res.exists:
             return None
 
-        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)
+        return EntityMetadata.from_entity_response(res, include_state)

{durabletask-0.0.0.dev63 → durabletask-0.0.0.dev64}/durabletask/entities/__init__.py

@@ -8,9 +8,7 @@ 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",
-           "EntityOperationFailedException"]
+__all__ = ["EntityInstanceId", "DurableEntity", "EntityLock", "EntityContext", "EntityMetadata"]
 
 PACKAGE_NAME = "durabletask.entities"

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

@@ -0,0 +1,42 @@
+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)

{durabletask-0.0.0.dev63 → durabletask-0.0.0.dev64}/durabletask/entities/entity_metadata.py

@@ -44,22 +44,18 @@ 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.instanceId)
+            entity_id = EntityInstanceId.parse(entity_response.entity.instanceId)
         except ValueError:
             raise ValueError("Invalid entity instance ID in entity response.")
         entity_state = None
         if includes_state:
-            entity_state = entity.serializedState.value
+            entity_state = entity_response.entity.serializedState.value
         return EntityMetadata(
             id=entity_id,
-            last_modified=entity.lastModifiedTime.ToDatetime(timezone.utc),
-            backlog_queue_size=entity.backlogQueueSize,
-            locked_by=entity.lockedBy.value,
+            last_modified=entity_response.entity.lastModifiedTime.ToDatetime(timezone.utc),
+            backlog_queue_size=entity_response.entity.backlogQueueSize,
+            locked_by=entity_response.entity.lockedBy.value,
             includes_state=includes_state,
             state=entity_state
         )

{durabletask-0.0.0.dev63 → durabletask-0.0.0.dev64}/durabletask/internal/helpers.py

@@ -184,13 +184,6 @@ 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="")