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

acceldata/models/api/catalog/auto_anomaly_summary.py

@@ -0,0 +1,124 @@
+# 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.big_decimal import BigDecimal
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AutoAnomalySummary(BaseModel):
+    """
+    AutoAnomalySummary
+    """ # noqa: E501
+    analysis_summary: Dict[str, Any] = Field(alias="analysisSummary")
+    anomaly_percent: BigDecimal = Field(alias="anomalyPercent")
+    columns_analyzed: List[StrictStr] = Field(alias="columnsAnalyzed")
+    event_time: datetime = Field(alias="eventTime")
+    execution_id: StrictInt = Field(alias="executionId")
+    number_of_anomalies: StrictInt = Field(alias="numberOfAnomalies")
+    number_of_columns_analyzed: StrictInt = Field(alias="numberOfColumnsAnalyzed")
+    status: StrictStr
+    status_message: Optional[StrictStr] = Field(default=None, alias="statusMessage")
+    tenant_id: StrictStr = Field(alias="tenantId")
+    top_anomalous_features: List[StrictStr] = Field(alias="topAnomalousFeatures")
+    top_segments: List[StrictStr] = Field(alias="topSegments")
+    total_columns: StrictInt = Field(alias="totalColumns")
+    total_records_processed: StrictInt = Field(alias="totalRecordsProcessed")
+    __properties: ClassVar[List[str]] = ["analysisSummary", "anomalyPercent", "columnsAnalyzed", "eventTime", "executionId", "numberOfAnomalies", "numberOfColumnsAnalyzed", "status", "statusMessage", "tenantId", "topAnomalousFeatures", "topSegments", "totalColumns", "totalRecordsProcessed"]
+
+    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 AutoAnomalySummary 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 anomaly_percent
+        if self.anomaly_percent:
+            _dict['anomalyPercent'] = self.anomaly_percent.to_dict()
+        # set to None if status_message (nullable) is None
+        # and model_fields_set contains the field
+        if self.status_message is None and "status_message" in self.model_fields_set:
+            _dict['statusMessage'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AutoAnomalySummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analysisSummary": obj.get("analysisSummary"),
+            "anomalyPercent": BigDecimal.from_dict(obj["anomalyPercent"]) if obj.get("anomalyPercent") is not None else None,
+            "columnsAnalyzed": obj.get("columnsAnalyzed"),
+            "eventTime": obj.get("eventTime"),
+            "executionId": obj.get("executionId"),
+            "numberOfAnomalies": obj.get("numberOfAnomalies"),
+            "numberOfColumnsAnalyzed": obj.get("numberOfColumnsAnalyzed"),
+            "status": obj.get("status"),
+            "statusMessage": obj.get("statusMessage"),
+            "tenantId": obj.get("tenantId"),
+            "topAnomalousFeatures": obj.get("topAnomalousFeatures"),
+            "topSegments": obj.get("topSegments"),
+            "totalColumns": obj.get("totalColumns"),
+            "totalRecordsProcessed": obj.get("totalRecordsProcessed")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/backing_asset.py

@@ -0,0 +1,126 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.marker_config import MarkerConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BackingAsset(BaseModel):
+    """
+    BackingAsset
+    """ # noqa: E501
+    custom_query: Optional[StrictStr] = Field(default=None, alias="customQuery")
+    custom_table_asset_ids: Optional[List[StrictInt]] = Field(default=None, alias="customTableAssetIds")
+    id: Optional[StrictInt] = None
+    marker: Optional[MarkerConfig] = None
+    rule_id: Optional[StrictInt] = Field(default=None, alias="ruleId")
+    table_alias: Optional[StrictStr] = Field(default=None, alias="tableAlias")
+    table_asset_id: Optional[StrictInt] = Field(default=None, alias="tableAssetId")
+    table_asset_uid: Optional[StrictStr] = Field(default=None, alias="tableAssetUid")
+    __properties: ClassVar[List[str]] = ["customQuery", "customTableAssetIds", "id", "marker", "ruleId", "tableAlias", "tableAssetId", "tableAssetUid"]
+
+    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 BackingAsset 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 marker
+        if self.marker:
+            _dict['marker'] = self.marker.to_dict()
+        # set to None if custom_query (nullable) is None
+        # and model_fields_set contains the field
+        if self.custom_query is None and "custom_query" in self.model_fields_set:
+            _dict['customQuery'] = None
+
+        # set to None if custom_table_asset_ids (nullable) is None
+        # and model_fields_set contains the field
+        if self.custom_table_asset_ids is None and "custom_table_asset_ids" in self.model_fields_set:
+            _dict['customTableAssetIds'] = None
+
+        # set to None if table_alias (nullable) is None
+        # and model_fields_set contains the field
+        if self.table_alias is None and "table_alias" in self.model_fields_set:
+            _dict['tableAlias'] = None
+
+        # set to None if table_asset_uid (nullable) is None
+        # and model_fields_set contains the field
+        if self.table_asset_uid is None and "table_asset_uid" in self.model_fields_set:
+            _dict['tableAssetUid'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BackingAsset from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "customQuery": obj.get("customQuery"),
+            "customTableAssetIds": obj.get("customTableAssetIds"),
+            "id": obj.get("id"),
+            "marker": MarkerConfig.from_dict(obj["marker"]) if obj.get("marker") is not None else None,
+            "ruleId": obj.get("ruleId"),
+            "tableAlias": obj.get("tableAlias"),
+            "tableAssetId": obj.get("tableAssetId"),
+            "tableAssetUid": obj.get("tableAssetUid")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/below_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 BelowConfigs(BaseModel):
+    """
+    BelowConfigs
+    """ # 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 BelowConfigs 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 BelowConfigs 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/big_decimal.py

@@ -0,0 +1,100 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.big_integer import BigInteger
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BigDecimal(BaseModel):
+    """
+    BigDecimal
+    """ # noqa: E501
+    int_val: BigInteger = Field(alias="intVal")
+    scale: StrictInt
+    precision: StrictInt
+    string_cache: StrictStr = Field(alias="stringCache")
+    int_compact: StrictInt = Field(alias="intCompact")
+    __properties: ClassVar[List[str]] = ["intVal", "scale", "precision", "stringCache", "intCompact"]
+
+    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 BigDecimal 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 int_val
+        if self.int_val:
+            _dict['intVal'] = self.int_val.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BigDecimal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "intVal": BigInteger.from_dict(obj["intVal"]) if obj.get("intVal") is not None else None,
+            "scale": obj.get("scale"),
+            "precision": obj.get("precision"),
+            "stringCache": obj.get("stringCache"),
+            "intCompact": obj.get("intCompact")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/big_integer.py

@@ -0,0 +1,98 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BigInteger(BaseModel):
+    """
+    BigInteger
+    """ # noqa: E501
+    signum: StrictInt
+    mag: List[Dict[str, Any]]
+    bit_count_plus_one: StrictInt = Field(alias="bitCountPlusOne")
+    bit_length_plus_one: StrictInt = Field(alias="bitLengthPlusOne")
+    lowest_set_bit_plus_two: StrictInt = Field(alias="lowestSetBitPlusTwo")
+    first_nonzero_int_num_plus_two: StrictInt = Field(alias="firstNonzeroIntNumPlusTwo")
+    __properties: ClassVar[List[str]] = ["signum", "mag", "bitCountPlusOne", "bitLengthPlusOne", "lowestSetBitPlusTwo", "firstNonzeroIntNumPlusTwo"]
+
+    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 BigInteger 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 BigInteger from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "signum": obj.get("signum"),
+            "mag": obj.get("mag"),
+            "bitCountPlusOne": obj.get("bitCountPlusOne"),
+            "bitLengthPlusOne": obj.get("bitLengthPlusOne"),
+            "lowestSetBitPlusTwo": obj.get("lowestSetBitPlusTwo"),
+            "firstNonzeroIntNumPlusTwo": obj.get("firstNonzeroIntNumPlusTwo")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/bounds_date_time_marker_config.py

@@ -0,0 +1,110 @@
+# 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, 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 BoundsDateTimeMarkerConfig(BaseModel):
+    """
+    BoundsDateTimeMarkerConfig
+    """ # noqa: E501
+    base_asset_id: Optional[StrictInt] = Field(default=None, alias="baseAssetId")
+    date_column_name: StrictStr = Field(alias="dateColumnName")
+    format: StrictStr
+    from_date: Optional[StrictStr] = Field(default=None, alias="fromDate")
+    time_zone_id: StrictStr = Field(alias="timeZoneId")
+    to_date: Optional[StrictStr] = Field(default=None, alias="toDate")
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["baseAssetId", "dateColumnName", "format", "fromDate", "timeZoneId", "toDate", "type"]
+
+    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 BoundsDateTimeMarkerConfig 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 from_date (nullable) is None
+        # and model_fields_set contains the field
+        if self.from_date is None and "from_date" in self.model_fields_set:
+            _dict['fromDate'] = None
+
+        # set to None if to_date (nullable) is None
+        # and model_fields_set contains the field
+        if self.to_date is None and "to_date" in self.model_fields_set:
+            _dict['toDate'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BoundsDateTimeMarkerConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "baseAssetId": obj.get("baseAssetId"),
+            "dateColumnName": obj.get("dateColumnName"),
+            "format": obj.get("format"),
+            "fromDate": obj.get("fromDate"),
+            "timeZoneId": obj.get("timeZoneId"),
+            "toDate": obj.get("toDate"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+