bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/scrape_formats.py

@@ -0,0 +1,183 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.scrape_scored_image import ScrapeScoredImage
+    from ..models.scrape_scored_link import ScrapeScoredLink
+
+
+T = TypeVar("T", bound="ScrapeFormats")
+
+
+@_attrs_define
+class ScrapeFormats:
+    """
+    Attributes:
+        raw_html (Union[Unset, str]):
+        html (Union[Unset, str]):
+        markdown (Union[Unset, str]):
+        links (Union[Unset, list['ScrapeScoredLink'], list[str]]): Plain URL strings by default. When
+            markdownIncludeMedia=true, an array of ScrapeScoredLink objects.
+        images (Union[Unset, list['ScrapeScoredImage'], list[str]]): Plain URL strings by default. When
+            markdownIncludeMedia=true, an array of ScrapeScoredImage objects.
+    """
+
+    raw_html: Union[Unset, str] = UNSET
+    html: Union[Unset, str] = UNSET
+    markdown: Union[Unset, str] = UNSET
+    links: Union[Unset, list["ScrapeScoredLink"], list[str]] = UNSET
+    images: Union[Unset, list["ScrapeScoredImage"], list[str]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        raw_html = self.raw_html
+
+        html = self.html
+
+        markdown = self.markdown
+
+        links: Union[Unset, list[dict[str, Any]], list[str]]
+        if isinstance(self.links, Unset):
+            links = UNSET
+        elif isinstance(self.links, list):
+            links = []
+            for links_type_0_item_data in self.links:
+                links_type_0_item = links_type_0_item_data.to_dict()
+                links.append(links_type_0_item)
+
+        else:
+            links = self.links
+
+        images: Union[Unset, list[dict[str, Any]], list[str]]
+        if isinstance(self.images, Unset):
+            images = UNSET
+        elif isinstance(self.images, list):
+            images = []
+            for images_type_0_item_data in self.images:
+                images_type_0_item = images_type_0_item_data.to_dict()
+                images.append(images_type_0_item)
+
+        else:
+            images = self.images
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if raw_html is not UNSET:
+            field_dict["raw_html"] = raw_html
+        if html is not UNSET:
+            field_dict["html"] = html
+        if markdown is not UNSET:
+            field_dict["markdown"] = markdown
+        if links is not UNSET:
+            field_dict["links"] = links
+        if images is not UNSET:
+            field_dict["images"] = images
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.scrape_scored_image import ScrapeScoredImage
+        from ..models.scrape_scored_link import ScrapeScoredLink
+
+        d = dict(src_dict)
+        raw_html = d.pop("raw_html", UNSET)
+
+        html = d.pop("html", UNSET)
+
+        markdown = d.pop("markdown", UNSET)
+
+        def _parse_links(
+            data: object,
+        ) -> Union[Unset, list["ScrapeScoredLink"], list[str]]:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                links_type_0 = []
+                _links_type_0 = data
+                for links_type_0_item_data in _links_type_0:
+                    links_type_0_item = ScrapeScoredLink.from_dict(
+                        links_type_0_item_data
+                    )
+
+                    links_type_0.append(links_type_0_item)
+
+                return links_type_0
+            except:  # noqa: E722
+                pass
+            if not isinstance(data, list):
+                raise TypeError()
+            links_type_1 = cast(list[str], data)
+
+            return links_type_1
+
+        links = _parse_links(d.pop("links", UNSET))
+
+        def _parse_images(
+            data: object,
+        ) -> Union[Unset, list["ScrapeScoredImage"], list[str]]:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                images_type_0 = []
+                _images_type_0 = data
+                for images_type_0_item_data in _images_type_0:
+                    images_type_0_item = ScrapeScoredImage.from_dict(
+                        images_type_0_item_data
+                    )
+
+                    images_type_0.append(images_type_0_item)
+
+                return images_type_0
+            except:  # noqa: E722
+                pass
+            if not isinstance(data, list):
+                raise TypeError()
+            images_type_1 = cast(list[str], data)
+
+            return images_type_1
+
+        images = _parse_images(d.pop("images", UNSET))
+
+        scrape_formats = cls(
+            raw_html=raw_html,
+            html=html,
+            markdown=markdown,
+            links=links,
+            images=images,
+        )
+
+        scrape_formats.additional_properties = d
+        return scrape_formats
+
+    @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_markdown_tokens.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="ScrapeMarkdownTokens")
+
+
+@_attrs_define
+class ScrapeMarkdownTokens:
+    """
+    Attributes:
+        kept (int): Estimated token count of the returned (possibly truncated) markdown.
+        total (int): Estimated token count of the full markdown before any truncation.
+        truncated (bool): True when the output was truncated to fit within the requested `token_budget`.
+    """
+
+    kept: int
+    total: int
+    truncated: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        kept = self.kept
+
+        total = self.total
+
+        truncated = self.truncated
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "kept": kept,
+                "total": total,
+                "truncated": truncated,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        kept = d.pop("kept")
+
+        total = d.pop("total")
+
+        truncated = d.pop("truncated")
+
+        scrape_markdown_tokens = cls(
+            kept=kept,
+            total=total,
+            truncated=truncated,
+        )
+
+        scrape_markdown_tokens.additional_properties = d
+        return scrape_markdown_tokens
+
+    @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_metadata.py

@@ -0,0 +1,262 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ScrapeMetadata")
+
+
+@_attrs_define
+class ScrapeMetadata:
+    """
+    Attributes:
+        title (Union[None, str]):
+        description (Union[None, str]):
+        language (Union[None, str]):
+        canonical_url (Union[None, str]):
+        og_title (Union[None, str]):
+        og_description (Union[None, str]):
+        og_image (Union[None, str]):
+        byline (Union[None, str]): Article byline (author). Always present in the metadata object. Null when not
+            extracted or not a structured-markdown request. Non-null values available only on the synchronous response and
+            webhook delivery. Always `null` on `GET /v1/scrape/:id`, bulk results, and cached hits.
+        published_at (Union[None, datetime.datetime]): Article published timestamp. Always present in the metadata
+            object. Null when not extracted or not a structured-markdown request. Non-null values available only on the
+            synchronous response and webhook delivery. Always `null` on `GET /v1/scrape/:id`, bulk results, and cached hits.
+        og_url (Union[None, Unset, str]):
+        og_site_name (Union[None, Unset, str]):
+        robots (Union[None, Unset, str]):
+    """
+
+    title: Union[None, str]
+    description: Union[None, str]
+    language: Union[None, str]
+    canonical_url: Union[None, str]
+    og_title: Union[None, str]
+    og_description: Union[None, str]
+    og_image: Union[None, str]
+    byline: Union[None, str]
+    published_at: Union[None, datetime.datetime]
+    og_url: Union[None, Unset, str] = UNSET
+    og_site_name: Union[None, Unset, str] = UNSET
+    robots: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        title: Union[None, str]
+        title = self.title
+
+        description: Union[None, str]
+        description = self.description
+
+        language: Union[None, str]
+        language = self.language
+
+        canonical_url: Union[None, str]
+        canonical_url = self.canonical_url
+
+        og_title: Union[None, str]
+        og_title = self.og_title
+
+        og_description: Union[None, str]
+        og_description = self.og_description
+
+        og_image: Union[None, str]
+        og_image = self.og_image
+
+        byline: Union[None, str]
+        byline = self.byline
+
+        published_at: Union[None, str]
+        if isinstance(self.published_at, datetime.datetime):
+            published_at = self.published_at.isoformat()
+        else:
+            published_at = self.published_at
+
+        og_url: Union[None, Unset, str]
+        if isinstance(self.og_url, Unset):
+            og_url = UNSET
+        else:
+            og_url = self.og_url
+
+        og_site_name: Union[None, Unset, str]
+        if isinstance(self.og_site_name, Unset):
+            og_site_name = UNSET
+        else:
+            og_site_name = self.og_site_name
+
+        robots: Union[None, Unset, str]
+        if isinstance(self.robots, Unset):
+            robots = UNSET
+        else:
+            robots = self.robots
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "title": title,
+                "description": description,
+                "language": language,
+                "canonicalUrl": canonical_url,
+                "ogTitle": og_title,
+                "ogDescription": og_description,
+                "ogImage": og_image,
+                "byline": byline,
+                "publishedAt": published_at,
+            }
+        )
+        if og_url is not UNSET:
+            field_dict["ogUrl"] = og_url
+        if og_site_name is not UNSET:
+            field_dict["ogSiteName"] = og_site_name
+        if robots is not UNSET:
+            field_dict["robots"] = robots
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_title(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        title = _parse_title(d.pop("title"))
+
+        def _parse_description(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        description = _parse_description(d.pop("description"))
+
+        def _parse_language(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        language = _parse_language(d.pop("language"))
+
+        def _parse_canonical_url(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        canonical_url = _parse_canonical_url(d.pop("canonicalUrl"))
+
+        def _parse_og_title(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        og_title = _parse_og_title(d.pop("ogTitle"))
+
+        def _parse_og_description(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        og_description = _parse_og_description(d.pop("ogDescription"))
+
+        def _parse_og_image(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        og_image = _parse_og_image(d.pop("ogImage"))
+
+        def _parse_byline(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        byline = _parse_byline(d.pop("byline"))
+
+        def _parse_published_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                published_at_type_0 = isoparse(data)
+
+                return published_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        published_at = _parse_published_at(d.pop("publishedAt"))
+
+        def _parse_og_url(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)
+
+        og_url = _parse_og_url(d.pop("ogUrl", UNSET))
+
+        def _parse_og_site_name(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)
+
+        og_site_name = _parse_og_site_name(d.pop("ogSiteName", UNSET))
+
+        def _parse_robots(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)
+
+        robots = _parse_robots(d.pop("robots", UNSET))
+
+        scrape_metadata = cls(
+            title=title,
+            description=description,
+            language=language,
+            canonical_url=canonical_url,
+            og_title=og_title,
+            og_description=og_description,
+            og_image=og_image,
+            byline=byline,
+            published_at=published_at,
+            og_url=og_url,
+            og_site_name=og_site_name,
+            robots=robots,
+        )
+
+        scrape_metadata.additional_properties = d
+        return scrape_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/scrape_queued_envelope.py

@@ -0,0 +1,124 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.scrape_queued_envelope_schema_version import (
+    ScrapeQueuedEnvelopeSchemaVersion,
+)
+from ..models.scrape_queued_envelope_status import ScrapeQueuedEnvelopeStatus
+
+T = TypeVar("T", bound="ScrapeQueuedEnvelope")
+
+
+@_attrs_define
+class ScrapeQueuedEnvelope:
+    """
+    Example:
+        {'schema_version': 1, 'status': 'queued', 'id': 'sc_01j9abc123', 'url': 'https://example.com', 'status_url':
+            'https://api.bytekit.com/v1/scrape/sc_01j9abc123', 'queued_at': datetime.datetime(2025, 1, 15, 12, 0,
+            tzinfo=datetime.timezone(datetime.timedelta(0), 'Z')), 'events': []}
+
+    Attributes:
+        schema_version (ScrapeQueuedEnvelopeSchemaVersion): Envelope contract version emitted by current producers.
+            Consumers reading persisted envelopes must tolerate its absence as legacy v0 during rolling deploys.
+        status (ScrapeQueuedEnvelopeStatus):
+        id (str): Stable job identifier (sc_… prefixed).
+        url (str):
+        status_url (str):
+        queued_at (datetime.datetime):
+        events (list[str]):
+    """
+
+    schema_version: ScrapeQueuedEnvelopeSchemaVersion
+    status: ScrapeQueuedEnvelopeStatus
+    id: str
+    url: str
+    status_url: str
+    queued_at: datetime.datetime
+    events: list[str]
+    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
+
+        status_url = self.status_url
+
+        queued_at = self.queued_at.isoformat()
+
+        events = self.events
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "schema_version": schema_version,
+                "status": status,
+                "id": id,
+                "url": url,
+                "status_url": status_url,
+                "queued_at": queued_at,
+                "events": events,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        schema_version = ScrapeQueuedEnvelopeSchemaVersion(d.pop("schema_version"))
+
+        status = ScrapeQueuedEnvelopeStatus(d.pop("status"))
+
+        id = d.pop("id")
+
+        url = d.pop("url")
+
+        status_url = d.pop("status_url")
+
+        queued_at = isoparse(d.pop("queued_at"))
+
+        events = cast(list[str], d.pop("events"))
+
+        scrape_queued_envelope = cls(
+            schema_version=schema_version,
+            status=status,
+            id=id,
+            url=url,
+            status_url=status_url,
+            queued_at=queued_at,
+            events=events,
+        )
+
+        scrape_queued_envelope.additional_properties = d
+        return scrape_queued_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_queued_envelope_schema_version.py

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

bytekit/models/scrape_queued_envelope_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ScrapeQueuedEnvelopeStatus(str, Enum):
+    QUEUED = "queued"
+
+    def __str__(self) -> str:
+        return str(self.value)