bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/create_scrape_bulk_body_defaults.py

@@ -0,0 +1,167 @@
+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 ..models.create_scrape_bulk_body_defaults_formats_item import (
+    CreateScrapeBulkBodyDefaultsFormatsItem,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.cookie import Cookie
+    from ..models.create_scrape_bulk_body_defaults_headers import (
+        CreateScrapeBulkBodyDefaultsHeaders,
+    )
+
+
+T = TypeVar("T", bound="CreateScrapeBulkBodyDefaults")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyDefaults:
+    """
+    Attributes:
+        formats (Union[Unset, list[CreateScrapeBulkBodyDefaultsFormatsItem]]):
+        country (Union[Unset, str]):  Default: 'US'.
+        cookies (Union[Unset, list['Cookie']]):
+        headers (Union[Unset, CreateScrapeBulkBodyDefaultsHeaders]):
+        delay_ms (Union[Unset, int]):  Default: 0.
+        timeout_ms (Union[Unset, int]):  Default: 30000.
+        clean_markdown (Union[Unset, bool]): Bulk-level default for LLM markdown cleaning, applied to
+            every scrape entry that does not set its own
+            `clean_markdown`. When `true` and `markdown` is in
+            `formats`, the converted markdown is sent to Groq for
+            cleaning before delivery; any Groq failure returns the
+            raw markdown plus a warning. Billing: 3× credits and wire
+            bytes applied only when cleaning succeeds.
+             Default: False.
+    """
+
+    formats: Union[Unset, list[CreateScrapeBulkBodyDefaultsFormatsItem]] = UNSET
+    country: Union[Unset, str] = "US"
+    cookies: Union[Unset, list["Cookie"]] = UNSET
+    headers: Union[Unset, "CreateScrapeBulkBodyDefaultsHeaders"] = UNSET
+    delay_ms: Union[Unset, int] = 0
+    timeout_ms: Union[Unset, int] = 30000
+    clean_markdown: Union[Unset, bool] = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        formats: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.formats, Unset):
+            formats = []
+            for formats_item_data in self.formats:
+                formats_item = formats_item_data.value
+                formats.append(formats_item)
+
+        country = self.country
+
+        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)
+
+        headers: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.headers, Unset):
+            headers = self.headers.to_dict()
+
+        delay_ms = self.delay_ms
+
+        timeout_ms = self.timeout_ms
+
+        clean_markdown = self.clean_markdown
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if formats is not UNSET:
+            field_dict["formats"] = formats
+        if country is not UNSET:
+            field_dict["country"] = country
+        if cookies is not UNSET:
+            field_dict["cookies"] = cookies
+        if headers is not UNSET:
+            field_dict["headers"] = headers
+        if delay_ms is not UNSET:
+            field_dict["delay_ms"] = delay_ms
+        if timeout_ms is not UNSET:
+            field_dict["timeout_ms"] = timeout_ms
+        if clean_markdown is not UNSET:
+            field_dict["clean_markdown"] = clean_markdown
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cookie import Cookie
+        from ..models.create_scrape_bulk_body_defaults_headers import (
+            CreateScrapeBulkBodyDefaultsHeaders,
+        )
+
+        d = dict(src_dict)
+        formats = []
+        _formats = d.pop("formats", UNSET)
+        for formats_item_data in _formats or []:
+            formats_item = CreateScrapeBulkBodyDefaultsFormatsItem(formats_item_data)
+
+            formats.append(formats_item)
+
+        country = d.pop("country", UNSET)
+
+        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)
+
+        _headers = d.pop("headers", UNSET)
+        headers: Union[Unset, CreateScrapeBulkBodyDefaultsHeaders]
+        if isinstance(_headers, Unset):
+            headers = UNSET
+        else:
+            headers = CreateScrapeBulkBodyDefaultsHeaders.from_dict(_headers)
+
+        delay_ms = d.pop("delay_ms", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        clean_markdown = d.pop("clean_markdown", UNSET)
+
+        create_scrape_bulk_body_defaults = cls(
+            formats=formats,
+            country=country,
+            cookies=cookies,
+            headers=headers,
+            delay_ms=delay_ms,
+            timeout_ms=timeout_ms,
+            clean_markdown=clean_markdown,
+        )
+
+        create_scrape_bulk_body_defaults.additional_properties = d
+        return create_scrape_bulk_body_defaults
+
+    @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/create_scrape_bulk_body_defaults_formats_item.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class CreateScrapeBulkBodyDefaultsFormatsItem(str, Enum):
+    HTML = "html"
+    IMAGES = "images"
+    LINKS = "links"
+    MARKDOWN = "markdown"
+    RAW_HTML = "raw_html"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_scrape_bulk_body_defaults_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="CreateScrapeBulkBodyDefaultsHeaders")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyDefaultsHeaders:
+    """ """
+
+    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)
+        create_scrape_bulk_body_defaults_headers = cls()
+
+        create_scrape_bulk_body_defaults_headers.additional_properties = d
+        return create_scrape_bulk_body_defaults_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/create_scrape_bulk_body_items_item.py

@@ -0,0 +1,226 @@
+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 ..models.create_scrape_bulk_body_items_item_formats_item import (
+    CreateScrapeBulkBodyItemsItemFormatsItem,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.cookie import Cookie
+    from ..models.create_scrape_bulk_body_items_item_custom import (
+        CreateScrapeBulkBodyItemsItemCustom,
+    )
+    from ..models.create_scrape_bulk_body_items_item_headers import (
+        CreateScrapeBulkBodyItemsItemHeaders,
+    )
+    from ..models.create_scrape_bulk_body_items_item_metadata import (
+        CreateScrapeBulkBodyItemsItemMetadata,
+    )
+
+
+T = TypeVar("T", bound="CreateScrapeBulkBodyItemsItem")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyItemsItem:
+    """
+    Attributes:
+        url (str):
+        formats (Union[Unset, list[CreateScrapeBulkBodyItemsItemFormatsItem]]):
+        country (Union[Unset, str]):
+        cookies (Union[Unset, list['Cookie']]):
+        headers (Union[Unset, CreateScrapeBulkBodyItemsItemHeaders]):
+        delay_ms (Union[Unset, int]):
+        timeout_ms (Union[Unset, int]):
+        metadata (Union[Unset, CreateScrapeBulkBodyItemsItemMetadata]):
+        clean_markdown (Union[Unset, bool]): Per-item override for LLM markdown cleaning. When
+            `true` and `markdown` is in `formats`, the converted
+            markdown is sent to Groq for cleaning (boilerplate
+            removal, ad stripping) before delivery. Graceful
+            degradation: any Groq failure returns the raw markdown
+            unchanged plus a warning. Billing: 3× credits and wire
+            bytes applied only when cleaning succeeds.
+             Default: False.
+        custom (Union[Unset, CreateScrapeBulkBodyItemsItemCustom]): Per-item user-supplied JSON payload, capped at 4096
+            UTF-8 bytes. Overrides the top-level `custom` for this
+            entry. Echoed on the entry's success envelope in the
+            bulk results response. Applies to scrape-type entries
+            only.
+    """
+
+    url: str
+    formats: Union[Unset, list[CreateScrapeBulkBodyItemsItemFormatsItem]] = UNSET
+    country: Union[Unset, str] = UNSET
+    cookies: Union[Unset, list["Cookie"]] = UNSET
+    headers: Union[Unset, "CreateScrapeBulkBodyItemsItemHeaders"] = UNSET
+    delay_ms: Union[Unset, int] = UNSET
+    timeout_ms: Union[Unset, int] = UNSET
+    metadata: Union[Unset, "CreateScrapeBulkBodyItemsItemMetadata"] = UNSET
+    clean_markdown: Union[Unset, bool] = False
+    custom: Union[Unset, "CreateScrapeBulkBodyItemsItemCustom"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        formats: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.formats, Unset):
+            formats = []
+            for formats_item_data in self.formats:
+                formats_item = formats_item_data.value
+                formats.append(formats_item)
+
+        country = self.country
+
+        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)
+
+        headers: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.headers, Unset):
+            headers = self.headers.to_dict()
+
+        delay_ms = self.delay_ms
+
+        timeout_ms = self.timeout_ms
+
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        clean_markdown = self.clean_markdown
+
+        custom: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.custom, Unset):
+            custom = self.custom.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+        if formats is not UNSET:
+            field_dict["formats"] = formats
+        if country is not UNSET:
+            field_dict["country"] = country
+        if cookies is not UNSET:
+            field_dict["cookies"] = cookies
+        if headers is not UNSET:
+            field_dict["headers"] = headers
+        if delay_ms is not UNSET:
+            field_dict["delay_ms"] = delay_ms
+        if timeout_ms is not UNSET:
+            field_dict["timeout_ms"] = timeout_ms
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if clean_markdown is not UNSET:
+            field_dict["clean_markdown"] = clean_markdown
+        if custom is not UNSET:
+            field_dict["custom"] = custom
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cookie import Cookie
+        from ..models.create_scrape_bulk_body_items_item_custom import (
+            CreateScrapeBulkBodyItemsItemCustom,
+        )
+        from ..models.create_scrape_bulk_body_items_item_headers import (
+            CreateScrapeBulkBodyItemsItemHeaders,
+        )
+        from ..models.create_scrape_bulk_body_items_item_metadata import (
+            CreateScrapeBulkBodyItemsItemMetadata,
+        )
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        formats = []
+        _formats = d.pop("formats", UNSET)
+        for formats_item_data in _formats or []:
+            formats_item = CreateScrapeBulkBodyItemsItemFormatsItem(formats_item_data)
+
+            formats.append(formats_item)
+
+        country = d.pop("country", UNSET)
+
+        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)
+
+        _headers = d.pop("headers", UNSET)
+        headers: Union[Unset, CreateScrapeBulkBodyItemsItemHeaders]
+        if isinstance(_headers, Unset):
+            headers = UNSET
+        else:
+            headers = CreateScrapeBulkBodyItemsItemHeaders.from_dict(_headers)
+
+        delay_ms = d.pop("delay_ms", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, CreateScrapeBulkBodyItemsItemMetadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = CreateScrapeBulkBodyItemsItemMetadata.from_dict(_metadata)
+
+        clean_markdown = d.pop("clean_markdown", UNSET)
+
+        _custom = d.pop("custom", UNSET)
+        custom: Union[Unset, CreateScrapeBulkBodyItemsItemCustom]
+        if isinstance(_custom, Unset):
+            custom = UNSET
+        else:
+            custom = CreateScrapeBulkBodyItemsItemCustom.from_dict(_custom)
+
+        create_scrape_bulk_body_items_item = cls(
+            url=url,
+            formats=formats,
+            country=country,
+            cookies=cookies,
+            headers=headers,
+            delay_ms=delay_ms,
+            timeout_ms=timeout_ms,
+            metadata=metadata,
+            clean_markdown=clean_markdown,
+            custom=custom,
+        )
+
+        create_scrape_bulk_body_items_item.additional_properties = d
+        return create_scrape_bulk_body_items_item
+
+    @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/create_scrape_bulk_body_items_item_custom.py

@@ -0,0 +1,50 @@
+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="CreateScrapeBulkBodyItemsItemCustom")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyItemsItemCustom:
+    """Per-item user-supplied JSON payload, capped at 4096
+    UTF-8 bytes. Overrides the top-level `custom` for this
+    entry. Echoed on the entry's success envelope in the
+    bulk results response. Applies to scrape-type entries
+    only.
+
+    """
+
+    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)
+        create_scrape_bulk_body_items_item_custom = cls()
+
+        create_scrape_bulk_body_items_item_custom.additional_properties = d
+        return create_scrape_bulk_body_items_item_custom
+
+    @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/create_scrape_bulk_body_items_item_formats_item.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class CreateScrapeBulkBodyItemsItemFormatsItem(str, Enum):
+    HTML = "html"
+    IMAGES = "images"
+    LINKS = "links"
+    MARKDOWN = "markdown"
+    RAW_HTML = "raw_html"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_scrape_bulk_body_items_item_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="CreateScrapeBulkBodyItemsItemHeaders")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyItemsItemHeaders:
+    """ """
+
+    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)
+        create_scrape_bulk_body_items_item_headers = cls()
+
+        create_scrape_bulk_body_items_item_headers.additional_properties = d
+        return create_scrape_bulk_body_items_item_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/create_scrape_bulk_body_items_item_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="CreateScrapeBulkBodyItemsItemMetadata")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyItemsItemMetadata:
+    """ """
+
+    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)
+        create_scrape_bulk_body_items_item_metadata = cls()
+
+        create_scrape_bulk_body_items_item_metadata.additional_properties = d
+        return create_scrape_bulk_body_items_item_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