hatchet-sdk 0.47.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

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

@@ -1,123 +1,4 @@
 import asyncio
-import inspect
-from concurrent.futures import Executor
-from functools import partial, wraps
-from threading import Thread
-from typing import Any
-
-
-## TODO: Stricter typing here
-def sync_to_async(func: Any) -> Any:
-    """
-    A decorator to run a synchronous function or coroutine in an asynchronous context with added
-    asyncio loop safety.
-
-    This decorator allows you to safely call synchronous functions or coroutines from an
-    asynchronous function by running them in an executor.
-
-    Args:
-        func (callable): The synchronous function or coroutine to be run asynchronously.
-
-    Returns:
-        callable: An asynchronous wrapper function that runs the given function in an executor.
-
-    Example:
-        @sync_to_async
-        def sync_function(x, y):
-            return x + y
-
-        @sync_to_async
-        async def async_function(x, y):
-            return x + y
-
-
-        def undecorated_function(x, y):
-            return x + y
-
-        async def main():
-            result1 = await sync_function(1, 2)
-            result2 = await async_function(3, 4)
-            result3 = await sync_to_async(undecorated_function)(5, 6)
-            print(result1, result2, result3)
-
-        asyncio.run(main())
-    """
-
-    ## TODO: Stricter typing here
-    @wraps(func)
-    async def run(
-        *args: Any,
-        loop: asyncio.AbstractEventLoop | None = None,
-        executor: Executor | None = None,
-        **kwargs: Any
-    ) -> Any:
-        """
-        The asynchronous wrapper function that runs the given function in an executor.
-
-        Args:
-            *args: Positional arguments to pass to the function.
-            loop (asyncio.AbstractEventLoop, optional): The event loop to use. If None, the current running loop is used.
-            executor (concurrent.futures.Executor, optional): The executor to use. If None, the default executor is used.
-            **kwargs: Keyword arguments to pass to the function.
-
-        Returns:
-            The result of the function call.
-        """
-        if loop is None:
-            loop = asyncio.get_running_loop()
-
-        if inspect.iscoroutinefunction(func):
-            # Wrap the coroutine to run it in an executor
-            async def wrapper() -> Any:
-                return await func(*args, **kwargs)
-
-            pfunc = partial(asyncio.run, wrapper())
-            return await loop.run_in_executor(executor, pfunc)
-        else:
-            # Run the synchronous function in an executor
-            pfunc = partial(func, *args, **kwargs)
-            return await loop.run_in_executor(executor, pfunc)
-
-    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, *a, **kw) -> 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, *a, **kw) -> 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:

hatchet_sdk/utils/proto_enums.py

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

hatchet_sdk/utils/timedelta_to_expression.py

@@ -0,0 +1,23 @@
+from datetime import timedelta
+
+DAY = 86400
+HOUR = 3600
+MINUTE = 60
+
+Duration = timedelta | str
+
+
+def timedelta_to_expr(td: Duration) -> str:
+    if isinstance(td, str):
+        return td
+
+    seconds = td.seconds
+
+    if seconds % DAY == 0:
+        return f"{seconds // DAY}d"
+    elif seconds % HOUR == 0:
+        return f"{seconds // HOUR}h"
+    elif seconds % MINUTE == 0:
+        return f"{seconds // MINUTE}m"
+    else:
+        return f"{seconds}s"

hatchet_sdk/utils/typing.py

@@ -1,12 +1,20 @@
-from typing import Any, Type, TypeGuard, TypeVar
+from typing import Any, Mapping, Type, TypeGuard, TypeVar
 
 from pydantic import BaseModel
 
 T = TypeVar("T", bound=BaseModel)
 
 
-def is_basemodel_subclass(model: Any) -> bool:
+def is_basemodel_subclass(model: Any) -> TypeGuard[Type[BaseModel]]:
     try:
         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