bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/scrape_scored_image.py

@@ -0,0 +1,128 @@
+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
+
+T = TypeVar("T", bound="ScrapeScoredImage")
+
+
+@_attrs_define
+class ScrapeScoredImage:
+    """
+    Attributes:
+        url (str):
+        alt (Union[None, str]):
+        width (Union[None, int]):
+        height (Union[None, int]):
+        format_ (Union[None, str]):
+        score (float):
+    """
+
+    url: str
+    alt: Union[None, str]
+    width: Union[None, int]
+    height: Union[None, int]
+    format_: Union[None, str]
+    score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        alt: Union[None, str]
+        alt = self.alt
+
+        width: Union[None, int]
+        width = self.width
+
+        height: Union[None, int]
+        height = self.height
+
+        format_: Union[None, str]
+        format_ = self.format_
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+                "alt": alt,
+                "width": width,
+                "height": height,
+                "format": format_,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        def _parse_alt(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        alt = _parse_alt(d.pop("alt"))
+
+        def _parse_width(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        width = _parse_width(d.pop("width"))
+
+        def _parse_height(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        height = _parse_height(d.pop("height"))
+
+        def _parse_format_(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        format_ = _parse_format_(d.pop("format"))
+
+        score = d.pop("score")
+
+        scrape_scored_image = cls(
+            url=url,
+            alt=alt,
+            width=width,
+            height=height,
+            format_=format_,
+            score=score,
+        )
+
+        scrape_scored_image.additional_properties = d
+        return scrape_scored_image
+
+    @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_scored_link.py

@@ -0,0 +1,94 @@
+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
+
+T = TypeVar("T", bound="ScrapeScoredLink")
+
+
+@_attrs_define
+class ScrapeScoredLink:
+    """
+    Attributes:
+        url (str):
+        text (str):
+        is_internal (bool):
+        rel (Union[None, str]):
+    """
+
+    url: str
+    text: str
+    is_internal: bool
+    rel: Union[None, str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        text = self.text
+
+        is_internal = self.is_internal
+
+        rel: Union[None, str]
+        rel = self.rel
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+                "text": text,
+                "isInternal": is_internal,
+                "rel": rel,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        text = d.pop("text")
+
+        is_internal = d.pop("isInternal")
+
+        def _parse_rel(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        rel = _parse_rel(d.pop("rel"))
+
+        scrape_scored_link = cls(
+            url=url,
+            text=text,
+            is_internal=is_internal,
+            rel=rel,
+        )
+
+        scrape_scored_link.additional_properties = d
+        return scrape_scored_link
+
+    @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_stats.py

@@ -0,0 +1,75 @@
+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="ScrapeStats")
+
+
+@_attrs_define
+class ScrapeStats:
+    """
+    Attributes:
+        chars (int):
+        tokens (int):
+        blocks (int):
+    """
+
+    chars: int
+    tokens: int
+    blocks: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        chars = self.chars
+
+        tokens = self.tokens
+
+        blocks = self.blocks
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "chars": chars,
+                "tokens": tokens,
+                "blocks": blocks,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        chars = d.pop("chars")
+
+        tokens = d.pop("tokens")
+
+        blocks = d.pop("blocks")
+
+        scrape_stats = cls(
+            chars=chars,
+            tokens=tokens,
+            blocks=blocks,
+        )
+
+        scrape_stats.additional_properties = d
+        return scrape_stats
+
+    @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_success_envelope.py

@@ -0,0 +1,345 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.scrape_success_envelope_cache import ScrapeSuccessEnvelopeCache
+from ..models.scrape_success_envelope_schema_version import (
+    ScrapeSuccessEnvelopeSchemaVersion,
+)
+from ..models.scrape_success_envelope_status import ScrapeSuccessEnvelopeStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.scrape_formats import ScrapeFormats
+    from ..models.scrape_markdown_tokens import ScrapeMarkdownTokens
+    from ..models.scrape_metadata import ScrapeMetadata
+    from ..models.scrape_stats import ScrapeStats
+    from ..models.scrape_success_envelope_custom import ScrapeSuccessEnvelopeCustom
+    from ..models.scrape_table import ScrapeTable
+    from ..models.scrape_warning import ScrapeWarning
+
+
+T = TypeVar("T", bound="ScrapeSuccessEnvelope")
+
+
+@_attrs_define
+class ScrapeSuccessEnvelope:
+    r"""
+    Example:
+        {'schema_version': 1, 'status': 'success', 'id': 'sc_01j9abc123', 'url': 'https://example.com', 'final_url':
+            'https://example.com/', 'content_type': 'text/html; charset=UTF-8', 'content_length': 1256, 'status_code': 200,
+            'retrieved_at': datetime.datetime(2025, 1, 15, 12, 0, tzinfo=datetime.timezone(datetime.timedelta(0), 'Z')),
+            'formats': {'raw_html': '<html><body><h1>Hello World</h1><p>Example page with a <a href="/about">link</a> and an
+            image.</p></body></html>', 'html': '<html><body><h1>Hello World</h1><p>Example page with a <a
+            href="/about">link</a> and an image.</p></body></html>', 'markdown': '# Hello World\n\nExample page with a
+            [link](/about) and an image.\n\n![Alt text](https://example.com/photo.png)', 'links': [{'url':
+            'https://example.com/about', 'text': 'link', 'isInternal': True, 'rel': None}], 'images': [{'url':
+            'https://example.com/photo.png', 'alt': 'Alt text', 'width': 800, 'height': 600, 'format': 'png', 'score':
+            0.95}]}, 'metadata': {'title': 'Example Domain', 'description': 'An example page for demonstration', 'language':
+            'en', 'canonicalUrl': 'https://example.com', 'ogTitle': 'Example Domain', 'ogDescription': None, 'ogImage':
+            None, 'byline': 'Jane Doe', 'publishedAt': datetime.datetime(2025, 1, 15, 9, 0,
+            tzinfo=datetime.timezone(datetime.timedelta(0), 'Z'))}, 'tables': [{'kind': 'data', 'gfm': '| Col1 | Col2
+            |\n|------|------|\n| A | B |', 'rows': 2, 'cols': 2}], 'warnings': [{'code': 'lossy_table', 'message': 'Table
+            at index 3 was simplified', 'element': '<table>...</table>'}], 'stats': {'chars': 1256, 'tokens': 312, 'blocks':
+            4}}
+
+    Attributes:
+        schema_version (ScrapeSuccessEnvelopeSchemaVersion): Envelope contract version emitted by current producers.
+            Consumers reading persisted envelopes must tolerate its absence as legacy v0 during rolling deploys.
+        status (ScrapeSuccessEnvelopeStatus):
+        id (str): Stable job identifier (sc_… prefixed). Canonical field. Example: sc_01j9abc123.
+        url (str):
+        final_url (str):
+        content_type (str):
+        content_length (int): Compressed wire bytes transferred for this request — the basis for
+            bandwidth-billed plans. Reflects what crossed the network on your behalf
+            (e.g. gzip/brotli-compressed size), not the decompressed content length.
+        status_code (Union[None, int]):
+        retrieved_at (datetime.datetime):
+        formats (ScrapeFormats):
+        metadata (ScrapeMetadata):
+        tables (Union[Unset, list['ScrapeTable']]): Tables extracted from the page. Present only when
+            markdown_include_media=true. Present only on the synchronous response and webhook delivery. Not included in `GET
+            /v1/scrape/:id`, bulk results, or cached hits.
+        warnings (Union[Unset, list['ScrapeWarning']]): Warnings about markdown processing, tag filtering, or requested
+            persisted artifacts. Markdown-pipeline and tag-filter warnings require `markdown_include_warnings=true`;
+            `artifact_unavailable` may appear independently when a requested persisted format cannot be rehydrated.
+        stats (Union[Unset, ScrapeStats]):
+        markdown_tokens (Union[Unset, ScrapeMarkdownTokens]):
+        billing_multiplier (Union[Unset, float]): The multiplier applied to wire bytes to compute `billed_bytes` for
+            this call (e.g. 0.5 for a cache hit, 1.0-2.0 for format combinations, or higher when `clean_markdown`
+            succeeded). Present whenever this call's billing amount has been finalized; omitted if unavailable.
+        billed_bytes (Union[Unset, int]): The actual bandwidth billed for this call — `round(content_length *
+            billing_multiplier)`. Present alongside `billing_multiplier`.
+        custom (Union[Unset, ScrapeSuccessEnvelopeCustom]): Custom metadata provided by the caller in the request
+            `custom` field. Stored verbatim and round-tripped on the synchronous response and webhook delivery. Not included
+            in `GET /v1/scrape/:id`, bulk results, or cached hits. Omitted when no custom metadata was provided.
+        cache (Union[Unset, ScrapeSuccessEnvelopeCache]): Cache verdict for the request that produced this envelope.
+            `hit` — served
+            from a prior cache entry (billed at 0.5×). `miss` — no reusable entry was
+            found, so the result was freshly fetched. `bypass` — `cache_ttl: '0'`
+            skipped the read. Cache-eligible fresh results are written through;
+            safety-classified WAF husks remain live-only. Present on the async success
+            envelope (synchronous and webhook delivery); omitted by paths with no cache
+            verdict (e.g. bulk results).
+        cache_age_s (Union[Unset, int]): Age in whole seconds of the cache entry replayed on a `hit`. Clamped to ≥ 0 to
+            absorb clock skew. Present only on `cache: hit`.
+    """
+
+    schema_version: ScrapeSuccessEnvelopeSchemaVersion
+    status: ScrapeSuccessEnvelopeStatus
+    id: str
+    url: str
+    final_url: str
+    content_type: str
+    content_length: int
+    status_code: Union[None, int]
+    retrieved_at: datetime.datetime
+    formats: "ScrapeFormats"
+    metadata: "ScrapeMetadata"
+    tables: Union[Unset, list["ScrapeTable"]] = UNSET
+    warnings: Union[Unset, list["ScrapeWarning"]] = UNSET
+    stats: Union[Unset, "ScrapeStats"] = UNSET
+    markdown_tokens: Union[Unset, "ScrapeMarkdownTokens"] = UNSET
+    billing_multiplier: Union[Unset, float] = UNSET
+    billed_bytes: Union[Unset, int] = UNSET
+    custom: Union[Unset, "ScrapeSuccessEnvelopeCustom"] = UNSET
+    cache: Union[Unset, ScrapeSuccessEnvelopeCache] = UNSET
+    cache_age_s: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        schema_version = self.schema_version.value
+
+        status = self.status.value
+
+        id = self.id
+
+        url = self.url
+
+        final_url = self.final_url
+
+        content_type = self.content_type
+
+        content_length = self.content_length
+
+        status_code: Union[None, int]
+        status_code = self.status_code
+
+        retrieved_at = self.retrieved_at.isoformat()
+
+        formats = self.formats.to_dict()
+
+        metadata = self.metadata.to_dict()
+
+        tables: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.tables, Unset):
+            tables = []
+            for tables_item_data in self.tables:
+                tables_item = tables_item_data.to_dict()
+                tables.append(tables_item)
+
+        warnings: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.warnings, Unset):
+            warnings = []
+            for warnings_item_data in self.warnings:
+                warnings_item = warnings_item_data.to_dict()
+                warnings.append(warnings_item)
+
+        stats: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.stats, Unset):
+            stats = self.stats.to_dict()
+
+        markdown_tokens: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.markdown_tokens, Unset):
+            markdown_tokens = self.markdown_tokens.to_dict()
+
+        billing_multiplier = self.billing_multiplier
+
+        billed_bytes = self.billed_bytes
+
+        custom: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.custom, Unset):
+            custom = self.custom.to_dict()
+
+        cache: Union[Unset, str] = UNSET
+        if not isinstance(self.cache, Unset):
+            cache = self.cache.value
+
+        cache_age_s = self.cache_age_s
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "schema_version": schema_version,
+                "status": status,
+                "id": id,
+                "url": url,
+                "final_url": final_url,
+                "content_type": content_type,
+                "content_length": content_length,
+                "status_code": status_code,
+                "retrieved_at": retrieved_at,
+                "formats": formats,
+                "metadata": metadata,
+            }
+        )
+        if tables is not UNSET:
+            field_dict["tables"] = tables
+        if warnings is not UNSET:
+            field_dict["warnings"] = warnings
+        if stats is not UNSET:
+            field_dict["stats"] = stats
+        if markdown_tokens is not UNSET:
+            field_dict["markdown_tokens"] = markdown_tokens
+        if billing_multiplier is not UNSET:
+            field_dict["billing_multiplier"] = billing_multiplier
+        if billed_bytes is not UNSET:
+            field_dict["billed_bytes"] = billed_bytes
+        if custom is not UNSET:
+            field_dict["custom"] = custom
+        if cache is not UNSET:
+            field_dict["cache"] = cache
+        if cache_age_s is not UNSET:
+            field_dict["cache_age_s"] = cache_age_s
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.scrape_formats import ScrapeFormats
+        from ..models.scrape_markdown_tokens import ScrapeMarkdownTokens
+        from ..models.scrape_metadata import ScrapeMetadata
+        from ..models.scrape_stats import ScrapeStats
+        from ..models.scrape_success_envelope_custom import ScrapeSuccessEnvelopeCustom
+        from ..models.scrape_table import ScrapeTable
+        from ..models.scrape_warning import ScrapeWarning
+
+        d = dict(src_dict)
+        schema_version = ScrapeSuccessEnvelopeSchemaVersion(d.pop("schema_version"))
+
+        status = ScrapeSuccessEnvelopeStatus(d.pop("status"))
+
+        id = d.pop("id")
+
+        url = d.pop("url")
+
+        final_url = d.pop("final_url")
+
+        content_type = d.pop("content_type")
+
+        content_length = d.pop("content_length")
+
+        def _parse_status_code(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        status_code = _parse_status_code(d.pop("status_code"))
+
+        retrieved_at = isoparse(d.pop("retrieved_at"))
+
+        formats = ScrapeFormats.from_dict(d.pop("formats"))
+
+        metadata = ScrapeMetadata.from_dict(d.pop("metadata"))
+
+        tables = []
+        _tables = d.pop("tables", UNSET)
+        for tables_item_data in _tables or []:
+            tables_item = ScrapeTable.from_dict(tables_item_data)
+
+            tables.append(tables_item)
+
+        warnings = []
+        _warnings = d.pop("warnings", UNSET)
+        for warnings_item_data in _warnings or []:
+            warnings_item = ScrapeWarning.from_dict(warnings_item_data)
+
+            warnings.append(warnings_item)
+
+        _stats = d.pop("stats", UNSET)
+        stats: Union[Unset, ScrapeStats]
+        if isinstance(_stats, Unset):
+            stats = UNSET
+        else:
+            stats = ScrapeStats.from_dict(_stats)
+
+        _markdown_tokens = d.pop("markdown_tokens", UNSET)
+        markdown_tokens: Union[Unset, ScrapeMarkdownTokens]
+        if isinstance(_markdown_tokens, Unset):
+            markdown_tokens = UNSET
+        else:
+            markdown_tokens = ScrapeMarkdownTokens.from_dict(_markdown_tokens)
+
+        billing_multiplier = d.pop("billing_multiplier", UNSET)
+
+        billed_bytes = d.pop("billed_bytes", UNSET)
+
+        _custom = d.pop("custom", UNSET)
+        custom: Union[Unset, ScrapeSuccessEnvelopeCustom]
+        if isinstance(_custom, Unset):
+            custom = UNSET
+        else:
+            custom = ScrapeSuccessEnvelopeCustom.from_dict(_custom)
+
+        _cache = d.pop("cache", UNSET)
+        cache: Union[Unset, ScrapeSuccessEnvelopeCache]
+        if isinstance(_cache, Unset):
+            cache = UNSET
+        else:
+            cache = ScrapeSuccessEnvelopeCache(_cache)
+
+        cache_age_s = d.pop("cache_age_s", UNSET)
+
+        scrape_success_envelope = cls(
+            schema_version=schema_version,
+            status=status,
+            id=id,
+            url=url,
+            final_url=final_url,
+            content_type=content_type,
+            content_length=content_length,
+            status_code=status_code,
+            retrieved_at=retrieved_at,
+            formats=formats,
+            metadata=metadata,
+            tables=tables,
+            warnings=warnings,
+            stats=stats,
+            markdown_tokens=markdown_tokens,
+            billing_multiplier=billing_multiplier,
+            billed_bytes=billed_bytes,
+            custom=custom,
+            cache=cache,
+            cache_age_s=cache_age_s,
+        )
+
+        scrape_success_envelope.additional_properties = d
+        return scrape_success_envelope
+
+    @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_success_envelope_cache.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ScrapeSuccessEnvelopeCache(str, Enum):
+    BYPASS = "bypass"
+    HIT = "hit"
+    MISS = "miss"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/scrape_success_envelope_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="ScrapeSuccessEnvelopeCustom")
+
+
+@_attrs_define
+class ScrapeSuccessEnvelopeCustom:
+    """Custom metadata provided by the caller in the request `custom` field. Stored verbatim and round-tripped on the
+    synchronous response and webhook delivery. Not included in `GET /v1/scrape/:id`, bulk results, or cached hits.
+    Omitted when no custom metadata was provided.
+
+    """
+
+    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_success_envelope_custom = cls()
+
+        scrape_success_envelope_custom.additional_properties = d
+        return scrape_success_envelope_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