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

acceldata/models/api/catalog/column_metric_with_anomaly_details.py

@@ -0,0 +1,119 @@
+# 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, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ColumnMetricWithAnomalyDetails(BaseModel):
+    """
+    ColumnMetricWithAnomalyDetails
+    """ # noqa: E501
+    expected_lower_bound: Union[StrictFloat, StrictInt] = Field(alias="expectedLowerBound")
+    expected_upper_bound: Union[StrictFloat, StrictInt] = Field(alias="expectedUpperBound")
+    feedback: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: NOT_ANOMALY, ANOMALY, EXCLUDE, NO_FEEDBACK.")
+    insert_date_time: Optional[StrictStr] = Field(default=None, alias="insertDateTime")
+    is_metric_anomalous: StrictBool = Field(alias="isMetricAnomalous")
+    metric_date: StrictStr = Field(alias="metricDate")
+    metric_type: StrictStr = Field(description="Allowed values at generation time: COMPLETENESS, DISTINCT_COUNT, MINIMUM, MAXIMUM, MEAN, STANDARD_DEVIATION, SKEWNESS, KURTOSIS, SUM, COEF_OF_VAR, MIN_LENGTH, MAX_LENGTH, AVG_LENGTH, MIN_KEYS, MAX_KEYS, AVG_KEYS, MIN_ARRAY_LENGTH, MAX_ARRAY_LENGTH, AVG_ARRAY_LENGTH.", alias="metricType")
+    metric_value: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="metricValue")
+    strength: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: HIGH, MEDIUM, LOW.")
+    __properties: ClassVar[List[str]] = ["expectedLowerBound", "expectedUpperBound", "feedback", "insertDateTime", "isMetricAnomalous", "metricDate", "metricType", "metricValue", "strength"]
+
+    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 ColumnMetricWithAnomalyDetails 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,
+        )
+        # set to None if feedback (nullable) is None
+        # and model_fields_set contains the field
+        if self.feedback is None and "feedback" in self.model_fields_set:
+            _dict['feedback'] = None
+
+        # set to None if insert_date_time (nullable) is None
+        # and model_fields_set contains the field
+        if self.insert_date_time is None and "insert_date_time" in self.model_fields_set:
+            _dict['insertDateTime'] = None
+
+        # set to None if strength (nullable) is None
+        # and model_fields_set contains the field
+        if self.strength is None and "strength" in self.model_fields_set:
+            _dict['strength'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ColumnMetricWithAnomalyDetails from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "expectedLowerBound": obj.get("expectedLowerBound"),
+            "expectedUpperBound": obj.get("expectedUpperBound"),
+            "feedback": obj.get("feedback"),
+            "insertDateTime": obj.get("insertDateTime"),
+            "isMetricAnomalous": obj.get("isMetricAnomalous"),
+            "metricDate": obj.get("metricDate"),
+            "metricType": obj.get("metricType"),
+            "metricValue": obj.get("metricValue"),
+            "strength": obj.get("strength")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/column_variable.py

@@ -0,0 +1,111 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ColumnVariable(BaseModel):
+    """
+    ColumnVariable
+    """ # noqa: E501
+    format: Optional[StrictStr] = None
+    get_only_with_variable_name: ColumnVariable = Field(alias="getOnlyWithVariableName")
+    is_number: StrictBool = Field(alias="isNumber")
+    name: StrictStr
+    value: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["format", "getOnlyWithVariableName", "isNumber", "name", "value"]
+
+    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 ColumnVariable 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 get_only_with_variable_name
+        if self.get_only_with_variable_name:
+            _dict['getOnlyWithVariableName'] = self.get_only_with_variable_name.to_dict()
+        # set to None if format (nullable) is None
+        # and model_fields_set contains the field
+        if self.format is None and "format" in self.model_fields_set:
+            _dict['format'] = None
+
+        # set to None if value (nullable) is None
+        # and model_fields_set contains the field
+        if self.value is None and "value" in self.model_fields_set:
+            _dict['value'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ColumnVariable from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "format": obj.get("format"),
+            "getOnlyWithVariableName": ColumnVariable.from_dict(obj["getOnlyWithVariableName"]) if obj.get("getOnlyWithVariableName") is not None else None,
+            "isNumber": obj.get("isNumber"),
+            "name": obj.get("name"),
+            "value": obj.get("value")
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+ColumnVariable.model_rebuild(raise_errors=False)
+

acceldata/models/api/catalog/composite_policy_execution.py

@@ -0,0 +1,102 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.composite_policy_item_execution import CompositePolicyItemExecution
+from acceldata.models.api.catalog.generic_rule_execution import GenericRuleExecution
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CompositePolicyExecution(BaseModel):
+    """
+    CompositePolicyExecution
+    """ # noqa: E501
+    execution: GenericRuleExecution
+    items: List[CompositePolicyItemExecution]
+    __properties: ClassVar[List[str]] = ["execution", "items"]
+
+    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 CompositePolicyExecution 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 execution
+        if self.execution:
+            _dict['execution'] = self.execution.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositePolicyExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "execution": GenericRuleExecution.from_dict(obj["execution"]) if obj.get("execution") is not None else None,
+            "items": [CompositePolicyItemExecution.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/composite_policy_item_execution.py

@@ -0,0 +1,104 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CompositePolicyItemExecution(BaseModel):
+    """
+    CompositePolicyItemExecution
+    """ # noqa: E501
+    error: Optional[StrictStr] = None
+    execution_id: StrictInt = Field(alias="executionId")
+    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
+    id: Optional[StrictInt] = None
+    rule_item_id: Optional[StrictInt] = Field(default=None, alias="ruleItemId")
+    started_at: datetime = Field(alias="startedAt")
+    __properties: ClassVar[List[str]] = ["error", "executionId", "finishedAt", "id", "ruleItemId", "startedAt"]
+
+    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 CompositePolicyItemExecution 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,
+        )
+        # set to None if error (nullable) is None
+        # and model_fields_set contains the field
+        if self.error is None and "error" in self.model_fields_set:
+            _dict['error'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CompositePolicyItemExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "error": obj.get("error"),
+            "executionId": obj.get("executionId"),
+            "finishedAt": obj.get("finishedAt"),
+            "id": obj.get("id"),
+            "ruleItemId": obj.get("ruleItemId"),
+            "startedAt": obj.get("startedAt")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/connection.py

@@ -0,0 +1,118 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.analytics_pipeline import AnalyticsPipeline
+from acceldata.models.api.catalog.connection_type import ConnectionType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class Connection(BaseModel):
+    """
+    Connection
+    """ # noqa: E501
+    analytics_pipeline: AnalyticsPipeline = Field(alias="analyticsPipeline")
+    assemblies_count: StrictInt = Field(alias="assembliesCount")
+    configuration: Optional[Dict[str, StrictStr]] = None
+    connection_type: ConnectionType = Field(alias="connectionType")
+    created_at: datetime = Field(alias="createdAt")
+    description: Optional[StrictStr] = None
+    id: Optional[StrictInt] = None
+    name: StrictStr
+    updated_at: datetime = Field(alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["analyticsPipeline", "assembliesCount", "configuration", "connectionType", "createdAt", "description", "id", "name", "updatedAt"]
+
+    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 Connection 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 analytics_pipeline
+        if self.analytics_pipeline:
+            _dict['analyticsPipeline'] = self.analytics_pipeline.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of connection_type
+        if self.connection_type:
+            _dict['connectionType'] = self.connection_type.to_dict()
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Connection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analyticsPipeline": AnalyticsPipeline.from_dict(obj["analyticsPipeline"]) if obj.get("analyticsPipeline") is not None else None,
+            "assembliesCount": obj.get("assembliesCount"),
+            "configuration": obj.get("configuration"),
+            "connectionType": ConnectionType.from_dict(obj["connectionType"]) if obj.get("connectionType") is not None else None,
+            "createdAt": obj.get("createdAt"),
+            "description": obj.get("description"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/connection_test_result.py

@@ -0,0 +1,106 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ConnectionTestResult(BaseModel):
+    """
+    ConnectionTestResult
+    """ # noqa: E501
+    is_parent_available: StrictBool = Field(alias="isParentAvailable")
+    message: Optional[StrictStr] = None
+    parent_list: Dict[str, Any] = Field(alias="parentList")
+    request_id: Optional[StrictStr] = Field(default=None, alias="requestId")
+    status: StrictStr
+    __properties: ClassVar[List[str]] = ["isParentAvailable", "message", "parentList", "requestId", "status"]
+
+    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 ConnectionTestResult 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,
+        )
+        # set to None if message (nullable) is None
+        # and model_fields_set contains the field
+        if self.message is None and "message" in self.model_fields_set:
+            _dict['message'] = None
+
+        # set to None if request_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.request_id is None and "request_id" in self.model_fields_set:
+            _dict['requestId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ConnectionTestResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "isParentAvailable": obj.get("isParentAvailable"),
+            "message": obj.get("message"),
+            "parentList": obj.get("parentList"),
+            "requestId": obj.get("requestId"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+