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

arthur_client/api_bindings/models/patch_alert_rule.py

@@ -20,6 +20,7 @@ import json
 from pydantic import BaseModel, ConfigDict, 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
 
@@ -33,8 +34,9 @@ class PatchAlertRule(BaseModel):
     bound: Optional[AlertBound] = None
     query: Optional[StrictStr] = None
     metric_name: Optional[StrictStr] = None
+    interval: Optional[AlertRuleInterval] = None
     notification_webhook_ids: Optional[List[StrictStr]] = None
-    __properties: ClassVar[List[str]] = ["name", "description", "threshold", "bound", "query", "metric_name", "notification_webhook_ids"]
+    __properties: ClassVar[List[str]] = ["name", "description", "threshold", "bound", "query", "metric_name", "interval", "notification_webhook_ids"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -75,6 +77,9 @@ class PatchAlertRule(BaseModel):
             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 name (nullable) is None
         # and model_fields_set contains the field
         if self.name is None and "name" in self.model_fields_set:
@@ -105,6 +110,11 @@ class PatchAlertRule(BaseModel):
         if self.metric_name is None and "metric_name" in self.model_fields_set:
             _dict['metric_name'] = None
 
+        # set to None if interval (nullable) is None
+        # and model_fields_set contains the field
+        if self.interval is None and "interval" in self.model_fields_set:
+            _dict['interval'] = None
+
         # set to None if notification_webhook_ids (nullable) is None
         # and model_fields_set contains the field
         if self.notification_webhook_ids is None and "notification_webhook_ids" in self.model_fields_set:
@@ -128,6 +138,7 @@ class PatchAlertRule(BaseModel):
             "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,
             "notification_webhook_ids": obj.get("notification_webhook_ids")
         })
         return _obj

arthur_client/api_bindings/models/post_alert.py

@@ -21,6 +21,7 @@ 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
 
@@ -33,10 +34,11 @@ class PostAlert(BaseModel):
     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
-    __properties: ClassVar[List[str]] = ["description", "timestamp", "value", "threshold", "bound", "dimensions", "alert_rule_id", "job_id"]
+    __properties: ClassVar[List[str]] = ["description", "timestamp", "value", "threshold", "bound", "interval", "dimensions", "alert_rule_id", "job_id"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -77,6 +79,9 @@ class PostAlert(BaseModel):
             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:
@@ -109,6 +114,7 @@ class PostAlert(BaseModel):
             "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")

arthur_client/api_bindings/models/post_alert_rule.py

@@ -20,6 +20,7 @@ import json
 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
 
@@ -33,8 +34,9 @@ class PostAlertRule(BaseModel):
     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.")
     notification_webhook_ids: Optional[List[StrictStr]] = Field(default=None, description="The notification webhook IDs where the alert rule will send alert notification.")
-    __properties: ClassVar[List[str]] = ["name", "description", "threshold", "bound", "query", "metric_name", "notification_webhook_ids"]
+    __properties: ClassVar[List[str]] = ["name", "description", "threshold", "bound", "query", "metric_name", "interval", "notification_webhook_ids"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -75,6 +77,9 @@ class PostAlertRule(BaseModel):
             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:
@@ -98,6 +103,7 @@ class PostAlertRule(BaseModel):
             "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,
             "notification_webhook_ids": obj.get("notification_webhook_ids")
         })
         return _obj

arthur_client/api_bindings/models/post_metrics_query.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from arthur_client.api_bindings.models.alert_rule_interval import AlertRuleInterval
 from arthur_client.api_bindings.models.post_metrics_query_time_range import PostMetricsQueryTimeRange
 from arthur_client.api_bindings.models.result_filter import ResultFilter
 from typing import Optional, Set
@@ -30,9 +31,10 @@ class PostMetricsQuery(BaseModel):
     """ # noqa: E501
     query: StrictStr = Field(description="Query for retrieving the metrics.")
     time_range: PostMetricsQueryTimeRange = Field(description="Time range to filter the metrics by.")
+    interval: Optional[AlertRuleInterval] = None
     limit: Optional[StrictInt] = Field(default=50, description="Limit the number of metrics returned. Defaults to 50.")
     result_filter: Optional[ResultFilter] = None
-    __properties: ClassVar[List[str]] = ["query", "time_range", "limit", "result_filter"]
+    __properties: ClassVar[List[str]] = ["query", "time_range", "interval", "limit", "result_filter"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -76,9 +78,17 @@ class PostMetricsQuery(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of time_range
         if self.time_range:
             _dict['time_range'] = self.time_range.to_dict()
+        # 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 result_filter
         if self.result_filter:
             _dict['result_filter'] = self.result_filter.to_dict()
+        # set to None if interval (nullable) is None
+        # and model_fields_set contains the field
+        if self.interval is None and "interval" in self.model_fields_set:
+            _dict['interval'] = None
+
         # set to None if result_filter (nullable) is None
         # and model_fields_set contains the field
         if self.result_filter is None and "result_filter" in self.model_fields_set:
@@ -98,6 +108,7 @@ class PostMetricsQuery(BaseModel):
         _obj = cls.model_validate({
             "query": obj.get("query"),
             "time_range": PostMetricsQueryTimeRange.from_dict(obj["time_range"]) if obj.get("time_range") is not None else None,
+            "interval": AlertRuleInterval.from_dict(obj["interval"]) if obj.get("interval") is not None else None,
             "limit": obj.get("limit") if obj.get("limit") is not None else 50,
             "result_filter": ResultFilter.from_dict(obj["result_filter"]) if obj.get("result_filter") is not None else None
         })

arthur_client/api_bindings/models/validate_alert_rule_query_req.py

@@ -0,0 +1,87 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ValidateAlertRuleQueryReq(BaseModel):
+    """
+    ValidateAlertRuleQueryReq
+    """ # noqa: E501
+    query: StrictStr = Field(description="The query of the alert rule.")
+    __properties: ClassVar[List[str]] = ["query"]
+
+    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 ValidateAlertRuleQueryReq 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 ValidateAlertRuleQueryReq from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "query": obj.get("query")
+        })
+        return _obj
+
+

arthur_client/api_bindings/test/test_alert.py

@@ -40,6 +40,9 @@ class TestAlert(unittest.TestCase):
                 value = 1.337,
                 threshold = 1.337,
                 bound = 'upper_bound',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 dimensions = None,
                 alert_rule_id = '',
                 job_id = '',
@@ -58,6 +61,9 @@ class TestAlert(unittest.TestCase):
                 value = 1.337,
                 threshold = 1.337,
                 bound = 'upper_bound',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 dimensions = None,
                 alert_rule_id = '',
                 created_at = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'),

arthur_client/api_bindings/test/test_alert_rule.py

@@ -45,6 +45,9 @@ class TestAlertRule(unittest.TestCase):
                 bound = 'upper_bound',
                 query = '',
                 metric_name = '',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 last_updated_by_user = arthur_client.api_bindings.models.user.User(
                     created_at = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), 
                     updated_at = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), 
@@ -75,6 +78,9 @@ class TestAlertRule(unittest.TestCase):
                 bound = 'upper_bound',
                 query = '',
                 metric_name = '',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 notification_webhooks = [
                     arthur_client.api_bindings.models.alert_rule_notification_webhook.AlertRuleNotificationWebhook(
                         id = '', 

arthur_client/api_bindings/test/test_alert_rule_interval.py

@@ -0,0 +1,54 @@
+# 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
+
+
+import unittest
+
+from arthur_client.api_bindings.models.alert_rule_interval import AlertRuleInterval
+
+class TestAlertRuleInterval(unittest.TestCase):
+    """AlertRuleInterval unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def make_instance(self, include_optional) -> AlertRuleInterval:
+        """Test AlertRuleInterval
+            include_optional is a boolean, when False only required
+            params are included, when True both required and
+            optional params are included """
+        # uncomment below to create an instance of `AlertRuleInterval`
+        """
+        model = AlertRuleInterval()
+        if include_optional:
+            return AlertRuleInterval(
+                unit = 'seconds',
+                count = 56
+            )
+        else:
+            return AlertRuleInterval(
+                unit = 'seconds',
+                count = 56,
+        )
+        """
+
+    def testAlertRuleInterval(self):
+        """Test AlertRuleInterval"""
+        # inst_req_only = self.make_instance(include_optional=False)
+        # inst_req_and_optional = self.make_instance(include_optional=True)
+
+if __name__ == '__main__':
+    unittest.main()

arthur_client/api_bindings/test/test_alert_rule_sql_validation_resp.py

@@ -0,0 +1,58 @@
+# 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
+
+
+import unittest
+
+from arthur_client.api_bindings.models.alert_rule_sql_validation_resp import AlertRuleSQLValidationResp
+
+class TestAlertRuleSQLValidationResp(unittest.TestCase):
+    """AlertRuleSQLValidationResp unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def make_instance(self, include_optional) -> AlertRuleSQLValidationResp:
+        """Test AlertRuleSQLValidationResp
+            include_optional is a boolean, when False only required
+            params are included, when True both required and
+            optional params are included """
+        # uncomment below to create an instance of `AlertRuleSQLValidationResp`
+        """
+        model = AlertRuleSQLValidationResp()
+        if include_optional:
+            return AlertRuleSQLValidationResp(
+                has_metric_timestamp_col = True,
+                has_metric_value_col = True,
+                has_time_templates = True,
+                has_interval_templates = True
+            )
+        else:
+            return AlertRuleSQLValidationResp(
+                has_metric_timestamp_col = True,
+                has_metric_value_col = True,
+                has_time_templates = True,
+                has_interval_templates = True,
+        )
+        """
+
+    def testAlertRuleSQLValidationResp(self):
+        """Test AlertRuleSQLValidationResp"""
+        # inst_req_only = self.make_instance(include_optional=False)
+        # inst_req_and_optional = self.make_instance(include_optional=True)
+
+if __name__ == '__main__':
+    unittest.main()

arthur_client/api_bindings/test/test_alert_rules_v1_api.py

@@ -54,6 +54,13 @@ class TestAlertRulesV1Api(unittest.TestCase):
         """
         pass
 
+    def test_post_alert_rule_query_validation(self) -> None:
+        """Test case for post_alert_rule_query_validation
+
+        Validate A Model Alert Rule Query
+        """
+        pass
+
     def test_post_model_alert_rule(self) -> None:
         """Test case for post_model_alert_rule
 

arthur_client/api_bindings/test/test_created_alerts.py

@@ -42,6 +42,9 @@ class TestCreatedAlerts(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', 
@@ -73,6 +76,9 @@ class TestCreatedAlerts(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', 

arthur_client/api_bindings/test/test_infinite_resource_list_alert.py

@@ -42,6 +42,9 @@ class TestInfiniteResourceListAlert(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', 
@@ -66,6 +69,9 @@ class TestInfiniteResourceListAlert(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', 

arthur_client/api_bindings/test/test_interval_unit.py

@@ -0,0 +1,33 @@
+# 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
+
+
+import unittest
+
+from arthur_client.api_bindings.models.interval_unit import IntervalUnit
+
+class TestIntervalUnit(unittest.TestCase):
+    """IntervalUnit unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def testIntervalUnit(self):
+        """Test IntervalUnit"""
+        # inst = IntervalUnit()
+
+if __name__ == '__main__':
+    unittest.main()

arthur_client/api_bindings/test/test_metrics_column_list_parameter_schema.py

@@ -39,13 +39,22 @@ class TestMetricsColumnListParameterSchema(unittest.TestCase):
                 optional = True,
                 friendly_name = '',
                 description = '',
-                parameter_type = 'column_list'
+                parameter_type = 'column_list',
+                tag_hints = [
+                    'llm_context'
+                    ],
+                source_dataset_parameter_key = '',
+                allowed_column_types = [
+                    null
+                    ],
+                allow_any_column_type = True
             )
         else:
             return MetricsColumnListParameterSchema(
                 parameter_key = '',
                 friendly_name = '',
                 description = '',
+                source_dataset_parameter_key = '',
         )
         """
 

arthur_client/api_bindings/test/{test_metrics_column_parameter_schema_allowed_column_types_inner.py → test_metrics_column_list_parameter_schema_allowed_column_types_inner.py}

@@ -14,10 +14,10 @@
 
 import unittest
 
-from arthur_client.api_bindings.models.metrics_column_parameter_schema_allowed_column_types_inner import MetricsColumnParameterSchemaAllowedColumnTypesInner
+from arthur_client.api_bindings.models.metrics_column_list_parameter_schema_allowed_column_types_inner import MetricsColumnListParameterSchemaAllowedColumnTypesInner
 
-class TestMetricsColumnParameterSchemaAllowedColumnTypesInner(unittest.TestCase):
-    """MetricsColumnParameterSchemaAllowedColumnTypesInner unit test stubs"""
+class TestMetricsColumnListParameterSchemaAllowedColumnTypesInner(unittest.TestCase):
+    """MetricsColumnListParameterSchemaAllowedColumnTypesInner unit test stubs"""
 
     def setUp(self):
         pass
@@ -25,16 +25,16 @@ class TestMetricsColumnParameterSchemaAllowedColumnTypesInner(unittest.TestCase)
     def tearDown(self):
         pass
 
-    def make_instance(self, include_optional) -> MetricsColumnParameterSchemaAllowedColumnTypesInner:
-        """Test MetricsColumnParameterSchemaAllowedColumnTypesInner
+    def make_instance(self, include_optional) -> MetricsColumnListParameterSchemaAllowedColumnTypesInner:
+        """Test MetricsColumnListParameterSchemaAllowedColumnTypesInner
             include_optional is a boolean, when False only required
             params are included, when True both required and
             optional params are included """
-        # uncomment below to create an instance of `MetricsColumnParameterSchemaAllowedColumnTypesInner`
+        # uncomment below to create an instance of `MetricsColumnListParameterSchemaAllowedColumnTypesInner`
         """
-        model = MetricsColumnParameterSchemaAllowedColumnTypesInner()
+        model = MetricsColumnListParameterSchemaAllowedColumnTypesInner()
         if include_optional:
-            return MetricsColumnParameterSchemaAllowedColumnTypesInner(
+            return MetricsColumnListParameterSchemaAllowedColumnTypesInner(
                 dtype = 'undefined',
                 object = {
                     'key' : null
@@ -42,7 +42,7 @@ class TestMetricsColumnParameterSchemaAllowedColumnTypesInner(unittest.TestCase)
                 items = None
             )
         else:
-            return MetricsColumnParameterSchemaAllowedColumnTypesInner(
+            return MetricsColumnListParameterSchemaAllowedColumnTypesInner(
                 dtype = 'undefined',
                 object = {
                     'key' : null
@@ -51,8 +51,8 @@ class TestMetricsColumnParameterSchemaAllowedColumnTypesInner(unittest.TestCase)
         )
         """
 
-    def testMetricsColumnParameterSchemaAllowedColumnTypesInner(self):
-        """Test MetricsColumnParameterSchemaAllowedColumnTypesInner"""
+    def testMetricsColumnListParameterSchemaAllowedColumnTypesInner(self):
+        """Test MetricsColumnListParameterSchemaAllowedColumnTypesInner"""
         # inst_req_only = self.make_instance(include_optional=False)
         # inst_req_and_optional = self.make_instance(include_optional=True)
 

arthur_client/api_bindings/test/test_patch_alert_rule.py

@@ -41,6 +41,9 @@ class TestPatchAlertRule(unittest.TestCase):
                 bound = 'upper_bound',
                 query = '',
                 metric_name = '',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 notification_webhook_ids = [
                     ''
                     ]

arthur_client/api_bindings/test/test_post_alert.py

@@ -40,6 +40,9 @@ class TestPostAlert(unittest.TestCase):
                 value = 1.337,
                 threshold = 1.337,
                 bound = 'upper_bound',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 dimensions = None,
                 alert_rule_id = '',
                 job_id = ''
@@ -51,6 +54,9 @@ class TestPostAlert(unittest.TestCase):
                 value = 1.337,
                 threshold = 1.337,
                 bound = 'upper_bound',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 dimensions = None,
                 alert_rule_id = '',
         )

arthur_client/api_bindings/test/test_post_alert_rule.py

@@ -41,6 +41,9 @@ class TestPostAlertRule(unittest.TestCase):
                 bound = 'upper_bound',
                 query = '',
                 metric_name = '',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
                 notification_webhook_ids = [
                     ''
                     ]
@@ -52,6 +55,9 @@ class TestPostAlertRule(unittest.TestCase):
                 bound = 'upper_bound',
                 query = '',
                 metric_name = '',
+                interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                    unit = 'seconds', 
+                    count = 56, ),
         )
         """
 

arthur_client/api_bindings/test/test_post_alerts.py

@@ -42,6 +42,9 @@ class TestPostAlerts(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', )
@@ -56,6 +59,9 @@ class TestPostAlerts(unittest.TestCase):
                         value = 1.337, 
                         threshold = 1.337, 
                         bound = 'upper_bound', 
+                        interval = arthur_client.api_bindings.models.alert_rule_interval.AlertRuleInterval(
+                            unit = 'seconds', 
+                            count = 56, ), 
                         dimensions = arthur_client.api_bindings.models.dimensions.dimensions(), 
                         alert_rule_id = '', 
                         job_id = '', )