bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/create_scrape_bulk_response_202.py

@@ -0,0 +1,166 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.create_scrape_bulk_response_202_status import (
+    CreateScrapeBulkResponse202Status,
+)
+
+T = TypeVar("T", bound="CreateScrapeBulkResponse202")
+
+
+@_attrs_define
+class CreateScrapeBulkResponse202:
+    """
+    Attributes:
+        id (str):  Example: bulk_01j9abc123.
+        status (CreateScrapeBulkResponse202Status):
+        total (int):
+        completed (int):
+        failed (int):
+        created_at (datetime.datetime):
+        completed_at (Union[None, datetime.datetime]):
+        total_credits_charged (int):
+        estimated_credits (Union[None, int]): Estimated credits at submission time. Null in GET responses.
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+    """
+
+    id: str
+    status: CreateScrapeBulkResponse202Status
+    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 = CreateScrapeBulkResponse202Status(d.pop("status"))
+
+        total = d.pop("total")
+
+        completed = d.pop("completed")
+
+        failed = d.pop("failed")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        def _parse_completed_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completed_at_type_0 = isoparse(data)
+
+                return completed_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        completed_at = _parse_completed_at(d.pop("completed_at"))
+
+        total_credits_charged = d.pop("total_credits_charged")
+
+        def _parse_estimated_credits(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        estimated_credits = _parse_estimated_credits(d.pop("estimated_credits"))
+
+        webhook_url = d.pop("webhook_url")
+
+        create_scrape_bulk_response_202 = cls(
+            id=id,
+            status=status,
+            total=total,
+            completed=completed,
+            failed=failed,
+            created_at=created_at,
+            completed_at=completed_at,
+            total_credits_charged=total_credits_charged,
+            estimated_credits=estimated_credits,
+            webhook_url=webhook_url,
+        )
+
+        create_scrape_bulk_response_202.additional_properties = d
+        return create_scrape_bulk_response_202
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/create_scrape_bulk_response_202_status.py

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

bytekit/models/create_search_body.py

@@ -0,0 +1,140 @@
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.create_search_body_date_range import CreateSearchBodyDateRange
+from ..models.create_search_body_type import CreateSearchBodyType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateSearchBody")
+
+
+@_attrs_define
+class CreateSearchBody:
+    """
+    Attributes:
+        query (str): The search query.
+        type_ (Union[Unset, CreateSearchBodyType]): Which search index to query. `web` (default) returns ranked organic
+            results; `news` returns news articles in the same `results` array, additionally populating `source` and `image`
+            on each item; `images` returns image results, populating `source`, `domain`, and a fuller `image` object (full-
+            image dimensions plus a thumbnail URL and dimensions) while omitting `snippet` and `date`. Billing is identical
+            for all three.
+             Default: CreateSearchBodyType.WEB.
+        limit (Union[Unset, int]): Maximum number of organic results to return. Results are fetched in pages of 10, so
+            the call costs `ceil(limit / 10)` credits (capped at 10).
+             Default: 10.
+        country (Union[Unset, str]): Two-letter country code to localize results (e.g. `us`, `de`), normalized to
+            lowercase. Defaults to `us`.
+             Default: 'us'.
+        language (Union[Unset, str]): Two-letter ISO-639-1 language code for results (e.g. `en`, `fr`), normalized to
+            lowercase. Defaults to `en`.
+             Default: 'en'.
+        date_range (Union[Unset, CreateSearchBodyDateRange]): Restrict results to a recency window: `any` (default, no
+            time filter), `hour` (past hour), `day` (past 24 hours), `week` (past week), `month` (past month), or `year`
+            (past year). Applies identically to every `type`; billing is unchanged.
+             Default: CreateSearchBodyDateRange.ANY.
+    """
+
+    query: str
+    type_: Union[Unset, CreateSearchBodyType] = CreateSearchBodyType.WEB
+    limit: Union[Unset, int] = 10
+    country: Union[Unset, str] = "us"
+    language: Union[Unset, str] = "en"
+    date_range: Union[Unset, CreateSearchBodyDateRange] = CreateSearchBodyDateRange.ANY
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        limit = self.limit
+
+        country = self.country
+
+        language = self.language
+
+        date_range: Union[Unset, str] = UNSET
+        if not isinstance(self.date_range, Unset):
+            date_range = self.date_range.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "query": query,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if country is not UNSET:
+            field_dict["country"] = country
+        if language is not UNSET:
+            field_dict["language"] = language
+        if date_range is not UNSET:
+            field_dict["date_range"] = date_range
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        query = d.pop("query")
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, CreateSearchBodyType]
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = CreateSearchBodyType(_type_)
+
+        limit = d.pop("limit", UNSET)
+
+        country = d.pop("country", UNSET)
+
+        language = d.pop("language", UNSET)
+
+        _date_range = d.pop("date_range", UNSET)
+        date_range: Union[Unset, CreateSearchBodyDateRange]
+        if isinstance(_date_range, Unset):
+            date_range = UNSET
+        else:
+            date_range = CreateSearchBodyDateRange(_date_range)
+
+        create_search_body = cls(
+            query=query,
+            type_=type_,
+            limit=limit,
+            country=country,
+            language=language,
+            date_range=date_range,
+        )
+
+        create_search_body.additional_properties = d
+        return create_search_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/create_search_body_date_range.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class CreateSearchBodyDateRange(str, Enum):
+    ANY = "any"
+    DAY = "day"
+    HOUR = "hour"
+    MONTH = "month"
+    WEEK = "week"
+    YEAR = "year"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_search_body_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CreateSearchBodyType(str, Enum):
+    IMAGES = "images"
+    NEWS = "news"
+    WEB = "web"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/create_search_response_200.py

@@ -0,0 +1,119 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.create_search_response_200_results_item import (
+        CreateSearchResponse200ResultsItem,
+    )
+
+
+T = TypeVar("T", bound="CreateSearchResponse200")
+
+
+@_attrs_define
+class CreateSearchResponse200:
+    """
+    Attributes:
+        id (str): Stable search identifier (prefixed `sr_`).
+        query (str): The query that was searched.
+        results (list['CreateSearchResponse200ResultsItem']): Ranked organic results merged across the fetched pages,
+            re-indexed so `position` runs contiguously from 1, and truncated to `limit`.
+        related_searches (list[str]): Related query suggestions surfaced by the search provider, merged and de-
+            duplicated across the fetched pages. Empty when the provider returns none.
+        credits_used (int): Credits consumed by this search call, equal to the number of pages fetched (`ceil(limit /
+            10)`, capped at 10).
+    """
+
+    id: str
+    query: str
+    results: list["CreateSearchResponse200ResultsItem"]
+    related_searches: list[str]
+    credits_used: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        query = self.query
+
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+        related_searches = self.related_searches
+
+        credits_used = self.credits_used
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "query": query,
+                "results": results,
+                "related_searches": related_searches,
+                "credits_used": credits_used,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_search_response_200_results_item import (
+            CreateSearchResponse200ResultsItem,
+        )
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        query = d.pop("query")
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = CreateSearchResponse200ResultsItem.from_dict(
+                results_item_data
+            )
+
+            results.append(results_item)
+
+        related_searches = cast(list[str], d.pop("related_searches"))
+
+        credits_used = d.pop("credits_used")
+
+        create_search_response_200 = cls(
+            id=id,
+            query=query,
+            results=results,
+            related_searches=related_searches,
+            credits_used=credits_used,
+        )
+
+        create_search_response_200.additional_properties = d
+        return create_search_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/create_search_response_200_results_item.py

@@ -0,0 +1,161 @@
+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.create_search_response_200_results_item_image import (
+        CreateSearchResponse200ResultsItemImage,
+    )
+
+
+T = TypeVar("T", bound="CreateSearchResponse200ResultsItem")
+
+
+@_attrs_define
+class CreateSearchResponse200ResultsItem:
+    """
+    Attributes:
+        position (int): 1-based rank of the result.
+        title (str):
+        url (str):
+        snippet (str): Short text excerpt for the result. Present for `web` and `news` results; omitted for `images`
+            results.
+        date (Union[None, Unset, str]): Published date of the result. For `web` and `news` results the key is always
+            present but is `null` when the provider reports no date; omitted entirely for `images` results.
+        source (Union[Unset, str]): Publisher / source name. Present for `news` and `images` results, when the provider
+            reports one.
+        domain (Union[Unset, str]): Hosting-page domain of the result. Present only for `images` results, when the
+            provider reports one.
+        image (Union[Unset, CreateSearchResponse200ResultsItemImage]): Image attached to the result. For `news` results
+            this is the thumbnail (only `url`). For `images` results it is the full image, additionally carrying its
+            dimensions and a thumbnail URL + dimensions. Each field past `url` is present only when the provider reports it.
+    """
+
+    position: int
+    title: str
+    url: str
+    snippet: str
+    date: Union[None, Unset, str] = UNSET
+    source: Union[Unset, str] = UNSET
+    domain: Union[Unset, str] = UNSET
+    image: Union[Unset, "CreateSearchResponse200ResultsItemImage"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        position = self.position
+
+        title = self.title
+
+        url = self.url
+
+        snippet = self.snippet
+
+        date: Union[None, Unset, str]
+        if isinstance(self.date, Unset):
+            date = UNSET
+        else:
+            date = self.date
+
+        source = self.source
+
+        domain = self.domain
+
+        image: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.image, Unset):
+            image = self.image.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "position": position,
+                "title": title,
+                "url": url,
+                "snippet": snippet,
+            }
+        )
+        if date is not UNSET:
+            field_dict["date"] = date
+        if source is not UNSET:
+            field_dict["source"] = source
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if image is not UNSET:
+            field_dict["image"] = image
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_search_response_200_results_item_image import (
+            CreateSearchResponse200ResultsItemImage,
+        )
+
+        d = dict(src_dict)
+        position = d.pop("position")
+
+        title = d.pop("title")
+
+        url = d.pop("url")
+
+        snippet = d.pop("snippet")
+
+        def _parse_date(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)
+
+        date = _parse_date(d.pop("date", UNSET))
+
+        source = d.pop("source", UNSET)
+
+        domain = d.pop("domain", UNSET)
+
+        _image = d.pop("image", UNSET)
+        image: Union[Unset, CreateSearchResponse200ResultsItemImage]
+        if isinstance(_image, Unset):
+            image = UNSET
+        else:
+            image = CreateSearchResponse200ResultsItemImage.from_dict(_image)
+
+        create_search_response_200_results_item = cls(
+            position=position,
+            title=title,
+            url=url,
+            snippet=snippet,
+            date=date,
+            source=source,
+            domain=domain,
+            image=image,
+        )
+
+        create_search_response_200_results_item.additional_properties = d
+        return create_search_response_200_results_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties