bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/list_monitor_captures_response_200.py

@@ -0,0 +1,101 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.capture_response import CaptureResponse
+
+
+T = TypeVar("T", bound="ListMonitorCapturesResponse200")
+
+
+@_attrs_define
+class ListMonitorCapturesResponse200:
+    """
+    Attributes:
+        data (list['CaptureResponse']):
+        next_cursor (Union[None, str]):
+        has_more (bool):
+    """
+
+    data: list["CaptureResponse"]
+    next_cursor: Union[None, str]
+    has_more: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        next_cursor: Union[None, str]
+        next_cursor = self.next_cursor
+
+        has_more = self.has_more
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+                "next_cursor": next_cursor,
+                "has_more": has_more,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.capture_response import CaptureResponse
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = CaptureResponse.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        def _parse_next_cursor(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        has_more = d.pop("has_more")
+
+        list_monitor_captures_response_200 = cls(
+            data=data,
+            next_cursor=next_cursor,
+            has_more=has_more,
+        )
+
+        list_monitor_captures_response_200.additional_properties = d
+        return list_monitor_captures_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

bytekit/models/list_monitors_response_200.py

@@ -0,0 +1,101 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.monitor_response import MonitorResponse
+
+
+T = TypeVar("T", bound="ListMonitorsResponse200")
+
+
+@_attrs_define
+class ListMonitorsResponse200:
+    """
+    Attributes:
+        data (list['MonitorResponse']):
+        next_cursor (Union[None, str]):
+        has_more (bool):
+    """
+
+    data: list["MonitorResponse"]
+    next_cursor: Union[None, str]
+    has_more: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        next_cursor: Union[None, str]
+        next_cursor = self.next_cursor
+
+        has_more = self.has_more
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+                "next_cursor": next_cursor,
+                "has_more": has_more,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.monitor_response import MonitorResponse
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = MonitorResponse.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        def _parse_next_cursor(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        has_more = d.pop("has_more")
+
+        list_monitors_response_200 = cls(
+            data=data,
+            next_cursor=next_cursor,
+            has_more=has_more,
+        )
+
+        list_monitors_response_200.additional_properties = d
+        return list_monitors_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

bytekit/models/list_monitors_status.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class ListMonitorsStatus(str, Enum):
+    ACTIVE = "active"
+    CANCELLED = "cancelled"
+    PAUSED = "paused"
+    PROCESSING = "processing"
+    SUSPENDED = "suspended"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/list_webhook_deliveries_response_200.py

@@ -0,0 +1,101 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.webhook_delivery_response import WebhookDeliveryResponse
+
+
+T = TypeVar("T", bound="ListWebhookDeliveriesResponse200")
+
+
+@_attrs_define
+class ListWebhookDeliveriesResponse200:
+    """
+    Attributes:
+        data (list['WebhookDeliveryResponse']):
+        next_cursor (Union[None, str]):
+        has_more (bool):
+    """
+
+    data: list["WebhookDeliveryResponse"]
+    next_cursor: Union[None, str]
+    has_more: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        next_cursor: Union[None, str]
+        next_cursor = self.next_cursor
+
+        has_more = self.has_more
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+                "next_cursor": next_cursor,
+                "has_more": has_more,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.webhook_delivery_response import WebhookDeliveryResponse
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = WebhookDeliveryResponse.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        def _parse_next_cursor(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        has_more = d.pop("has_more")
+
+        list_webhook_deliveries_response_200 = cls(
+            data=data,
+            next_cursor=next_cursor,
+            has_more=has_more,
+        )
+
+        list_webhook_deliveries_response_200.additional_properties = d
+        return list_webhook_deliveries_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

bytekit/models/list_webhook_deliveries_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ListWebhookDeliveriesStatus(str, Enum):
+    DELIVERED = "delivered"
+    EXHAUSTED = "exhausted"
+    FAILED = "failed"
+    PENDING = "pending"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/metadata.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Metadata")
+
+
+@_attrs_define
+class Metadata:
+    """Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized."""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        metadata = cls()
+
+        metadata.additional_properties = d
+        return metadata
+
+    @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

bytekit/models/monitor_create_request.py

@@ -0,0 +1,219 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+
+from ..models.monitor_create_request_interval_type import (
+    MonitorCreateRequestIntervalType,
+)
+from ..models.monitor_create_request_notify_on import MonitorCreateRequestNotifyOn
+from ..models.monitor_create_request_type import MonitorCreateRequestType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metadata import Metadata
+    from ..models.monitor_create_request_options import MonitorCreateRequestOptions
+    from ..models.monitor_create_request_scrape_options import (
+        MonitorCreateRequestScrapeOptions,
+    )
+    from ..models.monitor_create_request_webhook_headers import (
+        MonitorCreateRequestWebhookHeaders,
+    )
+
+
+T = TypeVar("T", bound="MonitorCreateRequest")
+
+
+@_attrs_define
+class MonitorCreateRequest:
+    """
+    Attributes:
+        url (str):
+        interval_type (MonitorCreateRequestIntervalType):
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+        type_ (Union[Unset, MonitorCreateRequestType]):
+        cron_expression (Union[Unset, str]): 5-field cron expression. Required when interval_type is "cron".
+        change_threshold (Union[Unset, float]):
+        notify_on (Union[Unset, MonitorCreateRequestNotifyOn]):
+        webhook_secret (Union[Unset, str]):
+        webhook_headers (Union[Unset, MonitorCreateRequestWebhookHeaders]): Max 20 headers. Keys must match
+            /^[A-Za-z0-9-]+$/ and not be reserved.
+        options (Union[Unset, MonitorCreateRequestOptions]): Screenshot monitor options (device, viewport, format,
+            etc.).
+        scrape_options (Union[Unset, MonitorCreateRequestScrapeOptions]): Scrape monitor options (formats, country,
+            headers, etc.). Only for type=scrape.
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    url: str
+    interval_type: MonitorCreateRequestIntervalType
+    webhook_url: str
+    type_: Union[Unset, MonitorCreateRequestType] = UNSET
+    cron_expression: Union[Unset, str] = UNSET
+    change_threshold: Union[Unset, float] = UNSET
+    notify_on: Union[Unset, MonitorCreateRequestNotifyOn] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    webhook_headers: Union[Unset, "MonitorCreateRequestWebhookHeaders"] = UNSET
+    options: Union[Unset, "MonitorCreateRequestOptions"] = UNSET
+    scrape_options: Union[Unset, "MonitorCreateRequestScrapeOptions"] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        interval_type = self.interval_type.value
+
+        webhook_url = self.webhook_url
+
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        cron_expression = self.cron_expression
+
+        change_threshold = self.change_threshold
+
+        notify_on: Union[Unset, str] = UNSET
+        if not isinstance(self.notify_on, Unset):
+            notify_on = self.notify_on.value
+
+        webhook_secret = self.webhook_secret
+
+        webhook_headers: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.webhook_headers, Unset):
+            webhook_headers = self.webhook_headers.to_dict()
+
+        options: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options.to_dict()
+
+        scrape_options: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.scrape_options, Unset):
+            scrape_options = self.scrape_options.to_dict()
+
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "url": url,
+                "interval_type": interval_type,
+                "webhook_url": webhook_url,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if cron_expression is not UNSET:
+            field_dict["cron_expression"] = cron_expression
+        if change_threshold is not UNSET:
+            field_dict["change_threshold"] = change_threshold
+        if notify_on is not UNSET:
+            field_dict["notify_on"] = notify_on
+        if webhook_secret is not UNSET:
+            field_dict["webhook_secret"] = webhook_secret
+        if webhook_headers is not UNSET:
+            field_dict["webhook_headers"] = webhook_headers
+        if options is not UNSET:
+            field_dict["options"] = options
+        if scrape_options is not UNSET:
+            field_dict["scrape_options"] = scrape_options
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.metadata import Metadata
+        from ..models.monitor_create_request_options import MonitorCreateRequestOptions
+        from ..models.monitor_create_request_scrape_options import (
+            MonitorCreateRequestScrapeOptions,
+        )
+        from ..models.monitor_create_request_webhook_headers import (
+            MonitorCreateRequestWebhookHeaders,
+        )
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        interval_type = MonitorCreateRequestIntervalType(d.pop("interval_type"))
+
+        webhook_url = d.pop("webhook_url")
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, MonitorCreateRequestType]
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = MonitorCreateRequestType(_type_)
+
+        cron_expression = d.pop("cron_expression", UNSET)
+
+        change_threshold = d.pop("change_threshold", UNSET)
+
+        _notify_on = d.pop("notify_on", UNSET)
+        notify_on: Union[Unset, MonitorCreateRequestNotifyOn]
+        if isinstance(_notify_on, Unset):
+            notify_on = UNSET
+        else:
+            notify_on = MonitorCreateRequestNotifyOn(_notify_on)
+
+        webhook_secret = d.pop("webhook_secret", UNSET)
+
+        _webhook_headers = d.pop("webhook_headers", UNSET)
+        webhook_headers: Union[Unset, MonitorCreateRequestWebhookHeaders]
+        if isinstance(_webhook_headers, Unset):
+            webhook_headers = UNSET
+        else:
+            webhook_headers = MonitorCreateRequestWebhookHeaders.from_dict(
+                _webhook_headers
+            )
+
+        _options = d.pop("options", UNSET)
+        options: Union[Unset, MonitorCreateRequestOptions]
+        if isinstance(_options, Unset):
+            options = UNSET
+        else:
+            options = MonitorCreateRequestOptions.from_dict(_options)
+
+        _scrape_options = d.pop("scrape_options", UNSET)
+        scrape_options: Union[Unset, MonitorCreateRequestScrapeOptions]
+        if isinstance(_scrape_options, Unset):
+            scrape_options = UNSET
+        else:
+            scrape_options = MonitorCreateRequestScrapeOptions.from_dict(
+                _scrape_options
+            )
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        monitor_create_request = cls(
+            url=url,
+            interval_type=interval_type,
+            webhook_url=webhook_url,
+            type_=type_,
+            cron_expression=cron_expression,
+            change_threshold=change_threshold,
+            notify_on=notify_on,
+            webhook_secret=webhook_secret,
+            webhook_headers=webhook_headers,
+            options=options,
+            scrape_options=scrape_options,
+            metadata=metadata,
+        )
+
+        return monitor_create_request

bytekit/models/monitor_create_request_interval_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class MonitorCreateRequestIntervalType(str, Enum):
+    CRON = "cron"
+    DAILY = "daily"
+    HOURLY = "hourly"
+    WEEKLY = "weekly"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/monitor_create_request_notify_on.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class MonitorCreateRequestNotifyOn(str, Enum):
+    CHANGE = "change"
+    EVERY = "every"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/monitor_create_request_options.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MonitorCreateRequestOptions")
+
+
+@_attrs_define
+class MonitorCreateRequestOptions:
+    """Screenshot monitor options (device, viewport, format, etc.)."""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        monitor_create_request_options = cls()
+
+        monitor_create_request_options.additional_properties = d
+        return monitor_create_request_options
+
+    @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