arthur-client 1.4.0__py3-none-any.whl → 1.4.1186__py3-none-any.whl

arthur_client/api_bindings/models/aggregation_spec_schema_init_args_inner.py

@@ -0,0 +1,164 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.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, StrictStr, ValidationError, field_validator
+from typing import Optional
+from arthur_client.api_bindings.models.metrics_column_list_parameter_schema import MetricsColumnListParameterSchema
+from arthur_client.api_bindings.models.metrics_column_parameter_schema import MetricsColumnParameterSchema
+from arthur_client.api_bindings.models.metrics_dataset_parameter_schema import MetricsDatasetParameterSchema
+from arthur_client.api_bindings.models.metrics_literal_parameter_schema import MetricsLiteralParameterSchema
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+AGGREGATIONSPECSCHEMAINITARGSINNER_ANY_OF_SCHEMAS = ["MetricsColumnListParameterSchema", "MetricsColumnParameterSchema", "MetricsDatasetParameterSchema", "MetricsLiteralParameterSchema"]
+
+class AggregationSpecSchemaInitArgsInner(BaseModel):
+    """
+    AggregationSpecSchemaInitArgsInner
+    """
+
+    # data type: MetricsDatasetParameterSchema
+    anyof_schema_1_validator: Optional[MetricsDatasetParameterSchema] = None
+    # data type: MetricsLiteralParameterSchema
+    anyof_schema_2_validator: Optional[MetricsLiteralParameterSchema] = None
+    # data type: MetricsColumnParameterSchema
+    anyof_schema_3_validator: Optional[MetricsColumnParameterSchema] = None
+    # data type: MetricsColumnListParameterSchema
+    anyof_schema_4_validator: Optional[MetricsColumnListParameterSchema] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[Union[MetricsColumnListParameterSchema, MetricsColumnParameterSchema, MetricsDatasetParameterSchema, MetricsLiteralParameterSchema]] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = { "MetricsColumnListParameterSchema", "MetricsColumnParameterSchema", "MetricsDatasetParameterSchema", "MetricsLiteralParameterSchema" }
+
+    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 = AggregationSpecSchemaInitArgsInner.model_construct()
+        error_messages = []
+        # validate data type: MetricsDatasetParameterSchema
+        if not isinstance(v, MetricsDatasetParameterSchema):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MetricsDatasetParameterSchema`")
+        else:
+            return v
+
+        # validate data type: MetricsLiteralParameterSchema
+        if not isinstance(v, MetricsLiteralParameterSchema):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MetricsLiteralParameterSchema`")
+        else:
+            return v
+
+        # validate data type: MetricsColumnParameterSchema
+        if not isinstance(v, MetricsColumnParameterSchema):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MetricsColumnParameterSchema`")
+        else:
+            return v
+
+        # validate data type: MetricsColumnListParameterSchema
+        if not isinstance(v, MetricsColumnListParameterSchema):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MetricsColumnListParameterSchema`")
+        else:
+            return v
+
+        if error_messages:
+            # no match
+            raise ValueError("No match found when setting the actual_instance in AggregationSpecSchemaInitArgsInner with anyOf schemas: MetricsColumnListParameterSchema, MetricsColumnParameterSchema, MetricsDatasetParameterSchema, MetricsLiteralParameterSchema. 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 = []
+        # anyof_schema_1_validator: Optional[MetricsDatasetParameterSchema] = None
+        try:
+            instance.actual_instance = MetricsDatasetParameterSchema.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+             error_messages.append(str(e))
+        # anyof_schema_2_validator: Optional[MetricsLiteralParameterSchema] = None
+        try:
+            instance.actual_instance = MetricsLiteralParameterSchema.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+             error_messages.append(str(e))
+        # anyof_schema_3_validator: Optional[MetricsColumnParameterSchema] = None
+        try:
+            instance.actual_instance = MetricsColumnParameterSchema.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+             error_messages.append(str(e))
+        # anyof_schema_4_validator: Optional[MetricsColumnListParameterSchema] = None
+        try:
+            instance.actual_instance = MetricsColumnListParameterSchema.from_json(json_str)
+            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 AggregationSpecSchemaInitArgsInner with anyOf schemas: MetricsColumnListParameterSchema, MetricsColumnParameterSchema, MetricsDatasetParameterSchema, MetricsLiteralParameterSchema. 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], MetricsColumnListParameterSchema, MetricsColumnParameterSchema, MetricsDatasetParameterSchema, MetricsLiteralParameterSchema]]:
+        """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())
+
+

arthur_client/api_bindings/models/alert.py

@@ -0,0 +1,143 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from arthur_client.api_bindings.models.alert_bound import AlertBound
+from arthur_client.api_bindings.models.alert_rule_interval import AlertRuleInterval
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Alert(BaseModel):
+    """
+    Alert
+    """ # noqa: E501
+    description: Optional[StrictStr]
+    timestamp: datetime = Field(description="The timestamp of the alert.")
+    value: Union[StrictFloat, StrictInt] = Field(description="The value of the metric that triggered the alert.")
+    threshold: Union[StrictFloat, StrictInt] = Field(description="The threshold that triggered the alert.")
+    bound: AlertBound = Field(description="The bound of the alert.")
+    interval: AlertRuleInterval = Field(description="The interval of the alert rule, commonly '1 day', '1 hour', etc.")
+    dimensions: Optional[Dict[str, Any]]
+    alert_rule_id: StrictStr = Field(description="The alert rule id of the alert.")
+    job_id: Optional[StrictStr] = None
+    created_at: datetime = Field(description="Time of record creation.")
+    updated_at: datetime = Field(description="Time of last record update.")
+    id: StrictStr = Field(description="The id of the alert.")
+    model_id: StrictStr = Field(description="The model id of the alert.")
+    alert_rule_name: StrictStr = Field(description="The name of the alert rule.")
+    alert_rule_metric_name: StrictStr = Field(description="The name of the metric returned by the alert rule query.")
+    is_duplicate_of: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["description", "timestamp", "value", "threshold", "bound", "interval", "dimensions", "alert_rule_id", "job_id", "created_at", "updated_at", "id", "model_id", "alert_rule_name", "alert_rule_metric_name", "is_duplicate_of"]
+
+    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 Alert 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 interval
+        if self.interval:
+            _dict['interval'] = self.interval.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
+
+        # set to None if dimensions (nullable) is None
+        # and model_fields_set contains the field
+        if self.dimensions is None and "dimensions" in self.model_fields_set:
+            _dict['dimensions'] = None
+
+        # set to None if job_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_id is None and "job_id" in self.model_fields_set:
+            _dict['job_id'] = None
+
+        # set to None if is_duplicate_of (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_duplicate_of is None and "is_duplicate_of" in self.model_fields_set:
+            _dict['is_duplicate_of'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Alert from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "description": obj.get("description"),
+            "timestamp": obj.get("timestamp"),
+            "value": obj.get("value"),
+            "threshold": obj.get("threshold"),
+            "bound": obj.get("bound"),
+            "interval": AlertRuleInterval.from_dict(obj["interval"]) if obj.get("interval") is not None else None,
+            "dimensions": obj.get("dimensions"),
+            "alert_rule_id": obj.get("alert_rule_id"),
+            "job_id": obj.get("job_id"),
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "id": obj.get("id"),
+            "model_id": obj.get("model_id"),
+            "alert_rule_name": obj.get("alert_rule_name"),
+            "alert_rule_metric_name": obj.get("alert_rule_metric_name"),
+            "is_duplicate_of": obj.get("is_duplicate_of")
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/alert_bound.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.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 AlertBound(str, Enum):
+    """
+    AlertBound
+    """
+
+    """
+    allowed enum values
+    """
+    UPPER_BOUND = 'upper_bound'
+    LOWER_BOUND = 'lower_bound'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AlertBound from a JSON string"""
+        return cls(json.loads(json_str))
+
+

arthur_client/api_bindings/models/alert_check_job_spec.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AlertCheckJobSpec(BaseModel):
+    """
+    AlertCheckJobSpec
+    """ # noqa: E501
+    job_type: Optional[StrictStr] = 'alert_check'
+    scope_model_id: StrictStr = Field(description="The id of the model to check alerts.")
+    check_range_start_timestamp: datetime = Field(description="The start timestamp to use for checking the alerts on the data.")
+    check_range_end_timestamp: datetime = Field(description="The end timestamp to use for checking the alerts on the data.")
+    __properties: ClassVar[List[str]] = ["job_type", "scope_model_id", "check_range_start_timestamp", "check_range_end_timestamp"]
+
+    @field_validator('job_type')
+    def job_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['alert_check']):
+            raise ValueError("must be one of enum values ('alert_check')")
+        return value
+
+    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 AlertCheckJobSpec 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 AlertCheckJobSpec from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "job_type": obj.get("job_type") if obj.get("job_type") is not None else 'alert_check',
+            "scope_model_id": obj.get("scope_model_id"),
+            "check_range_start_timestamp": obj.get("check_range_start_timestamp"),
+            "check_range_end_timestamp": obj.get("check_range_end_timestamp")
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/alert_rule.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from arthur_client.api_bindings.models.alert_bound import AlertBound
+from arthur_client.api_bindings.models.alert_rule_interval import AlertRuleInterval
+from arthur_client.api_bindings.models.alert_rule_notification_webhook import AlertRuleNotificationWebhook
+from arthur_client.api_bindings.models.user import User
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AlertRule(BaseModel):
+    """
+    AlertRule
+    """ # noqa: E501
+    created_at: datetime = Field(description="Time of record creation.")
+    updated_at: datetime = Field(description="Time of last record update.")
+    id: StrictStr = Field(description="The id of the alert rule.")
+    model_id: StrictStr = Field(description="The model id of the alert rule.")
+    name: StrictStr = Field(description="The name of the alert rule.")
+    description: Optional[StrictStr] = None
+    threshold: Union[StrictFloat, StrictInt] = Field(description="The threshold that will trigger the alert rule.")
+    bound: AlertBound = Field(description="The bound of the alert rule.")
+    query: StrictStr = Field(description="The query of the alert rule.")
+    metric_name: StrictStr = Field(description="The name of the metric returned by the alert rule query.")
+    interval: AlertRuleInterval = Field(description="The interval of the alert rule, commonly '1 day', '1 hour', etc.")
+    last_updated_by_user: Optional[User] = None
+    notification_webhooks: List[AlertRuleNotificationWebhook] = Field(description="Notification webhooks configured for the alert rule.")
+    __properties: ClassVar[List[str]] = ["created_at", "updated_at", "id", "model_id", "name", "description", "threshold", "bound", "query", "metric_name", "interval", "last_updated_by_user", "notification_webhooks"]
+
+    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 AlertRule 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 interval
+        if self.interval:
+            _dict['interval'] = self.interval.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_updated_by_user
+        if self.last_updated_by_user:
+            _dict['last_updated_by_user'] = self.last_updated_by_user.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in notification_webhooks (list)
+        _items = []
+        if self.notification_webhooks:
+            for _item_notification_webhooks in self.notification_webhooks:
+                if _item_notification_webhooks:
+                    _items.append(_item_notification_webhooks.to_dict())
+            _dict['notification_webhooks'] = _items
+        # 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
+
+        # set to None if last_updated_by_user (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_updated_by_user is None and "last_updated_by_user" in self.model_fields_set:
+            _dict['last_updated_by_user'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AlertRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "id": obj.get("id"),
+            "model_id": obj.get("model_id"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "threshold": obj.get("threshold"),
+            "bound": obj.get("bound"),
+            "query": obj.get("query"),
+            "metric_name": obj.get("metric_name"),
+            "interval": AlertRuleInterval.from_dict(obj["interval"]) if obj.get("interval") is not None else None,
+            "last_updated_by_user": User.from_dict(obj["last_updated_by_user"]) if obj.get("last_updated_by_user") is not None else None,
+            "notification_webhooks": [AlertRuleNotificationWebhook.from_dict(_item) for _item in obj["notification_webhooks"]] if obj.get("notification_webhooks") is not None else None
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/alert_rule_interval.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.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 arthur_client.api_bindings.models.interval_unit import IntervalUnit
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AlertRuleInterval(BaseModel):
+    """
+    AlertRuleInterval
+    """ # noqa: E501
+    unit: IntervalUnit = Field(description="Unit of time interval. Example: 'minutes'.")
+    count: StrictInt = Field(description="Number of units in the interval. Example: '5'.")
+    __properties: ClassVar[List[str]] = ["unit", "count"]
+
+    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 AlertRuleInterval 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 AlertRuleInterval from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "unit": obj.get("unit"),
+            "count": obj.get("count")
+        })
+        return _obj
+
+