bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/screenshot_request_device_scale_factor_type_2_type_1.py

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

bytekit/models/screenshot_request_device_scale_factor_type_3_type_1.py

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

bytekit/models/screenshot_request_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ScreenshotRequestFormat(str, Enum):
+    JPEG = "jpeg"
+    PNG = "png"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/screenshot_request_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="ScreenshotRequestHeaders")
+
+
+@_attrs_define
+class ScreenshotRequestHeaders:
+    """ """
+
+    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)
+        screenshot_request_headers = cls()
+
+        screenshot_request_headers.additional_properties = d
+        return screenshot_request_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/screenshot_request_wait_until.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ScreenshotRequestWaitUntil(str, Enum):
+    DOMCONTENTLOADED = "domcontentloaded"
+    LOAD = "load"
+    NETWORKIDLE = "networkidle"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/screenshot_response.py

@@ -0,0 +1,264 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.screenshot_response_status import ScreenshotResponseStatus
+
+T = TypeVar("T", bound="ScreenshotResponse")
+
+
+@_attrs_define
+class ScreenshotResponse:
+    """
+    Attributes:
+        id (str):  Example: ss_01j9abc123.
+        status (ScreenshotResponseStatus):
+        url (str):
+        image_url (Union[None, str]):
+        page_title (Union[None, str]):
+        image_width (Union[None, int]):
+        image_height (Union[None, int]):
+        file_size_bytes (Union[None, int]): Size of the generated image file (PNG/JPEG), in bytes. Informational only —
+            screenshots are billed on bandwidth, not on the image file size. The two are
+            uncorrelated (a heavy page can produce a small image, and vice versa).
+        credits_charged (Union[None, int]):
+        error_code (Union[None, str]):
+        error_message (Union[None, str]):
+        created_at (datetime.datetime):
+        completed_at (Union[None, datetime.datetime]):
+        expires_at (Union[None, datetime.datetime]):
+        poll_url (str):
+    """
+
+    id: str
+    status: ScreenshotResponseStatus
+    url: str
+    image_url: Union[None, str]
+    page_title: Union[None, str]
+    image_width: Union[None, int]
+    image_height: Union[None, int]
+    file_size_bytes: Union[None, int]
+    credits_charged: Union[None, int]
+    error_code: Union[None, str]
+    error_message: Union[None, str]
+    created_at: datetime.datetime
+    completed_at: Union[None, datetime.datetime]
+    expires_at: Union[None, datetime.datetime]
+    poll_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        status = self.status.value
+
+        url = self.url
+
+        image_url: Union[None, str]
+        image_url = self.image_url
+
+        page_title: Union[None, str]
+        page_title = self.page_title
+
+        image_width: Union[None, int]
+        image_width = self.image_width
+
+        image_height: Union[None, int]
+        image_height = self.image_height
+
+        file_size_bytes: Union[None, int]
+        file_size_bytes = self.file_size_bytes
+
+        credits_charged: Union[None, int]
+        credits_charged = self.credits_charged
+
+        error_code: Union[None, str]
+        error_code = self.error_code
+
+        error_message: Union[None, str]
+        error_message = self.error_message
+
+        created_at = self.created_at.isoformat()
+
+        completed_at: Union[None, str]
+        if isinstance(self.completed_at, datetime.datetime):
+            completed_at = self.completed_at.isoformat()
+        else:
+            completed_at = self.completed_at
+
+        expires_at: Union[None, str]
+        if isinstance(self.expires_at, datetime.datetime):
+            expires_at = self.expires_at.isoformat()
+        else:
+            expires_at = self.expires_at
+
+        poll_url = self.poll_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "status": status,
+                "url": url,
+                "image_url": image_url,
+                "page_title": page_title,
+                "image_width": image_width,
+                "image_height": image_height,
+                "file_size_bytes": file_size_bytes,
+                "credits_charged": credits_charged,
+                "error_code": error_code,
+                "error_message": error_message,
+                "created_at": created_at,
+                "completed_at": completed_at,
+                "expires_at": expires_at,
+                "poll_url": poll_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        status = ScreenshotResponseStatus(d.pop("status"))
+
+        url = d.pop("url")
+
+        def _parse_image_url(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        image_url = _parse_image_url(d.pop("image_url"))
+
+        def _parse_page_title(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        page_title = _parse_page_title(d.pop("page_title"))
+
+        def _parse_image_width(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        image_width = _parse_image_width(d.pop("image_width"))
+
+        def _parse_image_height(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        image_height = _parse_image_height(d.pop("image_height"))
+
+        def _parse_file_size_bytes(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        file_size_bytes = _parse_file_size_bytes(d.pop("file_size_bytes"))
+
+        def _parse_credits_charged(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        credits_charged = _parse_credits_charged(d.pop("credits_charged"))
+
+        def _parse_error_code(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        error_code = _parse_error_code(d.pop("error_code"))
+
+        def _parse_error_message(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        error_message = _parse_error_message(d.pop("error_message"))
+
+        created_at = isoparse(d.pop("created_at"))
+
+        def _parse_completed_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completed_at_type_0 = isoparse(data)
+
+                return completed_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        completed_at = _parse_completed_at(d.pop("completed_at"))
+
+        def _parse_expires_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                expires_at_type_0 = isoparse(data)
+
+                return expires_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        expires_at = _parse_expires_at(d.pop("expires_at"))
+
+        poll_url = d.pop("poll_url")
+
+        screenshot_response = cls(
+            id=id,
+            status=status,
+            url=url,
+            image_url=image_url,
+            page_title=page_title,
+            image_width=image_width,
+            image_height=image_height,
+            file_size_bytes=file_size_bytes,
+            credits_charged=credits_charged,
+            error_code=error_code,
+            error_message=error_message,
+            created_at=created_at,
+            completed_at=completed_at,
+            expires_at=expires_at,
+            poll_url=poll_url,
+        )
+
+        screenshot_response.additional_properties = d
+        return screenshot_response
+
+    @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/screenshot_response_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ScreenshotResponseStatus(str, Enum):
+    COMPLETED = "completed"
+    FAILED = "failed"
+    PENDING = "pending"
+    PROCESSING = "processing"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/sitemap_request.py

@@ -0,0 +1,210 @@
+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.sitemap_request_strategy import SitemapRequestStrategy
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metadata import Metadata
+    from ..models.sitemap_request_process_type_0 import SitemapRequestProcessType0
+
+
+T = TypeVar("T", bound="SitemapRequest")
+
+
+@_attrs_define
+class SitemapRequest:
+    """
+    Attributes:
+        url (str):
+        strategy (Union[Unset, SitemapRequestStrategy]):
+        max_depth (Union[Unset, int]):
+        max_urls (Union[Unset, int]):
+        process (Union['SitemapRequestProcessType0', None, Unset]):
+        webhook_url (Union[Unset, str]): Optional webhook endpoint URL (HTTPS only; http:// rejected with 400
+            invalid_url, reason scheme_unsupported). When omitted, no `sitemap.completed`/`sitemap.failed` webhook is
+            delivered and the job is poll-only via `GET /v1/sitemap/{id}`. When present, delivery is unchanged.
+            `webhook_secret` is ignored when `webhook_url` is absent.
+        webhook_secret (Union[None, Unset, str]):
+        cache_ttl (Union[Unset, str]): Max 90 days.
+        compact (Union[Unset, bool]):
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    url: str
+    strategy: Union[Unset, SitemapRequestStrategy] = UNSET
+    max_depth: Union[Unset, int] = UNSET
+    max_urls: Union[Unset, int] = UNSET
+    process: Union["SitemapRequestProcessType0", None, Unset] = UNSET
+    webhook_url: Union[Unset, str] = UNSET
+    webhook_secret: Union[None, Unset, str] = UNSET
+    cache_ttl: Union[Unset, str] = UNSET
+    compact: Union[Unset, bool] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.sitemap_request_process_type_0 import SitemapRequestProcessType0
+
+        url = self.url
+
+        strategy: Union[Unset, str] = UNSET
+        if not isinstance(self.strategy, Unset):
+            strategy = self.strategy.value
+
+        max_depth = self.max_depth
+
+        max_urls = self.max_urls
+
+        process: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.process, Unset):
+            process = UNSET
+        elif isinstance(self.process, SitemapRequestProcessType0):
+            process = self.process.to_dict()
+        else:
+            process = self.process
+
+        webhook_url = self.webhook_url
+
+        webhook_secret: Union[None, Unset, str]
+        if isinstance(self.webhook_secret, Unset):
+            webhook_secret = UNSET
+        else:
+            webhook_secret = self.webhook_secret
+
+        cache_ttl = self.cache_ttl
+
+        compact = self.compact
+
+        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(
+            {
+                "url": url,
+            }
+        )
+        if strategy is not UNSET:
+            field_dict["strategy"] = strategy
+        if max_depth is not UNSET:
+            field_dict["max_depth"] = max_depth
+        if max_urls is not UNSET:
+            field_dict["max_urls"] = max_urls
+        if process is not UNSET:
+            field_dict["process"] = process
+        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 cache_ttl is not UNSET:
+            field_dict["cache_ttl"] = cache_ttl
+        if compact is not UNSET:
+            field_dict["compact"] = compact
+        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.sitemap_request_process_type_0 import SitemapRequestProcessType0
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        _strategy = d.pop("strategy", UNSET)
+        strategy: Union[Unset, SitemapRequestStrategy]
+        if isinstance(_strategy, Unset):
+            strategy = UNSET
+        else:
+            strategy = SitemapRequestStrategy(_strategy)
+
+        max_depth = d.pop("max_depth", UNSET)
+
+        max_urls = d.pop("max_urls", UNSET)
+
+        def _parse_process(
+            data: object,
+        ) -> Union["SitemapRequestProcessType0", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                process_type_0 = SitemapRequestProcessType0.from_dict(data)
+
+                return process_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["SitemapRequestProcessType0", None, Unset], data)
+
+        process = _parse_process(d.pop("process", UNSET))
+
+        webhook_url = d.pop("webhook_url", UNSET)
+
+        def _parse_webhook_secret(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        webhook_secret = _parse_webhook_secret(d.pop("webhook_secret", UNSET))
+
+        cache_ttl = d.pop("cache_ttl", UNSET)
+
+        compact = d.pop("compact", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        sitemap_request = cls(
+            url=url,
+            strategy=strategy,
+            max_depth=max_depth,
+            max_urls=max_urls,
+            process=process,
+            webhook_url=webhook_url,
+            webhook_secret=webhook_secret,
+            cache_ttl=cache_ttl,
+            compact=compact,
+            metadata=metadata,
+        )
+
+        sitemap_request.additional_properties = d
+        return sitemap_request
+
+    @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/sitemap_request_process_type_0.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sitemap_request_process_type_0_options import (
+        SitemapRequestProcessType0Options,
+    )
+
+
+T = TypeVar("T", bound="SitemapRequestProcessType0")
+
+
+@_attrs_define
+class SitemapRequestProcessType0:
+    """
+    Attributes:
+        action (Union[Unset, str]):
+        options (Union[Unset, SitemapRequestProcessType0Options]):
+    """
+
+    action: Union[Unset, str] = UNSET
+    options: Union[Unset, "SitemapRequestProcessType0Options"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        action = self.action
+
+        options: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if action is not UNSET:
+            field_dict["action"] = action
+        if options is not UNSET:
+            field_dict["options"] = options
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sitemap_request_process_type_0_options import (
+            SitemapRequestProcessType0Options,
+        )
+
+        d = dict(src_dict)
+        action = d.pop("action", UNSET)
+
+        _options = d.pop("options", UNSET)
+        options: Union[Unset, SitemapRequestProcessType0Options]
+        if isinstance(_options, Unset):
+            options = UNSET
+        else:
+            options = SitemapRequestProcessType0Options.from_dict(_options)
+
+        sitemap_request_process_type_0 = cls(
+            action=action,
+            options=options,
+        )
+
+        sitemap_request_process_type_0.additional_properties = d
+        return sitemap_request_process_type_0
+
+    @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