bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/scrape_request.py

@@ -0,0 +1,485 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+
+from ..models.scrape_request_cache_ttl_type_1 import ScrapeRequestCacheTtlType1
+from ..models.scrape_request_events_item import ScrapeRequestEventsItem
+from ..models.scrape_request_formats_item import ScrapeRequestFormatsItem
+from ..models.scrape_request_markdown_images import ScrapeRequestMarkdownImages
+from ..models.scrape_request_markdown_links import ScrapeRequestMarkdownLinks
+from ..models.scrape_request_markdown_mode import ScrapeRequestMarkdownMode
+from ..models.scrape_request_token_encoding import ScrapeRequestTokenEncoding
+from ..models.scrape_request_x_internal_scrape_path import (
+    ScrapeRequestXInternalScrapePath,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.cookie import Cookie
+    from ..models.scrape_request_custom import ScrapeRequestCustom
+    from ..models.scrape_request_headers import ScrapeRequestHeaders
+
+
+T = TypeVar("T", bound="ScrapeRequest")
+
+
+@_attrs_define
+class ScrapeRequest:
+    r"""
+    Attributes:
+        url (str):
+        formats (Union[Unset, list[ScrapeRequestFormatsItem]]):
+        country (Union[Unset, str]):
+        cookies (Union[Unset, list['Cookie']]):
+        headers (Union[Unset, ScrapeRequestHeaders]):
+        delay_ms (Union[Unset, int]):
+        timeout_ms (Union[Unset, int]):
+        async_ (Union[Unset, bool]):
+        webhook_url (Union[Unset, str]): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+        events (Union[Unset, list[ScrapeRequestEventsItem]]):
+        markdown_mode (Union[Unset, ScrapeRequestMarkdownMode]): Markdown processing mode. article=article extraction
+            (default), raw=minimal cleanup, llm=compact LLM-optimised output.
+        markdown_query (Union[Unset, str]): BM25 query string for relevance-ranked content filtering. Omit or leave
+            empty to disable.
+        markdown_links (Union[Unset, ScrapeRequestMarkdownLinks]): Link rendering style in the markdown output. 'inline'
+            (default) keeps `[text](url)` as-is. 'text' strips URLs, keeping only anchor text. 'none' strips URLs and
+            removes reference definitions. 'references' converts to numbered `[text][N]` refs with a Links footer.
+        markdown_images (Union[Unset, ScrapeRequestMarkdownImages]): Image retention mode in the markdown output.
+            'inline' (default) keeps `![alt](url)` as-is. 'text' strips the URL, keeping only alt text. 'none' removes
+            images entirely. 'references' converts to numbered `![alt][N]` refs with an Images footer. Distinct from
+            markdown_filter_images (which drops low-signal images before conversion).
+        with_links_summary (Union[Unset, bool]): When true, appends a 'Links:\n[1]: url\n...' footer to the markdown
+            output, built from the extracted link list. Automatically enabled when markdown_links is 'references'.
+        with_images_summary (Union[Unset, bool]): When true, appends an 'Images:\n[1]: url\n...' footer to the markdown
+            output, built from the extracted image list.
+        markdown_compact (Union[Unset, bool]): Collapse excessive whitespace for a more compact output.
+        markdown_filter_images (Union[Unset, bool]): Filter low-signal images from the markdown output.
+        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 effective when `markdown` is in `formats`.
+        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, the response includes a top-level `stats` object with
+            `ScrapeStats` (chars, tokens, blocks). Only effective when `markdown` is in `formats`.
+        token_budget (Union[Unset, int]): Maximum token count for the markdown output. When set and `markdown` is in
+            `formats`, the output is truncated at the last paragraph → sentence → token boundary that keeps the estimated
+            count under this limit. Absent → no truncation. Triggers a `markdown_tokens` field in the response.
+        token_encoding (Union[Unset, ScrapeRequestTokenEncoding]): Tokenizer encoding hint for `token_budget`.
+            `cl100k_base` (default) matches GPT-4/4o; `o200k_base` matches GPT-4o-mini / o-series. Both use the same
+            4-char/token heuristic internally.
+        mobile (Union[Unset, bool]): When true, emulate a mobile device — the request uses a mobile (Android) user agent
+            and a mobile viewport, so the upstream serves the mobile version of the page. Default false (desktop). The value
+            is part of the cache key, so mobile and desktop responses are cached independently.
+        remove_base64_images (Union[Unset, bool]): When true (default), base64-encoded `data:` image sources are
+            stripped from the HTML before markdown conversion and from the `html` format output. Set to false to preserve
+            base64 images in the pipeline output. Does not affect `raw_html`, which always returns the original HTML
+            unchanged.
+        include_tags (Union[Unset, list[str]]): HTML element names (not CSS selectors) to keep. When non-empty, only
+            content within these elements is included in the `html` and `markdown` output. Applied before `exclude_tags`.
+            Does not affect `raw_html`, which always returns the full page.
+        exclude_tags (Union[Unset, list[str]]): HTML element names (not CSS selectors) to strip from the `html` and
+            `markdown` output. Applied after `include_tags` when both are present. Does not affect `raw_html`, which always
+            returns the full page.
+        cache_ttl (Union[ScrapeRequestCacheTtlType1, Unset, str]): How long a freshly fetched URL may be served from
+            cache. `0` (string or integer) skips the cache read; cache-eligible results are still written. `Nh`/`Nd` set a
+            TTL (capped at 168 h / 7 d). Safety-classified WAF husks are returned live but never stored in the shared cache.
+            Honoured on both the synchronous and asynchronous paths; the async success envelope reports the lookup outcome
+            via the `cache` field.
+        custom (Union[Unset, ScrapeRequestCustom]): User-supplied JSON payload, echoed back on the success envelope
+            (sync, async, webhook). Capped at 4096 UTF-8 bytes (`Buffer.byteLength`). Distinct from the system-owned
+            `metadata` column. Does NOT affect cache-key inputs — two requests differing only in `custom` resolve to the
+            same cache entry.
+        clean_markdown (Union[Unset, bool]): When `true` and `markdown` is in `formats`, the converted markdown is sent
+            to Groq LLM for cleaning (boilerplate removal, ad stripping, formatting improvement) before being returned.
+            Graceful degradation: any Groq failure (key unset, 4xx/5xx, timeout, empty response) returns the raw markdown
+            unchanged plus a warning in the `warnings` array. Billing: 3× credits and bytes applied only when cleaning
+            succeeds.
+        x_internal_scrape_path (Union[Unset, ScrapeRequestXInternalScrapePath]): Internal-only: forces the request onto
+            the worker enqueue branch and the lean-forced code path in scrape-worker. Requires X-Internal-Probe-Token
+            header. Not exposed via SDK generators.
+    """
+
+    url: str
+    formats: Union[Unset, list[ScrapeRequestFormatsItem]] = UNSET
+    country: Union[Unset, str] = UNSET
+    cookies: Union[Unset, list["Cookie"]] = UNSET
+    headers: Union[Unset, "ScrapeRequestHeaders"] = UNSET
+    delay_ms: Union[Unset, int] = UNSET
+    timeout_ms: Union[Unset, int] = UNSET
+    async_: Union[Unset, bool] = UNSET
+    webhook_url: Union[Unset, str] = UNSET
+    events: Union[Unset, list[ScrapeRequestEventsItem]] = UNSET
+    markdown_mode: Union[Unset, ScrapeRequestMarkdownMode] = UNSET
+    markdown_query: Union[Unset, str] = UNSET
+    markdown_links: Union[Unset, ScrapeRequestMarkdownLinks] = UNSET
+    markdown_images: Union[Unset, ScrapeRequestMarkdownImages] = 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
+    token_budget: Union[Unset, int] = UNSET
+    token_encoding: Union[Unset, ScrapeRequestTokenEncoding] = UNSET
+    mobile: Union[Unset, bool] = UNSET
+    remove_base64_images: Union[Unset, bool] = UNSET
+    include_tags: Union[Unset, list[str]] = UNSET
+    exclude_tags: Union[Unset, list[str]] = UNSET
+    cache_ttl: Union[ScrapeRequestCacheTtlType1, Unset, str] = UNSET
+    custom: Union[Unset, "ScrapeRequestCustom"] = UNSET
+    clean_markdown: Union[Unset, bool] = UNSET
+    x_internal_scrape_path: Union[Unset, ScrapeRequestXInternalScrapePath] = UNSET
+
+    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
+
+        async_ = self.async_
+
+        webhook_url = self.webhook_url
+
+        events: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for events_item_data in self.events:
+                events_item = events_item_data.value
+                events.append(events_item)
+
+        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
+
+        token_budget = self.token_budget
+
+        token_encoding: Union[Unset, str] = UNSET
+        if not isinstance(self.token_encoding, Unset):
+            token_encoding = self.token_encoding.value
+
+        mobile = self.mobile
+
+        remove_base64_images = self.remove_base64_images
+
+        include_tags: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.include_tags, Unset):
+            include_tags = self.include_tags
+
+        exclude_tags: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.exclude_tags, Unset):
+            exclude_tags = self.exclude_tags
+
+        cache_ttl: Union[Unset, int, str]
+        if isinstance(self.cache_ttl, Unset):
+            cache_ttl = UNSET
+        elif isinstance(self.cache_ttl, ScrapeRequestCacheTtlType1):
+            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()
+
+        clean_markdown = self.clean_markdown
+
+        x_internal_scrape_path: Union[Unset, str] = UNSET
+        if not isinstance(self.x_internal_scrape_path, Unset):
+            x_internal_scrape_path = self.x_internal_scrape_path.value
+
+        field_dict: dict[str, Any] = {}
+
+        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 async_ is not UNSET:
+            field_dict["async"] = async_
+        if webhook_url is not UNSET:
+            field_dict["webhook_url"] = webhook_url
+        if events is not UNSET:
+            field_dict["events"] = events
+        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
+        if token_budget is not UNSET:
+            field_dict["token_budget"] = token_budget
+        if token_encoding is not UNSET:
+            field_dict["token_encoding"] = token_encoding
+        if mobile is not UNSET:
+            field_dict["mobile"] = mobile
+        if remove_base64_images is not UNSET:
+            field_dict["remove_base64_images"] = remove_base64_images
+        if include_tags is not UNSET:
+            field_dict["include_tags"] = include_tags
+        if exclude_tags is not UNSET:
+            field_dict["exclude_tags"] = exclude_tags
+        if cache_ttl is not UNSET:
+            field_dict["cache_ttl"] = cache_ttl
+        if custom is not UNSET:
+            field_dict["custom"] = custom
+        if clean_markdown is not UNSET:
+            field_dict["clean_markdown"] = clean_markdown
+        if x_internal_scrape_path is not UNSET:
+            field_dict["x_internal_scrape_path"] = x_internal_scrape_path
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cookie import Cookie
+        from ..models.scrape_request_custom import ScrapeRequestCustom
+        from ..models.scrape_request_headers import ScrapeRequestHeaders
+
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        formats = []
+        _formats = d.pop("formats", UNSET)
+        for formats_item_data in _formats or []:
+            formats_item = ScrapeRequestFormatsItem(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, ScrapeRequestHeaders]
+        if isinstance(_headers, Unset):
+            headers = UNSET
+        else:
+            headers = ScrapeRequestHeaders.from_dict(_headers)
+
+        delay_ms = d.pop("delay_ms", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        async_ = d.pop("async", UNSET)
+
+        webhook_url = d.pop("webhook_url", UNSET)
+
+        events = []
+        _events = d.pop("events", UNSET)
+        for events_item_data in _events or []:
+            events_item = ScrapeRequestEventsItem(events_item_data)
+
+            events.append(events_item)
+
+        _markdown_mode = d.pop("markdown_mode", UNSET)
+        markdown_mode: Union[Unset, ScrapeRequestMarkdownMode]
+        if isinstance(_markdown_mode, Unset):
+            markdown_mode = UNSET
+        else:
+            markdown_mode = ScrapeRequestMarkdownMode(_markdown_mode)
+
+        markdown_query = d.pop("markdown_query", UNSET)
+
+        _markdown_links = d.pop("markdown_links", UNSET)
+        markdown_links: Union[Unset, ScrapeRequestMarkdownLinks]
+        if isinstance(_markdown_links, Unset):
+            markdown_links = UNSET
+        else:
+            markdown_links = ScrapeRequestMarkdownLinks(_markdown_links)
+
+        _markdown_images = d.pop("markdown_images", UNSET)
+        markdown_images: Union[Unset, ScrapeRequestMarkdownImages]
+        if isinstance(_markdown_images, Unset):
+            markdown_images = UNSET
+        else:
+            markdown_images = ScrapeRequestMarkdownImages(_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)
+
+        token_budget = d.pop("token_budget", UNSET)
+
+        _token_encoding = d.pop("token_encoding", UNSET)
+        token_encoding: Union[Unset, ScrapeRequestTokenEncoding]
+        if isinstance(_token_encoding, Unset):
+            token_encoding = UNSET
+        else:
+            token_encoding = ScrapeRequestTokenEncoding(_token_encoding)
+
+        mobile = d.pop("mobile", UNSET)
+
+        remove_base64_images = d.pop("remove_base64_images", UNSET)
+
+        include_tags = cast(list[str], d.pop("include_tags", UNSET))
+
+        exclude_tags = cast(list[str], d.pop("exclude_tags", UNSET))
+
+        def _parse_cache_ttl(
+            data: object,
+        ) -> Union[ScrapeRequestCacheTtlType1, Unset, str]:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, int):
+                    raise TypeError()
+                cache_ttl_type_1 = ScrapeRequestCacheTtlType1(data)
+
+                return cache_ttl_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union[ScrapeRequestCacheTtlType1, Unset, str], data)
+
+        cache_ttl = _parse_cache_ttl(d.pop("cache_ttl", UNSET))
+
+        _custom = d.pop("custom", UNSET)
+        custom: Union[Unset, ScrapeRequestCustom]
+        if isinstance(_custom, Unset):
+            custom = UNSET
+        else:
+            custom = ScrapeRequestCustom.from_dict(_custom)
+
+        clean_markdown = d.pop("clean_markdown", UNSET)
+
+        _x_internal_scrape_path = d.pop("x_internal_scrape_path", UNSET)
+        x_internal_scrape_path: Union[Unset, ScrapeRequestXInternalScrapePath]
+        if isinstance(_x_internal_scrape_path, Unset):
+            x_internal_scrape_path = UNSET
+        else:
+            x_internal_scrape_path = ScrapeRequestXInternalScrapePath(
+                _x_internal_scrape_path
+            )
+
+        scrape_request = cls(
+            url=url,
+            formats=formats,
+            country=country,
+            cookies=cookies,
+            headers=headers,
+            delay_ms=delay_ms,
+            timeout_ms=timeout_ms,
+            async_=async_,
+            webhook_url=webhook_url,
+            events=events,
+            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,
+            token_budget=token_budget,
+            token_encoding=token_encoding,
+            mobile=mobile,
+            remove_base64_images=remove_base64_images,
+            include_tags=include_tags,
+            exclude_tags=exclude_tags,
+            cache_ttl=cache_ttl,
+            custom=custom,
+            clean_markdown=clean_markdown,
+            x_internal_scrape_path=x_internal_scrape_path,
+        )
+
+        return scrape_request

bytekit/models/scrape_request_cache_ttl_type_1.py

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

bytekit/models/scrape_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="ScrapeRequestCustom")
+
+
+@_attrs_define
+class ScrapeRequestCustom:
+    """User-supplied JSON payload, echoed back on the success envelope (sync, async, webhook). Capped at 4096 UTF-8 bytes
+    (`Buffer.byteLength`). Distinct from the system-owned `metadata` column. Does NOT affect cache-key inputs — two
+    requests differing only in `custom` resolve to the same cache entry.
+
+    """
+
+    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)
+        scrape_request_custom = cls()
+
+        scrape_request_custom.additional_properties = d
+        return scrape_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/scrape_request_events_item.py

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

bytekit/models/scrape_request_formats_item.py

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

bytekit/models/scrape_request_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="ScrapeRequestHeaders")
+
+
+@_attrs_define
+class ScrapeRequestHeaders:
+    """ """
+
+    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)
+        scrape_request_headers = cls()
+
+        scrape_request_headers.additional_properties = d
+        return scrape_request_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/scrape_request_markdown_images.py

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

bytekit/models/scrape_request_markdown_links.py

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

bytekit/models/scrape_request_markdown_mode.py

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

bytekit/models/scrape_request_token_encoding.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ScrapeRequestTokenEncoding(str, Enum):
+    CL100K_BASE = "cl100k_base"
+    O200K_BASE = "o200k_base"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/scrape_request_x_internal_scrape_path.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ScrapeRequestXInternalScrapePath(str, Enum):
+    LEAN_FORCED = "lean-forced"
+
+    def __str__(self) -> str:
+        return str(self.value)