bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/create_bulk_body_items_item.py

@@ -0,0 +1,380 @@
+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.create_bulk_body_items_item_device import CreateBulkBodyItemsItemDevice
+from ..models.create_bulk_body_items_item_formats_item import (
+    CreateBulkBodyItemsItemFormatsItem,
+)
+from ..models.create_bulk_body_items_item_scenario import (
+    CreateBulkBodyItemsItemScenario,
+)
+from ..models.create_bulk_body_items_item_type import CreateBulkBodyItemsItemType
+from ..models.create_bulk_body_items_item_wait_until import (
+    CreateBulkBodyItemsItemWaitUntil,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.create_bulk_body_items_item_viewport_type_0 import (
+        CreateBulkBodyItemsItemViewportType0,
+    )
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="CreateBulkBodyItemsItem")
+
+
+@_attrs_define
+class CreateBulkBodyItemsItem:
+    """
+    Attributes:
+        url (str):
+        type_ (Union[Unset, CreateBulkBodyItemsItemType]):  Default: CreateBulkBodyItemsItemType.SCREENSHOT.
+        device (Union[Unset, CreateBulkBodyItemsItemDevice]):
+        format_ (Union[Unset, str]): Image format for screenshot entries (e.g. jpeg, png).
+        quality (Union[Unset, int]):
+        full_page (Union[Unset, bool]):
+        block_ads (Union[Unset, bool]):
+        block_cookie_banners (Union[Unset, bool]):
+        scroll (Union[Unset, bool]):
+        include_html (Union[Unset, bool]):
+        country (Union[None, Unset, str]): ISO 3166-1 alpha-2. `null` is coerced to `US`.
+        language (Union[None, Unset, str]):
+        dark_mode (Union[Unset, bool]):
+        formats (Union[Unset, list[CreateBulkBodyItemsItemFormatsItem]]): Scrape output formats (scrape entries).
+        wait_until (Union[Unset, CreateBulkBodyItemsItemWaitUntil]):
+        wait_for_selector (Union[None, Unset, str]):
+        delay_ms (Union[Unset, int]):
+        viewport (Union['CreateBulkBodyItemsItemViewportType0', None, Unset]):
+        duration (Union[Unset, int]): Recording duration (seconds). Accepted but inert while recordings are deactivated.
+        scenario (Union[Unset, CreateBulkBodyItemsItemScenario]): Recording scenario. Accepted but inert while
+            recordings are deactivated.
+        metadata (Union[Unset, Metadata]): Arbitrary key-value metadata. Max 4096 bytes when JSON-serialized.
+    """
+
+    url: str
+    type_: Union[Unset, CreateBulkBodyItemsItemType] = (
+        CreateBulkBodyItemsItemType.SCREENSHOT
+    )
+    device: Union[Unset, CreateBulkBodyItemsItemDevice] = UNSET
+    format_: Union[Unset, str] = UNSET
+    quality: Union[Unset, int] = UNSET
+    full_page: Union[Unset, bool] = UNSET
+    block_ads: Union[Unset, bool] = UNSET
+    block_cookie_banners: Union[Unset, bool] = UNSET
+    scroll: Union[Unset, bool] = UNSET
+    include_html: Union[Unset, bool] = UNSET
+    country: Union[None, Unset, str] = UNSET
+    language: Union[None, Unset, str] = UNSET
+    dark_mode: Union[Unset, bool] = UNSET
+    formats: Union[Unset, list[CreateBulkBodyItemsItemFormatsItem]] = UNSET
+    wait_until: Union[Unset, CreateBulkBodyItemsItemWaitUntil] = UNSET
+    wait_for_selector: Union[None, Unset, str] = UNSET
+    delay_ms: Union[Unset, int] = UNSET
+    viewport: Union["CreateBulkBodyItemsItemViewportType0", None, Unset] = UNSET
+    duration: Union[Unset, int] = UNSET
+    scenario: Union[Unset, CreateBulkBodyItemsItemScenario] = 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.create_bulk_body_items_item_viewport_type_0 import (
+            CreateBulkBodyItemsItemViewportType0,
+        )
+
+        url = self.url
+
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        device: Union[Unset, str] = UNSET
+        if not isinstance(self.device, Unset):
+            device = self.device.value
+
+        format_ = self.format_
+
+        quality = self.quality
+
+        full_page = self.full_page
+
+        block_ads = self.block_ads
+
+        block_cookie_banners = self.block_cookie_banners
+
+        scroll = self.scroll
+
+        include_html = self.include_html
+
+        country: Union[None, Unset, str]
+        if isinstance(self.country, Unset):
+            country = UNSET
+        else:
+            country = self.country
+
+        language: Union[None, Unset, str]
+        if isinstance(self.language, Unset):
+            language = UNSET
+        else:
+            language = self.language
+
+        dark_mode = self.dark_mode
+
+        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)
+
+        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
+
+        viewport: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.viewport, Unset):
+            viewport = UNSET
+        elif isinstance(self.viewport, CreateBulkBodyItemsItemViewportType0):
+            viewport = self.viewport.to_dict()
+        else:
+            viewport = self.viewport
+
+        duration = self.duration
+
+        scenario: Union[Unset, str] = UNSET
+        if not isinstance(self.scenario, Unset):
+            scenario = self.scenario.value
+
+        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 type_ is not UNSET:
+            field_dict["type"] = type_
+        if device is not UNSET:
+            field_dict["device"] = device
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if quality is not UNSET:
+            field_dict["quality"] = quality
+        if full_page is not UNSET:
+            field_dict["full_page"] = full_page
+        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 scroll is not UNSET:
+            field_dict["scroll"] = scroll
+        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 dark_mode is not UNSET:
+            field_dict["dark_mode"] = dark_mode
+        if formats is not UNSET:
+            field_dict["formats"] = formats
+        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 viewport is not UNSET:
+            field_dict["viewport"] = viewport
+        if duration is not UNSET:
+            field_dict["duration"] = duration
+        if scenario is not UNSET:
+            field_dict["scenario"] = scenario
+        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_items_item_viewport_type_0 import (
+            CreateBulkBodyItemsItemViewportType0,
+        )
+        from ..models.metadata import Metadata
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, CreateBulkBodyItemsItemType]
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = CreateBulkBodyItemsItemType(_type_)
+
+        _device = d.pop("device", UNSET)
+        device: Union[Unset, CreateBulkBodyItemsItemDevice]
+        if isinstance(_device, Unset):
+            device = UNSET
+        else:
+            device = CreateBulkBodyItemsItemDevice(_device)
+
+        format_ = d.pop("format", UNSET)
+
+        quality = d.pop("quality", UNSET)
+
+        full_page = d.pop("full_page", UNSET)
+
+        block_ads = d.pop("block_ads", UNSET)
+
+        block_cookie_banners = d.pop("block_cookie_banners", UNSET)
+
+        scroll = d.pop("scroll", UNSET)
+
+        include_html = d.pop("include_html", UNSET)
+
+        def _parse_country(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)
+
+        country = _parse_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))
+
+        dark_mode = d.pop("dark_mode", UNSET)
+
+        formats = []
+        _formats = d.pop("formats", UNSET)
+        for formats_item_data in _formats or []:
+            formats_item = CreateBulkBodyItemsItemFormatsItem(formats_item_data)
+
+            formats.append(formats_item)
+
+        _wait_until = d.pop("wait_until", UNSET)
+        wait_until: Union[Unset, CreateBulkBodyItemsItemWaitUntil]
+        if isinstance(_wait_until, Unset):
+            wait_until = UNSET
+        else:
+            wait_until = CreateBulkBodyItemsItemWaitUntil(_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)
+
+        def _parse_viewport(
+            data: object,
+        ) -> Union["CreateBulkBodyItemsItemViewportType0", 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 = CreateBulkBodyItemsItemViewportType0.from_dict(data)
+
+                return viewport_type_0
+            except:  # noqa: E722
+                pass
+            return cast(
+                Union["CreateBulkBodyItemsItemViewportType0", None, Unset], data
+            )
+
+        viewport = _parse_viewport(d.pop("viewport", UNSET))
+
+        duration = d.pop("duration", UNSET)
+
+        _scenario = d.pop("scenario", UNSET)
+        scenario: Union[Unset, CreateBulkBodyItemsItemScenario]
+        if isinstance(_scenario, Unset):
+            scenario = UNSET
+        else:
+            scenario = CreateBulkBodyItemsItemScenario(_scenario)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        create_bulk_body_items_item = cls(
+            url=url,
+            type_=type_,
+            device=device,
+            format_=format_,
+            quality=quality,
+            full_page=full_page,
+            block_ads=block_ads,
+            block_cookie_banners=block_cookie_banners,
+            scroll=scroll,
+            include_html=include_html,
+            country=country,
+            language=language,
+            dark_mode=dark_mode,
+            formats=formats,
+            wait_until=wait_until,
+            wait_for_selector=wait_for_selector,
+            delay_ms=delay_ms,
+            viewport=viewport,
+            duration=duration,
+            scenario=scenario,
+            metadata=metadata,
+        )
+
+        create_bulk_body_items_item.additional_properties = d
+        return create_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_bulk_body_items_item_device.py

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

bytekit/models/create_bulk_body_items_item_formats_item.py

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

bytekit/models/create_bulk_body_items_item_scenario.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CreateBulkBodyItemsItemScenario(str, Enum):
+    NAVIGATE = "navigate"
+    SCROLL = "scroll"
+    STATIC = "static"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_bulk_body_items_item_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class CreateBulkBodyItemsItemType(str, Enum):
+    SCRAPE = "scrape"
+    SCREENSHOT = "screenshot"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_bulk_body_items_item_viewport_type_0.py

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

bytekit/models/create_bulk_body_items_item_wait_until.py

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

bytekit/models/create_bulk_response_202.py

@@ -0,0 +1,164 @@
+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.create_bulk_response_202_status import CreateBulkResponse202Status
+
+T = TypeVar("T", bound="CreateBulkResponse202")
+
+
+@_attrs_define
+class CreateBulkResponse202:
+    """
+    Attributes:
+        id (str):  Example: bulk_01j9abc123.
+        status (CreateBulkResponse202Status):
+        total (int):
+        completed (int):
+        failed (int):
+        created_at (datetime.datetime):
+        completed_at (Union[None, datetime.datetime]):
+        total_credits_charged (int):
+        estimated_credits (Union[None, int]): Estimated credits at submission time. Null in GET responses.
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+    """
+
+    id: str
+    status: CreateBulkResponse202Status
+    total: int
+    completed: int
+    failed: int
+    created_at: datetime.datetime
+    completed_at: Union[None, datetime.datetime]
+    total_credits_charged: int
+    estimated_credits: Union[None, int]
+    webhook_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
+
+        total = self.total
+
+        completed = self.completed
+
+        failed = self.failed
+
+        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
+
+        total_credits_charged = self.total_credits_charged
+
+        estimated_credits: Union[None, int]
+        estimated_credits = self.estimated_credits
+
+        webhook_url = self.webhook_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "status": status,
+                "total": total,
+                "completed": completed,
+                "failed": failed,
+                "created_at": created_at,
+                "completed_at": completed_at,
+                "total_credits_charged": total_credits_charged,
+                "estimated_credits": estimated_credits,
+                "webhook_url": webhook_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 = CreateBulkResponse202Status(d.pop("status"))
+
+        total = d.pop("total")
+
+        completed = d.pop("completed")
+
+        failed = d.pop("failed")
+
+        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"))
+
+        total_credits_charged = d.pop("total_credits_charged")
+
+        def _parse_estimated_credits(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        estimated_credits = _parse_estimated_credits(d.pop("estimated_credits"))
+
+        webhook_url = d.pop("webhook_url")
+
+        create_bulk_response_202 = cls(
+            id=id,
+            status=status,
+            total=total,
+            completed=completed,
+            failed=failed,
+            created_at=created_at,
+            completed_at=completed_at,
+            total_credits_charged=total_credits_charged,
+            estimated_credits=estimated_credits,
+            webhook_url=webhook_url,
+        )
+
+        create_bulk_response_202.additional_properties = d
+        return create_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_bulk_response_202_status.py

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