acceldata-sdk-python 26.7.0__py3-none-any.whl

acceldata/exceptions/exceptions.py

@@ -0,0 +1,174 @@
+# coding: utf-8
+
+"""
+    Pipeline Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+class OpenApiException(Exception):
+    """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+    def __init__(self, msg, path_to_item=None, valid_classes=None,
+                 key_type=None) -> None:
+        """ Raises an exception for TypeErrors
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list): a list of keys an indices to get to the
+                                 current_item
+                                 None if unset
+            valid_classes (tuple): the primitive classes that current item
+                                   should be an instance of
+                                   None if unset
+            key_type (bool): False if our value is a value in a dict
+                             True if it is a key in a dict
+                             False if our item is an item in a list
+                             None if unset
+        """
+        self.path_to_item = path_to_item
+        self.valid_classes = valid_classes
+        self.key_type = key_type
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list) the path to the exception in the
+                received_data dict. None if unset
+        """
+
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Raised when an attribute reference or assignment fails.
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        if http_resp:
+            self.status = http_resp.status
+            self.reason = http_resp.reason
+            self.body = http_resp.data
+            self.headers = http_resp.getheaders()
+        else:
+            self.status = status
+            self.reason = reason
+            self.body = None
+            self.headers = None
+        # So ``str(e)``, ``e.args``, and ``raise ... from e`` tracebacks stay useful without relying on ``__str__`` alone.
+        summary = self._summary_line()
+        super().__init__(summary)
+
+    def _summary_line(self) -> str:
+        if self.reason:
+            return f"HTTP transport failure (status={self.status!r}): {self.reason}"
+        return f"HTTP transport failure (status={self.status!r})"
+
+    def __str__(self):
+        """Custom error messages for exception"""
+        error_message = "({0})\n"\
+                        "Reason: {1}\n".format(self.status, self.reason)
+        if self.headers:
+            error_message += "HTTP response headers: {0}\n".format(
+                self.headers)
+
+        if self.body:
+            error_message += "HTTP response body: {0}\n".format(self.body)
+
+        return error_message
+
+class BadRequestException(ApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        super(BadRequestException, self).__init__(status, reason, http_resp)
+
+class NotFoundException(ApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        super(NotFoundException, self).__init__(status, reason, http_resp)
+
+
+class UnauthorizedException(ApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        super(UnauthorizedException, self).__init__(status, reason, http_resp)
+
+
+class ForbiddenException(ApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        super(ForbiddenException, self).__init__(status, reason, http_resp)
+
+
+class ServiceException(ApiException):
+
+    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+        super(ServiceException, self).__init__(status, reason, http_resp)
+
+
+def render_path(path_to_item):
+    """Returns a string representation of a path"""
+    result = ""
+    for pth in path_to_item:
+        if isinstance(pth, int):
+            result += "[{0}]".format(pth)
+        else:
+            result += "['{0}']".format(pth)
+    return result

acceldata/exceptions/sdk_exceptions.py

@@ -0,0 +1,98 @@
+"""Client-side and workflow exceptions for the Acceldata Python SDK (non-HTTP errors)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class AcceldataSdkException(Exception):
+    """Raised for validation mistakes, unsupported SDK usage, or workflow outcomes (not API HTTP errors).
+
+    Subclasses set :attr:`code` for stable programmatic handling alongside :attr:`message`.
+    """
+
+    code: str = "SDK_ERROR"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        if code is not None:
+            self.code = code
+
+
+class InvalidPolicyTypeError(AcceldataSdkException):
+    """Raised when :meth:`~acceldata.client.adoc_client.AdocClient.get_policy` receives an unsupported policy kind."""
+
+    code = "INVALID_POLICY_TYPE"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        allowed_policy_types: tuple[str, ...] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.allowed_policy_types = allowed_policy_types
+
+
+class InvalidPipelineRunLookupError(AcceldataSdkException):
+    """Raised when resolving a pipeline run without the required identifiers."""
+
+    code = "INVALID_PIPELINE_RUN_LOOKUP"
+
+
+class PipelineRunNotFoundError(AcceldataSdkException):
+    """Raised when no run exists for the given ``continuation_id`` on a pipeline."""
+
+    code = "PIPELINE_RUN_NOT_FOUND"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        continuation_id: str,
+        pipeline_id: int,
+    ) -> None:
+        super().__init__(message)
+        self.continuation_id = continuation_id
+        self.pipeline_id = pipeline_id
+
+
+class PolicyExecutionCompletedWithWarningError(AcceldataSdkException):
+    """Raised when a policy run finishes with warnings and failure strategy requires failing on warnings."""
+
+    code = "POLICY_EXECUTION_COMPLETED_WITH_WARNING"
+
+    def __init__(self, message: str, *, details: Any = None) -> None:
+        super().__init__(message)
+        self.details = details
+
+
+class PolicyExecutionCompletedWithErrorResultError(AcceldataSdkException):
+    """Raised when a policy run finishes with errors and failure strategy requires raising."""
+
+    code = "POLICY_EXECUTION_COMPLETED_WITH_ERROR"
+
+    def __init__(self, message: str, *, details: Any = None) -> None:
+        super().__init__(message)
+        self.details = details
+
+
+class InvalidRuleTypeError(AcceldataSdkException):
+    """Raised when a rule type is not supported for the requested operation."""
+
+    code = "INVALID_RULE_TYPE"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        allowed_rule_types: tuple[str, ...] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.allowed_rule_types = allowed_rule_types

acceldata/mappers/__init__.py

@@ -0,0 +1,21 @@
+"""Map generated catalog API models to values the SDK uses in services and helpers."""
+
+from acceldata.mappers.catalog_executions import (
+    catalog_generic_execution_branch_typename,
+    catalog_generic_execution_payload,
+    catalog_generic_rule_execution_payload,
+    catalog_rule_execution_nested_payload,
+    execution_status_pair_from_result,
+    rule_execution_error_message_from_result,
+    rule_execution_id_from_generic_post_response,
+)
+
+__all__ = [
+    "catalog_generic_execution_branch_typename",
+    "catalog_generic_execution_payload",
+    "catalog_generic_rule_execution_payload",
+    "catalog_rule_execution_nested_payload",
+    "execution_status_pair_from_result",
+    "rule_execution_error_message_from_result",
+    "rule_execution_id_from_generic_post_response",
+]

acceldata/mappers/catalog_executions.py

@@ -0,0 +1,107 @@
+"""Extract concrete payloads from catalog execution response wrappers."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from acceldata.models.api.catalog.execution_result import ExecutionResult
+from acceldata.models.api.catalog.generic_execution import GenericExecution
+from acceldata.models.api.catalog.generic_rule_execution import GenericRuleExecution
+
+LOGGER = logging.getLogger(__name__)
+
+
+def catalog_generic_execution_payload(ge: GenericExecution | None) -> Any | None:
+    """Return the resolved concrete branch inside ``GenericExecution``, or ``None``."""
+    if ge is None:
+        return None
+    return getattr(ge, "actual_instance", None)
+
+
+def catalog_generic_rule_execution_payload(gre: GenericRuleExecution | None) -> Any | None:
+    """Return the resolved ``RuleExecution`` / ``DQRuleExecution`` inside ``GenericRuleExecution``."""
+    if gre is None:
+        return None
+    return getattr(gre, "actual_instance", None)
+
+
+def catalog_rule_execution_nested_payload(inner: Any | None) -> Any | None:
+    """Normalize ``execution`` on result/list DTOs: unwrap ``GenericRuleExecution`` when present."""
+    if inner is None:
+        return None
+    if isinstance(inner, GenericRuleExecution):
+        return catalog_generic_rule_execution_payload(inner)
+    return inner
+
+
+def rule_execution_id_from_generic_post_response(ge: GenericExecution) -> int | None:
+    """Numeric ``RuleExecution.id`` from POST ``.../executions`` (DQ / reconciliation / cadence)."""
+    inst = catalog_generic_execution_payload(ge)
+    if inst is None:
+        return None
+    inner = getattr(inst, "execution", None)
+    if inner is None:
+        return None
+    concrete = catalog_rule_execution_nested_payload(inner)
+    if concrete is None:
+        return None
+    rid = getattr(concrete, "id", None)
+    return int(rid) if rid is not None else None
+
+
+def _status_pair_from_rule_execution_like(inner: Any | None) -> tuple[str, str] | None:
+    if inner is None:
+        return None
+    es = getattr(inner, "execution_status", None)
+    rs = getattr(inner, "result_status", None)
+    if not isinstance(es, str) or not isinstance(rs, str):
+        return None
+    return es, rs
+
+
+def execution_status_pair_from_result(er: ExecutionResult) -> tuple[str, str]:
+    """``(executionStatus, resultStatus)`` as on the catalog wire; default ERRORED for both if unknown."""
+    from acceldata.models.sdk.catalog.policy_filter import RuleExecutionStatus
+
+    err = RuleExecutionStatus.ERRORED.value, RuleExecutionStatus.ERRORED.value
+    inner = catalog_rule_execution_nested_payload(er.execution) if er.execution is not None else None
+    pair = _status_pair_from_rule_execution_like(inner)
+    if pair is not None:
+        return pair
+
+    # Fall back to serialized payload if execution object is missing/unexpected.
+    # This keeps support for looser/untyped call sites while avoiding unnecessary
+    # pydantic union-serializer warnings for partial model_construct test objects.
+    try:
+        payload = er.to_dict()
+        ex = payload.get("execution")
+        if isinstance(ex, dict):
+            es = ex.get("executionStatus")
+            rs = ex.get("resultStatus")
+            if isinstance(es, str) and isinstance(rs, str):
+                return es, rs
+    except Exception:
+        LOGGER.debug(
+            "ExecutionResult.to_dict() failed; using parsed execution fields",
+            exc_info=True,
+        )
+
+    return err
+
+
+def rule_execution_error_message_from_result(er: ExecutionResult) -> str | None:
+    """``execution_error`` from the nested rule execution payload, if present."""
+    inner = catalog_rule_execution_nested_payload(er.execution) if er.execution is not None else None
+    if inner is None:
+        return None
+    msg = getattr(inner, "execution_error", None)
+    return msg if isinstance(msg, str) else None
+
+
+def catalog_generic_execution_branch_typename(ge: GenericExecution | None) -> str | None:
+    """Short class name of the resolved ``GenericExecution`` branch (for logs)."""
+    inst = catalog_generic_execution_payload(ge)
+    if inst is None:
+        return None
+    return type(inst).__name__

acceldata/models/api/catalog/above_configs.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.above_configs_success import AboveConfigsSuccess
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AboveConfigs(BaseModel):
+    """
+    AboveConfigs
+    """ # noqa: E501
+    direction: StrictStr = Field(description="Allowed values at generation time: ABOVE, BELOW, RANGE, CHANGES_BY, DECREASED_BY, INCREASED_BY.")
+    success: AboveConfigsSuccess
+    warning: Optional[AboveConfigsSuccess] = None
+    __properties: ClassVar[List[str]] = ["direction", "success", "warning"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AboveConfigs 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 success
+        if self.success:
+            _dict['success'] = self.success.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of warning
+        if self.warning:
+            _dict['warning'] = self.warning.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AboveConfigs from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "direction": obj.get("direction"),
+            "success": AboveConfigsSuccess.from_dict(obj["success"]) if obj.get("success") is not None else None,
+            "warning": AboveConfigsSuccess.from_dict(obj["warning"]) if obj.get("warning") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/above_configs_success.py

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, ValidationError, field_validator
+from typing import Optional, Union
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+ABOVECONFIGSSUCCESS_ANY_OF_SCHEMAS = ["float", "str"]
+
+class AboveConfigsSuccess(BaseModel):
+    """
+    Numeric value as JSON number or string (API may quote decimals).
+    """
+
+    # data type: float
+    anyof_schema_1_validator: Optional[Union[StrictFloat, StrictInt]] = None
+    # data type: str
+    anyof_schema_2_validator: Optional[StrictStr] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[Union[float, str]] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = { "float", "str" }
+
+    model_config = {
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_anyof(cls, v):
+        instance = AboveConfigsSuccess.model_construct()
+        error_messages = []
+        # validate data type: float
+        try:
+            instance.anyof_schema_1_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: str
+        try:
+            instance.anyof_schema_2_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        if error_messages:
+            # no match
+            raise ValueError("No match found when setting the actual_instance in AboveConfigsSuccess with anyOf schemas: float, str. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Dict[str, Any]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        # deserialize data into float
+        try:
+            # validation
+            instance.anyof_schema_1_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_1_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into str
+        try:
+            # validation
+            instance.anyof_schema_2_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_2_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if error_messages:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into AboveConfigsSuccess with anyOf schemas: float, str. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], float, str]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+