bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/clip.py

@@ -0,0 +1,83 @@
+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="Clip")
+
+
+@_attrs_define
+class Clip:
+    """
+    Attributes:
+        x (int):
+        y (int):
+        width (int):
+        height (int):
+    """
+
+    x: int
+    y: int
+    width: int
+    height: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        x = self.x
+
+        y = self.y
+
+        width = self.width
+
+        height = self.height
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "x": x,
+                "y": y,
+                "width": width,
+                "height": height,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        x = d.pop("x")
+
+        y = d.pop("y")
+
+        width = d.pop("width")
+
+        height = d.pop("height")
+
+        clip = cls(
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+        )
+
+        clip.additional_properties = d
+        return clip
+
+    @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/cookie.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Cookie")
+
+
+@_attrs_define
+class Cookie:
+    """
+    Attributes:
+        name (str):
+        value (str):
+        domain (Union[Unset, str]):
+        path (Union[Unset, str]):
+        secure (Union[Unset, bool]):
+        http_only (Union[Unset, bool]):
+    """
+
+    name: str
+    value: str
+    domain: Union[Unset, str] = UNSET
+    path: Union[Unset, str] = UNSET
+    secure: Union[Unset, bool] = UNSET
+    http_only: Union[Unset, bool] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        value = self.value
+
+        domain = self.domain
+
+        path = self.path
+
+        secure = self.secure
+
+        http_only = self.http_only
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "name": name,
+                "value": value,
+            }
+        )
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if path is not UNSET:
+            field_dict["path"] = path
+        if secure is not UNSET:
+            field_dict["secure"] = secure
+        if http_only is not UNSET:
+            field_dict["httpOnly"] = http_only
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        value = d.pop("value")
+
+        domain = d.pop("domain", UNSET)
+
+        path = d.pop("path", UNSET)
+
+        secure = d.pop("secure", UNSET)
+
+        http_only = d.pop("httpOnly", UNSET)
+
+        cookie = cls(
+            name=name,
+            value=value,
+            domain=domain,
+            path=path,
+            secure=secure,
+            http_only=http_only,
+        )
+
+        return cookie

bytekit/models/create_bulk_body.py

@@ -0,0 +1,155 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.create_bulk_body_defaults import CreateBulkBodyDefaults
+    from ..models.create_bulk_body_items_item import CreateBulkBodyItemsItem
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="CreateBulkBody")
+
+
+@_attrs_define
+class CreateBulkBody:
+    """Provide `urls` (simple list) OR `items` (per-item config), not
+    both. `type` selects the capture kind per entry — only
+    `screenshot` and `scrape` are accepted (`recording` is
+    deactivated). Behaviour fields may be set per item or via
+    `defaults`; a per-item value overrides the matching default.
+
+        Attributes:
+            webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+                scheme_unsupported)
+            urls (Union[Unset, list[str]]): Simple URL list. Provide urls OR items, not both.
+            items (Union[Unset, list['CreateBulkBodyItemsItem']]): Per-item configs. Provide urls OR items, not both.
+            defaults (Union[Unset, CreateBulkBodyDefaults]): Default behaviour applied to every entry unless the item
+                overrides it.
+            webhook_secret (Union[Unset, str]):
+            metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    webhook_url: str
+    urls: Union[Unset, list[str]] = UNSET
+    items: Union[Unset, list["CreateBulkBodyItemsItem"]] = UNSET
+    defaults: Union[Unset, "CreateBulkBodyDefaults"] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        webhook_url = self.webhook_url
+
+        urls: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.urls, Unset):
+            urls = self.urls
+
+        items: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.items, Unset):
+            items = []
+            for items_item_data in self.items:
+                items_item = items_item_data.to_dict()
+                items.append(items_item)
+
+        defaults: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.defaults, Unset):
+            defaults = self.defaults.to_dict()
+
+        webhook_secret = self.webhook_secret
+
+        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(self.additional_properties)
+        field_dict.update(
+            {
+                "webhook_url": webhook_url,
+            }
+        )
+        if urls is not UNSET:
+            field_dict["urls"] = urls
+        if items is not UNSET:
+            field_dict["items"] = items
+        if defaults is not UNSET:
+            field_dict["defaults"] = defaults
+        if webhook_secret is not UNSET:
+            field_dict["webhook_secret"] = webhook_secret
+        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.create_bulk_body_defaults import CreateBulkBodyDefaults
+        from ..models.create_bulk_body_items_item import CreateBulkBodyItemsItem
+        from ..models.metadata import Metadata
+
+        d = dict(src_dict)
+        webhook_url = d.pop("webhook_url")
+
+        urls = cast(list[str], d.pop("urls", UNSET))
+
+        items = []
+        _items = d.pop("items", UNSET)
+        for items_item_data in _items or []:
+            items_item = CreateBulkBodyItemsItem.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        _defaults = d.pop("defaults", UNSET)
+        defaults: Union[Unset, CreateBulkBodyDefaults]
+        if isinstance(_defaults, Unset):
+            defaults = UNSET
+        else:
+            defaults = CreateBulkBodyDefaults.from_dict(_defaults)
+
+        webhook_secret = d.pop("webhook_secret", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        create_bulk_body = cls(
+            webhook_url=webhook_url,
+            urls=urls,
+            items=items,
+            defaults=defaults,
+            webhook_secret=webhook_secret,
+            metadata=metadata,
+        )
+
+        create_bulk_body.additional_properties = d
+        return create_bulk_body
+
+    @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