hatchet-sdk 1.9.1__tar.gz → 1.10.0__tar.gz

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.9.1
+Version: 1.10.0
 Summary: 
 License: MIT
 Author: Alexander Belanger

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/client.py

@@ -5,6 +5,7 @@ from hatchet_sdk.clients.listeners.run_event_listener import RunEventListenerCli
 from hatchet_sdk.clients.listeners.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.features.cron import CronClient
+from hatchet_sdk.features.filters import FiltersClient
 from hatchet_sdk.features.logs import LogsClient
 from hatchet_sdk.features.metrics import MetricsClient
 from hatchet_sdk.features.rate_limits import RateLimitsClient
@@ -34,6 +35,7 @@ class Client:
         self.debug = debug
 
         self.cron = CronClient(self.config)
+        self.filters = FiltersClient(self.config)
         self.logs = LogsClient(self.config)
         self.metrics = MetricsClient(self.config)
         self.rate_limits = RateLimitsClient(self.config)

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/admin.py

@@ -46,9 +46,7 @@ class ScheduleTriggerWorkflowOptions(BaseModel):
 
 
 class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions):
-    additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
     desired_worker_id: str | None = None
-    namespace: str | None = None
     sticky: bool = False
     key: str | None = None
 
@@ -253,8 +251,7 @@ class AdminClient:
         try:
             namespace = options.namespace or self.namespace
 
-            if namespace != "" and not name.startswith(self.namespace):
-                name = f"{namespace}{name}"
+            name = self.config.apply_namespace(name, namespace)
 
             request = self._prepare_schedule_workflow_request(
                 name, schedules, input, options
@@ -312,8 +309,7 @@ class AdminClient:
 
         namespace = options.namespace or self.namespace
 
-        if namespace != "" and not workflow_name.startswith(self.namespace):
-            workflow_name = f"{namespace}{workflow_name}"
+        workflow_name = self.config.apply_namespace(workflow_name, namespace)
 
         return self._prepare_workflow_request(workflow_name, input, trigger_options)
 

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/dispatcher/action_listener.py

@@ -73,14 +73,27 @@ class ActionPayload(BaseModel):
     step_run_errors: dict[str, str] = Field(default_factory=dict)
     triggered_by: str | None = None
     triggers: JSONSerializableMapping = Field(default_factory=dict)
+    filter_payload: JSONSerializableMapping = Field(default_factory=dict)
 
     @field_validator(
-        "input", "parents", "overrides", "user_data", "step_run_errors", mode="before"
+        "input",
+        "parents",
+        "overrides",
+        "user_data",
+        "step_run_errors",
+        "filter_payload",
+        mode="before",
     )
     @classmethod
     def validate_fields(cls, v: Any) -> Any:
         return v or {}
 
+    @model_validator(mode="after")
+    def validate_filter_payload(self) -> "ActionPayload":
+        self.filter_payload = self.triggers.get("filter_payload", {})
+
+        return self
+
 
 class ActionType(str, Enum):
     START_STEP_RUN = "START_STEP_RUN"

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/events.py

@@ -6,7 +6,12 @@ from typing import List, cast
 from google.protobuf import timestamp_pb2
 from pydantic import BaseModel, Field
 
+from hatchet_sdk.clients.rest.api.event_api import EventApi
+from hatchet_sdk.clients.rest.api.workflow_runs_api import WorkflowRunsApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.v1_event_list import V1EventList
 from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.connection import new_conn
 from hatchet_sdk.contracts.events_pb2 import (
@@ -33,6 +38,8 @@ def proto_timestamp_now() -> timestamp_pb2.Timestamp:
 class PushEventOptions(BaseModel):
     additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
     namespace: str | None = None
+    priority: int | None = None
+    scope: str | None = None
 
 
 class BulkPushEventOptions(BaseModel):
@@ -43,16 +50,26 @@ class BulkPushEventWithMetadata(BaseModel):
     key: str
     payload: JSONSerializableMapping = Field(default_factory=dict)
     additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
+    priority: int | None = None
+    scope: str | None = None
 
 
-class EventClient:
+class EventClient(BaseRestClient):
     def __init__(self, config: ClientConfig):
+        super().__init__(config)
+
         conn = new_conn(config, False)
-        self.client = EventsServiceStub(conn)
+        self.events_service_client = EventsServiceStub(conn)
 
         self.token = config.token
         self.namespace = config.namespace
 
+    def _wra(self, client: ApiClient) -> WorkflowRunsApi:
+        return WorkflowRunsApi(client)
+
+    def _ea(self, client: ApiClient) -> EventApi:
+        return EventApi(client)
+
     async def aio_push(
         self,
         event_key: str,
@@ -79,7 +96,7 @@ class EventClient:
         options: PushEventOptions = PushEventOptions(),
     ) -> Event:
         namespace = options.namespace or self.namespace
-        namespaced_event_key = namespace + event_key
+        namespaced_event_key = self.client_config.apply_namespace(event_key, namespace)
 
         try:
             meta_bytes = json.dumps(options.additional_metadata)
@@ -96,16 +113,21 @@ class EventClient:
             payload=payload_str,
             eventTimestamp=proto_timestamp_now(),
             additionalMetadata=meta_bytes,
+            priority=options.priority,
+            scope=options.scope,
         )
 
-        return cast(Event, self.client.Push(request, metadata=get_metadata(self.token)))
+        return cast(
+            Event,
+            self.events_service_client.Push(request, metadata=get_metadata(self.token)),
+        )
 
     def _create_push_event_request(
         self,
         event: BulkPushEventWithMetadata,
         namespace: str,
     ) -> PushEventRequest:
-        event_key = namespace + event.key
+        event_key = self.client_config.apply_namespace(event.key, namespace)
         payload = event.payload
 
         meta = event.additional_metadata
@@ -125,6 +147,8 @@ class EventClient:
             payload=serialized_payload,
             eventTimestamp=proto_timestamp_now(),
             additionalMetadata=meta_str,
+            priority=event.priority,
+            scope=event.scope,
         )
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
@@ -145,7 +169,9 @@ class EventClient:
         return list(
             cast(
                 Events,
-                self.client.BulkPush(bulk_request, metadata=get_metadata(self.token)),
+                self.events_service_client.BulkPush(
+                    bulk_request, metadata=get_metadata(self.token)
+                ),
             ).events
         )
 
@@ -157,7 +183,7 @@ class EventClient:
             message=message,
         )
 
-        self.client.PutLog(request, metadata=get_metadata(self.token))
+        self.events_service_client.PutLog(request, metadata=get_metadata(self.token))
 
     @tenacity_retry
     def stream(self, data: str | bytes, step_run_id: str) -> None:
@@ -174,4 +200,28 @@ class EventClient:
             message=data_bytes,
         )
 
-        self.client.PutStreamEvent(request, metadata=get_metadata(self.token))
+        self.events_service_client.PutStreamEvent(
+            request, metadata=get_metadata(self.token)
+        )
+
+    async def aio_list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        keys: list[str] | None = None,
+    ) -> V1EventList:
+        return await asyncio.to_thread(self.list, offset=offset, limit=limit, keys=keys)
+
+    def list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        keys: list[str] | None = None,
+    ) -> V1EventList:
+        with self.client() as client:
+            return self._ea(client).v1_event_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                keys=keys,
+            )

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/rest/__init__.py

@@ -20,6 +20,7 @@ __version__ = "1.0.0"
 from hatchet_sdk.clients.rest.api.api_token_api import APITokenApi
 from hatchet_sdk.clients.rest.api.default_api import DefaultApi
 from hatchet_sdk.clients.rest.api.event_api import EventApi
+from hatchet_sdk.clients.rest.api.filter_api import FilterApi
 from hatchet_sdk.clients.rest.api.github_api import GithubApi
 from hatchet_sdk.clients.rest.api.healthcheck_api import HealthcheckApi
 from hatchet_sdk.clients.rest.api.log_api import LogApi
@@ -229,7 +230,17 @@ from hatchet_sdk.clients.rest.models.user_tenant_memberships_list import (
 )
 from hatchet_sdk.clients.rest.models.user_tenant_public import UserTenantPublic
 from hatchet_sdk.clients.rest.models.v1_cancel_task_request import V1CancelTaskRequest
+from hatchet_sdk.clients.rest.models.v1_create_filter_request import (
+    V1CreateFilterRequest,
+)
 from hatchet_sdk.clients.rest.models.v1_dag_children import V1DagChildren
+from hatchet_sdk.clients.rest.models.v1_event import V1Event
+from hatchet_sdk.clients.rest.models.v1_event_list import V1EventList
+from hatchet_sdk.clients.rest.models.v1_event_workflow_run_summary import (
+    V1EventWorkflowRunSummary,
+)
+from hatchet_sdk.clients.rest.models.v1_filter import V1Filter
+from hatchet_sdk.clients.rest.models.v1_filter_list import V1FilterList
 from hatchet_sdk.clients.rest.models.v1_log_line import V1LogLine
 from hatchet_sdk.clients.rest.models.v1_log_line_level import V1LogLineLevel
 from hatchet_sdk.clients.rest.models.v1_log_line_list import V1LogLineList

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/rest/api/__init__.py

@@ -4,6 +4,7 @@
 from hatchet_sdk.clients.rest.api.api_token_api import APITokenApi
 from hatchet_sdk.clients.rest.api.default_api import DefaultApi
 from hatchet_sdk.clients.rest.api.event_api import EventApi
+from hatchet_sdk.clients.rest.api.filter_api import FilterApi
 from hatchet_sdk.clients.rest.api.github_api import GithubApi
 from hatchet_sdk.clients.rest.api.healthcheck_api import HealthcheckApi
 from hatchet_sdk.clients.rest.api.log_api import LogApi

{hatchet_sdk-1.9.1 → hatchet_sdk-1.10.0}/hatchet_sdk/clients/rest/api/event_api.py

@@ -37,6 +37,7 @@ from hatchet_sdk.clients.rest.models.event_update_cancel200_response import (
 )
 from hatchet_sdk.clients.rest.models.events import Events
 from hatchet_sdk.clients.rest.models.replay_event_request import ReplayEventRequest
+from hatchet_sdk.clients.rest.models.v1_event_list import V1EventList
 from hatchet_sdk.clients.rest.models.workflow_run_status import WorkflowRunStatus
 from hatchet_sdk.clients.rest.rest import RESTResponseType
 
@@ -2546,3 +2547,337 @@ class EventApi:
             _host=_host,
             _request_auth=_request_auth,
         )
+
+    @validate_call
+    def v1_event_list(
+        self,
+        tenant: Annotated[
+            str,
+            Field(
+                min_length=36, strict=True, max_length=36, description="The tenant id"
+            ),
+        ],
+        offset: Annotated[
+            Optional[StrictInt], Field(description="The number to skip")
+        ] = None,
+        limit: Annotated[
+            Optional[StrictInt], Field(description="The number to limit by")
+        ] = None,
+        keys: Annotated[
+            Optional[List[StrictStr]], Field(description="A list of keys to filter by")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> V1EventList:
+        """List events
+
+        Lists all events for a tenant.
+
+        :param tenant: The tenant id (required)
+        :type tenant: str
+        :param offset: The number to skip
+        :type offset: int
+        :param limit: The number to limit by
+        :type limit: int
+        :param keys: A list of keys to filter by
+        :type keys: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_event_list_serialize(
+            tenant=tenant,
+            offset=offset,
+            limit=limit,
+            keys=keys,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1EventList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+    @validate_call
+    def v1_event_list_with_http_info(
+        self,
+        tenant: Annotated[
+            str,
+            Field(
+                min_length=36, strict=True, max_length=36, description="The tenant id"
+            ),
+        ],
+        offset: Annotated[
+            Optional[StrictInt], Field(description="The number to skip")
+        ] = None,
+        limit: Annotated[
+            Optional[StrictInt], Field(description="The number to limit by")
+        ] = None,
+        keys: Annotated[
+            Optional[List[StrictStr]], Field(description="A list of keys to filter by")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[V1EventList]:
+        """List events
+
+        Lists all events for a tenant.
+
+        :param tenant: The tenant id (required)
+        :type tenant: str
+        :param offset: The number to skip
+        :type offset: int
+        :param limit: The number to limit by
+        :type limit: int
+        :param keys: A list of keys to filter by
+        :type keys: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_event_list_serialize(
+            tenant=tenant,
+            offset=offset,
+            limit=limit,
+            keys=keys,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1EventList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def v1_event_list_without_preload_content(
+        self,
+        tenant: Annotated[
+            str,
+            Field(
+                min_length=36, strict=True, max_length=36, description="The tenant id"
+            ),
+        ],
+        offset: Annotated[
+            Optional[StrictInt], Field(description="The number to skip")
+        ] = None,
+        limit: Annotated[
+            Optional[StrictInt], Field(description="The number to limit by")
+        ] = None,
+        keys: Annotated[
+            Optional[List[StrictStr]], Field(description="A list of keys to filter by")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """List events
+
+        Lists all events for a tenant.
+
+        :param tenant: The tenant id (required)
+        :type tenant: str
+        :param offset: The number to skip
+        :type offset: int
+        :param limit: The number to limit by
+        :type limit: int
+        :param keys: A list of keys to filter by
+        :type keys: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_event_list_serialize(
+            tenant=tenant,
+            offset=offset,
+            limit=limit,
+            keys=keys,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1EventList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+    def _v1_event_list_serialize(
+        self,
+        tenant,
+        offset,
+        limit,
+        keys,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            "keys": "multi",
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if tenant is not None:
+            _path_params["tenant"] = tenant
+        # process the query parameters
+        if offset is not None:
+
+            _query_params.append(("offset", offset))
+
+        if limit is not None:
+
+            _query_params.append(("limit", limit))
+
+        if keys is not None:
+
+            _query_params.append(("keys", keys))
+
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+        # set the HTTP header `Accept`
+        if "Accept" not in _header_params:
+            _header_params["Accept"] = self.api_client.select_header_accept(
+                ["application/json"]
+            )
+
+        # authentication setting
+        _auth_settings: List[str] = ["cookieAuth", "bearerAuth"]
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/api/v1/stable/tenants/{tenant}/events",
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth,
+        )