bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/fetch_request.py

@@ -0,0 +1,276 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+
+from ..models.fetch_request_cache_ttl_type_1 import FetchRequestCacheTtlType1
+from ..models.fetch_request_format import FetchRequestFormat
+from ..models.fetch_request_markdown_images import FetchRequestMarkdownImages
+from ..models.fetch_request_markdown_links import FetchRequestMarkdownLinks
+from ..models.fetch_request_markdown_mode import FetchRequestMarkdownMode
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.fetch_request_custom import FetchRequestCustom
+
+
+T = TypeVar("T", bound="FetchRequest")
+
+
+@_attrs_define
+class FetchRequest:
+    """
+    Attributes:
+        url (str):
+        format_ (Union[Unset, FetchRequestFormat]):
+        country (Union[Unset, str]):
+        timeout_ms (Union[Unset, int]):
+        cache_ttl (Union[FetchRequestCacheTtlType1, Unset, str]): How long a freshly fetched URL may be served from
+            cache. `0` skips the cache read; cache-eligible fresh results are still written with the default 7-day TTL so
+            later non-zero-TTL callers can HIT. Safety-classified WAF husks remain live-only and are not written. Accepts
+            `Nh` (hours, up to 168h), `Nd` (days, up to 7d), or the integer `0`. Examples: `0`, `48h`, `2d`. Invalid values
+            receive a 422 validation_error with an actionable message.
+        custom (Union[Unset, FetchRequestCustom]): User-supplied JSON payload, base64-encoded into the `X-Fetch-Custom`
+            response header so callers can correlate the response back to caller-side state (job IDs, batch metadata, etc.).
+            Capped at 4096 UTF-8 bytes after JSON serialization. Does NOT affect cache-key inputs — two requests differing
+            only in `custom` share the same cache slot.
+        markdown_mode (Union[Unset, FetchRequestMarkdownMode]): Markdown processing mode. Only used when
+            format=markdown.
+        markdown_query (Union[Unset, str]): BM25 query string for relevance-ranked filtering. Only used when
+            format=markdown.
+        markdown_links (Union[Unset, FetchRequestMarkdownLinks]): Link rendering style. Only used when format=markdown.
+        markdown_images (Union[Unset, FetchRequestMarkdownImages]): Image retention mode. Only used when
+            format=markdown.
+        with_links_summary (Union[Unset, bool]): Append a Links footer to the markdown output. Only used when
+            format=markdown.
+        with_images_summary (Union[Unset, bool]): Append an Images footer to the markdown output. Only used when
+            format=markdown.
+        markdown_compact (Union[Unset, bool]): Compact whitespace output. Only used when format=markdown.
+        markdown_filter_images (Union[Unset, bool]): Filter low-signal images. Only used when format=markdown.
+        markdown_include_media (Union[Unset, bool]): When true, `formats.links` and `formats.images` return
+            `ScrapeScoredLink[]` / `ScrapeScoredImage[]` (rich objects) instead of `string[]`, and a top-level `tables`
+            array is included. Only used when format=markdown.
+        markdown_include_warnings (Union[Unset, bool]): When true, enables markdown-pipeline and tag-filter warnings for
+            affected html and markdown requests. Artifact availability warnings such as `artifact_unavailable` may appear
+            independently of this flag.
+        markdown_include_stats (Union[Unset, bool]): When true, includes a top-level `stats` object with `ScrapeStats`
+            (chars, tokens, blocks). Only used when format=markdown.
+    """
+
+    url: str
+    format_: Union[Unset, FetchRequestFormat] = UNSET
+    country: Union[Unset, str] = UNSET
+    timeout_ms: Union[Unset, int] = UNSET
+    cache_ttl: Union[FetchRequestCacheTtlType1, Unset, str] = UNSET
+    custom: Union[Unset, "FetchRequestCustom"] = UNSET
+    markdown_mode: Union[Unset, FetchRequestMarkdownMode] = UNSET
+    markdown_query: Union[Unset, str] = UNSET
+    markdown_links: Union[Unset, FetchRequestMarkdownLinks] = UNSET
+    markdown_images: Union[Unset, FetchRequestMarkdownImages] = UNSET
+    with_links_summary: Union[Unset, bool] = UNSET
+    with_images_summary: Union[Unset, bool] = UNSET
+    markdown_compact: Union[Unset, bool] = UNSET
+    markdown_filter_images: Union[Unset, bool] = UNSET
+    markdown_include_media: Union[Unset, bool] = UNSET
+    markdown_include_warnings: Union[Unset, bool] = UNSET
+    markdown_include_stats: Union[Unset, bool] = UNSET
+
+    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
+
+        timeout_ms = self.timeout_ms
+
+        cache_ttl: Union[Unset, int, str]
+        if isinstance(self.cache_ttl, Unset):
+            cache_ttl = UNSET
+        elif isinstance(self.cache_ttl, FetchRequestCacheTtlType1):
+            cache_ttl = self.cache_ttl.value
+        else:
+            cache_ttl = self.cache_ttl
+
+        custom: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.custom, Unset):
+            custom = self.custom.to_dict()
+
+        markdown_mode: Union[Unset, str] = UNSET
+        if not isinstance(self.markdown_mode, Unset):
+            markdown_mode = self.markdown_mode.value
+
+        markdown_query = self.markdown_query
+
+        markdown_links: Union[Unset, str] = UNSET
+        if not isinstance(self.markdown_links, Unset):
+            markdown_links = self.markdown_links.value
+
+        markdown_images: Union[Unset, str] = UNSET
+        if not isinstance(self.markdown_images, Unset):
+            markdown_images = self.markdown_images.value
+
+        with_links_summary = self.with_links_summary
+
+        with_images_summary = self.with_images_summary
+
+        markdown_compact = self.markdown_compact
+
+        markdown_filter_images = self.markdown_filter_images
+
+        markdown_include_media = self.markdown_include_media
+
+        markdown_include_warnings = self.markdown_include_warnings
+
+        markdown_include_stats = self.markdown_include_stats
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if country is not UNSET:
+            field_dict["country"] = country
+        if timeout_ms is not UNSET:
+            field_dict["timeout_ms"] = timeout_ms
+        if cache_ttl is not UNSET:
+            field_dict["cache_ttl"] = cache_ttl
+        if custom is not UNSET:
+            field_dict["custom"] = custom
+        if markdown_mode is not UNSET:
+            field_dict["markdown_mode"] = markdown_mode
+        if markdown_query is not UNSET:
+            field_dict["markdown_query"] = markdown_query
+        if markdown_links is not UNSET:
+            field_dict["markdown_links"] = markdown_links
+        if markdown_images is not UNSET:
+            field_dict["markdown_images"] = markdown_images
+        if with_links_summary is not UNSET:
+            field_dict["with_links_summary"] = with_links_summary
+        if with_images_summary is not UNSET:
+            field_dict["with_images_summary"] = with_images_summary
+        if markdown_compact is not UNSET:
+            field_dict["markdown_compact"] = markdown_compact
+        if markdown_filter_images is not UNSET:
+            field_dict["markdown_filter_images"] = markdown_filter_images
+        if markdown_include_media is not UNSET:
+            field_dict["markdown_include_media"] = markdown_include_media
+        if markdown_include_warnings is not UNSET:
+            field_dict["markdown_include_warnings"] = markdown_include_warnings
+        if markdown_include_stats is not UNSET:
+            field_dict["markdown_include_stats"] = markdown_include_stats
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.fetch_request_custom import FetchRequestCustom
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        _format_ = d.pop("format", UNSET)
+        format_: Union[Unset, FetchRequestFormat]
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = FetchRequestFormat(_format_)
+
+        country = d.pop("country", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        def _parse_cache_ttl(
+            data: object,
+        ) -> Union[FetchRequestCacheTtlType1, Unset, str]:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, int):
+                    raise TypeError()
+                cache_ttl_type_1 = FetchRequestCacheTtlType1(data)
+
+                return cache_ttl_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union[FetchRequestCacheTtlType1, Unset, str], data)
+
+        cache_ttl = _parse_cache_ttl(d.pop("cache_ttl", UNSET))
+
+        _custom = d.pop("custom", UNSET)
+        custom: Union[Unset, FetchRequestCustom]
+        if isinstance(_custom, Unset):
+            custom = UNSET
+        else:
+            custom = FetchRequestCustom.from_dict(_custom)
+
+        _markdown_mode = d.pop("markdown_mode", UNSET)
+        markdown_mode: Union[Unset, FetchRequestMarkdownMode]
+        if isinstance(_markdown_mode, Unset):
+            markdown_mode = UNSET
+        else:
+            markdown_mode = FetchRequestMarkdownMode(_markdown_mode)
+
+        markdown_query = d.pop("markdown_query", UNSET)
+
+        _markdown_links = d.pop("markdown_links", UNSET)
+        markdown_links: Union[Unset, FetchRequestMarkdownLinks]
+        if isinstance(_markdown_links, Unset):
+            markdown_links = UNSET
+        else:
+            markdown_links = FetchRequestMarkdownLinks(_markdown_links)
+
+        _markdown_images = d.pop("markdown_images", UNSET)
+        markdown_images: Union[Unset, FetchRequestMarkdownImages]
+        if isinstance(_markdown_images, Unset):
+            markdown_images = UNSET
+        else:
+            markdown_images = FetchRequestMarkdownImages(_markdown_images)
+
+        with_links_summary = d.pop("with_links_summary", UNSET)
+
+        with_images_summary = d.pop("with_images_summary", UNSET)
+
+        markdown_compact = d.pop("markdown_compact", UNSET)
+
+        markdown_filter_images = d.pop("markdown_filter_images", UNSET)
+
+        markdown_include_media = d.pop("markdown_include_media", UNSET)
+
+        markdown_include_warnings = d.pop("markdown_include_warnings", UNSET)
+
+        markdown_include_stats = d.pop("markdown_include_stats", UNSET)
+
+        fetch_request = cls(
+            url=url,
+            format_=format_,
+            country=country,
+            timeout_ms=timeout_ms,
+            cache_ttl=cache_ttl,
+            custom=custom,
+            markdown_mode=markdown_mode,
+            markdown_query=markdown_query,
+            markdown_links=markdown_links,
+            markdown_images=markdown_images,
+            with_links_summary=with_links_summary,
+            with_images_summary=with_images_summary,
+            markdown_compact=markdown_compact,
+            markdown_filter_images=markdown_filter_images,
+            markdown_include_media=markdown_include_media,
+            markdown_include_warnings=markdown_include_warnings,
+            markdown_include_stats=markdown_include_stats,
+        )
+
+        return fetch_request

bytekit/models/fetch_request_cache_ttl_type_1.py

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

bytekit/models/fetch_request_custom.py

@@ -0,0 +1,48 @@
+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="FetchRequestCustom")
+
+
+@_attrs_define
+class FetchRequestCustom:
+    """User-supplied JSON payload, base64-encoded into the `X-Fetch-Custom` response header so callers can correlate the
+    response back to caller-side state (job IDs, batch metadata, etc.). Capped at 4096 UTF-8 bytes after JSON
+    serialization. Does NOT affect cache-key inputs — two requests differing only in `custom` share the same cache slot.
+
+    """
+
+    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)
+        fetch_request_custom = cls()
+
+        fetch_request_custom.additional_properties = d
+        return fetch_request_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/fetch_request_format.py

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

bytekit/models/fetch_request_markdown_images.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class FetchRequestMarkdownImages(str, Enum):
+    INLINE = "inline"
+    NONE = "none"
+    REFERENCES = "references"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/fetch_request_markdown_links.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class FetchRequestMarkdownLinks(str, Enum):
+    INLINE = "inline"
+    NONE = "none"
+    REFERENCES = "references"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/fetch_request_markdown_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class FetchRequestMarkdownMode(str, Enum):
+    ARTICLE = "article"
+    LLM = "llm"
+    RAW = "raw"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/get_bulk_response_200.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.get_bulk_response_200_status import GetBulkResponse200Status
+
+T = TypeVar("T", bound="GetBulkResponse200")
+
+
+@_attrs_define
+class GetBulkResponse200:
+    """
+    Attributes:
+        id (str):  Example: bulk_01j9abc123.
+        status (GetBulkResponse200Status):
+        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]): Null in GET responses (computed at submission time only).
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+    """
+
+    id: str
+    status: GetBulkResponse200Status
+    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 = GetBulkResponse200Status(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")
+
+        get_bulk_response_200 = 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,
+        )
+
+        get_bulk_response_200.additional_properties = d
+        return get_bulk_response_200
+
+    @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/get_bulk_response_200_status.py

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

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

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

bytekit/models/get_fetch_format.py

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