stackit-observability 0.0.1a0__py3-none-any.whl

stackit/observability/models/update_alert_config_route_payload.py

@@ -0,0 +1,157 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+from stackit.observability.models.create_alert_config_route_payload_routes_inner import (
+    CreateAlertConfigRoutePayloadRoutesInner,
+)
+
+
+class UpdateAlertConfigRoutePayload(BaseModel):
+    """
+    The root node of the routing tree.
+    """
+
+    group_by: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=200)]]] = Field(
+        default=None,
+        description="The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping.",
+        alias="groupBy",
+    )
+    group_interval: Optional[Annotated[str, Field(min_length=2, strict=True, max_length=8)]] = Field(
+        default="5m",
+        description="How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) `Additional Validators:` * must be a valid time format",
+        alias="groupInterval",
+    )
+    group_wait: Optional[Annotated[str, Field(min_length=2, strict=True, max_length=8)]] = Field(
+        default="30s",
+        description="How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) `Additional Validators:` * must be a valid time format",
+        alias="groupWait",
+    )
+    match: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. A set of equality matchers an alert has to fulfill to match the node.  `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * key and values should only include the characters: a-zA-Z0-9_./@&?:-",
+    )
+    match_re: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. A set of regex-matchers an alert has to fulfill to match the node.  `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters",
+        alias="matchRe",
+    )
+    matchers: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=200)]]] = Field(
+        default=None,
+        description="A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters",
+    )
+    receiver: Annotated[str, Field(min_length=1, strict=True, max_length=200)] = Field(
+        description="Receiver that should be one item of receivers `Additional Validators:` * must be a in name of receivers"
+    )
+    repeat_interval: Optional[Annotated[str, Field(min_length=2, strict=True, max_length=8)]] = Field(
+        default="4h",
+        description="How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). `Additional Validators:` * must be a valid time format",
+        alias="repeatInterval",
+    )
+    routes: Optional[List[CreateAlertConfigRoutePayloadRoutesInner]] = Field(
+        default=None, description="Zero or more child routes."
+    )
+    __properties: ClassVar[List[str]] = [
+        "groupBy",
+        "groupInterval",
+        "groupWait",
+        "match",
+        "matchRe",
+        "matchers",
+        "receiver",
+        "repeatInterval",
+        "routes",
+    ]
+
+    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 UpdateAlertConfigRoutePayload 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 each item in routes (list)
+        _items = []
+        if self.routes:
+            for _item in self.routes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["routes"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateAlertConfigRoutePayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "groupBy": obj.get("groupBy"),
+                "groupInterval": obj.get("groupInterval") if obj.get("groupInterval") is not None else "5m",
+                "groupWait": obj.get("groupWait") if obj.get("groupWait") is not None else "30s",
+                "match": obj.get("match"),
+                "matchRe": obj.get("matchRe"),
+                "matchers": obj.get("matchers"),
+                "receiver": obj.get("receiver"),
+                "repeatInterval": obj.get("repeatInterval") if obj.get("repeatInterval") is not None else "4h",
+                "routes": (
+                    [CreateAlertConfigRoutePayloadRoutesInner.from_dict(_item) for _item in obj["routes"]]
+                    if obj.get("routes") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

stackit/observability/models/update_alert_configs_payload.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
+
+from stackit.observability.models.update_alert_configs_payload_global import (
+    UpdateAlertConfigsPayloadGlobal,
+)
+from stackit.observability.models.update_alert_configs_payload_inhibit_rules import (
+    UpdateAlertConfigsPayloadInhibitRules,
+)
+from stackit.observability.models.update_alert_configs_payload_receivers_inner import (
+    UpdateAlertConfigsPayloadReceiversInner,
+)
+from stackit.observability.models.update_alert_configs_payload_route import (
+    UpdateAlertConfigsPayloadRoute,
+)
+
+
+class UpdateAlertConfigsPayload(BaseModel):
+    """
+    Alert config
+    """
+
+    var_global: Optional[UpdateAlertConfigsPayloadGlobal] = Field(default=None, alias="global")
+    inhibit_rules: Optional[UpdateAlertConfigsPayloadInhibitRules] = Field(default=None, alias="inhibitRules")
+    receivers: List[UpdateAlertConfigsPayloadReceiversInner] = Field(description="A list of notification receivers.")
+    route: UpdateAlertConfigsPayloadRoute
+    __properties: ClassVar[List[str]] = ["global", "inhibitRules", "receivers", "route"]
+
+    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 UpdateAlertConfigsPayload 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 var_global
+        if self.var_global:
+            _dict["global"] = self.var_global.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of inhibit_rules
+        if self.inhibit_rules:
+            _dict["inhibitRules"] = self.inhibit_rules.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in receivers (list)
+        _items = []
+        if self.receivers:
+            for _item in self.receivers:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["receivers"] = _items
+        # override the default output from pydantic by calling `to_dict()` of route
+        if self.route:
+            _dict["route"] = self.route.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateAlertConfigsPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "global": (
+                    UpdateAlertConfigsPayloadGlobal.from_dict(obj["global"]) if obj.get("global") is not None else None
+                ),
+                "inhibitRules": (
+                    UpdateAlertConfigsPayloadInhibitRules.from_dict(obj["inhibitRules"])
+                    if obj.get("inhibitRules") is not None
+                    else None
+                ),
+                "receivers": (
+                    [UpdateAlertConfigsPayloadReceiversInner.from_dict(_item) for _item in obj["receivers"]]
+                    if obj.get("receivers") is not None
+                    else None
+                ),
+                "route": (
+                    UpdateAlertConfigsPayloadRoute.from_dict(obj["route"]) if obj.get("route") is not None else None
+                ),
+            }
+        )
+        return _obj

stackit/observability/models/update_alert_configs_payload_global.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+
+class UpdateAlertConfigsPayloadGlobal(BaseModel):
+    """
+    Global config. If nothing passed the default argus config will be used.
+    """
+
+    opsgenie_api_key: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="Opsgenie api key `Additional Validators:` * should only include the characters: a-zA-Z0-9-",
+        alias="opsgenieApiKey",
+    )
+    opsgenie_api_url: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="Opsgenie api url `Additional Validators:` * must be a syntactically valid url address",
+        alias="opsgenieApiUrl",
+    )
+    resolve_timeout: Optional[Annotated[str, Field(min_length=2, strict=True, max_length=8)]] = Field(
+        default="5m",
+        description="ResolveTimeout is the default value used by alertmanager if the alert does not include EndsAt, after this time passes it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt.  `Additional Validators:` * must be a valid time format",
+        alias="resolveTimeout",
+    )
+    smtp_auth_identity: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="Auth identity. `Additional Validators:` * must be a syntactically valid email address",
+        alias="smtpAuthIdentity",
+    )
+    smtp_auth_password: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None, description="SMTP Auth using LOGIN and PLAIN.", alias="smtpAuthPassword"
+    )
+    smtp_auth_username: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server.",
+        alias="smtpAuthUsername",
+    )
+    smtp_from: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="The default SMTP From header field.  `Additional Validators:` * must be a syntactically valid email address",
+        alias="smtpFrom",
+    )
+    smtp_smarthost: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None,
+        description="The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). Example: smtp.example.org:587  `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:-",
+        alias="smtpSmarthost",
+    )
+    __properties: ClassVar[List[str]] = [
+        "opsgenieApiKey",
+        "opsgenieApiUrl",
+        "resolveTimeout",
+        "smtpAuthIdentity",
+        "smtpAuthPassword",
+        "smtpAuthUsername",
+        "smtpFrom",
+        "smtpSmarthost",
+    ]
+
+    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 UpdateAlertConfigsPayloadGlobal 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 UpdateAlertConfigsPayloadGlobal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "opsgenieApiKey": obj.get("opsgenieApiKey"),
+                "opsgenieApiUrl": obj.get("opsgenieApiUrl"),
+                "resolveTimeout": obj.get("resolveTimeout") if obj.get("resolveTimeout") is not None else "5m",
+                "smtpAuthIdentity": obj.get("smtpAuthIdentity"),
+                "smtpAuthPassword": obj.get("smtpAuthPassword"),
+                "smtpAuthUsername": obj.get("smtpAuthUsername"),
+                "smtpFrom": obj.get("smtpFrom"),
+                "smtpSmarthost": obj.get("smtpSmarthost"),
+            }
+        )
+        return _obj

stackit/observability/models/update_alert_configs_payload_inhibit_rules.py

@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+
+class UpdateAlertConfigsPayloadInhibitRules(BaseModel):
+    """
+    A list of inhibition rules.
+    """
+
+    equal: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=200)]]] = Field(
+        default=None,
+        description="Labels that must have an equal value in the source and target alert for the inhibition to take effect. `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:-",
+    )
+    source_match: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. Matchers for which one or more alerts have to exist for the inhibition to take effect. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters * each key and value should only include the characters: a-zA-Z0-9_./@&?:-",
+        alias="sourceMatch",
+    )
+    source_match_re: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. Regex match `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters",
+        alias="sourceMatchRe",
+    )
+    target_match: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. Matchers that have to be fulfilled in the alerts to be muted. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters * each key and value should only include the characters: a-zA-Z0-9_./@&?:-",
+        alias="targetMatch",
+    )
+    target_match_re: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="map of key:value. Matchers that have to be fulfilled in the alerts to be muted. Regex. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters",
+        alias="targetMatchRe",
+    )
+    __properties: ClassVar[List[str]] = ["equal", "sourceMatch", "sourceMatchRe", "targetMatch", "targetMatchRe"]
+
+    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 UpdateAlertConfigsPayloadInhibitRules 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 UpdateAlertConfigsPayloadInhibitRules from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "equal": obj.get("equal"),
+                "sourceMatch": obj.get("sourceMatch"),
+                "sourceMatchRe": obj.get("sourceMatchRe"),
+                "targetMatch": obj.get("targetMatch"),
+                "targetMatchRe": obj.get("targetMatchRe"),
+            }
+        )
+        return _obj