bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/monitor_update_request.py

@@ -0,0 +1,223 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+
+from ..models.monitor_update_request_interval_type import (
+    MonitorUpdateRequestIntervalType,
+)
+from ..models.monitor_update_request_notify_on import MonitorUpdateRequestNotifyOn
+from ..models.monitor_update_request_status import MonitorUpdateRequestStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metadata import Metadata
+    from ..models.monitor_update_request_options import MonitorUpdateRequestOptions
+    from ..models.monitor_update_request_scrape_options import (
+        MonitorUpdateRequestScrapeOptions,
+    )
+    from ..models.monitor_update_request_webhook_headers import (
+        MonitorUpdateRequestWebhookHeaders,
+    )
+
+
+T = TypeVar("T", bound="MonitorUpdateRequest")
+
+
+@_attrs_define
+class MonitorUpdateRequest:
+    """
+    Attributes:
+        url (Union[Unset, str]):
+        interval_type (Union[Unset, MonitorUpdateRequestIntervalType]):
+        cron_expression (Union[Unset, str]):
+        change_threshold (Union[Unset, float]):
+        notify_on (Union[Unset, MonitorUpdateRequestNotifyOn]):
+        webhook_url (Union[Unset, str]): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+        webhook_secret (Union[Unset, str]):
+        webhook_headers (Union[Unset, MonitorUpdateRequestWebhookHeaders]):
+        status (Union[Unset, MonitorUpdateRequestStatus]):
+        options (Union[Unset, MonitorUpdateRequestOptions]):
+        scrape_options (Union[Unset, MonitorUpdateRequestScrapeOptions]):
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    url: Union[Unset, str] = UNSET
+    interval_type: Union[Unset, MonitorUpdateRequestIntervalType] = UNSET
+    cron_expression: Union[Unset, str] = UNSET
+    change_threshold: Union[Unset, float] = UNSET
+    notify_on: Union[Unset, MonitorUpdateRequestNotifyOn] = UNSET
+    webhook_url: Union[Unset, str] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    webhook_headers: Union[Unset, "MonitorUpdateRequestWebhookHeaders"] = UNSET
+    status: Union[Unset, MonitorUpdateRequestStatus] = UNSET
+    options: Union[Unset, "MonitorUpdateRequestOptions"] = UNSET
+    scrape_options: Union[Unset, "MonitorUpdateRequestScrapeOptions"] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        interval_type: Union[Unset, str] = UNSET
+        if not isinstance(self.interval_type, Unset):
+            interval_type = self.interval_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_url = self.webhook_url
+
+        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()
+
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+        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({})
+        if url is not UNSET:
+            field_dict["url"] = url
+        if interval_type is not UNSET:
+            field_dict["interval_type"] = interval_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_url is not UNSET:
+            field_dict["webhook_url"] = webhook_url
+        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 status is not UNSET:
+            field_dict["status"] = status
+        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_update_request_options import MonitorUpdateRequestOptions
+        from ..models.monitor_update_request_scrape_options import (
+            MonitorUpdateRequestScrapeOptions,
+        )
+        from ..models.monitor_update_request_webhook_headers import (
+            MonitorUpdateRequestWebhookHeaders,
+        )
+
+        d = dict(src_dict)
+        url = d.pop("url", UNSET)
+
+        _interval_type = d.pop("interval_type", UNSET)
+        interval_type: Union[Unset, MonitorUpdateRequestIntervalType]
+        if isinstance(_interval_type, Unset):
+            interval_type = UNSET
+        else:
+            interval_type = MonitorUpdateRequestIntervalType(_interval_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, MonitorUpdateRequestNotifyOn]
+        if isinstance(_notify_on, Unset):
+            notify_on = UNSET
+        else:
+            notify_on = MonitorUpdateRequestNotifyOn(_notify_on)
+
+        webhook_url = d.pop("webhook_url", UNSET)
+
+        webhook_secret = d.pop("webhook_secret", UNSET)
+
+        _webhook_headers = d.pop("webhook_headers", UNSET)
+        webhook_headers: Union[Unset, MonitorUpdateRequestWebhookHeaders]
+        if isinstance(_webhook_headers, Unset):
+            webhook_headers = UNSET
+        else:
+            webhook_headers = MonitorUpdateRequestWebhookHeaders.from_dict(
+                _webhook_headers
+            )
+
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, MonitorUpdateRequestStatus]
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = MonitorUpdateRequestStatus(_status)
+
+        _options = d.pop("options", UNSET)
+        options: Union[Unset, MonitorUpdateRequestOptions]
+        if isinstance(_options, Unset):
+            options = UNSET
+        else:
+            options = MonitorUpdateRequestOptions.from_dict(_options)
+
+        _scrape_options = d.pop("scrape_options", UNSET)
+        scrape_options: Union[Unset, MonitorUpdateRequestScrapeOptions]
+        if isinstance(_scrape_options, Unset):
+            scrape_options = UNSET
+        else:
+            scrape_options = MonitorUpdateRequestScrapeOptions.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_update_request = cls(
+            url=url,
+            interval_type=interval_type,
+            cron_expression=cron_expression,
+            change_threshold=change_threshold,
+            notify_on=notify_on,
+            webhook_url=webhook_url,
+            webhook_secret=webhook_secret,
+            webhook_headers=webhook_headers,
+            status=status,
+            options=options,
+            scrape_options=scrape_options,
+            metadata=metadata,
+        )
+
+        return monitor_update_request

bytekit/models/monitor_update_request_interval_type.py

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

bytekit/models/monitor_update_request_notify_on.py

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

bytekit/models/monitor_update_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="MonitorUpdateRequestOptions")
+
+
+@_attrs_define
+class MonitorUpdateRequestOptions:
+    """ """
+
+    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_update_request_options = cls()
+
+        monitor_update_request_options.additional_properties = d
+        return monitor_update_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

bytekit/models/monitor_update_request_scrape_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="MonitorUpdateRequestScrapeOptions")
+
+
+@_attrs_define
+class MonitorUpdateRequestScrapeOptions:
+    """ """
+
+    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_update_request_scrape_options = cls()
+
+        monitor_update_request_scrape_options.additional_properties = d
+        return monitor_update_request_scrape_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

bytekit/models/monitor_update_request_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class MonitorUpdateRequestStatus(str, Enum):
+    ACTIVE = "active"
+    PAUSED = "paused"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/monitor_update_request_webhook_headers.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="MonitorUpdateRequestWebhookHeaders")
+
+
+@_attrs_define
+class MonitorUpdateRequestWebhookHeaders:
+    """ """
+
+    additional_properties: dict[str, str] = _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_update_request_webhook_headers = cls()
+
+        monitor_update_request_webhook_headers.additional_properties = d
+        return monitor_update_request_webhook_headers
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/scrape_error_envelope.py

@@ -0,0 +1,113 @@
+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
+
+from ..models.scrape_error_envelope_schema_version import (
+    ScrapeErrorEnvelopeSchemaVersion,
+)
+from ..models.scrape_error_envelope_status import ScrapeErrorEnvelopeStatus
+
+if TYPE_CHECKING:
+    from ..models.scrape_error_envelope_error import ScrapeErrorEnvelopeError
+
+
+T = TypeVar("T", bound="ScrapeErrorEnvelope")
+
+
+@_attrs_define
+class ScrapeErrorEnvelope:
+    """
+    Example:
+        {'schema_version': 1, 'status': 'failed', 'id': 'sc_01j9abc123', 'error': {'code': 'blocked', 'message':
+            'Request blocked by the upstream site', 'http_status': 403, 'failed_at': datetime.datetime(2025, 1, 15, 12, 0,
+            tzinfo=datetime.timezone(datetime.timedelta(0), 'Z'))}}
+
+    Attributes:
+        schema_version (ScrapeErrorEnvelopeSchemaVersion): Envelope contract version emitted by current producers.
+            Consumers reading persisted envelopes must tolerate its absence as legacy v0 during rolling deploys.
+        status (ScrapeErrorEnvelopeStatus):
+        id (Union[None, str]): Stable job identifier (sc_… prefixed) when available; null when the job was never queued
+            (e.g. validation failure).
+        error (ScrapeErrorEnvelopeError):
+    """
+
+    schema_version: ScrapeErrorEnvelopeSchemaVersion
+    status: ScrapeErrorEnvelopeStatus
+    id: Union[None, str]
+    error: "ScrapeErrorEnvelopeError"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        schema_version = self.schema_version.value
+
+        status = self.status.value
+
+        id: Union[None, str]
+        id = self.id
+
+        error = self.error.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "schema_version": schema_version,
+                "status": status,
+                "id": id,
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.scrape_error_envelope_error import ScrapeErrorEnvelopeError
+
+        d = dict(src_dict)
+        schema_version = ScrapeErrorEnvelopeSchemaVersion(d.pop("schema_version"))
+
+        status = ScrapeErrorEnvelopeStatus(d.pop("status"))
+
+        def _parse_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        id = _parse_id(d.pop("id"))
+
+        error = ScrapeErrorEnvelopeError.from_dict(d.pop("error"))
+
+        scrape_error_envelope = cls(
+            schema_version=schema_version,
+            status=status,
+            id=id,
+            error=error,
+        )
+
+        scrape_error_envelope.additional_properties = d
+        return scrape_error_envelope
+
+    @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/scrape_error_envelope_error.py

@@ -0,0 +1,93 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.scrape_error_envelope_error_code import ScrapeErrorEnvelopeErrorCode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ScrapeErrorEnvelopeError")
+
+
+@_attrs_define
+class ScrapeErrorEnvelopeError:
+    """
+    Attributes:
+        code (ScrapeErrorEnvelopeErrorCode):
+        message (str):
+        failed_at (datetime.datetime):
+        http_status (Union[Unset, int]):
+    """
+
+    code: ScrapeErrorEnvelopeErrorCode
+    message: str
+    failed_at: datetime.datetime
+    http_status: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code.value
+
+        message = self.message
+
+        failed_at = self.failed_at.isoformat()
+
+        http_status = self.http_status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+                "failed_at": failed_at,
+            }
+        )
+        if http_status is not UNSET:
+            field_dict["http_status"] = http_status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = ScrapeErrorEnvelopeErrorCode(d.pop("code"))
+
+        message = d.pop("message")
+
+        failed_at = isoparse(d.pop("failed_at"))
+
+        http_status = d.pop("http_status", UNSET)
+
+        scrape_error_envelope_error = cls(
+            code=code,
+            message=message,
+            failed_at=failed_at,
+            http_status=http_status,
+        )
+
+        scrape_error_envelope_error.additional_properties = d
+        return scrape_error_envelope_error
+
+    @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/scrape_error_envelope_error_code.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class ScrapeErrorEnvelopeErrorCode(str, Enum):
+    BLOCKED = "blocked"
+    INTERNAL_ERROR = "internal_error"
+    INVALID_URL = "invalid_url"
+    PAYLOAD_TOO_LARGE = "payload_too_large"
+    QUOTA_EXHAUSTED = "quota_exhausted"
+    RATE_LIMITED = "rate_limited"
+    REQUEST_TOO_LARGE = "request_too_large"
+    TIMEOUT = "timeout"
+    UNSUPPORTED_CONTENT_TYPE = "unsupported_content_type"
+    UPSTREAM_ERROR = "upstream_error"
+    VALIDATION_ERROR = "validation_error"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/scrape_error_envelope_schema_version.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class ScrapeErrorEnvelopeSchemaVersion(IntEnum):
+    VALUE_1 = 1
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/scrape_error_envelope_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ScrapeErrorEnvelopeStatus(str, Enum):
+    FAILED = "failed"
+
+    def __str__(self) -> str:
+        return str(self.value)