hatchet-sdk 0.46.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

hatchet_sdk/rate_limit.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
-from typing import Union
+from enum import Enum
 
-from celpy import CELEvalError, Environment
+from celpy import CELEvalError, Environment  # type: ignore
 
 from hatchet_sdk.contracts.workflows_pb2 import CreateStepRateLimit
 
@@ -15,7 +15,7 @@ def validate_cel_expression(expr: str) -> bool:
         return False
 
 
-class RateLimitDuration:
+class RateLimitDuration(str, Enum):
     SECOND = "SECOND"
     MINUTE = "MINUTE"
     HOUR = "HOUR"
@@ -40,7 +40,6 @@ class RateLimit:
         units (int or str, default=1): The number of units or a CEL expression for dynamic unit calculation.
         limit (int or str, optional): The rate limit value or a CEL expression for dynamic limit calculation.
         duration (str, default=RateLimitDuration.MINUTE): The window duration of the rate limit.
-        key (str, optional): Deprecated. Use static_key instead.
 
     Usage:
         1. Static rate limit:
@@ -61,29 +60,21 @@ class RateLimit:
 
     Raises:
         ValueError: If invalid combinations of attributes are provided or if CEL expressions are invalid.
-        DeprecationWarning: If the deprecated 'key' attribute is used.
     """
 
-    key: Union[str, None] = None
-    static_key: Union[str, None] = None
-    dynamic_key: Union[str, None] = None
-    units: Union[int, str] = 1
-    limit: Union[int, str, None] = None
+    static_key: str | None = None
+    dynamic_key: str | None = None
+    units: str | int = 1
+    limit: int | str | None = None
     duration: RateLimitDuration = RateLimitDuration.MINUTE
 
-    _req: CreateStepRateLimit = None
+    _req: CreateStepRateLimit | None = None
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         # juggle the key and key_expr fields
         key = self.static_key
         key_expression = self.dynamic_key
 
-        if self.key is not None:
-            DeprecationWarning(
-                "key is deprecated and will be removed in a future release, please use static_key instead"
-            )
-            key = self.key
-
         if key_expression is not None:
             if key is not None:
                 raise ValueError("Cannot have both static key and dynamic key set")

hatchet_sdk/token.py

@@ -1,20 +1,25 @@
 import base64
-import json
 
+from pydantic import BaseModel
 
-def get_tenant_id_from_jwt(token: str) -> str:
-    claims = extract_claims_from_jwt(token)
 
-    return claims.get("sub")
+class Claims(BaseModel):
+    sub: str
+    server_url: str
+    grpc_broadcast_address: str
+
+
+def get_tenant_id_from_jwt(token: str) -> str:
+    return extract_claims_from_jwt(token).sub
 
 
-def get_addresses_from_jwt(token: str) -> (str, str):
+def get_addresses_from_jwt(token: str) -> tuple[str, str]:
     claims = extract_claims_from_jwt(token)
 
-    return claims.get("server_url"), claims.get("grpc_broadcast_address")
+    return claims.server_url, claims.grpc_broadcast_address
 
 
-def extract_claims_from_jwt(token: str):
+def extract_claims_from_jwt(token: str) -> Claims:
     parts = token.split(".")
     if len(parts) != 3:
         raise ValueError("Invalid token format")
@@ -22,6 +27,5 @@ def extract_claims_from_jwt(token: str):
     claims_part = parts[1]
     claims_part += "=" * ((4 - len(claims_part) % 4) % 4)  # Padding for base64 decoding
     claims_data = base64.urlsafe_b64decode(claims_part)
-    claims = json.loads(claims_data)
 
-    return claims
+    return Claims.model_validate_json(claims_data)

hatchet_sdk/utils/aio_utils.py

@@ -2,7 +2,6 @@ import asyncio
 import inspect
 from concurrent.futures import Executor
 from functools import partial, wraps
-from threading import Thread
 from typing import Any
 
 
@@ -81,45 +80,6 @@ def sync_to_async(func: Any) -> Any:
     return run
 
 
-class EventLoopThread:
-    """A class that manages an asyncio event loop running in a separate thread."""
-
-    def __init__(self) -> None:
-        """
-        Initializes the EventLoopThread by creating an event loop
-        and setting up a thread to run the loop.
-        """
-        self.loop = asyncio.new_event_loop()
-        self.thread = Thread(target=self.run_loop_in_thread, args=(self.loop,))
-
-    def __enter__(self) -> asyncio.AbstractEventLoop:
-        """
-        Starts the thread running the event loop when entering the context.
-
-        Returns:
-            asyncio.AbstractEventLoop: The event loop running in the separate thread.
-        """
-        self.thread.start()
-        return self.loop
-
-    def __exit__(self) -> None:
-        """
-        Stops the event loop and joins the thread when exiting the context.
-        """
-        self.loop.call_soon_threadsafe(self.loop.stop)
-        self.thread.join()
-
-    def run_loop_in_thread(self, loop: asyncio.AbstractEventLoop) -> None:
-        """
-        Sets the event loop for the current thread and runs it forever.
-
-        Args:
-            loop (asyncio.AbstractEventLoop): The event loop to run.
-        """
-        asyncio.set_event_loop(loop)
-        loop.run_forever()
-
-
 def get_active_event_loop() -> asyncio.AbstractEventLoop | None:
     """
     Get the active event loop.

hatchet_sdk/utils/proto_enums.py

@@ -0,0 +1,54 @@
+from enum import Enum
+from typing import Type, TypeVar, overload
+
+from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
+
+TProtoEnumValue = TypeVar("TProtoEnumValue", bound=int)
+
+TProtoEnum = TypeVar("TProtoEnum", bound=EnumTypeWrapper)
+TPythonEnum = TypeVar("TPythonEnum", bound=Enum)
+
+
+def convert_python_enum_to_proto(
+    value: TPythonEnum | None, proto_enum: TProtoEnum
+) -> int | None:
+    if value is None:
+        return None
+
+    names = [item.name for item in proto_enum.DESCRIPTOR.values]
+
+    for name in names:
+        if name == value.name:
+            return proto_enum.Value(value.name)
+
+    raise ValueError(f"Value must be one of {names}. Got: {value}")
+
+
+@overload
+def convert_proto_enum_to_python(
+    value: TProtoEnumValue, python_enum_class: Type[TPythonEnum], proto_enum: TProtoEnum
+) -> TPythonEnum: ...
+
+
+@overload
+def convert_proto_enum_to_python(
+    value: None, python_enum_class: Type[TPythonEnum], proto_enum: TProtoEnum
+) -> None: ...
+
+
+def convert_proto_enum_to_python(
+    value: TProtoEnumValue | None,
+    python_enum_class: Type[TPythonEnum],
+    proto_enum: TProtoEnum,
+) -> TPythonEnum | None:
+    if value is None:
+        return None
+
+    return python_enum_class[proto_enum.Name(value)]
+
+
+def maybe_int_to_str(value: int | None) -> str | None:
+    if value is None:
+        return None
+
+    return str(value)

hatchet_sdk/utils/typing.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeGuard, TypeVar
+from typing import Any, Mapping, Type, TypeVar
 
 from pydantic import BaseModel
 
@@ -10,3 +10,11 @@ def is_basemodel_subclass(model: Any) -> bool:
         return issubclass(model, BaseModel)
     except TypeError:
         return False
+
+
+class WorkflowValidator(BaseModel):
+    workflow_input: Type[BaseModel] | None = None
+    step_output: Type[BaseModel] | None = None
+
+
+JSONSerializableMapping = Mapping[str, Any]

hatchet_sdk/v0/__init__.py

@@ -0,0 +1,251 @@
+from hatchet_sdk.v0.clients.rest.models.accept_invite_request import AcceptInviteRequest
+
+# import models into sdk package
+from hatchet_sdk.v0.clients.rest.models.api_error import APIError
+from hatchet_sdk.v0.clients.rest.models.api_errors import APIErrors
+from hatchet_sdk.v0.clients.rest.models.api_meta import APIMeta
+from hatchet_sdk.v0.clients.rest.models.api_meta_auth import APIMetaAuth
+from hatchet_sdk.v0.clients.rest.models.api_meta_integration import APIMetaIntegration
+from hatchet_sdk.v0.clients.rest.models.api_resource_meta import APIResourceMeta
+from hatchet_sdk.v0.clients.rest.models.api_token import APIToken
+from hatchet_sdk.v0.clients.rest.models.create_api_token_request import (
+    CreateAPITokenRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.create_api_token_response import (
+    CreateAPITokenResponse,
+)
+from hatchet_sdk.v0.clients.rest.models.create_pull_request_from_step_run import (
+    CreatePullRequestFromStepRun,
+)
+from hatchet_sdk.v0.clients.rest.models.create_tenant_invite_request import (
+    CreateTenantInviteRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.create_tenant_request import CreateTenantRequest
+from hatchet_sdk.v0.clients.rest.models.event import Event
+from hatchet_sdk.v0.clients.rest.models.event_data import EventData
+from hatchet_sdk.v0.clients.rest.models.event_key_list import EventKeyList
+from hatchet_sdk.v0.clients.rest.models.event_list import EventList
+from hatchet_sdk.v0.clients.rest.models.event_order_by_direction import (
+    EventOrderByDirection,
+)
+from hatchet_sdk.v0.clients.rest.models.event_order_by_field import EventOrderByField
+from hatchet_sdk.v0.clients.rest.models.event_workflow_run_summary import (
+    EventWorkflowRunSummary,
+)
+from hatchet_sdk.v0.clients.rest.models.get_step_run_diff_response import (
+    GetStepRunDiffResponse,
+)
+from hatchet_sdk.v0.clients.rest.models.github_app_installation import (
+    GithubAppInstallation,
+)
+from hatchet_sdk.v0.clients.rest.models.github_branch import GithubBranch
+from hatchet_sdk.v0.clients.rest.models.github_repo import GithubRepo
+from hatchet_sdk.v0.clients.rest.models.job import Job
+from hatchet_sdk.v0.clients.rest.models.job_run import JobRun
+from hatchet_sdk.v0.clients.rest.models.job_run_status import JobRunStatus
+from hatchet_sdk.v0.clients.rest.models.link_github_repository_request import (
+    LinkGithubRepositoryRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.list_api_tokens_response import (
+    ListAPITokensResponse,
+)
+from hatchet_sdk.v0.clients.rest.models.list_github_app_installations_response import (
+    ListGithubAppInstallationsResponse,
+)
+from hatchet_sdk.v0.clients.rest.models.list_pull_requests_response import (
+    ListPullRequestsResponse,
+)
+from hatchet_sdk.v0.clients.rest.models.log_line import LogLine
+from hatchet_sdk.v0.clients.rest.models.log_line_level import LogLineLevel
+from hatchet_sdk.v0.clients.rest.models.log_line_list import LogLineList
+from hatchet_sdk.v0.clients.rest.models.log_line_order_by_direction import (
+    LogLineOrderByDirection,
+)
+from hatchet_sdk.v0.clients.rest.models.log_line_order_by_field import (
+    LogLineOrderByField,
+)
+from hatchet_sdk.v0.clients.rest.models.pagination_response import PaginationResponse
+from hatchet_sdk.v0.clients.rest.models.pull_request import PullRequest
+from hatchet_sdk.v0.clients.rest.models.pull_request_state import PullRequestState
+from hatchet_sdk.v0.clients.rest.models.reject_invite_request import RejectInviteRequest
+from hatchet_sdk.v0.clients.rest.models.replay_event_request import ReplayEventRequest
+from hatchet_sdk.v0.clients.rest.models.rerun_step_run_request import (
+    RerunStepRunRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.step import Step
+from hatchet_sdk.v0.clients.rest.models.step_run import StepRun
+from hatchet_sdk.v0.clients.rest.models.step_run_diff import StepRunDiff
+from hatchet_sdk.v0.clients.rest.models.step_run_status import StepRunStatus
+from hatchet_sdk.v0.clients.rest.models.tenant import Tenant
+from hatchet_sdk.v0.clients.rest.models.tenant_invite import TenantInvite
+from hatchet_sdk.v0.clients.rest.models.tenant_invite_list import TenantInviteList
+from hatchet_sdk.v0.clients.rest.models.tenant_list import TenantList
+from hatchet_sdk.v0.clients.rest.models.tenant_member import TenantMember
+from hatchet_sdk.v0.clients.rest.models.tenant_member_list import TenantMemberList
+from hatchet_sdk.v0.clients.rest.models.tenant_member_role import TenantMemberRole
+from hatchet_sdk.v0.clients.rest.models.trigger_workflow_run_request import (
+    TriggerWorkflowRunRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.update_tenant_invite_request import (
+    UpdateTenantInviteRequest,
+)
+from hatchet_sdk.v0.clients.rest.models.user import User
+from hatchet_sdk.v0.clients.rest.models.user_login_request import UserLoginRequest
+from hatchet_sdk.v0.clients.rest.models.user_register_request import UserRegisterRequest
+from hatchet_sdk.v0.clients.rest.models.user_tenant_memberships_list import (
+    UserTenantMembershipsList,
+)
+from hatchet_sdk.v0.clients.rest.models.user_tenant_public import UserTenantPublic
+from hatchet_sdk.v0.clients.rest.models.worker_list import WorkerList
+from hatchet_sdk.v0.clients.rest.models.workflow import Workflow
+from hatchet_sdk.v0.clients.rest.models.workflow_deployment_config import (
+    WorkflowDeploymentConfig,
+)
+from hatchet_sdk.v0.clients.rest.models.workflow_list import WorkflowList
+from hatchet_sdk.v0.clients.rest.models.workflow_run import WorkflowRun
+from hatchet_sdk.v0.clients.rest.models.workflow_run_list import WorkflowRunList
+from hatchet_sdk.v0.clients.rest.models.workflow_run_status import WorkflowRunStatus
+from hatchet_sdk.v0.clients.rest.models.workflow_run_triggered_by import (
+    WorkflowRunTriggeredBy,
+)
+from hatchet_sdk.v0.clients.rest.models.workflow_tag import WorkflowTag
+from hatchet_sdk.v0.clients.rest.models.workflow_trigger_cron_ref import (
+    WorkflowTriggerCronRef,
+)
+from hatchet_sdk.v0.clients.rest.models.workflow_trigger_event_ref import (
+    WorkflowTriggerEventRef,
+)
+from hatchet_sdk.v0.clients.rest.models.workflow_triggers import WorkflowTriggers
+from hatchet_sdk.v0.clients.rest.models.workflow_version import WorkflowVersion
+from hatchet_sdk.v0.clients.rest.models.workflow_version_definition import (
+    WorkflowVersionDefinition,
+)
+from hatchet_sdk.v0.clients.rest.models.workflow_version_meta import WorkflowVersionMeta
+from hatchet_sdk.v0.contracts.workflows_pb2 import (
+    ConcurrencyLimitStrategy,
+    CreateWorkflowVersionOpts,
+    RateLimitDuration,
+    StickyStrategy,
+    WorkerLabelComparator,
+)
+from hatchet_sdk.v0.utils.aio_utils import sync_to_async
+
+from .client import new_client
+from .clients.admin import (
+    ChildTriggerWorkflowOptions,
+    DedupeViolationErr,
+    ScheduleTriggerWorkflowOptions,
+    TriggerWorkflowOptions,
+)
+from .clients.events import PushEventOptions
+from .clients.run_event_listener import StepRunEventType, WorkflowRunEventType
+from .context.context import Context
+from .context.worker_context import WorkerContext
+from .hatchet import ClientConfig, Hatchet, concurrency, on_failure_step, step, workflow
+from .worker import Worker, WorkerStartOptions, WorkerStatus
+from .workflow import ConcurrencyExpression
+
+__all__ = [
+    "AcceptInviteRequest",
+    "APIError",
+    "APIErrors",
+    "APIMeta",
+    "APIMetaAuth",
+    "APIMetaIntegration",
+    "APIResourceMeta",
+    "APIToken",
+    "CreateAPITokenRequest",
+    "CreateAPITokenResponse",
+    "CreatePullRequestFromStepRun",
+    "CreateTenantInviteRequest",
+    "CreateTenantRequest",
+    "Event",
+    "EventData",
+    "EventKeyList",
+    "EventList",
+    "EventOrderByDirection",
+    "EventOrderByField",
+    "EventWorkflowRunSummary",
+    "GetStepRunDiffResponse",
+    "GithubAppInstallation",
+    "GithubBranch",
+    "GithubRepo",
+    "Job",
+    "JobRun",
+    "JobRunStatus",
+    "LinkGithubRepositoryRequest",
+    "ListAPITokensResponse",
+    "ListGithubAppInstallationsResponse",
+    "ListPullRequestsResponse",
+    "LogLine",
+    "LogLineLevel",
+    "LogLineList",
+    "LogLineOrderByDirection",
+    "LogLineOrderByField",
+    "PaginationResponse",
+    "PullRequest",
+    "PullRequestState",
+    "RejectInviteRequest",
+    "ReplayEventRequest",
+    "RerunStepRunRequest",
+    "Step",
+    "StepRun",
+    "StepRunDiff",
+    "StepRunStatus",
+    "sync_to_async",
+    "Tenant",
+    "TenantInvite",
+    "TenantInviteList",
+    "TenantList",
+    "TenantMember",
+    "TenantMemberList",
+    "TenantMemberRole",
+    "TriggerWorkflowRunRequest",
+    "UpdateTenantInviteRequest",
+    "User",
+    "UserLoginRequest",
+    "UserRegisterRequest",
+    "UserTenantMembershipsList",
+    "UserTenantPublic",
+    "Worker",
+    "WorkerLabelComparator",
+    "WorkerList",
+    "Workflow",
+    "WorkflowDeploymentConfig",
+    "WorkflowList",
+    "WorkflowRun",
+    "WorkflowRunList",
+    "WorkflowRunStatus",
+    "WorkflowRunTriggeredBy",
+    "WorkflowTag",
+    "WorkflowTriggerCronRef",
+    "WorkflowTriggerEventRef",
+    "WorkflowTriggers",
+    "WorkflowVersion",
+    "WorkflowVersionDefinition",
+    "WorkflowVersionMeta",
+    "ConcurrencyLimitStrategy",
+    "CreateWorkflowVersionOpts",
+    "RateLimitDuration",
+    "StickyStrategy",
+    "new_client",
+    "ChildTriggerWorkflowOptions",
+    "DedupeViolationErr",
+    "ScheduleTriggerWorkflowOptions",
+    "TriggerWorkflowOptions",
+    "PushEventOptions",
+    "StepRunEventType",
+    "WorkflowRunEventType",
+    "Context",
+    "WorkerContext",
+    "ClientConfig",
+    "Hatchet",
+    "concurrency",
+    "on_failure_step",
+    "step",
+    "workflow",
+    "Worker",
+    "WorkerStartOptions",
+    "WorkerStatus",
+    "ConcurrencyExpression",
+]

hatchet_sdk/v0/client.py

@@ -0,0 +1,119 @@
+import asyncio
+from logging import Logger
+from typing import Callable
+
+import grpc
+
+from hatchet_sdk.v0.clients.run_event_listener import RunEventListenerClient
+from hatchet_sdk.v0.clients.workflow_listener import PooledWorkflowRunListener
+from hatchet_sdk.v0.connection import new_conn
+
+from .clients.admin import AdminClient, new_admin
+from .clients.dispatcher.dispatcher import DispatcherClient, new_dispatcher
+from .clients.events import EventClient, new_event
+from .clients.rest_client import RestApi
+from .loader import ClientConfig, ConfigLoader
+
+
+class Client:
+    admin: AdminClient
+    dispatcher: DispatcherClient
+    event: EventClient
+    rest: RestApi
+    workflow_listener: PooledWorkflowRunListener
+    logInterceptor: Logger
+    debug: bool = False
+
+    @classmethod
+    def from_environment(
+        cls,
+        defaults: ClientConfig = ClientConfig(),
+        debug: bool = False,
+        *opts_functions: Callable[[ClientConfig], None],
+    ):
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        config: ClientConfig = ConfigLoader(".").load_client_config(defaults)
+        for opt_function in opts_functions:
+            opt_function(config)
+
+        return cls.from_config(config, debug)
+
+    @classmethod
+    def from_config(
+        cls,
+        config: ClientConfig = ClientConfig(),
+        debug: bool = False,
+    ):
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        if config.tls_config is None:
+            raise ValueError("TLS config is required")
+
+        if config.host_port is None:
+            raise ValueError("Host and port are required")
+
+        conn: grpc.Channel = new_conn(config)
+
+        # Instantiate clients
+        event_client = new_event(conn, config)
+        admin_client = new_admin(config)
+        dispatcher_client = new_dispatcher(config)
+        rest_client = RestApi(config.server_url, config.token, config.tenant_id)
+        workflow_listener = None  # Initialize this if needed
+
+        return cls(
+            event_client,
+            admin_client,
+            dispatcher_client,
+            workflow_listener,
+            rest_client,
+            config,
+            debug,
+        )
+
+    def __init__(
+        self,
+        event_client: EventClient,
+        admin_client: AdminClient,
+        dispatcher_client: DispatcherClient,
+        workflow_listener: PooledWorkflowRunListener,
+        rest_client: RestApi,
+        config: ClientConfig,
+        debug: bool = False,
+    ):
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        self.admin = admin_client
+        self.dispatcher = dispatcher_client
+        self.event = event_client
+        self.rest = rest_client
+        self.config = config
+        self.listener = RunEventListenerClient(config)
+        self.workflow_listener = workflow_listener
+        self.logInterceptor = config.logInterceptor
+        self.debug = debug
+
+
+def with_host_port(host: str, port: int):
+    def with_host_port_impl(config: ClientConfig):
+        config.host = host
+        config.port = port
+
+    return with_host_port_impl
+
+
+new_client = Client.from_environment
+new_client_raw = Client.from_config