hatchet-sdk 1.18.1__py3-none-any.whl → 1.20.0__py3-none-any.whl

hatchet_sdk/v0/hatchet.py

@@ -1,310 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Callable, Optional, ParamSpec, Type, TypeVar, Union
-
-from pydantic import BaseModel
-from typing_extensions import deprecated
-
-from hatchet_sdk.contracts.workflows_pb2 import (
-    ConcurrencyLimitStrategy,
-    CreateStepRateLimit,
-    DesiredWorkerLabels,
-    StickyStrategy,
-)
-from hatchet_sdk.v0.clients.rest_client import RestApi
-from hatchet_sdk.v0.context.context import Context
-from hatchet_sdk.v0.features.cron import CronClient
-from hatchet_sdk.v0.features.scheduled import ScheduledClient
-from hatchet_sdk.v0.labels import DesiredWorkerLabel
-from hatchet_sdk.v0.loader import ClientConfig, ConfigLoader
-from hatchet_sdk.v0.rate_limit import RateLimit
-from hatchet_sdk.v0.v2.callable import HatchetCallable
-
-from ..logger import logger
-from .client import Client, new_client, new_client_raw
-from .clients.admin import AdminClient
-from .clients.dispatcher.dispatcher import DispatcherClient
-from .clients.events import EventClient
-from .clients.run_event_listener import RunEventListenerClient
-from .worker.worker import Worker
-from .workflow import (
-    ConcurrencyExpression,
-    WorkflowInterface,
-    WorkflowMeta,
-    WorkflowStepProtocol,
-)
-
-T = TypeVar("T", bound=BaseModel)
-R = TypeVar("R")
-P = ParamSpec("P")
-
-TWorkflow = TypeVar("TWorkflow", bound=object)
-
-
-def workflow(
-    name: str = "",
-    on_events: list[str] | None = None,
-    on_crons: list[str] | None = None,
-    version: str = "",
-    timeout: str = "60m",
-    schedule_timeout: str = "5m",
-    sticky: Union[StickyStrategy.Value, None] = None,  # type: ignore[name-defined]
-    default_priority: int | None = None,
-    concurrency: ConcurrencyExpression | None = None,
-    input_validator: Type[T] | None = None,
-) -> Callable[[Type[TWorkflow]], WorkflowMeta]:
-    on_events = on_events or []
-    on_crons = on_crons or []
-
-    def inner(cls: Type[TWorkflow]) -> WorkflowMeta:
-        nonlocal name
-        name = name or str(cls.__name__)
-
-        setattr(cls, "on_events", on_events)
-        setattr(cls, "on_crons", on_crons)
-        setattr(cls, "name", name)
-        setattr(cls, "version", version)
-        setattr(cls, "timeout", timeout)
-        setattr(cls, "schedule_timeout", schedule_timeout)
-        setattr(cls, "sticky", sticky)
-        setattr(cls, "default_priority", default_priority)
-        setattr(cls, "concurrency_expression", concurrency)
-
-        # Define a new class with the same name and bases as the original, but
-        # with WorkflowMeta as its metaclass
-
-        ## TODO: Figure out how to type this metaclass correctly
-        setattr(cls, "input_validator", input_validator)
-
-        return WorkflowMeta(name, cls.__bases__, dict(cls.__dict__))
-
-    return inner
-
-
-def step(
-    name: str = "",
-    timeout: str = "",
-    parents: list[str] | None = None,
-    retries: int = 0,
-    rate_limits: list[RateLimit] | None = None,
-    desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
-    backoff_factor: float | None = None,
-    backoff_max_seconds: int | None = None,
-) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    parents = parents or []
-
-    def inner(func: Callable[P, R]) -> Callable[P, R]:
-        limits = None
-        if rate_limits:
-            limits = [rate_limit._req for rate_limit in rate_limits or []]
-
-        setattr(func, "_step_name", name.lower() or str(func.__name__).lower())
-        setattr(func, "_step_parents", parents)
-        setattr(func, "_step_timeout", timeout)
-        setattr(func, "_step_retries", retries)
-        setattr(func, "_step_rate_limits", limits)
-        setattr(func, "_step_backoff_factor", backoff_factor)
-        setattr(func, "_step_backoff_max_seconds", backoff_max_seconds)
-
-        def create_label(d: DesiredWorkerLabel) -> DesiredWorkerLabels:
-            value = d["value"] if "value" in d else None
-            return DesiredWorkerLabels(
-                strValue=str(value) if not isinstance(value, int) else None,
-                intValue=value if isinstance(value, int) else None,
-                required=d["required"] if "required" in d else None,  # type: ignore[arg-type]
-                weight=d["weight"] if "weight" in d else None,
-                comparator=d["comparator"] if "comparator" in d else None,  # type: ignore[arg-type]
-            )
-
-        setattr(
-            func,
-            "_step_desired_worker_labels",
-            {key: create_label(d) for key, d in desired_worker_labels.items()},
-        )
-
-        return func
-
-    return inner
-
-
-def on_failure_step(
-    name: str = "",
-    timeout: str = "",
-    retries: int = 0,
-    rate_limits: list[RateLimit] | None = None,
-    backoff_factor: float | None = None,
-    backoff_max_seconds: int | None = None,
-) -> Callable[..., Any]:
-    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
-        limits = None
-        if rate_limits:
-            limits = [
-                CreateStepRateLimit(key=rate_limit.static_key, units=rate_limit.units)  # type: ignore[arg-type]
-                for rate_limit in rate_limits or []
-            ]
-
-        setattr(
-            func, "_on_failure_step_name", name.lower() or str(func.__name__).lower()
-        )
-        setattr(func, "_on_failure_step_timeout", timeout)
-        setattr(func, "_on_failure_step_retries", retries)
-        setattr(func, "_on_failure_step_rate_limits", limits)
-        setattr(func, "_on_failure_step_backoff_factor", backoff_factor)
-        setattr(func, "_on_failure_step_backoff_max_seconds", backoff_max_seconds)
-
-        return func
-
-    return inner
-
-
-def concurrency(
-    name: str = "",
-    max_runs: int = 1,
-    limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
-) -> Callable[..., Any]:
-    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
-        setattr(
-            func,
-            "_concurrency_fn_name",
-            name.lower() or str(func.__name__).lower(),
-        )
-        setattr(func, "_concurrency_max_runs", max_runs)
-        setattr(func, "_concurrency_limit_strategy", limit_strategy)
-
-        return func
-
-    return inner
-
-
-class HatchetRest:
-    """
-    Main client for interacting with the Hatchet API.
-
-    This class provides access to various client interfaces and utility methods
-    for working with Hatchet via the REST API,
-
-    Attributes:
-        rest (RestApi): Interface for REST API operations.
-    """
-
-    rest: RestApi
-
-    def __init__(self, config: ClientConfig = ClientConfig()):
-        _config: ClientConfig = ConfigLoader(".").load_client_config(config)
-        self.rest = RestApi(_config.server_url, _config.token, _config.tenant_id)
-
-
-class Hatchet:
-    """
-    Main client for interacting with the Hatchet SDK.
-
-    This class provides access to various client interfaces and utility methods
-    for working with Hatchet workers, workflows, and steps.
-
-    Attributes:
-        cron (CronClient): Interface for cron trigger operations.
-
-        admin (AdminClient): Interface for administrative operations.
-        dispatcher (DispatcherClient): Interface for dispatching operations.
-        event (EventClient): Interface for event-related operations.
-        rest (RestApi): Interface for REST API operations.
-    """
-
-    _client: Client
-    cron: CronClient
-    scheduled: ScheduledClient
-
-    @classmethod
-    def from_environment(
-        cls, defaults: ClientConfig = ClientConfig(), **kwargs: Any
-    ) -> "Hatchet":
-        return cls(client=new_client(defaults), **kwargs)
-
-    @classmethod
-    def from_config(cls, config: ClientConfig, **kwargs: Any) -> "Hatchet":
-        return cls(client=new_client_raw(config), **kwargs)
-
-    def __init__(
-        self,
-        debug: bool = False,
-        client: Optional[Client] = None,
-        config: ClientConfig = ClientConfig(),
-    ):
-        """
-        Initialize a new Hatchet instance.
-
-        Args:
-            debug (bool, optional): Enable debug logging.
-            client (Optional[Client], optional): A pre-configured Client instance.
-            config (ClientConfig, optional): Configuration for creating a new Client.
-        """
-        if client is not None:
-            self._client = client
-        else:
-            self._client = new_client(config, debug)
-
-        if debug:
-            logger.setLevel(logging.DEBUG)
-
-        self.cron = CronClient(self._client)
-        self.scheduled = ScheduledClient(self._client)
-
-    @property
-    @deprecated(
-        "Direct access to client is deprecated and will be removed in a future version. Use specific client properties (Hatchet.admin, Hatchet.dispatcher, Hatchet.event, Hatchet.rest) instead. [0.32.0]",
-    )
-    def client(self) -> Client:
-        return self._client
-
-    @property
-    def admin(self) -> AdminClient:
-        return self._client.admin
-
-    @property
-    def dispatcher(self) -> DispatcherClient:
-        return self._client.dispatcher
-
-    @property
-    def event(self) -> EventClient:
-        return self._client.event
-
-    @property
-    def rest(self) -> RestApi:
-        return self._client.rest
-
-    @property
-    def listener(self) -> RunEventListenerClient:
-        return self._client.listener
-
-    @property
-    def config(self) -> ClientConfig:
-        return self._client.config
-
-    @property
-    def tenant_id(self) -> str:
-        return self._client.config.tenant_id
-
-    concurrency = staticmethod(concurrency)
-
-    workflow = staticmethod(workflow)
-
-    step = staticmethod(step)
-
-    on_failure_step = staticmethod(on_failure_step)
-
-    def worker(
-        self, name: str, max_runs: int | None = None, labels: dict[str, str | int] = {}
-    ) -> Worker:
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-
-        return Worker(
-            name=name,
-            max_runs=max_runs,
-            labels=labels,
-            config=self._client.config,
-            debug=self._client.debug,
-            owned_loop=loop is None,
-        )

hatchet_sdk/v0/labels.py

@@ -1,10 +0,0 @@
-from typing import TypedDict
-
-
-class DesiredWorkerLabel(TypedDict, total=False):
-    value: str | int
-    required: bool | None = None
-    weight: int | None = None
-    comparator: int | None = (
-        None  # _ClassVar[WorkerLabelComparator] TODO figure out type
-    )

hatchet_sdk/v0/loader.py

@@ -1,244 +0,0 @@
-import os
-from logging import Logger, getLogger
-from typing import Dict, Optional
-from warnings import warn
-
-import yaml
-
-from .token import get_addresses_from_jwt, get_tenant_id_from_jwt
-
-
-class ClientTLSConfig:
-    def __init__(
-        self,
-        tls_strategy: str,
-        cert_file: str,
-        key_file: str,
-        ca_file: str,
-        server_name: str,
-    ):
-        self.tls_strategy = tls_strategy
-        self.cert_file = cert_file
-        self.key_file = key_file
-        self.ca_file = ca_file
-        self.server_name = server_name
-
-
-class ClientConfig:
-    logInterceptor: Logger
-
-    def __init__(
-        self,
-        tenant_id: str = None,
-        tls_config: ClientTLSConfig = None,
-        token: str = None,
-        host_port: str = "localhost:7070",
-        server_url: str = "https://app.dev.hatchet-tools.com",
-        namespace: str = None,
-        listener_v2_timeout: int = None,
-        logger: Logger = None,
-        grpc_max_recv_message_length: int = 4 * 1024 * 1024,  # 4MB
-        grpc_max_send_message_length: int = 4 * 1024 * 1024,  # 4MB
-        worker_healthcheck_port: int | None = None,
-        worker_healthcheck_enabled: bool | None = None,
-        worker_preset_labels: dict[str, str] = {},
-        enable_force_kill_sync_threads: bool = False,
-    ):
-        self.tenant_id = tenant_id
-        self.tls_config = tls_config
-        self.host_port = host_port
-        self.token = token
-        self.server_url = server_url
-        self.namespace = ""
-        self.logInterceptor = logger
-        self.grpc_max_recv_message_length = grpc_max_recv_message_length
-        self.grpc_max_send_message_length = grpc_max_send_message_length
-        self.worker_healthcheck_port = worker_healthcheck_port
-        self.worker_healthcheck_enabled = worker_healthcheck_enabled
-        self.worker_preset_labels = worker_preset_labels
-        self.enable_force_kill_sync_threads = enable_force_kill_sync_threads
-
-        if not self.logInterceptor:
-            self.logInterceptor = getLogger()
-
-        # case on whether the namespace already has a trailing underscore
-        if namespace and not namespace.endswith("_"):
-            self.namespace = f"{namespace}_"
-        elif namespace:
-            self.namespace = namespace
-
-        self.namespace = self.namespace.lower()
-
-        self.listener_v2_timeout = listener_v2_timeout
-
-
-class ConfigLoader:
-    def __init__(self, directory: str):
-        self.directory = directory
-
-    def load_client_config(self, defaults: ClientConfig) -> ClientConfig:
-        config_file_path = os.path.join(self.directory, "client.yaml")
-        config_data: object = {"tls": {}}
-
-        # determine if client.yaml exists
-        if os.path.exists(config_file_path):
-            with open(config_file_path, "r") as file:
-                config_data = yaml.safe_load(file)
-
-        def get_config_value(key, env_var):
-            if key in config_data:
-                return config_data[key]
-
-            if self._get_env_var(env_var) is not None:
-                return self._get_env_var(env_var)
-
-            return getattr(defaults, key, None)
-
-        namespace = get_config_value("namespace", "HATCHET_CLIENT_NAMESPACE")
-
-        tenant_id = get_config_value("tenantId", "HATCHET_CLIENT_TENANT_ID")
-        token = get_config_value("token", "HATCHET_CLIENT_TOKEN")
-        listener_v2_timeout = get_config_value(
-            "listener_v2_timeout", "HATCHET_CLIENT_LISTENER_V2_TIMEOUT"
-        )
-        listener_v2_timeout = int(listener_v2_timeout) if listener_v2_timeout else None
-
-        if not token:
-            raise ValueError(
-                "Token must be set via HATCHET_CLIENT_TOKEN environment variable"
-            )
-
-        host_port = get_config_value("hostPort", "HATCHET_CLIENT_HOST_PORT")
-        server_url: str | None = None
-
-        grpc_max_recv_message_length = get_config_value(
-            "grpc_max_recv_message_length",
-            "HATCHET_CLIENT_GRPC_MAX_RECV_MESSAGE_LENGTH",
-        )
-        grpc_max_send_message_length = get_config_value(
-            "grpc_max_send_message_length",
-            "HATCHET_CLIENT_GRPC_MAX_SEND_MESSAGE_LENGTH",
-        )
-
-        if grpc_max_recv_message_length:
-            grpc_max_recv_message_length = int(grpc_max_recv_message_length)
-
-        if grpc_max_send_message_length:
-            grpc_max_send_message_length = int(grpc_max_send_message_length)
-
-        if not host_port:
-            # extract host and port from token
-            server_url, grpc_broadcast_address = get_addresses_from_jwt(token)
-            host_port = grpc_broadcast_address
-
-        if not tenant_id:
-            tenant_id = get_tenant_id_from_jwt(token)
-
-        tls_config = self._load_tls_config(config_data["tls"], host_port)
-
-        worker_healthcheck_port = int(
-            get_config_value(
-                "worker_healthcheck_port", "HATCHET_CLIENT_WORKER_HEALTHCHECK_PORT"
-            )
-            or 8001
-        )
-
-        worker_healthcheck_enabled = (
-            str(
-                get_config_value(
-                    "worker_healthcheck_port",
-                    "HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED",
-                )
-            )
-            == "True"
-        )
-
-        #  Add preset labels to the worker config
-        worker_preset_labels: dict[str, str] = defaults.worker_preset_labels
-
-        autoscaling_target = get_config_value(
-            "autoscaling_target", "HATCHET_CLIENT_AUTOSCALING_TARGET"
-        )
-
-        if autoscaling_target:
-            worker_preset_labels["hatchet-autoscaling-target"] = autoscaling_target
-
-        legacy_otlp_headers = get_config_value(
-            "otel_exporter_otlp_endpoint", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_ENDPOINT"
-        )
-
-        legacy_otlp_headers = get_config_value(
-            "otel_exporter_otlp_headers", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS"
-        )
-
-        if legacy_otlp_headers or legacy_otlp_headers:
-            warn(
-                "The `otel_exporter_otlp_*` fields are no longer supported as of SDK version `0.46.0`. Please see the documentation on OpenTelemetry at https://docs.hatchet.run/home/features/opentelemetry for more information on how to migrate to the new `HatchetInstrumentor`."
-            )
-
-        enable_force_kill_sync_threads = bool(
-            get_config_value(
-                "enable_force_kill_sync_threads",
-                "HATCHET_CLIENT_ENABLE_FORCE_KILL_SYNC_THREADS",
-            )
-            == "True"
-            or False
-        )
-        return ClientConfig(
-            tenant_id=tenant_id,
-            tls_config=tls_config,
-            token=token,
-            host_port=host_port,
-            server_url=server_url,
-            namespace=namespace,
-            listener_v2_timeout=listener_v2_timeout,
-            logger=defaults.logInterceptor,
-            grpc_max_recv_message_length=grpc_max_recv_message_length,
-            grpc_max_send_message_length=grpc_max_send_message_length,
-            worker_healthcheck_port=worker_healthcheck_port,
-            worker_healthcheck_enabled=worker_healthcheck_enabled,
-            worker_preset_labels=worker_preset_labels,
-            enable_force_kill_sync_threads=enable_force_kill_sync_threads,
-        )
-
-    def _load_tls_config(self, tls_data: Dict, host_port) -> ClientTLSConfig:
-        tls_strategy = (
-            tls_data["tlsStrategy"]
-            if "tlsStrategy" in tls_data
-            else self._get_env_var("HATCHET_CLIENT_TLS_STRATEGY")
-        )
-
-        if not tls_strategy:
-            tls_strategy = "tls"
-
-        cert_file = (
-            tls_data["tlsCertFile"]
-            if "tlsCertFile" in tls_data
-            else self._get_env_var("HATCHET_CLIENT_TLS_CERT_FILE")
-        )
-        key_file = (
-            tls_data["tlsKeyFile"]
-            if "tlsKeyFile" in tls_data
-            else self._get_env_var("HATCHET_CLIENT_TLS_KEY_FILE")
-        )
-        ca_file = (
-            tls_data["tlsRootCAFile"]
-            if "tlsRootCAFile" in tls_data
-            else self._get_env_var("HATCHET_CLIENT_TLS_ROOT_CA_FILE")
-        )
-
-        server_name = (
-            tls_data["tlsServerName"]
-            if "tlsServerName" in tls_data
-            else self._get_env_var("HATCHET_CLIENT_TLS_SERVER_NAME")
-        )
-
-        # if server_name is not set, use the host from the host_port
-        if not server_name:
-            server_name = host_port.split(":")[0]
-
-        return ClientTLSConfig(tls_strategy, cert_file, key_file, ca_file, server_name)
-
-    @staticmethod
-    def _get_env_var(env_var: str, default: Optional[str] = None) -> str:
-        return os.environ.get(env_var, default)

hatchet_sdk/v0/metadata.py

@@ -1,2 +0,0 @@
-def get_metadata(token: str):
-    return [("authorization", "bearer " + token)]