bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/create_fetch_bulk_body.py

@@ -0,0 +1,161 @@
+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_fetch_bulk_body_defaults import CreateFetchBulkBodyDefaults
+    from ..models.create_fetch_bulk_body_metadata import CreateFetchBulkBodyMetadata
+    from ..models.create_fetch_bulk_body_urls_item_type_1 import (
+        CreateFetchBulkBodyUrlsItemType1,
+    )
+
+
+T = TypeVar("T", bound="CreateFetchBulkBody")
+
+
+@_attrs_define
+class CreateFetchBulkBody:
+    """
+    Attributes:
+        urls (list[Union['CreateFetchBulkBodyUrlsItemType1', str]]):
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+        defaults (Union[Unset, CreateFetchBulkBodyDefaults]):
+        webhook_secret (Union[Unset, str]):
+        metadata (Union[Unset, CreateFetchBulkBodyMetadata]):
+    """
+
+    urls: list[Union["CreateFetchBulkBodyUrlsItemType1", str]]
+    webhook_url: str
+    defaults: Union[Unset, "CreateFetchBulkBodyDefaults"] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    metadata: Union[Unset, "CreateFetchBulkBodyMetadata"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.create_fetch_bulk_body_urls_item_type_1 import (
+            CreateFetchBulkBodyUrlsItemType1,
+        )
+
+        urls = []
+        for urls_item_data in self.urls:
+            urls_item: Union[dict[str, Any], str]
+            if isinstance(urls_item_data, CreateFetchBulkBodyUrlsItemType1):
+                urls_item = urls_item_data.to_dict()
+            else:
+                urls_item = urls_item_data
+            urls.append(urls_item)
+
+        webhook_url = self.webhook_url
+
+        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(
+            {
+                "urls": urls,
+                "webhook_url": webhook_url,
+            }
+        )
+        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_fetch_bulk_body_defaults import CreateFetchBulkBodyDefaults
+        from ..models.create_fetch_bulk_body_metadata import CreateFetchBulkBodyMetadata
+        from ..models.create_fetch_bulk_body_urls_item_type_1 import (
+            CreateFetchBulkBodyUrlsItemType1,
+        )
+
+        d = dict(src_dict)
+        urls = []
+        _urls = d.pop("urls")
+        for urls_item_data in _urls:
+
+            def _parse_urls_item(
+                data: object,
+            ) -> Union["CreateFetchBulkBodyUrlsItemType1", str]:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    urls_item_type_1 = CreateFetchBulkBodyUrlsItemType1.from_dict(data)
+
+                    return urls_item_type_1
+                except:  # noqa: E722
+                    pass
+                return cast(Union["CreateFetchBulkBodyUrlsItemType1", str], data)
+
+            urls_item = _parse_urls_item(urls_item_data)
+
+            urls.append(urls_item)
+
+        webhook_url = d.pop("webhook_url")
+
+        _defaults = d.pop("defaults", UNSET)
+        defaults: Union[Unset, CreateFetchBulkBodyDefaults]
+        if isinstance(_defaults, Unset):
+            defaults = UNSET
+        else:
+            defaults = CreateFetchBulkBodyDefaults.from_dict(_defaults)
+
+        webhook_secret = d.pop("webhook_secret", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, CreateFetchBulkBodyMetadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = CreateFetchBulkBodyMetadata.from_dict(_metadata)
+
+        create_fetch_bulk_body = cls(
+            urls=urls,
+            webhook_url=webhook_url,
+            defaults=defaults,
+            webhook_secret=webhook_secret,
+            metadata=metadata,
+        )
+
+        create_fetch_bulk_body.additional_properties = d
+        return create_fetch_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

bytekit/models/create_fetch_bulk_body_defaults.py

@@ -0,0 +1,91 @@
+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 ..models.create_fetch_bulk_body_defaults_format import (
+    CreateFetchBulkBodyDefaultsFormat,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateFetchBulkBodyDefaults")
+
+
+@_attrs_define
+class CreateFetchBulkBodyDefaults:
+    """
+    Attributes:
+        format_ (Union[Unset, CreateFetchBulkBodyDefaultsFormat]):
+        country (Union[Unset, str]):  Default: 'US'.
+        cache_ttl (Union[Unset, str]):  Default: '48h'.
+    """
+
+    format_: Union[Unset, CreateFetchBulkBodyDefaultsFormat] = UNSET
+    country: Union[Unset, str] = "US"
+    cache_ttl: Union[Unset, str] = "48h"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        format_: Union[Unset, str] = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        country = self.country
+
+        cache_ttl = self.cache_ttl
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if country is not UNSET:
+            field_dict["country"] = country
+        if cache_ttl is not UNSET:
+            field_dict["cache_ttl"] = cache_ttl
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _format_ = d.pop("format", UNSET)
+        format_: Union[Unset, CreateFetchBulkBodyDefaultsFormat]
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = CreateFetchBulkBodyDefaultsFormat(_format_)
+
+        country = d.pop("country", UNSET)
+
+        cache_ttl = d.pop("cache_ttl", UNSET)
+
+        create_fetch_bulk_body_defaults = cls(
+            format_=format_,
+            country=country,
+            cache_ttl=cache_ttl,
+        )
+
+        create_fetch_bulk_body_defaults.additional_properties = d
+        return create_fetch_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_fetch_bulk_body_defaults_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class CreateFetchBulkBodyDefaultsFormat(str, Enum):
+    HTML = "html"
+    MARKDOWN = "markdown"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_fetch_bulk_body_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="CreateFetchBulkBodyMetadata")
+
+
+@_attrs_define
+class CreateFetchBulkBodyMetadata:
+    """ """
+
+    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_fetch_bulk_body_metadata = cls()
+
+        create_fetch_bulk_body_metadata.additional_properties = d
+        return create_fetch_bulk_body_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

bytekit/models/create_fetch_bulk_body_urls_item_type_1.py

@@ -0,0 +1,102 @@
+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 ..models.create_fetch_bulk_body_urls_item_type_1_format import (
+    CreateFetchBulkBodyUrlsItemType1Format,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateFetchBulkBodyUrlsItemType1")
+
+
+@_attrs_define
+class CreateFetchBulkBodyUrlsItemType1:
+    """
+    Attributes:
+        url (str):
+        format_ (Union[Unset, CreateFetchBulkBodyUrlsItemType1Format]):
+        country (Union[Unset, str]):
+        cache_ttl (Union[Unset, str]):
+    """
+
+    url: str
+    format_: Union[Unset, CreateFetchBulkBodyUrlsItemType1Format] = UNSET
+    country: Union[Unset, str] = UNSET
+    cache_ttl: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        format_: Union[Unset, str] = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        country = self.country
+
+        cache_ttl = self.cache_ttl
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if country is not UNSET:
+            field_dict["country"] = country
+        if cache_ttl is not UNSET:
+            field_dict["cache_ttl"] = cache_ttl
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        _format_ = d.pop("format", UNSET)
+        format_: Union[Unset, CreateFetchBulkBodyUrlsItemType1Format]
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = CreateFetchBulkBodyUrlsItemType1Format(_format_)
+
+        country = d.pop("country", UNSET)
+
+        cache_ttl = d.pop("cache_ttl", UNSET)
+
+        create_fetch_bulk_body_urls_item_type_1 = cls(
+            url=url,
+            format_=format_,
+            country=country,
+            cache_ttl=cache_ttl,
+        )
+
+        create_fetch_bulk_body_urls_item_type_1.additional_properties = d
+        return create_fetch_bulk_body_urls_item_type_1
+
+    @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_fetch_bulk_body_urls_item_type_1_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class CreateFetchBulkBodyUrlsItemType1Format(str, Enum):
+    HTML = "html"
+    MARKDOWN = "markdown"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_fetch_bulk_response_202.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="CreateFetchBulkResponse202")
+
+
+@_attrs_define
+class CreateFetchBulkResponse202:
+    """ """
+
+    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_fetch_bulk_response_202 = cls()
+
+        create_fetch_bulk_response_202.additional_properties = d
+        return create_fetch_bulk_response_202
+
+    @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.py

@@ -0,0 +1,179 @@
+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_scrape_bulk_body_custom import CreateScrapeBulkBodyCustom
+    from ..models.create_scrape_bulk_body_defaults import CreateScrapeBulkBodyDefaults
+    from ..models.create_scrape_bulk_body_items_item import (
+        CreateScrapeBulkBodyItemsItem,
+    )
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="CreateScrapeBulkBody")
+
+
+@_attrs_define
+class CreateScrapeBulkBody:
+    """
+    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['CreateScrapeBulkBodyItemsItem']]): Per-item configs. Provide urls OR items, not both.
+        defaults (Union[Unset, CreateScrapeBulkBodyDefaults]):
+        webhook_secret (Union[Unset, str]):
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+        custom (Union[Unset, CreateScrapeBulkBodyCustom]): Top-level user-supplied JSON payload, capped at 4096 UTF-8
+            bytes. Applied to every scrape-type entry that does not
+            provide its own per-entry `custom` (the per-entry value wins).
+            Echoed on each entry's success envelope in the bulk results
+            response (the key is omitted when no `custom` was supplied at
+            either level). Distinct from the system-owned `metadata`
+            column and never used as a cache-key input.
+    """
+
+    webhook_url: str
+    urls: Union[Unset, list[str]] = UNSET
+    items: Union[Unset, list["CreateScrapeBulkBodyItemsItem"]] = UNSET
+    defaults: Union[Unset, "CreateScrapeBulkBodyDefaults"] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+    custom: Union[Unset, "CreateScrapeBulkBodyCustom"] = 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()
+
+        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(
+            {
+                "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
+        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.create_scrape_bulk_body_custom import CreateScrapeBulkBodyCustom
+        from ..models.create_scrape_bulk_body_defaults import (
+            CreateScrapeBulkBodyDefaults,
+        )
+        from ..models.create_scrape_bulk_body_items_item import (
+            CreateScrapeBulkBodyItemsItem,
+        )
+        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 = CreateScrapeBulkBodyItemsItem.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        _defaults = d.pop("defaults", UNSET)
+        defaults: Union[Unset, CreateScrapeBulkBodyDefaults]
+        if isinstance(_defaults, Unset):
+            defaults = UNSET
+        else:
+            defaults = CreateScrapeBulkBodyDefaults.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)
+
+        _custom = d.pop("custom", UNSET)
+        custom: Union[Unset, CreateScrapeBulkBodyCustom]
+        if isinstance(_custom, Unset):
+            custom = UNSET
+        else:
+            custom = CreateScrapeBulkBodyCustom.from_dict(_custom)
+
+        create_scrape_bulk_body = cls(
+            webhook_url=webhook_url,
+            urls=urls,
+            items=items,
+            defaults=defaults,
+            webhook_secret=webhook_secret,
+            metadata=metadata,
+            custom=custom,
+        )
+
+        create_scrape_bulk_body.additional_properties = d
+        return create_scrape_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

bytekit/models/create_scrape_bulk_body_custom.py

@@ -0,0 +1,52 @@
+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="CreateScrapeBulkBodyCustom")
+
+
+@_attrs_define
+class CreateScrapeBulkBodyCustom:
+    """Top-level user-supplied JSON payload, capped at 4096 UTF-8
+    bytes. Applied to every scrape-type entry that does not
+    provide its own per-entry `custom` (the per-entry value wins).
+    Echoed on each entry's success envelope in the bulk results
+    response (the key is omitted when no `custom` was supplied at
+    either level). Distinct from the system-owned `metadata`
+    column and never used as a cache-key input.
+
+    """
+
+    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_custom = cls()
+
+        create_scrape_bulk_body_custom.additional_properties = d
+        return create_scrape_bulk_body_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