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

hatchet_sdk/clients/dispatcher/dispatcher.py

@@ -55,17 +55,19 @@ class DispatcherClient:
         for key, value in preset_labels.items():
             req.labels[key] = WorkerLabels(strValue=str(value))
 
-        # Register the worker
-        response: WorkerRegisterResponse = await self.aio_client.Register(
-            WorkerRegisterRequest(
-                workerName=req.worker_name,
-                actions=req.actions,
-                services=req.services,
-                maxRuns=req.max_runs,
-                labels=req.labels,
+        response = cast(
+            WorkerRegisterResponse,
+            await self.aio_client.Register(
+                WorkerRegisterRequest(
+                    workerName=req.worker_name,
+                    actions=req.actions,
+                    services=req.services,
+                    maxRuns=req.slots,
+                    labels=req.labels,
+                ),
+                timeout=DEFAULT_REGISTER_TIMEOUT,
+                metadata=get_metadata(self.token),
             ),
-            timeout=DEFAULT_REGISTER_TIMEOUT,
-            metadata=get_metadata(self.token),
         )
 
         return ActionListener(self.config, response.workerId)
@@ -93,8 +95,8 @@ class DispatcherClient:
     async def _try_send_step_action_event(
         self, action: Action, event_type: StepActionEventType, payload: str
     ) -> grpc.aio.UnaryUnaryCall[StepActionEvent, ActionEventResponse]:
-        eventTimestamp = Timestamp()
-        eventTimestamp.GetCurrentTime()
+        event_timestamp = Timestamp()
+        event_timestamp.GetCurrentTime()
 
         event = StepActionEvent(
             workerId=action.worker_id,
@@ -103,7 +105,7 @@ class DispatcherClient:
             stepId=action.step_id,
             stepRunId=action.step_run_id,
             actionId=action.action_id,
-            eventTimestamp=eventTimestamp,
+            eventTimestamp=event_timestamp,
             eventType=event_type,
             eventPayload=payload,
             retryCount=action.retry_count,
@@ -120,15 +122,15 @@ class DispatcherClient:
     async def send_group_key_action_event(
         self, action: Action, event_type: GroupKeyActionEventType, payload: str
     ) -> grpc.aio.UnaryUnaryCall[GroupKeyActionEvent, ActionEventResponse]:
-        eventTimestamp = Timestamp()
-        eventTimestamp.GetCurrentTime()
+        event_timestamp = Timestamp()
+        event_timestamp.GetCurrentTime()
 
         event = GroupKeyActionEvent(
             workerId=action.worker_id,
             workflowRunId=action.workflow_run_id,
             getGroupKeyRunId=action.get_group_key_run_id,
             actionId=action.action_id,
-            eventTimestamp=eventTimestamp,
+            eventTimestamp=event_timestamp,
             eventType=event_type,
             eventPayload=payload,
         )

hatchet_sdk/clients/durable_event_listener.py

@@ -0,0 +1,327 @@
+import asyncio
+import json
+from collections.abc import AsyncIterator
+from typing import Any, Literal, cast
+
+import grpc
+import grpc.aio
+from grpc._cython import cygrpc  # type: ignore[attr-defined]
+from pydantic import BaseModel, ConfigDict
+
+from hatchet_sdk.clients.event_ts import ThreadSafeEvent, read_with_interrupt
+from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
+from hatchet_sdk.config import ClientConfig
+from hatchet_sdk.connection import new_conn
+from hatchet_sdk.contracts.v1.dispatcher_pb2 import (
+    DurableEvent,
+    ListenForDurableEventRequest,
+)
+from hatchet_sdk.contracts.v1.dispatcher_pb2 import (
+    RegisterDurableEventRequest as RegisterDurableEventRequestProto,
+)
+from hatchet_sdk.contracts.v1.dispatcher_pb2_grpc import V1DispatcherStub
+from hatchet_sdk.contracts.v1.shared.condition_pb2 import DurableEventListenerConditions
+from hatchet_sdk.logger import logger
+from hatchet_sdk.metadata import get_metadata
+from hatchet_sdk.waits import SleepCondition, UserEventCondition
+
+DEFAULT_DURABLE_EVENT_LISTENER_RETRY_INTERVAL = 3  # seconds
+DEFAULT_DURABLE_EVENT_LISTENER_RETRY_COUNT = 5
+DEFAULT_DURABLE_EVENT_LISTENER_INTERRUPT_INTERVAL = 1800  # 30 minutes
+
+
+class _Subscription:
+    def __init__(self, id: int, task_id: str, signal_key: str):
+        self.id = id
+        self.task_id = task_id
+        self.signal_key = signal_key
+        self.queue: asyncio.Queue[DurableEvent | None] = asyncio.Queue()
+
+    async def __aiter__(self) -> "_Subscription":
+        return self
+
+    async def __anext__(self) -> DurableEvent | None:
+        return await self.queue.get()
+
+    async def get(self) -> DurableEvent:
+        event = await self.queue.get()
+
+        if event is None:
+            raise StopAsyncIteration
+
+        return event
+
+    async def put(self, item: DurableEvent) -> None:
+        await self.queue.put(item)
+
+    async def close(self) -> None:
+        await self.queue.put(None)
+
+
+class RegisterDurableEventRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    task_id: str
+    signal_key: str
+    conditions: list[SleepCondition | UserEventCondition]
+
+    def to_proto(self) -> RegisterDurableEventRequestProto:
+        return RegisterDurableEventRequestProto(
+            task_id=self.task_id,
+            signal_key=self.signal_key,
+            conditions=DurableEventListenerConditions(
+                sleep_conditions=[
+                    c.to_pb() for c in self.conditions if isinstance(c, SleepCondition)
+                ],
+                user_event_conditions=[
+                    c.to_pb()
+                    for c in self.conditions
+                    if isinstance(c, UserEventCondition)
+                ],
+            ),
+        )
+
+
+class DurableEventListener:
+    def __init__(self, config: ClientConfig):
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        conn = new_conn(config, True)
+        self.client = V1DispatcherStub(conn)  # type: ignore[no-untyped-call]
+        self.token = config.token
+        self.config = config
+
+        # list of all active subscriptions, mapping from a subscription id to a task id and signal key
+        self.subscriptions_to_task_id_signal_key: dict[int, tuple[str, str]] = {}
+
+        # task id-signal key tuples mapped to an array of subscription ids
+        self.task_id_signal_key_to_subscriptions: dict[tuple[str, str], list[int]] = {}
+
+        self.subscription_counter: int = 0
+        self.subscription_counter_lock: asyncio.Lock = asyncio.Lock()
+
+        self.requests: asyncio.Queue[ListenForDurableEventRequest | int] = (
+            asyncio.Queue()
+        )
+
+        self.listener: (
+            grpc.aio.UnaryStreamCall[ListenForDurableEventRequest, DurableEvent] | None
+        ) = None
+        self.listener_task: asyncio.Task[None] | None = None
+
+        self.curr_requester: int = 0
+
+        self.events: dict[int, _Subscription] = {}
+
+        self.interrupter: asyncio.Task[None] | None = None
+
+    async def _interrupter(self) -> None:
+        """
+        _interrupter runs in a separate thread and interrupts the listener according to a configurable duration.
+        """
+        await asyncio.sleep(DEFAULT_DURABLE_EVENT_LISTENER_INTERRUPT_INTERVAL)
+
+        if self.interrupt is not None:
+            self.interrupt.set()
+
+    async def _init_producer(self) -> None:
+        try:
+            if not self.listener:
+                while True:
+                    try:
+                        self.listener = await self._retry_subscribe()
+
+                        logger.debug("Workflow run listener connected.")
+
+                        # spawn an interrupter task
+                        if self.interrupter is not None and not self.interrupter.done():
+                            self.interrupter.cancel()
+
+                        self.interrupter = asyncio.create_task(self._interrupter())
+
+                        while True:
+                            self.interrupt = ThreadSafeEvent()
+                            if self.listener is None:
+                                continue
+
+                            t = asyncio.create_task(
+                                read_with_interrupt(self.listener, self.interrupt)
+                            )
+                            await self.interrupt.wait()
+
+                            if not t.done():
+                                logger.warning(
+                                    "Interrupted read_with_interrupt task of durable event listener"
+                                )
+
+                                t.cancel()
+                                if self.listener:
+                                    self.listener.cancel()
+                                await asyncio.sleep(
+                                    DEFAULT_DURABLE_EVENT_LISTENER_RETRY_INTERVAL
+                                )
+                                break
+
+                            event = t.result()
+
+                            if event is cygrpc.EOF:
+                                break
+
+                            # get a list of subscriptions for this task-signal pair
+                            subscriptions = (
+                                self.task_id_signal_key_to_subscriptions.get(
+                                    (event.task_id, event.signal_key), []
+                                )
+                            )
+
+                            for subscription_id in subscriptions:
+                                await self.events[subscription_id].put(event)
+
+                    except grpc.RpcError as e:
+                        logger.debug(f"grpc error in durable event listener: {e}")
+                        await asyncio.sleep(
+                            DEFAULT_DURABLE_EVENT_LISTENER_RETRY_INTERVAL
+                        )
+                        continue
+
+        except Exception as e:
+            logger.error(f"Error in durable event listener: {e}")
+
+            self.listener = None
+
+            # close all subscriptions
+            for subscription_id in self.events:
+                await self.events[subscription_id].close()
+
+            raise e
+
+    async def _request(self) -> AsyncIterator[ListenForDurableEventRequest]:
+        self.curr_requester = self.curr_requester + 1
+
+        # replay all existing subscriptions
+        for task_id, signal_key in set(
+            self.subscriptions_to_task_id_signal_key.values()
+        ):
+            yield ListenForDurableEventRequest(
+                task_id=task_id,
+                signal_key=signal_key,
+            )
+
+        while True:
+            request = await self.requests.get()
+
+            # if the request is an int which matches the current requester, then we should stop
+            if request == self.curr_requester:
+                break
+
+            # if we've gotten an int that doesn't match the current requester, then we should ignore it
+            if isinstance(request, int):
+                continue
+
+            yield request
+            self.requests.task_done()
+
+    def cleanup_subscription(self, subscription_id: int) -> None:
+        task_id_signal_key = self.subscriptions_to_task_id_signal_key[subscription_id]
+
+        if task_id_signal_key in self.task_id_signal_key_to_subscriptions:
+            self.task_id_signal_key_to_subscriptions[task_id_signal_key].remove(
+                subscription_id
+            )
+
+        del self.subscriptions_to_task_id_signal_key[subscription_id]
+        del self.events[subscription_id]
+
+    async def subscribe(self, task_id: str, signal_key: str) -> DurableEvent:
+        try:
+            # create a new subscription id, place a mutex on the counter
+            async with self.subscription_counter_lock:
+                self.subscription_counter += 1
+                subscription_id = self.subscription_counter
+
+            self.subscriptions_to_task_id_signal_key[subscription_id] = (
+                task_id,
+                signal_key,
+            )
+
+            if (task_id, signal_key) not in self.task_id_signal_key_to_subscriptions:
+                self.task_id_signal_key_to_subscriptions[(task_id, signal_key)] = [
+                    subscription_id
+                ]
+            else:
+                self.task_id_signal_key_to_subscriptions[(task_id, signal_key)].append(
+                    subscription_id
+                )
+
+            self.events[subscription_id] = _Subscription(
+                subscription_id, task_id, signal_key
+            )
+
+            await self.requests.put(
+                ListenForDurableEventRequest(
+                    task_id=task_id,
+                    signal_key=signal_key,
+                )
+            )
+
+            if not self.listener_task or self.listener_task.done():
+                self.listener_task = asyncio.create_task(self._init_producer())
+
+            return await self.events[subscription_id].get()
+        except asyncio.CancelledError:
+            raise
+        finally:
+            self.cleanup_subscription(subscription_id)
+
+    async def _retry_subscribe(
+        self,
+    ) -> grpc.aio.UnaryStreamCall[ListenForDurableEventRequest, DurableEvent]:
+        retries = 0
+
+        while retries < DEFAULT_DURABLE_EVENT_LISTENER_RETRY_COUNT:
+            try:
+                if retries > 0:
+                    await asyncio.sleep(DEFAULT_DURABLE_EVENT_LISTENER_RETRY_INTERVAL)
+
+                # signal previous async iterator to stop
+                if self.curr_requester != 0:
+                    self.requests.put_nowait(self.curr_requester)
+
+                return cast(
+                    grpc.aio.UnaryStreamCall[
+                        ListenForDurableEventRequest, DurableEvent
+                    ],
+                    self.client.ListenForDurableEvent(
+                        self._request(),
+                        metadata=get_metadata(self.token),
+                    ),
+                )
+            except grpc.RpcError as e:
+                if e.code() == grpc.StatusCode.UNAVAILABLE:
+                    retries = retries + 1
+                else:
+                    raise ValueError(f"gRPC error: {e}")
+
+        raise ValueError("Failed to connect to durable event listener")
+
+    @tenacity_retry
+    def register_durable_event(
+        self, request: RegisterDurableEventRequest
+    ) -> Literal[True]:
+        self.client.RegisterDurableEvent(
+            request.to_proto(),
+            timeout=5,
+            metadata=get_metadata(self.token),
+        )
+
+        return True
+
+    @tenacity_retry
+    async def result(self, task_id: str, signal_key: str) -> dict[str, Any]:
+        event = await self.subscribe(task_id, signal_key)
+
+        return cast(dict[str, Any], json.loads(event.data.decode("utf-8")))

hatchet_sdk/clients/rest/__init__.py

@@ -230,8 +230,10 @@ 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_dag_children import V1DagChildren
+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
 from hatchet_sdk.clients.rest.models.v1_replay_task_request import V1ReplayTaskRequest
-from hatchet_sdk.clients.rest.models.v1_task import V1Task
 from hatchet_sdk.clients.rest.models.v1_task_event import V1TaskEvent
 from hatchet_sdk.clients.rest.models.v1_task_event_list import V1TaskEventList
 from hatchet_sdk.clients.rest.models.v1_task_event_type import V1TaskEventType
@@ -243,8 +245,17 @@ from hatchet_sdk.clients.rest.models.v1_task_run_status import V1TaskRunStatus
 from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
 from hatchet_sdk.clients.rest.models.v1_task_summary import V1TaskSummary
 from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
+    V1TriggerWorkflowRunRequest,
+)
 from hatchet_sdk.clients.rest.models.v1_workflow_run import V1WorkflowRun
 from hatchet_sdk.clients.rest.models.v1_workflow_run_details import V1WorkflowRunDetails
+from hatchet_sdk.clients.rest.models.v1_workflow_run_display_name import (
+    V1WorkflowRunDisplayName,
+)
+from hatchet_sdk.clients.rest.models.v1_workflow_run_display_name_list import (
+    V1WorkflowRunDisplayNameList,
+)
 from hatchet_sdk.clients.rest.models.v1_workflow_type import V1WorkflowType
 from hatchet_sdk.clients.rest.models.webhook_worker import WebhookWorker
 from hatchet_sdk.clients.rest.models.webhook_worker_create_request import (

hatchet_sdk/clients/rest/api/log_api.py

@@ -25,6 +25,7 @@ from hatchet_sdk.clients.rest.models.log_line_order_by_direction import (
     LogLineOrderByDirection,
 )
 from hatchet_sdk.clients.rest.models.log_line_order_by_field import LogLineOrderByField
+from hatchet_sdk.clients.rest.models.v1_log_line_list import V1LogLineList
 from hatchet_sdk.clients.rest.rest import RESTResponseType
 
 
@@ -445,3 +446,260 @@ class LogApi:
             _host=_host,
             _request_auth=_request_auth,
         )
+
+    @validate_call
+    async def v1_log_line_list(
+        self,
+        task: Annotated[
+            str,
+            Field(min_length=36, strict=True, max_length=36, description="The task id"),
+        ],
+        _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,
+    ) -> V1LogLineList:
+        """List log lines
+
+        Lists log lines for a task
+
+        :param task: The task id (required)
+        :type task: 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_log_line_list_serialize(
+            task=task,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1LogLineList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+    @validate_call
+    async def v1_log_line_list_with_http_info(
+        self,
+        task: Annotated[
+            str,
+            Field(min_length=36, strict=True, max_length=36, description="The task id"),
+        ],
+        _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[V1LogLineList]:
+        """List log lines
+
+        Lists log lines for a task
+
+        :param task: The task id (required)
+        :type task: 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_log_line_list_serialize(
+            task=task,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1LogLineList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    async def v1_log_line_list_without_preload_content(
+        self,
+        task: Annotated[
+            str,
+            Field(min_length=36, strict=True, max_length=36, description="The task id"),
+        ],
+        _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 log lines
+
+        Lists log lines for a task
+
+        :param task: The task id (required)
+        :type task: 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_log_line_list_serialize(
+            task=task,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1LogLineList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+    def _v1_log_line_list_serialize(
+        self,
+        task,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {}
+
+        _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 task is not None:
+            _path_params["task"] = task
+        # process the query parameters
+        # 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/tasks/{task}/logs",
+            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,
+        )