hatchet-sdk 1.16.4__py3-none-any.whl → 1.17.0__py3-none-any.whl

hatchet_sdk/clients/rest/models/v1_webhook_hmac_auth.py

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing_extensions import Self
+
+from hatchet_sdk.clients.rest.models.v1_webhook_hmac_algorithm import (
+    V1WebhookHMACAlgorithm,
+)
+from hatchet_sdk.clients.rest.models.v1_webhook_hmac_encoding import (
+    V1WebhookHMACEncoding,
+)
+
+
+class V1WebhookHMACAuth(BaseModel):
+    """
+    V1WebhookHMACAuth
+    """  # noqa: E501
+
+    algorithm: V1WebhookHMACAlgorithm = Field(
+        description="The HMAC algorithm to use for the webhook"
+    )
+    encoding: V1WebhookHMACEncoding = Field(
+        description="The encoding to use for the HMAC signature"
+    )
+    signature_header_name: StrictStr = Field(
+        description="The name of the header to use for the HMAC signature",
+        alias="signatureHeaderName",
+    )
+    signing_secret: StrictStr = Field(
+        description="The secret key used to sign the HMAC signature",
+        alias="signingSecret",
+    )
+    __properties: ClassVar[List[str]] = [
+        "algorithm",
+        "encoding",
+        "signatureHeaderName",
+        "signingSecret",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1WebhookHMACAuth from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1WebhookHMACAuth from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "algorithm": obj.get("algorithm"),
+                "encoding": obj.get("encoding"),
+                "signatureHeaderName": obj.get("signatureHeaderName"),
+                "signingSecret": obj.get("signingSecret"),
+            }
+        )
+        return _obj

hatchet_sdk/clients/rest/models/v1_webhook_hmac_encoding.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+
+from typing_extensions import Self
+
+
+class V1WebhookHMACEncoding(str, Enum):
+    """
+    V1WebhookHMACEncoding
+    """
+
+    """
+    allowed enum values
+    """
+    HEX = "HEX"
+    BASE64 = "BASE64"
+    BASE64URL = "BASE64URL"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of V1WebhookHMACEncoding from a JSON string"""
+        return cls(json.loads(json_str))

hatchet_sdk/clients/rest/models/v1_webhook_list.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+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.pagination_response import PaginationResponse
+from hatchet_sdk.clients.rest.models.v1_webhook import V1Webhook
+
+
+class V1WebhookList(BaseModel):
+    """
+    V1WebhookList
+    """  # noqa: E501
+
+    pagination: Optional[PaginationResponse] = None
+    rows: Optional[List[V1Webhook]] = None
+    __properties: ClassVar[List[str]] = ["pagination", "rows"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1WebhookList from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict["pagination"] = self.pagination.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
+        _items = []
+        if self.rows:
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
+            _dict["rows"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1WebhookList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "pagination": (
+                    PaginationResponse.from_dict(obj["pagination"])
+                    if obj.get("pagination") is not None
+                    else None
+                ),
+                "rows": (
+                    [V1Webhook.from_dict(_item) for _item in obj["rows"]]
+                    if obj.get("rows") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

hatchet_sdk/clients/rest/models/v1_webhook_receive200_response.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing_extensions import Self
+
+
+class V1WebhookReceive200Response(BaseModel):
+    """
+    V1WebhookReceive200Response
+    """  # noqa: E501
+
+    message: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["message"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1WebhookReceive200Response from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1WebhookReceive200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"message": obj.get("message")})
+        return _obj

hatchet_sdk/clients/rest/models/v1_webhook_source_name.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+
+from typing_extensions import Self
+
+
+class V1WebhookSourceName(str, Enum):
+    """
+    V1WebhookSourceName
+    """
+
+    """
+    allowed enum values
+    """
+    GENERIC = "GENERIC"
+    GITHUB = "GITHUB"
+    STRIPE = "STRIPE"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of V1WebhookSourceName from a JSON string"""
+        return cls(json.loads(json_str))

hatchet_sdk/context/context.py

@@ -21,10 +21,11 @@ from hatchet_sdk.conditions import (
     flatten_conditions,
 )
 from hatchet_sdk.context.worker_context import WorkerContext
+from hatchet_sdk.exceptions import TaskRunError
 from hatchet_sdk.features.runs import RunsClient
 from hatchet_sdk.logger import logger
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
-from hatchet_sdk.utils.typing import JSONSerializableMapping
+from hatchet_sdk.utils.typing import JSONSerializableMapping, LogLevel
 from hatchet_sdk.worker.runner.utils.capture_logs import AsyncLogSender, LogRecord
 
 if TYPE_CHECKING:
@@ -211,7 +212,9 @@ class Context:
                 line = str(line)
 
         logger.info(line)
-        self.log_sender.publish(LogRecord(message=line, step_run_id=self.step_run_id))
+        self.log_sender.publish(
+            LogRecord(message=line, step_run_id=self.step_run_id, level=LogLevel.INFO)
+        )
 
     def release_slot(self) -> None:
         """
@@ -360,15 +363,41 @@ class Context:
         task: "Task[TWorkflowInput, R]",
     ) -> str | None:
         """
+        **DEPRECATED**: Use `get_task_run_error` instead.
+
         A helper intended to be used in an on-failure step to retrieve the error that occurred in a specific upstream task run.
 
         :param task: The task whose error you want to retrieve.
         :return: The error message of the task run, or None if no error occurred.
         """
+        warn(
+            "`fetch_task_run_error` is deprecated. Use `get_task_run_error` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         errors = self.data.step_run_errors
 
         return errors.get(task.name)
 
+    def get_task_run_error(
+        self,
+        task: "Task[TWorkflowInput, R]",
+    ) -> TaskRunError | None:
+        """
+        A helper intended to be used in an on-failure step to retrieve the error that occurred in a specific upstream task run.
+
+        :param task: The task whose error you want to retrieve.
+        :return: The error message of the task run, or None if no error occurred.
+        """
+        errors = self.data.step_run_errors
+
+        error = errors.get(task.name)
+
+        if not error:
+            return None
+
+        return TaskRunError.deserialize(error)
+
 
 class DurableContext(Context):
     def __init__(

hatchet_sdk/exceptions.py

@@ -1,4 +1,10 @@
+import json
 import traceback
+from typing import cast
+
+
+class InvalidDependencyError(Exception):
+    pass
 
 
 class NonRetryableException(Exception):  # noqa: N818
@@ -9,28 +15,42 @@ class DedupeViolationError(Exception):
     """Raised by the Hatchet library to indicate that a workflow has already been run with this deduplication value."""
 
 
+TASK_RUN_ERROR_METADATA_KEY = "__hatchet_error_metadata__"
+
+
 class TaskRunError(Exception):
     def __init__(
         self,
         exc: str,
         exc_type: str,
         trace: str,
+        task_run_external_id: str | None,
     ) -> None:
         self.exc = exc
         self.exc_type = exc_type
         self.trace = trace
+        self.task_run_external_id = task_run_external_id
 
     def __str__(self) -> str:
-        return self.serialize()
+        return self.serialize(include_metadata=False)
 
     def __repr__(self) -> str:
         return str(self)
 
-    def serialize(self) -> str:
+    def serialize(self, include_metadata: bool) -> str:
         if not self.exc_type or not self.exc:
             return ""
 
-        return (
+        metadata = json.dumps(
+            {
+                TASK_RUN_ERROR_METADATA_KEY: {
+                    "task_run_external_id": self.task_run_external_id,
+                }
+            },
+            indent=None,
+        )
+
+        result = (
             self.exc_type.replace(": ", ":::")
             + ": "
             + self.exc.replace("\n", "\\\n")
@@ -38,6 +58,40 @@ class TaskRunError(Exception):
             + self.trace
         )
 
+        if include_metadata:
+            return result + "\n\n" + metadata
+
+        return result
+
+    @classmethod
+    def _extract_metadata(cls, serialized: str) -> tuple[str, dict[str, str | None]]:
+        metadata = serialized.split("\n")[-1]
+
+        try:
+            parsed = json.loads(metadata)
+
+            if (
+                TASK_RUN_ERROR_METADATA_KEY in parsed
+                and "task_run_external_id" in parsed[TASK_RUN_ERROR_METADATA_KEY]
+            ):
+                serialized = serialized.replace(metadata, "").strip()
+                return serialized, cast(
+                    dict[str, str | None], parsed[TASK_RUN_ERROR_METADATA_KEY]
+                )
+
+            return serialized, {}
+        except json.JSONDecodeError:
+            return serialized, {}
+
+    @classmethod
+    def _unpack_serialized_error(cls, serialized: str) -> tuple[str | None, str, str]:
+        serialized, metadata = cls._extract_metadata(serialized)
+
+        external_id = metadata.get("task_run_external_id", None)
+        header, trace = serialized.split("\n", 1)
+
+        return external_id, header, trace
+
     @classmethod
     def deserialize(cls, serialized: str) -> "TaskRunError":
         if not serialized:
@@ -45,10 +99,16 @@ class TaskRunError(Exception):
                 exc="",
                 exc_type="",
                 trace="",
+                task_run_external_id=None,
             )
 
+        task_run_external_id = None
+
         try:
-            header, trace = serialized.split("\n", 1)
+            task_run_external_id, header, trace = cls._unpack_serialized_error(
+                serialized
+            )
+
             exc_type, exc = header.split(": ", 1)
         except ValueError:
             ## If we get here, we saw an error that was not serialized how we expected,
@@ -57,6 +117,7 @@ class TaskRunError(Exception):
                 exc=serialized,
                 exc_type="HatchetError",
                 trace="",
+                task_run_external_id=task_run_external_id,
             )
 
         exc_type = exc_type.replace(":::", ": ")
@@ -66,16 +127,20 @@ class TaskRunError(Exception):
             exc=exc,
             exc_type=exc_type,
             trace=trace,
+            task_run_external_id=task_run_external_id,
         )
 
     @classmethod
-    def from_exception(cls, exc: Exception) -> "TaskRunError":
+    def from_exception(
+        cls, exc: Exception, task_run_external_id: str | None
+    ) -> "TaskRunError":
         return cls(
             exc=str(exc),
             exc_type=type(exc).__name__,
             trace="".join(
                 traceback.format_exception(type(exc), exc, exc.__traceback__)
             ),
+            task_run_external_id=task_run_external_id,
         )