hatchet-sdk 1.0.0a1__tar.gz → 1.0.2__tar.gz

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.0.0a1
+Version: 1.0.2
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run
@@ -29,6 +29,7 @@ Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: protobuf (>=5.29.1,<6.0.0)
 Requires-Dist: pydantic (>=2.6.3,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.7.1,<3.0.0)
+Requires-Dist: pytest-timeout (>=2.3.1,<3.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: tenacity (>=8.4.1)

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/__init__.py

@@ -98,6 +98,7 @@ from hatchet_sdk.clients.rest.models.user_tenant_memberships_list import (
     UserTenantMembershipsList,
 )
 from hatchet_sdk.clients.rest.models.user_tenant_public import UserTenantPublic
+from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
 from hatchet_sdk.clients.rest.models.worker_list import WorkerList
 from hatchet_sdk.clients.rest.models.workflow import Workflow
 from hatchet_sdk.clients.rest.models.workflow_deployment_config import (
@@ -135,6 +136,7 @@ from hatchet_sdk.contracts.workflows_pb2 import (
     RateLimitDuration,
     WorkerLabelComparator,
 )
+from hatchet_sdk.features.runs import BulkCancelReplayOpts, RunFilter
 from hatchet_sdk.hatchet import Hatchet
 from hatchet_sdk.runnables.task import Task
 from hatchet_sdk.runnables.types import (
@@ -264,4 +266,7 @@ __all__ = [
     "DurableContext",
     "RegisterDurableEventRequest",
     "TaskDefaults",
+    "BulkCancelReplayOpts",
+    "RunFilter",
+    "V1TaskStatus",
 ]

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/client.py

@@ -5,11 +5,18 @@ import grpc
 from hatchet_sdk.clients.admin import AdminClient
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 from hatchet_sdk.clients.events import EventClient, new_event
-from hatchet_sdk.clients.rest_client import RestApi
 from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.connection import new_conn
+from hatchet_sdk.features.cron import CronClient
+from hatchet_sdk.features.logs import LogsClient
+from hatchet_sdk.features.metrics import MetricsClient
+from hatchet_sdk.features.rate_limits import RateLimitsClient
+from hatchet_sdk.features.runs import RunsClient
+from hatchet_sdk.features.scheduled import ScheduledClient
+from hatchet_sdk.features.workers import WorkersClient
+from hatchet_sdk.features.workflows import WorkflowsClient
 
 
 class Client:
@@ -20,7 +27,6 @@ class Client:
         admin_client: AdminClient | None = None,
         dispatcher_client: DispatcherClient | None = None,
         workflow_listener: PooledWorkflowRunListener | None | None = None,
-        rest_client: RestApi | None = None,
         debug: bool = False,
     ):
         try:
@@ -35,10 +41,16 @@ class Client:
         self.admin = admin_client or AdminClient(config)
         self.dispatcher = dispatcher_client or DispatcherClient(config)
         self.event = event_client or new_event(conn, config)
-        self.rest = rest_client or RestApi(
-            config.server_url, config.token, config.tenant_id
-        )
         self.listener = RunEventListenerClient(config)
         self.workflow_listener = workflow_listener
         self.logInterceptor = config.logger
         self.debug = debug
+
+        self.cron = CronClient(self.config)
+        self.logs = LogsClient(self.config)
+        self.metrics = MetricsClient(self.config)
+        self.rate_limits = RateLimitsClient(self.config)
+        self.runs = RunsClient(self.config)
+        self.scheduled = ScheduledClient(self.config)
+        self.workers = WorkersClient(self.config)
+        self.workflows = WorkflowsClient(self.config)

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/clients/admin.py

@@ -163,12 +163,6 @@ class AdminClient:
         workflow: workflow_protos.CreateWorkflowVersionRequest,
         overrides: workflow_protos.CreateWorkflowVersionRequest | None = None,
     ) -> workflow_protos.CreateWorkflowVersionResponse:
-        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
-        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
-        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
-        if not self.pooled_workflow_listener:
-            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
         return await asyncio.to_thread(self.put_workflow, name, workflow, overrides)
 
     @tenacity_retry
@@ -178,12 +172,6 @@ class AdminClient:
         limit: int,
         duration: RateLimitDuration = RateLimitDuration.SECOND,
     ) -> None:
-        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
-        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
-        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
-        if not self.pooled_workflow_listener:
-            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
         return await asyncio.to_thread(self.put_rate_limit, key, limit, duration)
 
     @tenacity_retry
@@ -194,12 +182,6 @@ class AdminClient:
         input: JSONSerializableMapping = {},
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> v0_workflow_protos.WorkflowVersion:
-        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
-        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
-        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
-        if not self.pooled_workflow_listener:
-            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
         return await asyncio.to_thread(
             self.schedule_workflow, name, schedules, input, options
         )
@@ -334,6 +316,7 @@ class AdminClient:
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
                 raise DedupeViolationErr(e.details())
+            raise e
 
         return WorkflowRunRef(
             workflow_run_id=resp.workflow_run_id,

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/clients/dispatcher/action_listener.py

@@ -277,9 +277,7 @@ class ActionListener:
                         )
 
                         t.cancel()
-
-                        if listener:
-                            listener.cancel()
+                        listener.cancel()
 
                         break
 
@@ -421,7 +419,7 @@ class ActionListener:
         except Exception as e:
             logger.error(f"failed to unregister: {e}")
 
-        if self.interrupt:
+        if self.interrupt:  # type: ignore[truthy-bool]
             self.interrupt.set()
 
     def unregister(self) -> WorkerUnsubscribeRequest:

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/clients/durable_event_listener.py

@@ -159,8 +159,8 @@ class DurableEventListener:
                                 )
 
                                 t.cancel()
-                                if self.listener:
-                                    self.listener.cancel()
+                                self.listener.cancel()
+
                                 await asyncio.sleep(
                                     DEFAULT_DURABLE_EVENT_LISTENER_RETRY_INTERVAL
                                 )
@@ -237,6 +237,8 @@ class DurableEventListener:
         del self.events[subscription_id]
 
     async def subscribe(self, task_id: str, signal_key: str) -> DurableEvent:
+        subscription_id: int | None = None
+
         try:
             # create a new subscription id, place a mutex on the counter
             async with self.subscription_counter_lock:
@@ -275,7 +277,8 @@ class DurableEventListener:
         except asyncio.CancelledError:
             raise
         finally:
-            self.cleanup_subscription(subscription_id)
+            if subscription_id:
+                self.cleanup_subscription(subscription_id)
 
     async def _retry_subscribe(
         self,

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/clients/events.py

@@ -86,8 +86,7 @@ class EventClient:
         namespaced_event_key = namespace + event_key
 
         try:
-            meta = options.additional_metadata
-            meta_bytes = None if meta is None else json.dumps(meta)
+            meta_bytes = json.dumps(options.additional_metadata)
         except Exception as e:
             raise ValueError(f"Error encoding meta: {e}")
 

{hatchet_sdk-1.0.0a1/hatchet_sdk/v0 → hatchet_sdk-1.0.2/hatchet_sdk}/clients/rest/models/workflow_runs_metrics.py

@@ -22,13 +22,17 @@ from typing import Any, ClassVar, Dict, List, Optional, Set
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import Self
 
+from hatchet_sdk.clients.rest.models.workflow_runs_metrics_counts import (
+    WorkflowRunsMetricsCounts,
+)
+
 
 class WorkflowRunsMetrics(BaseModel):
     """
     WorkflowRunsMetrics
     """  # noqa: E501
 
-    counts: Optional[Dict[str, Any]] = None
+    counts: Optional[WorkflowRunsMetricsCounts] = None
     __properties: ClassVar[List[str]] = ["counts"]
 
     model_config = ConfigDict(

hatchet_sdk-1.0.2/hatchet_sdk/clients/v1/api_client.py

@@ -0,0 +1,81 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import AsyncContextManager, Callable, Coroutine, ParamSpec, TypeVar
+
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.configuration import Configuration
+from hatchet_sdk.config import ClientConfig
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+
+## Type variables to use with coroutines.
+## See https://stackoverflow.com/questions/73240620/the-right-way-to-type-hint-a-coroutine-function
+## Return type
+R = TypeVar("R")
+
+## Yield type
+Y = TypeVar("Y")
+
+## Send type
+S = TypeVar("S")
+
+P = ParamSpec("P")
+
+
+def maybe_additional_metadata_to_kv(
+    additional_metadata: dict[str, str] | JSONSerializableMapping | None
+) -> list[str] | None:
+    if not additional_metadata:
+        return None
+
+    return [f"{k}:{v}" for k, v in additional_metadata.items()]
+
+
+class BaseRestClient:
+    def __init__(self, config: ClientConfig) -> None:
+        self.tenant_id = config.tenant_id
+
+        self.client_config = config
+        self.api_config = Configuration(
+            host=config.server_url,
+            access_token=config.token,
+        )
+
+        self.api_config.datetime_format = "%Y-%m-%dT%H:%M:%S.%fZ"
+
+    def client(self) -> AsyncContextManager[ApiClient]:
+        return ApiClient(self.api_config)
+
+    def _run_async_function_do_not_use_directly(
+        self,
+        async_func: Callable[P, Coroutine[Y, S, R]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> R:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(async_func(*args, **kwargs))
+        finally:
+            loop.close()
+
+    def _run_async_from_sync(
+        self,
+        async_func: Callable[P, Coroutine[Y, S, R]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> R:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop and loop.is_running():
+            return loop.run_until_complete(async_func(*args, **kwargs))
+        else:
+            with ThreadPoolExecutor() as executor:
+                future = executor.submit(
+                    lambda: self._run_async_function_do_not_use_directly(
+                        async_func, *args, **kwargs
+                    )
+                )
+                return future.result()

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/clients/workflow_listener.py

@@ -132,8 +132,8 @@ class PooledWorkflowRunListener:
                                 )
 
                                 t.cancel()
-                                if self.listener:
-                                    self.listener.cancel()
+                                self.listener.cancel()
+
                                 await asyncio.sleep(
                                     DEFAULT_WORKFLOW_LISTENER_RETRY_INTERVAL
                                 )
@@ -203,6 +203,8 @@ class PooledWorkflowRunListener:
         del self.events[subscription_id]
 
     async def subscribe(self, workflow_run_id: str) -> WorkflowRunEvent:
+        subscription_id: int | None = None
+
         try:
             # create a new subscription id, place a mutex on the counter
             await self.subscription_counter_lock.acquire()
@@ -234,7 +236,8 @@ class PooledWorkflowRunListener:
         except asyncio.CancelledError:
             raise
         finally:
-            self.cleanup_subscription(subscription_id)
+            if subscription_id:
+                self.cleanup_subscription(subscription_id)
 
     async def result(self, workflow_run_id: str) -> dict[str, Any]:
         from hatchet_sdk.clients.admin import DedupeViolationErr

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/context/context.py

@@ -17,9 +17,6 @@ from hatchet_sdk.clients.durable_event_listener import (
     RegisterDurableEventRequest,
 )
 from hatchet_sdk.clients.events import EventClient
-from hatchet_sdk.clients.rest_client import RestApi
-from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
-from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.context.worker_context import WorkerContext
 from hatchet_sdk.logger import logger
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
@@ -53,12 +50,8 @@ class Context:
         dispatcher_client: DispatcherClient,
         admin_client: AdminClient,
         event_client: EventClient,
-        rest_client: RestApi,
-        workflow_listener: PooledWorkflowRunListener | None,
         durable_event_listener: DurableEventListener | None,
-        workflow_run_event_listener: RunEventListenerClient,
         worker: WorkerContext,
-        namespace: str = "",
         validator_registry: dict[str, WorkflowValidator] = {},
     ):
         self.worker = worker
@@ -68,16 +61,12 @@ class Context:
 
         self.action = action
 
-        self.step_run_id: str = action.step_run_id
+        self.step_run_id = action.step_run_id
         self.exit_flag = False
         self.dispatcher_client = dispatcher_client
         self.admin_client = admin_client
         self.event_client = event_client
-        self.rest_client = rest_client
-        self.workflow_listener = workflow_listener
         self.durable_event_listener = durable_event_listener
-        self.workflow_run_event_listener = workflow_run_event_listener
-        self.namespace = namespace
 
         # FIXME: this limits the number of concurrent log requests to 1, which means we can do about
         # 100 log lines per second but this depends on network.

{hatchet_sdk-1.0.0a1 → hatchet_sdk-1.0.2}/hatchet_sdk/features/cron.py

@@ -1,8 +1,11 @@
-from typing import List, Union
-
 from pydantic import BaseModel, Field, field_validator
 
-from hatchet_sdk.client import Client
+from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
+from hatchet_sdk.clients.rest.api.workflow_run_api import WorkflowRunApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.create_cron_workflow_trigger_request import (
+    CreateCronWorkflowTriggerRequest,
+)
 from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
 from hatchet_sdk.clients.rest.models.cron_workflows_list import CronWorkflowsList
 from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
@@ -11,6 +14,10 @@ from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
 from hatchet_sdk.clients.rest.models.workflow_run_order_by_direction import (
     WorkflowRunOrderByDirection,
 )
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 
@@ -62,27 +69,14 @@ class CreateCronTriggerConfig(BaseModel):
         return v
 
 
-class CronClient:
-    """
-    Client for managing workflow cron triggers synchronously.
-
-    Attributes:
-        _client (Client): The underlying client used to interact with the REST API.
-        aio (CronClientAsync): Asynchronous counterpart of CronClient.
-    """
-
-    _client: Client
-
-    def __init__(self, _client: Client):
-        """
-        Initializes the CronClient with a given Client instance.
+class CronClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunApi:
+        return WorkflowRunApi(client)
 
-        Args:
-            _client (Client): The client instance to be used for REST interactions.
-        """
-        self._client = _client
+    def _wa(self, client: ApiClient) -> WorkflowApi:
+        return WorkflowApi(client)
 
-    def create(
+    async def aio_create(
         self,
         workflow_name: str,
         cron_name: str,
@@ -91,7 +85,7 @@ class CronClient:
         additional_metadata: JSONSerializableMapping,
     ) -> CronWorkflows:
         """
-        Creates a new workflow cron trigger.
+        Asynchronously creates a new workflow cron trigger.
 
         Args:
             workflow_name (str): The name of the workflow to trigger.
@@ -107,38 +101,61 @@ class CronClient:
             expression=expression, input=input, additional_metadata=additional_metadata
         )
 
-        return self._client.rest.cron_create(
+        async with self.client() as client:
+            return await self._wra(client).cron_workflow_trigger_create(
+                tenant=self.client_config.tenant_id,
+                workflow=workflow_name,
+                create_cron_workflow_trigger_request=CreateCronWorkflowTriggerRequest(
+                    cronName=cron_name,
+                    cronExpression=validated_input.expression,
+                    input=dict(validated_input.input),
+                    additionalMetadata=dict(validated_input.additional_metadata),
+                ),
+            )
+
+    def create(
+        self,
+        workflow_name: str,
+        cron_name: str,
+        expression: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping,
+    ) -> CronWorkflows:
+        return self._run_async_from_sync(
+            self.aio_create,
             workflow_name,
             cron_name,
-            validated_input.expression,
-            validated_input.input,
-            validated_input.additional_metadata,
+            expression,
+            input,
+            additional_metadata,
         )
 
-    def delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
+    async def aio_delete(self, cron_id: str) -> None:
         """
-        Deletes a workflow cron trigger.
+        Asynchronously deletes a workflow cron trigger.
 
         Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
+            cron_id (str): The cron trigger ID or CronWorkflows instance to delete.
         """
-        self._client.rest.cron_delete(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        async with self.client() as client:
+            await self._wa(client).workflow_cron_delete(
+                tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
+            )
 
-    def list(
+    def delete(self, cron_id: str) -> None:
+        return self._run_async_from_sync(self.aio_delete, cron_id)
+
+    async def aio_list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: list[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
         order_by_field: CronWorkflowsOrderByField | None = None,
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Retrieves a list of all workflow cron triggers matching the criteria.
+        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -151,88 +168,30 @@ class CronClient:
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        return self._client.rest.cron_list(
-            offset=offset,
-            limit=limit,
-            workflow_id=workflow_id,
-            additional_metadata=additional_metadata,
-            order_by_field=order_by_field,
-            order_by_direction=order_by_direction,
-        )
-
-    def get(self, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
-        """
-        Retrieves a specific workflow cron trigger by ID.
-
-        Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
-
-        Returns:
-            CronWorkflows: The requested cron workflow instance.
-        """
-        return self._client.rest.cron_get(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
-
-    async def aio_create(
-        self,
-        workflow_name: str,
-        cron_name: str,
-        expression: str,
-        input: JSONSerializableMapping,
-        additional_metadata: JSONSerializableMapping,
-    ) -> CronWorkflows:
-        """
-        Asynchronously creates a new workflow cron trigger.
-
-        Args:
-            workflow_name (str): The name of the workflow to trigger.
-            cron_name (str): The name of the cron trigger.
-            expression (str): The cron expression defining the schedule.
-            input (dict): The input data for the cron workflow.
-            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger (e.g. {"key1": "value1", "key2": "value2"}).
-
-        Returns:
-            CronWorkflows: The created cron workflow instance.
-        """
-        validated_input = CreateCronTriggerConfig(
-            expression=expression, input=input, additional_metadata=additional_metadata
-        )
-
-        return await self._client.rest.aio_create_cron(
-            workflow_name=workflow_name,
-            cron_name=cron_name,
-            expression=validated_input.expression,
-            input=validated_input.input,
-            additional_metadata=validated_input.additional_metadata,
-        )
-
-    async def aio_delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
-        """
-        Asynchronously deletes a workflow cron trigger.
-
-        Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
-        """
-        await self._client.rest.aio_delete_cron(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        async with self.client() as client:
+            return await self._wa(client).cron_workflow_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                workflow_id=workflow_id,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                order_by_field=order_by_field,
+                order_by_direction=order_by_direction,
+            )
 
-    async def aio_list(
+    def list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: List[str] | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
         order_by_field: CronWorkflowsOrderByField | None = None,
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
+        Synchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -245,7 +204,8 @@ class CronClient:
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        return await self._client.rest.aio_list_crons(
+        return self._run_async_from_sync(
+            self.aio_list,
             offset=offset,
             limit=limit,
             workflow_id=workflow_id,
@@ -254,19 +214,29 @@ class CronClient:
             order_by_direction=order_by_direction,
         )
 
-    async def aio_get(self, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
+    async def aio_get(self, cron_id: str) -> CronWorkflows:
         """
         Asynchronously retrieves a specific workflow cron trigger by ID.
 
         Args:
-            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
+            cron_id (str): The cron trigger ID or CronWorkflows instance to retrieve.
 
         Returns:
             CronWorkflows: The requested cron workflow instance.
         """
+        async with self.client() as client:
+            return await self._wa(client).workflow_cron_get(
+                tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
+            )
+
+    def get(self, cron_id: str) -> CronWorkflows:
+        """
+        Synchronously retrieves a specific workflow cron trigger by ID.
 
-        return await self._client.rest.aio_get_cron(
-            cron_trigger.metadata.id
-            if isinstance(cron_trigger, CronWorkflows)
-            else cron_trigger
-        )
+        Args:
+            cron_id (str): The cron trigger ID or CronWorkflows instance to retrieve.
+
+        Returns:
+            CronWorkflows: The requested cron workflow instance.
+        """
+        return self._run_async_from_sync(self.aio_get, cron_id)