From bab5dbe2c50ba9c94dbedf880e884a4c873a030a Mon Sep 17 00:00:00 2001 From: "convoy-sdk-bot[bot]" <307218117+convoy-sdk-bot[bot]@users.noreply.github.com> Date: Thu, 13 Aug 2026 23:46:45 +0000 Subject: [PATCH] feat: regenerate API client from OpenAPI spec --- .../get_endpoint_period_failure_rates.py | 289 ++++++++++++++++++ src/convoy/models/__init__.py | 18 ++ ...point_period_failure_rates_response_200.py | 101 ++++++ ...point_period_failure_rates_response_400.py | 110 +++++++ ...point_period_failure_rates_response_401.py | 110 +++++++ ...point_period_failure_rates_response_404.py | 110 +++++++ .../models_endpoint_period_failure_rate.py | 97 ++++++ 7 files changed, 835 insertions(+) create mode 100644 src/convoy/api/endpoints/get_endpoint_period_failure_rates.py create mode 100644 src/convoy/models/get_endpoint_period_failure_rates_response_200.py create mode 100644 src/convoy/models/get_endpoint_period_failure_rates_response_400.py create mode 100644 src/convoy/models/get_endpoint_period_failure_rates_response_401.py create mode 100644 src/convoy/models/get_endpoint_period_failure_rates_response_404.py create mode 100644 src/convoy/models/models_endpoint_period_failure_rate.py diff --git a/src/convoy/api/endpoints/get_endpoint_period_failure_rates.py b/src/convoy/api/endpoints/get_endpoint_period_failure_rates.py new file mode 100644 index 0000000..8c3c316 --- /dev/null +++ b/src/convoy/api/endpoints/get_endpoint_period_failure_rates.py @@ -0,0 +1,289 @@ +from http import HTTPStatus +from typing import Any +from urllib.parse import quote + +import httpx + +from ... import errors +from ...client import AuthenticatedClient, Client +from ...models.get_endpoint_period_failure_rates_response_200 import ( + GetEndpointPeriodFailureRatesResponse200, +) +from ...models.get_endpoint_period_failure_rates_response_400 import ( + GetEndpointPeriodFailureRatesResponse400, +) +from ...models.get_endpoint_period_failure_rates_response_401 import ( + GetEndpointPeriodFailureRatesResponse401, +) +from ...models.get_endpoint_period_failure_rates_response_404 import ( + GetEndpointPeriodFailureRatesResponse404, +) +from ...types import UNSET, Response, Unset + + +def _get_kwargs( + project_id: str, + *, + endpoint_id: list[str] | Unset = UNSET, + start_date: str | Unset = UNSET, + end_date: str | Unset = UNSET, +) -> dict[str, Any]: + + params: dict[str, Any] = {} + + json_endpoint_id: list[str] | Unset = UNSET + if not isinstance(endpoint_id, Unset): + json_endpoint_id = endpoint_id + + params["endpointId"] = json_endpoint_id + + params["startDate"] = start_date + + params["endDate"] = end_date + + params = {k: v for k, v in params.items() if v is not UNSET and v is not None} + + _kwargs: dict[str, Any] = { + "method": "get", + "url": "/v1/projects/{project_id}/endpoints/period-failure-rates".format( + project_id=quote(str(project_id), safe=""), + ), + "params": params, + } + + return _kwargs + + +def _parse_response( + *, client: AuthenticatedClient | Client, response: httpx.Response +) -> ( + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 + | None +): + if response.status_code == 200: + response_200 = GetEndpointPeriodFailureRatesResponse200.from_dict( + response.json() + ) + + return response_200 + + if response.status_code == 400: + response_400 = GetEndpointPeriodFailureRatesResponse400.from_dict( + response.json() + ) + + return response_400 + + if response.status_code == 401: + response_401 = GetEndpointPeriodFailureRatesResponse401.from_dict( + response.json() + ) + + return response_401 + + if response.status_code == 404: + response_404 = GetEndpointPeriodFailureRatesResponse404.from_dict( + response.json() + ) + + return response_404 + + if client.raise_on_unexpected_status: + raise errors.UnexpectedStatus(response.status_code, response.content) + else: + return None + + +def _build_response( + *, client: AuthenticatedClient | Client, response: httpx.Response +) -> Response[ + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 +]: + return Response( + status_code=HTTPStatus(response.status_code), + content=response.content, + headers=response.headers, + parsed=_parse_response(client=client, response=response), + ) + + +def sync_detailed( + project_id: str, + *, + client: AuthenticatedClient, + endpoint_id: list[str] | Unset = UNSET, + start_date: str | Unset = UNSET, + end_date: str | Unset = UNSET, +) -> Response[ + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 +]: + """Endpoint period failure rates + + Display-only delivery rates for the given endpoint ids over a date range (default last 7 days). + Independent of the list so a slow COUNT cannot delay the table. + + Args: + project_id (str): + endpoint_id (list[str] | Unset): + start_date (str | Unset): + end_date (str | Unset): + + Raises: + errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. + httpx.TimeoutException: If the request takes longer than Client.timeout. + + Returns: + Response[GetEndpointPeriodFailureRatesResponse200 | GetEndpointPeriodFailureRatesResponse400 | GetEndpointPeriodFailureRatesResponse401 | GetEndpointPeriodFailureRatesResponse404] + """ + + kwargs = _get_kwargs( + project_id=project_id, + endpoint_id=endpoint_id, + start_date=start_date, + end_date=end_date, + ) + + response = client.get_httpx_client().request( + **kwargs, + ) + + return _build_response(client=client, response=response) + + +def sync( + project_id: str, + *, + client: AuthenticatedClient, + endpoint_id: list[str] | Unset = UNSET, + start_date: str | Unset = UNSET, + end_date: str | Unset = UNSET, +) -> ( + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 + | None +): + """Endpoint period failure rates + + Display-only delivery rates for the given endpoint ids over a date range (default last 7 days). + Independent of the list so a slow COUNT cannot delay the table. + + Args: + project_id (str): + endpoint_id (list[str] | Unset): + start_date (str | Unset): + end_date (str | Unset): + + Raises: + errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. + httpx.TimeoutException: If the request takes longer than Client.timeout. + + Returns: + GetEndpointPeriodFailureRatesResponse200 | GetEndpointPeriodFailureRatesResponse400 | GetEndpointPeriodFailureRatesResponse401 | GetEndpointPeriodFailureRatesResponse404 + """ + + return sync_detailed( + project_id=project_id, + client=client, + endpoint_id=endpoint_id, + start_date=start_date, + end_date=end_date, + ).parsed + + +async def asyncio_detailed( + project_id: str, + *, + client: AuthenticatedClient, + endpoint_id: list[str] | Unset = UNSET, + start_date: str | Unset = UNSET, + end_date: str | Unset = UNSET, +) -> Response[ + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 +]: + """Endpoint period failure rates + + Display-only delivery rates for the given endpoint ids over a date range (default last 7 days). + Independent of the list so a slow COUNT cannot delay the table. + + Args: + project_id (str): + endpoint_id (list[str] | Unset): + start_date (str | Unset): + end_date (str | Unset): + + Raises: + errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. + httpx.TimeoutException: If the request takes longer than Client.timeout. + + Returns: + Response[GetEndpointPeriodFailureRatesResponse200 | GetEndpointPeriodFailureRatesResponse400 | GetEndpointPeriodFailureRatesResponse401 | GetEndpointPeriodFailureRatesResponse404] + """ + + kwargs = _get_kwargs( + project_id=project_id, + endpoint_id=endpoint_id, + start_date=start_date, + end_date=end_date, + ) + + response = await client.get_async_httpx_client().request(**kwargs) + + return _build_response(client=client, response=response) + + +async def asyncio( + project_id: str, + *, + client: AuthenticatedClient, + endpoint_id: list[str] | Unset = UNSET, + start_date: str | Unset = UNSET, + end_date: str | Unset = UNSET, +) -> ( + GetEndpointPeriodFailureRatesResponse200 + | GetEndpointPeriodFailureRatesResponse400 + | GetEndpointPeriodFailureRatesResponse401 + | GetEndpointPeriodFailureRatesResponse404 + | None +): + """Endpoint period failure rates + + Display-only delivery rates for the given endpoint ids over a date range (default last 7 days). + Independent of the list so a slow COUNT cannot delay the table. + + Args: + project_id (str): + endpoint_id (list[str] | Unset): + start_date (str | Unset): + end_date (str | Unset): + + Raises: + errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. + httpx.TimeoutException: If the request takes longer than Client.timeout. + + Returns: + GetEndpointPeriodFailureRatesResponse200 | GetEndpointPeriodFailureRatesResponse400 | GetEndpointPeriodFailureRatesResponse401 | GetEndpointPeriodFailureRatesResponse404 + """ + + return ( + await asyncio_detailed( + project_id=project_id, + client=client, + endpoint_id=endpoint_id, + start_date=start_date, + end_date=end_date, + ) + ).parsed diff --git a/src/convoy/models/__init__.py b/src/convoy/models/__init__.py index 8fbd2fd..45d5391 100644 --- a/src/convoy/models/__init__.py +++ b/src/convoy/models/__init__.py @@ -214,6 +214,18 @@ from .get_endpoint_event_response_400 import GetEndpointEventResponse400 from .get_endpoint_event_response_401 import GetEndpointEventResponse401 from .get_endpoint_event_response_404 import GetEndpointEventResponse404 +from .get_endpoint_period_failure_rates_response_200 import ( + GetEndpointPeriodFailureRatesResponse200, +) +from .get_endpoint_period_failure_rates_response_400 import ( + GetEndpointPeriodFailureRatesResponse400, +) +from .get_endpoint_period_failure_rates_response_401 import ( + GetEndpointPeriodFailureRatesResponse401, +) +from .get_endpoint_period_failure_rates_response_404 import ( + GetEndpointPeriodFailureRatesResponse404, +) from .get_endpoint_response_200 import GetEndpointResponse200 from .get_endpoint_response_400 import GetEndpointResponse400 from .get_endpoint_response_401 import GetEndpointResponse401 @@ -360,6 +372,7 @@ ) from .models_dynamic_event_data_type_0 import ModelsDynamicEventDataType0 from .models_endpoint_authentication import ModelsEndpointAuthentication +from .models_endpoint_period_failure_rate import ModelsEndpointPeriodFailureRate from .models_endpoint_response import ModelsEndpointResponse from .models_event_delivery_response import ModelsEventDeliveryResponse from .models_event_response import ModelsEventResponse @@ -718,6 +731,10 @@ "GetEndpointEventResponse400", "GetEndpointEventResponse401", "GetEndpointEventResponse404", + "GetEndpointPeriodFailureRatesResponse200", + "GetEndpointPeriodFailureRatesResponse400", + "GetEndpointPeriodFailureRatesResponse401", + "GetEndpointPeriodFailureRatesResponse404", "GetEndpointResponse200", "GetEndpointResponse400", "GetEndpointResponse401", @@ -844,6 +861,7 @@ "ModelsDynamicEventCustomHeadersType0", "ModelsDynamicEventDataType0", "ModelsEndpointAuthentication", + "ModelsEndpointPeriodFailureRate", "ModelsEndpointResponse", "ModelsEventDeliveryResponse", "ModelsEventResponse", diff --git a/src/convoy/models/get_endpoint_period_failure_rates_response_200.py b/src/convoy/models/get_endpoint_period_failure_rates_response_200.py new file mode 100644 index 0000000..573063f --- /dev/null +++ b/src/convoy/models/get_endpoint_period_failure_rates_response_200.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +from collections.abc import Mapping +from typing import TYPE_CHECKING, Any, TypeVar + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +if TYPE_CHECKING: + from ..models.models_endpoint_period_failure_rate import ( + ModelsEndpointPeriodFailureRate, + ) + + +T = TypeVar("T", bound="GetEndpointPeriodFailureRatesResponse200") + + +@_attrs_define +class GetEndpointPeriodFailureRatesResponse200: + """ + Attributes: + message (str | Unset): + status (bool | Unset): + data (list[ModelsEndpointPeriodFailureRate] | Unset): + """ + + message: str | Unset = UNSET + status: bool | Unset = UNSET + data: list[ModelsEndpointPeriodFailureRate] | Unset = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + message = self.message + + status = self.status + + data: list[dict[str, Any]] | Unset = UNSET + if not isinstance(self.data, Unset): + data = [] + for data_item_data in self.data: + data_item = data_item_data.to_dict() + data.append(data_item) + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if message is not UNSET: + field_dict["message"] = message + if status is not UNSET: + field_dict["status"] = status + if data is not UNSET: + field_dict["data"] = data + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + from ..models.models_endpoint_period_failure_rate import ( + ModelsEndpointPeriodFailureRate, + ) + + d = dict(src_dict) + message = d.pop("message", UNSET) + + status = d.pop("status", UNSET) + + _data = d.pop("data", UNSET) + data: list[ModelsEndpointPeriodFailureRate] | Unset = UNSET + if _data is not UNSET: + data = [] + for data_item_data in _data: + data_item = ModelsEndpointPeriodFailureRate.from_dict(data_item_data) + + data.append(data_item) + + get_endpoint_period_failure_rates_response_200 = cls( + message=message, + status=status, + data=data, + ) + + get_endpoint_period_failure_rates_response_200.additional_properties = d + return get_endpoint_period_failure_rates_response_200 + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/src/convoy/models/get_endpoint_period_failure_rates_response_400.py b/src/convoy/models/get_endpoint_period_failure_rates_response_400.py new file mode 100644 index 0000000..5c62732 --- /dev/null +++ b/src/convoy/models/get_endpoint_period_failure_rates_response_400.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +from collections.abc import Mapping +from typing import TYPE_CHECKING, Any, TypeVar, cast + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +if TYPE_CHECKING: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + +T = TypeVar("T", bound="GetEndpointPeriodFailureRatesResponse400") + + +@_attrs_define +class GetEndpointPeriodFailureRatesResponse400: + """ + Attributes: + message (str | Unset): + status (bool | Unset): + data (HandlersStubType0 | None | Unset): + """ + + message: str | Unset = UNSET + status: bool | Unset = UNSET + data: HandlersStubType0 | None | Unset = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + message = self.message + + status = self.status + + data: dict[str, Any] | None | Unset + if isinstance(self.data, Unset): + data = UNSET + elif isinstance(self.data, HandlersStubType0): + data = self.data.to_dict() + else: + data = self.data + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if message is not UNSET: + field_dict["message"] = message + if status is not UNSET: + field_dict["status"] = status + if data is not UNSET: + field_dict["data"] = data + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + d = dict(src_dict) + message = d.pop("message", UNSET) + + status = d.pop("status", UNSET) + + def _parse_data(data: object) -> HandlersStubType0 | None | Unset: + if data is None: + return data + if isinstance(data, Unset): + return data + try: + if not isinstance(data, dict): + raise TypeError() + componentsschemashandlers_stub_type_0 = HandlersStubType0.from_dict( + data + ) + + return componentsschemashandlers_stub_type_0 + except (TypeError, ValueError, AttributeError, KeyError): + pass + return cast(HandlersStubType0 | None | Unset, data) + + data = _parse_data(d.pop("data", UNSET)) + + get_endpoint_period_failure_rates_response_400 = cls( + message=message, + status=status, + data=data, + ) + + get_endpoint_period_failure_rates_response_400.additional_properties = d + return get_endpoint_period_failure_rates_response_400 + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/src/convoy/models/get_endpoint_period_failure_rates_response_401.py b/src/convoy/models/get_endpoint_period_failure_rates_response_401.py new file mode 100644 index 0000000..4ec1713 --- /dev/null +++ b/src/convoy/models/get_endpoint_period_failure_rates_response_401.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +from collections.abc import Mapping +from typing import TYPE_CHECKING, Any, TypeVar, cast + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +if TYPE_CHECKING: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + +T = TypeVar("T", bound="GetEndpointPeriodFailureRatesResponse401") + + +@_attrs_define +class GetEndpointPeriodFailureRatesResponse401: + """ + Attributes: + message (str | Unset): + status (bool | Unset): + data (HandlersStubType0 | None | Unset): + """ + + message: str | Unset = UNSET + status: bool | Unset = UNSET + data: HandlersStubType0 | None | Unset = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + message = self.message + + status = self.status + + data: dict[str, Any] | None | Unset + if isinstance(self.data, Unset): + data = UNSET + elif isinstance(self.data, HandlersStubType0): + data = self.data.to_dict() + else: + data = self.data + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if message is not UNSET: + field_dict["message"] = message + if status is not UNSET: + field_dict["status"] = status + if data is not UNSET: + field_dict["data"] = data + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + d = dict(src_dict) + message = d.pop("message", UNSET) + + status = d.pop("status", UNSET) + + def _parse_data(data: object) -> HandlersStubType0 | None | Unset: + if data is None: + return data + if isinstance(data, Unset): + return data + try: + if not isinstance(data, dict): + raise TypeError() + componentsschemashandlers_stub_type_0 = HandlersStubType0.from_dict( + data + ) + + return componentsschemashandlers_stub_type_0 + except (TypeError, ValueError, AttributeError, KeyError): + pass + return cast(HandlersStubType0 | None | Unset, data) + + data = _parse_data(d.pop("data", UNSET)) + + get_endpoint_period_failure_rates_response_401 = cls( + message=message, + status=status, + data=data, + ) + + get_endpoint_period_failure_rates_response_401.additional_properties = d + return get_endpoint_period_failure_rates_response_401 + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/src/convoy/models/get_endpoint_period_failure_rates_response_404.py b/src/convoy/models/get_endpoint_period_failure_rates_response_404.py new file mode 100644 index 0000000..348cf7a --- /dev/null +++ b/src/convoy/models/get_endpoint_period_failure_rates_response_404.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +from collections.abc import Mapping +from typing import TYPE_CHECKING, Any, TypeVar, cast + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +if TYPE_CHECKING: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + +T = TypeVar("T", bound="GetEndpointPeriodFailureRatesResponse404") + + +@_attrs_define +class GetEndpointPeriodFailureRatesResponse404: + """ + Attributes: + message (str | Unset): + status (bool | Unset): + data (HandlersStubType0 | None | Unset): + """ + + message: str | Unset = UNSET + status: bool | Unset = UNSET + data: HandlersStubType0 | None | Unset = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + message = self.message + + status = self.status + + data: dict[str, Any] | None | Unset + if isinstance(self.data, Unset): + data = UNSET + elif isinstance(self.data, HandlersStubType0): + data = self.data.to_dict() + else: + data = self.data + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if message is not UNSET: + field_dict["message"] = message + if status is not UNSET: + field_dict["status"] = status + if data is not UNSET: + field_dict["data"] = data + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + from ..models.handlers_stub_type_0 import HandlersStubType0 + + d = dict(src_dict) + message = d.pop("message", UNSET) + + status = d.pop("status", UNSET) + + def _parse_data(data: object) -> HandlersStubType0 | None | Unset: + if data is None: + return data + if isinstance(data, Unset): + return data + try: + if not isinstance(data, dict): + raise TypeError() + componentsschemashandlers_stub_type_0 = HandlersStubType0.from_dict( + data + ) + + return componentsschemashandlers_stub_type_0 + except (TypeError, ValueError, AttributeError, KeyError): + pass + return cast(HandlersStubType0 | None | Unset, data) + + data = _parse_data(d.pop("data", UNSET)) + + get_endpoint_period_failure_rates_response_404 = cls( + message=message, + status=status, + data=data, + ) + + get_endpoint_period_failure_rates_response_404.additional_properties = d + return get_endpoint_period_failure_rates_response_404 + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/src/convoy/models/models_endpoint_period_failure_rate.py b/src/convoy/models/models_endpoint_period_failure_rate.py new file mode 100644 index 0000000..f236b3c --- /dev/null +++ b/src/convoy/models/models_endpoint_period_failure_rate.py @@ -0,0 +1,97 @@ +from __future__ import annotations + +from collections.abc import Mapping +from typing import Any, TypeVar + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +T = TypeVar("T", bound="ModelsEndpointPeriodFailureRate") + + +@_attrs_define +class ModelsEndpointPeriodFailureRate: + """ + Attributes: + failure_count (int | Unset): + period_failure_rate (float | Unset): + retry_count (int | Unset): + success_count (int | Unset): + uid (str | Unset): + """ + + failure_count: int | Unset = UNSET + period_failure_rate: float | Unset = UNSET + retry_count: int | Unset = UNSET + success_count: int | Unset = UNSET + uid: str | Unset = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + failure_count = self.failure_count + + period_failure_rate = self.period_failure_rate + + retry_count = self.retry_count + + success_count = self.success_count + + uid = self.uid + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if failure_count is not UNSET: + field_dict["failure_count"] = failure_count + if period_failure_rate is not UNSET: + field_dict["period_failure_rate"] = period_failure_rate + if retry_count is not UNSET: + field_dict["retry_count"] = retry_count + if success_count is not UNSET: + field_dict["success_count"] = success_count + if uid is not UNSET: + field_dict["uid"] = uid + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + d = dict(src_dict) + failure_count = d.pop("failure_count", UNSET) + + period_failure_rate = d.pop("period_failure_rate", UNSET) + + retry_count = d.pop("retry_count", UNSET) + + success_count = d.pop("success_count", UNSET) + + uid = d.pop("uid", UNSET) + + models_endpoint_period_failure_rate = cls( + failure_count=failure_count, + period_failure_rate=period_failure_rate, + retry_count=retry_count, + success_count=success_count, + uid=uid, + ) + + models_endpoint_period_failure_rate.additional_properties = d + return models_endpoint_period_failure_rate + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties