bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/get_usage_daily_response_200_data_item.py

@@ -0,0 +1,219 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="GetUsageDailyResponse200DataItem")
+
+
+@_attrs_define
+class GetUsageDailyResponse200DataItem:
+    """
+    Attributes:
+        date (datetime.date):
+        credits_single (int):
+        credits_bulk (int):
+        credits_monitor (int):
+        credits_search (int): Credits consumed by the search endpoint on this day.
+        credits_total (int):
+        bytes_total (int): Total bytes consumed on this day.
+        bytes_single (int): Bytes from single scrape requests.
+        bytes_bulk (int): Bytes from bulk requests.
+        bytes_scrape (int): Bytes from scrape requests.
+        bytes_monitor (int): Bytes from monitor requests.
+        bytes_screenshot (Union[Unset, int]): Bytes from screenshot requests.
+        bytes_recording (Union[Unset, int]): Bytes from recording requests.
+        bytes_scrape_md (Union[Unset, int]): Bytes from markdown-requested scrape requests.
+        bytes_fetch (Union[Unset, int]): Bytes from /v1/fetch requests.
+        bytes_fetch_md (Union[Unset, int]): Bytes from markdown-requested /v1/fetch requests.
+        bytes_crawl (Union[Unset, int]): Bytes from crawl (fetch) requests.
+        bytes_crawl_links (Union[Unset, int]): Bytes from crawl-links requests.
+        bytes_sitemap (Union[Unset, int]): Bytes from sitemap requests.
+    """
+
+    date: datetime.date
+    credits_single: int
+    credits_bulk: int
+    credits_monitor: int
+    credits_search: int
+    credits_total: int
+    bytes_total: int
+    bytes_single: int
+    bytes_bulk: int
+    bytes_scrape: int
+    bytes_monitor: int
+    bytes_screenshot: Union[Unset, int] = UNSET
+    bytes_recording: Union[Unset, int] = UNSET
+    bytes_scrape_md: Union[Unset, int] = UNSET
+    bytes_fetch: Union[Unset, int] = UNSET
+    bytes_fetch_md: Union[Unset, int] = UNSET
+    bytes_crawl: Union[Unset, int] = UNSET
+    bytes_crawl_links: Union[Unset, int] = UNSET
+    bytes_sitemap: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        date = self.date.isoformat()
+
+        credits_single = self.credits_single
+
+        credits_bulk = self.credits_bulk
+
+        credits_monitor = self.credits_monitor
+
+        credits_search = self.credits_search
+
+        credits_total = self.credits_total
+
+        bytes_total = self.bytes_total
+
+        bytes_single = self.bytes_single
+
+        bytes_bulk = self.bytes_bulk
+
+        bytes_scrape = self.bytes_scrape
+
+        bytes_monitor = self.bytes_monitor
+
+        bytes_screenshot = self.bytes_screenshot
+
+        bytes_recording = self.bytes_recording
+
+        bytes_scrape_md = self.bytes_scrape_md
+
+        bytes_fetch = self.bytes_fetch
+
+        bytes_fetch_md = self.bytes_fetch_md
+
+        bytes_crawl = self.bytes_crawl
+
+        bytes_crawl_links = self.bytes_crawl_links
+
+        bytes_sitemap = self.bytes_sitemap
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "date": date,
+                "credits_single": credits_single,
+                "credits_bulk": credits_bulk,
+                "credits_monitor": credits_monitor,
+                "credits_search": credits_search,
+                "credits_total": credits_total,
+                "bytes_total": bytes_total,
+                "bytes_single": bytes_single,
+                "bytes_bulk": bytes_bulk,
+                "bytes_scrape": bytes_scrape,
+                "bytes_monitor": bytes_monitor,
+            }
+        )
+        if bytes_screenshot is not UNSET:
+            field_dict["bytes_screenshot"] = bytes_screenshot
+        if bytes_recording is not UNSET:
+            field_dict["bytes_recording"] = bytes_recording
+        if bytes_scrape_md is not UNSET:
+            field_dict["bytes_scrape_md"] = bytes_scrape_md
+        if bytes_fetch is not UNSET:
+            field_dict["bytes_fetch"] = bytes_fetch
+        if bytes_fetch_md is not UNSET:
+            field_dict["bytes_fetch_md"] = bytes_fetch_md
+        if bytes_crawl is not UNSET:
+            field_dict["bytes_crawl"] = bytes_crawl
+        if bytes_crawl_links is not UNSET:
+            field_dict["bytes_crawl_links"] = bytes_crawl_links
+        if bytes_sitemap is not UNSET:
+            field_dict["bytes_sitemap"] = bytes_sitemap
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        date = isoparse(d.pop("date")).date()
+
+        credits_single = d.pop("credits_single")
+
+        credits_bulk = d.pop("credits_bulk")
+
+        credits_monitor = d.pop("credits_monitor")
+
+        credits_search = d.pop("credits_search")
+
+        credits_total = d.pop("credits_total")
+
+        bytes_total = d.pop("bytes_total")
+
+        bytes_single = d.pop("bytes_single")
+
+        bytes_bulk = d.pop("bytes_bulk")
+
+        bytes_scrape = d.pop("bytes_scrape")
+
+        bytes_monitor = d.pop("bytes_monitor")
+
+        bytes_screenshot = d.pop("bytes_screenshot", UNSET)
+
+        bytes_recording = d.pop("bytes_recording", UNSET)
+
+        bytes_scrape_md = d.pop("bytes_scrape_md", UNSET)
+
+        bytes_fetch = d.pop("bytes_fetch", UNSET)
+
+        bytes_fetch_md = d.pop("bytes_fetch_md", UNSET)
+
+        bytes_crawl = d.pop("bytes_crawl", UNSET)
+
+        bytes_crawl_links = d.pop("bytes_crawl_links", UNSET)
+
+        bytes_sitemap = d.pop("bytes_sitemap", UNSET)
+
+        get_usage_daily_response_200_data_item = cls(
+            date=date,
+            credits_single=credits_single,
+            credits_bulk=credits_bulk,
+            credits_monitor=credits_monitor,
+            credits_search=credits_search,
+            credits_total=credits_total,
+            bytes_total=bytes_total,
+            bytes_single=bytes_single,
+            bytes_bulk=bytes_bulk,
+            bytes_scrape=bytes_scrape,
+            bytes_monitor=bytes_monitor,
+            bytes_screenshot=bytes_screenshot,
+            bytes_recording=bytes_recording,
+            bytes_scrape_md=bytes_scrape_md,
+            bytes_fetch=bytes_fetch,
+            bytes_fetch_md=bytes_fetch_md,
+            bytes_crawl=bytes_crawl,
+            bytes_crawl_links=bytes_crawl_links,
+            bytes_sitemap=bytes_sitemap,
+        )
+
+        get_usage_daily_response_200_data_item.additional_properties = d
+        return get_usage_daily_response_200_data_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

bytekit/models/get_usage_response_200.py

@@ -0,0 +1,344 @@
+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.get_usage_response_200_plan_type import GetUsageResponse200PlanType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.bandwidth_balance import BandwidthBalance
+    from ..models.credit_balance import CreditBalance
+
+
+T = TypeVar("T", bound="GetUsageResponse200")
+
+
+@_attrs_define
+class GetUsageResponse200:
+    """
+    Attributes:
+        period_start (datetime.datetime):
+        period_end (datetime.datetime):
+        credits_used (int):
+        credits_single (int):
+        credits_bulk (int):
+        credits_monitor (int):
+        credits_search (int): Credits consumed by the search endpoint this billing period. Reported as a distinct line
+            item, not folded into other per-source credit counts.
+        credits_limit (int):
+        credits_remaining (int):
+        has_overage (bool):
+        overage_credits (int):
+        plan_name (str): Human-readable plan name (e.g. "Starter", "Pro").
+        plan_price_cents (int): Plan base price in cents.
+        plan_type (GetUsageResponse200PlanType): Derived plan category. "payg" for pay-as-you-go plans, "free" for the
+            free tier, "subscription" for all others.
+        period_days_elapsed (int): Days elapsed since period_start.
+        bytes_used (int): Present in dual/bytes billing mode.
+        bytes_single (int):
+        bytes_bulk (int):
+        bytes_scrape (int):
+        bytes_monitor (int):
+        bytes_limit (int):
+        bytes_remaining (int):
+        rollover_bytes (int):
+        topup_bytes (int):
+        request_count (int): Total API requests in the current billing period.
+        request_count_previous_period (Union[None, int]): Total API requests in the previous billing period. Null when
+            no prior period exists (first billing period).
+        playground_api_key_id (Union[None, str]): The account's playground API key id (ak_-prefixed), or null if none
+            exists. Playground traffic (requests issued from the dashboard playground) is billed into the account totals
+            under this key, but the key is hidden from the key-management list. The usage dashboard uses this id to offer a
+            "Playground" filter so per-key usage reconciles with the overall total.
+        bandwidth (BandwidthBalance):
+        credits_ (CreditBalance):
+        topup_spent_cents (Union[Unset, int]): Total top-up spend in cents for this billing period. Present only in
+            dual/bytes billing mode.
+        topup_balance_bytes (Union[Unset, int]): Remaining top-up bytes: max(0, topup_bytes − max(0, bytes_used −
+            included_bytes − rollover_bytes)). Present only in dual/bytes billing mode.
+    """
+
+    period_start: datetime.datetime
+    period_end: datetime.datetime
+    credits_used: int
+    credits_single: int
+    credits_bulk: int
+    credits_monitor: int
+    credits_search: int
+    credits_limit: int
+    credits_remaining: int
+    has_overage: bool
+    overage_credits: int
+    plan_name: str
+    plan_price_cents: int
+    plan_type: GetUsageResponse200PlanType
+    period_days_elapsed: int
+    bytes_used: int
+    bytes_single: int
+    bytes_bulk: int
+    bytes_scrape: int
+    bytes_monitor: int
+    bytes_limit: int
+    bytes_remaining: int
+    rollover_bytes: int
+    topup_bytes: int
+    request_count: int
+    request_count_previous_period: Union[None, int]
+    playground_api_key_id: Union[None, str]
+    bandwidth: "BandwidthBalance"
+    credits_: "CreditBalance"
+    topup_spent_cents: Union[Unset, int] = UNSET
+    topup_balance_bytes: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        period_start = self.period_start.isoformat()
+
+        period_end = self.period_end.isoformat()
+
+        credits_used = self.credits_used
+
+        credits_single = self.credits_single
+
+        credits_bulk = self.credits_bulk
+
+        credits_monitor = self.credits_monitor
+
+        credits_search = self.credits_search
+
+        credits_limit = self.credits_limit
+
+        credits_remaining = self.credits_remaining
+
+        has_overage = self.has_overage
+
+        overage_credits = self.overage_credits
+
+        plan_name = self.plan_name
+
+        plan_price_cents = self.plan_price_cents
+
+        plan_type = self.plan_type.value
+
+        period_days_elapsed = self.period_days_elapsed
+
+        bytes_used = self.bytes_used
+
+        bytes_single = self.bytes_single
+
+        bytes_bulk = self.bytes_bulk
+
+        bytes_scrape = self.bytes_scrape
+
+        bytes_monitor = self.bytes_monitor
+
+        bytes_limit = self.bytes_limit
+
+        bytes_remaining = self.bytes_remaining
+
+        rollover_bytes = self.rollover_bytes
+
+        topup_bytes = self.topup_bytes
+
+        request_count = self.request_count
+
+        request_count_previous_period: Union[None, int]
+        request_count_previous_period = self.request_count_previous_period
+
+        playground_api_key_id: Union[None, str]
+        playground_api_key_id = self.playground_api_key_id
+
+        bandwidth = self.bandwidth.to_dict()
+
+        credits_ = self.credits_.to_dict()
+
+        topup_spent_cents = self.topup_spent_cents
+
+        topup_balance_bytes = self.topup_balance_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "period_start": period_start,
+                "period_end": period_end,
+                "credits_used": credits_used,
+                "credits_single": credits_single,
+                "credits_bulk": credits_bulk,
+                "credits_monitor": credits_monitor,
+                "credits_search": credits_search,
+                "credits_limit": credits_limit,
+                "credits_remaining": credits_remaining,
+                "has_overage": has_overage,
+                "overage_credits": overage_credits,
+                "plan_name": plan_name,
+                "plan_price_cents": plan_price_cents,
+                "plan_type": plan_type,
+                "period_days_elapsed": period_days_elapsed,
+                "bytes_used": bytes_used,
+                "bytes_single": bytes_single,
+                "bytes_bulk": bytes_bulk,
+                "bytes_scrape": bytes_scrape,
+                "bytes_monitor": bytes_monitor,
+                "bytes_limit": bytes_limit,
+                "bytes_remaining": bytes_remaining,
+                "rollover_bytes": rollover_bytes,
+                "topup_bytes": topup_bytes,
+                "request_count": request_count,
+                "request_count_previous_period": request_count_previous_period,
+                "playground_api_key_id": playground_api_key_id,
+                "bandwidth": bandwidth,
+                "credits": credits_,
+            }
+        )
+        if topup_spent_cents is not UNSET:
+            field_dict["topup_spent_cents"] = topup_spent_cents
+        if topup_balance_bytes is not UNSET:
+            field_dict["topup_balance_bytes"] = topup_balance_bytes
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bandwidth_balance import BandwidthBalance
+        from ..models.credit_balance import CreditBalance
+
+        d = dict(src_dict)
+        period_start = isoparse(d.pop("period_start"))
+
+        period_end = isoparse(d.pop("period_end"))
+
+        credits_used = d.pop("credits_used")
+
+        credits_single = d.pop("credits_single")
+
+        credits_bulk = d.pop("credits_bulk")
+
+        credits_monitor = d.pop("credits_monitor")
+
+        credits_search = d.pop("credits_search")
+
+        credits_limit = d.pop("credits_limit")
+
+        credits_remaining = d.pop("credits_remaining")
+
+        has_overage = d.pop("has_overage")
+
+        overage_credits = d.pop("overage_credits")
+
+        plan_name = d.pop("plan_name")
+
+        plan_price_cents = d.pop("plan_price_cents")
+
+        plan_type = GetUsageResponse200PlanType(d.pop("plan_type"))
+
+        period_days_elapsed = d.pop("period_days_elapsed")
+
+        bytes_used = d.pop("bytes_used")
+
+        bytes_single = d.pop("bytes_single")
+
+        bytes_bulk = d.pop("bytes_bulk")
+
+        bytes_scrape = d.pop("bytes_scrape")
+
+        bytes_monitor = d.pop("bytes_monitor")
+
+        bytes_limit = d.pop("bytes_limit")
+
+        bytes_remaining = d.pop("bytes_remaining")
+
+        rollover_bytes = d.pop("rollover_bytes")
+
+        topup_bytes = d.pop("topup_bytes")
+
+        request_count = d.pop("request_count")
+
+        def _parse_request_count_previous_period(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        request_count_previous_period = _parse_request_count_previous_period(
+            d.pop("request_count_previous_period")
+        )
+
+        def _parse_playground_api_key_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        playground_api_key_id = _parse_playground_api_key_id(
+            d.pop("playground_api_key_id")
+        )
+
+        bandwidth = BandwidthBalance.from_dict(d.pop("bandwidth"))
+
+        credits_ = CreditBalance.from_dict(d.pop("credits"))
+
+        topup_spent_cents = d.pop("topup_spent_cents", UNSET)
+
+        topup_balance_bytes = d.pop("topup_balance_bytes", UNSET)
+
+        get_usage_response_200 = cls(
+            period_start=period_start,
+            period_end=period_end,
+            credits_used=credits_used,
+            credits_single=credits_single,
+            credits_bulk=credits_bulk,
+            credits_monitor=credits_monitor,
+            credits_search=credits_search,
+            credits_limit=credits_limit,
+            credits_remaining=credits_remaining,
+            has_overage=has_overage,
+            overage_credits=overage_credits,
+            plan_name=plan_name,
+            plan_price_cents=plan_price_cents,
+            plan_type=plan_type,
+            period_days_elapsed=period_days_elapsed,
+            bytes_used=bytes_used,
+            bytes_single=bytes_single,
+            bytes_bulk=bytes_bulk,
+            bytes_scrape=bytes_scrape,
+            bytes_monitor=bytes_monitor,
+            bytes_limit=bytes_limit,
+            bytes_remaining=bytes_remaining,
+            rollover_bytes=rollover_bytes,
+            topup_bytes=topup_bytes,
+            request_count=request_count,
+            request_count_previous_period=request_count_previous_period,
+            playground_api_key_id=playground_api_key_id,
+            bandwidth=bandwidth,
+            credits_=credits_,
+            topup_spent_cents=topup_spent_cents,
+            topup_balance_bytes=topup_balance_bytes,
+        )
+
+        get_usage_response_200.additional_properties = d
+        return get_usage_response_200
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/get_usage_response_200_plan_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class GetUsageResponse200PlanType(str, Enum):
+    FREE = "free"
+    PAYG = "payg"
+    SUBSCRIPTION = "subscription"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/list_bulk_screenshots_response_200.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ListBulkScreenshotsResponse200")
+
+
+@_attrs_define
+class ListBulkScreenshotsResponse200:
+    """ """
+
+    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)
+        list_bulk_screenshots_response_200 = cls()
+
+        list_bulk_screenshots_response_200.additional_properties = d
+        return list_bulk_screenshots_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