bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/scrape_success_envelope_schema_version.py

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

bytekit/models/scrape_success_envelope_status.py

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

bytekit/models/scrape_table.py

@@ -0,0 +1,96 @@
+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 ..models.scrape_table_kind import ScrapeTableKind
+
+T = TypeVar("T", bound="ScrapeTable")
+
+
+@_attrs_define
+class ScrapeTable:
+    """
+    Attributes:
+        kind (ScrapeTableKind):
+        gfm (Union[None, str]):
+        rows (int):
+        cols (int):
+    """
+
+    kind: ScrapeTableKind
+    gfm: Union[None, str]
+    rows: int
+    cols: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        kind = self.kind.value
+
+        gfm: Union[None, str]
+        gfm = self.gfm
+
+        rows = self.rows
+
+        cols = self.cols
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "kind": kind,
+                "gfm": gfm,
+                "rows": rows,
+                "cols": cols,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        kind = ScrapeTableKind(d.pop("kind"))
+
+        def _parse_gfm(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        gfm = _parse_gfm(d.pop("gfm"))
+
+        rows = d.pop("rows")
+
+        cols = d.pop("cols")
+
+        scrape_table = cls(
+            kind=kind,
+            gfm=gfm,
+            rows=rows,
+            cols=cols,
+        )
+
+        scrape_table.additional_properties = d
+        return scrape_table
+
+    @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_table_kind.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ScrapeTableKind(str, Enum):
+    DATA = "data"
+    LAYOUT_UNWRAPPED = "layout-unwrapped"
+    LOSSY = "lossy"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/scrape_warning.py

@@ -0,0 +1,88 @@
+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 ..models.scrape_warning_code import ScrapeWarningCode
+
+T = TypeVar("T", bound="ScrapeWarning")
+
+
+@_attrs_define
+class ScrapeWarning:
+    """
+    Attributes:
+        code (ScrapeWarningCode):
+        message (str):
+        element (Union[None, str]):
+    """
+
+    code: ScrapeWarningCode
+    message: str
+    element: Union[None, str]
+    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
+
+        element: Union[None, str]
+        element = self.element
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+                "element": element,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = ScrapeWarningCode(d.pop("code"))
+
+        message = d.pop("message")
+
+        def _parse_element(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        element = _parse_element(d.pop("element"))
+
+        scrape_warning = cls(
+            code=code,
+            message=message,
+            element=element,
+        )
+
+        scrape_warning.additional_properties = d
+        return scrape_warning
+
+    @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_warning_code.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class ScrapeWarningCode(str, Enum):
+    ARTIFACT_UNAVAILABLE = "artifact_unavailable"
+    COMPLEX_MATH = "complex_math"
+    EXTRACTION_FALLBACK = "extraction_fallback"
+    LLM_CLEAN_FAILED = "llm_clean_failed"
+    LLM_CLEAN_UNAVAILABLE = "llm_clean_unavailable"
+    LOSSY_TABLE = "lossy_table"
+    MODE_DISABLED_FALLBACK = "mode_disabled_fallback"
+    QUERY_NO_MATCH = "query_no_match"
+    TRUNCATED = "truncated"
+    UNSUPPORTED_ELEMENT = "unsupported_element"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/screenshot_request.py

@@ -0,0 +1,445 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+
+from ..models.screenshot_request_device import ScreenshotRequestDevice
+from ..models.screenshot_request_device_scale_factor_type_1 import (
+    ScreenshotRequestDeviceScaleFactorType1,
+)
+from ..models.screenshot_request_device_scale_factor_type_2_type_1 import (
+    ScreenshotRequestDeviceScaleFactorType2Type1,
+)
+from ..models.screenshot_request_device_scale_factor_type_3_type_1 import (
+    ScreenshotRequestDeviceScaleFactorType3Type1,
+)
+from ..models.screenshot_request_format import ScreenshotRequestFormat
+from ..models.screenshot_request_wait_until import ScreenshotRequestWaitUntil
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.clip import Clip
+    from ..models.cookie import Cookie
+    from ..models.metadata import Metadata
+    from ..models.screenshot_request_headers import ScreenshotRequestHeaders
+    from ..models.viewport import Viewport
+
+
+T = TypeVar("T", bound="ScreenshotRequest")
+
+
+@_attrs_define
+class ScreenshotRequest:
+    """
+    Attributes:
+        url (str):
+        device (Union[Unset, ScreenshotRequestDevice]):
+        viewport (Union['Viewport', None, Unset]):
+        full_page (Union[Unset, bool]):
+        format_ (Union[Unset, ScreenshotRequestFormat]):
+        quality (Union[Unset, int]):
+        block_ads (Union[Unset, bool]):
+        block_cookie_banners (Union[Unset, bool]):
+        wait_until (Union[Unset, ScreenshotRequestWaitUntil]):
+        wait_for_selector (Union[None, Unset, str]):
+        delay_ms (Union[Unset, int]):
+        scroll (Union[Unset, bool]):
+        clip (Union['Clip', None, Unset]):
+        headers (Union[Unset, ScreenshotRequestHeaders]):
+        cookies (Union[Unset, list['Cookie']]):
+        dark_mode (Union[Unset, bool]):
+        device_scale_factor (Union[None, ScreenshotRequestDeviceScaleFactorType1,
+            ScreenshotRequestDeviceScaleFactorType2Type1, ScreenshotRequestDeviceScaleFactorType3Type1, Unset]):
+        include_html (Union[Unset, bool]):
+        country (Union[Unset, str]):
+        language (Union[None, Unset, str]):
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    url: str
+    device: Union[Unset, ScreenshotRequestDevice] = UNSET
+    viewport: Union["Viewport", None, Unset] = UNSET
+    full_page: Union[Unset, bool] = UNSET
+    format_: Union[Unset, ScreenshotRequestFormat] = UNSET
+    quality: Union[Unset, int] = UNSET
+    block_ads: Union[Unset, bool] = UNSET
+    block_cookie_banners: Union[Unset, bool] = UNSET
+    wait_until: Union[Unset, ScreenshotRequestWaitUntil] = UNSET
+    wait_for_selector: Union[None, Unset, str] = UNSET
+    delay_ms: Union[Unset, int] = UNSET
+    scroll: Union[Unset, bool] = UNSET
+    clip: Union["Clip", None, Unset] = UNSET
+    headers: Union[Unset, "ScreenshotRequestHeaders"] = UNSET
+    cookies: Union[Unset, list["Cookie"]] = UNSET
+    dark_mode: Union[Unset, bool] = UNSET
+    device_scale_factor: Union[
+        None,
+        ScreenshotRequestDeviceScaleFactorType1,
+        ScreenshotRequestDeviceScaleFactorType2Type1,
+        ScreenshotRequestDeviceScaleFactorType3Type1,
+        Unset,
+    ] = UNSET
+    include_html: Union[Unset, bool] = UNSET
+    country: Union[Unset, str] = UNSET
+    language: Union[None, Unset, str] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.clip import Clip
+        from ..models.viewport import Viewport
+
+        url = self.url
+
+        device: Union[Unset, str] = UNSET
+        if not isinstance(self.device, Unset):
+            device = self.device.value
+
+        viewport: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.viewport, Unset):
+            viewport = UNSET
+        elif isinstance(self.viewport, Viewport):
+            viewport = self.viewport.to_dict()
+        else:
+            viewport = self.viewport
+
+        full_page = self.full_page
+
+        format_: Union[Unset, str] = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        quality = self.quality
+
+        block_ads = self.block_ads
+
+        block_cookie_banners = self.block_cookie_banners
+
+        wait_until: Union[Unset, str] = UNSET
+        if not isinstance(self.wait_until, Unset):
+            wait_until = self.wait_until.value
+
+        wait_for_selector: Union[None, Unset, str]
+        if isinstance(self.wait_for_selector, Unset):
+            wait_for_selector = UNSET
+        else:
+            wait_for_selector = self.wait_for_selector
+
+        delay_ms = self.delay_ms
+
+        scroll = self.scroll
+
+        clip: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.clip, Unset):
+            clip = UNSET
+        elif isinstance(self.clip, Clip):
+            clip = self.clip.to_dict()
+        else:
+            clip = self.clip
+
+        headers: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.headers, Unset):
+            headers = self.headers.to_dict()
+
+        cookies: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.cookies, Unset):
+            cookies = []
+            for cookies_item_data in self.cookies:
+                cookies_item = cookies_item_data.to_dict()
+                cookies.append(cookies_item)
+
+        dark_mode = self.dark_mode
+
+        device_scale_factor: Union[None, Unset, int]
+        if isinstance(self.device_scale_factor, Unset):
+            device_scale_factor = UNSET
+        elif isinstance(
+            self.device_scale_factor, ScreenshotRequestDeviceScaleFactorType1
+        ):
+            device_scale_factor = self.device_scale_factor.value
+        elif isinstance(
+            self.device_scale_factor, ScreenshotRequestDeviceScaleFactorType2Type1
+        ):
+            device_scale_factor = self.device_scale_factor.value
+        elif isinstance(
+            self.device_scale_factor, ScreenshotRequestDeviceScaleFactorType3Type1
+        ):
+            device_scale_factor = self.device_scale_factor.value
+        else:
+            device_scale_factor = self.device_scale_factor
+
+        include_html = self.include_html
+
+        country = self.country
+
+        language: Union[None, Unset, str]
+        if isinstance(self.language, Unset):
+            language = UNSET
+        else:
+            language = self.language
+
+        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,
+            }
+        )
+        if device is not UNSET:
+            field_dict["device"] = device
+        if viewport is not UNSET:
+            field_dict["viewport"] = viewport
+        if full_page is not UNSET:
+            field_dict["full_page"] = full_page
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if quality is not UNSET:
+            field_dict["quality"] = quality
+        if block_ads is not UNSET:
+            field_dict["block_ads"] = block_ads
+        if block_cookie_banners is not UNSET:
+            field_dict["block_cookie_banners"] = block_cookie_banners
+        if wait_until is not UNSET:
+            field_dict["wait_until"] = wait_until
+        if wait_for_selector is not UNSET:
+            field_dict["wait_for_selector"] = wait_for_selector
+        if delay_ms is not UNSET:
+            field_dict["delay_ms"] = delay_ms
+        if scroll is not UNSET:
+            field_dict["scroll"] = scroll
+        if clip is not UNSET:
+            field_dict["clip"] = clip
+        if headers is not UNSET:
+            field_dict["headers"] = headers
+        if cookies is not UNSET:
+            field_dict["cookies"] = cookies
+        if dark_mode is not UNSET:
+            field_dict["dark_mode"] = dark_mode
+        if device_scale_factor is not UNSET:
+            field_dict["device_scale_factor"] = device_scale_factor
+        if include_html is not UNSET:
+            field_dict["include_html"] = include_html
+        if country is not UNSET:
+            field_dict["country"] = country
+        if language is not UNSET:
+            field_dict["language"] = language
+        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.clip import Clip
+        from ..models.cookie import Cookie
+        from ..models.metadata import Metadata
+        from ..models.screenshot_request_headers import ScreenshotRequestHeaders
+        from ..models.viewport import Viewport
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        _device = d.pop("device", UNSET)
+        device: Union[Unset, ScreenshotRequestDevice]
+        if isinstance(_device, Unset):
+            device = UNSET
+        else:
+            device = ScreenshotRequestDevice(_device)
+
+        def _parse_viewport(data: object) -> Union["Viewport", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                viewport_type_0 = Viewport.from_dict(data)
+
+                return viewport_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["Viewport", None, Unset], data)
+
+        viewport = _parse_viewport(d.pop("viewport", UNSET))
+
+        full_page = d.pop("full_page", UNSET)
+
+        _format_ = d.pop("format", UNSET)
+        format_: Union[Unset, ScreenshotRequestFormat]
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = ScreenshotRequestFormat(_format_)
+
+        quality = d.pop("quality", UNSET)
+
+        block_ads = d.pop("block_ads", UNSET)
+
+        block_cookie_banners = d.pop("block_cookie_banners", UNSET)
+
+        _wait_until = d.pop("wait_until", UNSET)
+        wait_until: Union[Unset, ScreenshotRequestWaitUntil]
+        if isinstance(_wait_until, Unset):
+            wait_until = UNSET
+        else:
+            wait_until = ScreenshotRequestWaitUntil(_wait_until)
+
+        def _parse_wait_for_selector(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)
+
+        wait_for_selector = _parse_wait_for_selector(d.pop("wait_for_selector", UNSET))
+
+        delay_ms = d.pop("delay_ms", UNSET)
+
+        scroll = d.pop("scroll", UNSET)
+
+        def _parse_clip(data: object) -> Union["Clip", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                clip_type_0 = Clip.from_dict(data)
+
+                return clip_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["Clip", None, Unset], data)
+
+        clip = _parse_clip(d.pop("clip", UNSET))
+
+        _headers = d.pop("headers", UNSET)
+        headers: Union[Unset, ScreenshotRequestHeaders]
+        if isinstance(_headers, Unset):
+            headers = UNSET
+        else:
+            headers = ScreenshotRequestHeaders.from_dict(_headers)
+
+        cookies = []
+        _cookies = d.pop("cookies", UNSET)
+        for cookies_item_data in _cookies or []:
+            cookies_item = Cookie.from_dict(cookies_item_data)
+
+            cookies.append(cookies_item)
+
+        dark_mode = d.pop("dark_mode", UNSET)
+
+        def _parse_device_scale_factor(
+            data: object,
+        ) -> Union[
+            None,
+            ScreenshotRequestDeviceScaleFactorType1,
+            ScreenshotRequestDeviceScaleFactorType2Type1,
+            ScreenshotRequestDeviceScaleFactorType3Type1,
+            Unset,
+        ]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, int):
+                    raise TypeError()
+                device_scale_factor_type_1 = ScreenshotRequestDeviceScaleFactorType1(
+                    data
+                )
+
+                return device_scale_factor_type_1
+            except:  # noqa: E722
+                pass
+            try:
+                if not isinstance(data, int):
+                    raise TypeError()
+                device_scale_factor_type_2_type_1 = (
+                    ScreenshotRequestDeviceScaleFactorType2Type1(data)
+                )
+
+                return device_scale_factor_type_2_type_1
+            except:  # noqa: E722
+                pass
+            try:
+                if not isinstance(data, int):
+                    raise TypeError()
+                device_scale_factor_type_3_type_1 = (
+                    ScreenshotRequestDeviceScaleFactorType3Type1(data)
+                )
+
+                return device_scale_factor_type_3_type_1
+            except:  # noqa: E722
+                pass
+            return cast(
+                Union[
+                    None,
+                    ScreenshotRequestDeviceScaleFactorType1,
+                    ScreenshotRequestDeviceScaleFactorType2Type1,
+                    ScreenshotRequestDeviceScaleFactorType3Type1,
+                    Unset,
+                ],
+                data,
+            )
+
+        device_scale_factor = _parse_device_scale_factor(
+            d.pop("device_scale_factor", UNSET)
+        )
+
+        include_html = d.pop("include_html", UNSET)
+
+        country = d.pop("country", UNSET)
+
+        def _parse_language(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)
+
+        language = _parse_language(d.pop("language", UNSET))
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        screenshot_request = cls(
+            url=url,
+            device=device,
+            viewport=viewport,
+            full_page=full_page,
+            format_=format_,
+            quality=quality,
+            block_ads=block_ads,
+            block_cookie_banners=block_cookie_banners,
+            wait_until=wait_until,
+            wait_for_selector=wait_for_selector,
+            delay_ms=delay_ms,
+            scroll=scroll,
+            clip=clip,
+            headers=headers,
+            cookies=cookies,
+            dark_mode=dark_mode,
+            device_scale_factor=device_scale_factor,
+            include_html=include_html,
+            country=country,
+            language=language,
+            metadata=metadata,
+        )
+
+        return screenshot_request

bytekit/models/screenshot_request_device.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ScreenshotRequestDevice(str, Enum):
+    DESKTOP = "desktop"
+    MOBILE = "mobile"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/screenshot_request_device_scale_factor_type_1.py

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