bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/get_scrape_bulk_response_200.py

@@ -0,0 +1,164 @@
+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.get_scrape_bulk_response_200_status import GetScrapeBulkResponse200Status
+
+T = TypeVar("T", bound="GetScrapeBulkResponse200")
+
+
+@_attrs_define
+class GetScrapeBulkResponse200:
+    """
+    Attributes:
+        id (str):  Example: bulk_01j9abc123.
+        status (GetScrapeBulkResponse200Status):
+        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]): Null in GET responses (computed at submission time only).
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+    """
+
+    id: str
+    status: GetScrapeBulkResponse200Status
+    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 = GetScrapeBulkResponse200Status(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")
+
+        get_scrape_bulk_response_200 = 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,
+        )
+
+        get_scrape_bulk_response_200.additional_properties = d
+        return get_scrape_bulk_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_scrape_bulk_response_200_status.py

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

bytekit/models/get_usage_by_endpoint_response_200.py

@@ -0,0 +1,114 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.get_usage_by_endpoint_response_200_rows_item import (
+        GetUsageByEndpointResponse200RowsItem,
+    )
+    from ..models.get_usage_by_endpoint_response_200_totals import (
+        GetUsageByEndpointResponse200Totals,
+    )
+
+
+T = TypeVar("T", bound="GetUsageByEndpointResponse200")
+
+
+@_attrs_define
+class GetUsageByEndpointResponse200:
+    """
+    Attributes:
+        from_ (datetime.date):
+        to (datetime.date):
+        rows (list['GetUsageByEndpointResponse200RowsItem']): One entry per endpoint with non-zero usage in the range.
+            Zero-byte endpoints are omitted.
+        totals (GetUsageByEndpointResponse200Totals):
+    """
+
+    from_: datetime.date
+    to: datetime.date
+    rows: list["GetUsageByEndpointResponse200RowsItem"]
+    totals: "GetUsageByEndpointResponse200Totals"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from_ = self.from_.isoformat()
+
+        to = self.to.isoformat()
+
+        rows = []
+        for rows_item_data in self.rows:
+            rows_item = rows_item_data.to_dict()
+            rows.append(rows_item)
+
+        totals = self.totals.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "from": from_,
+                "to": to,
+                "rows": rows,
+                "totals": totals,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.get_usage_by_endpoint_response_200_rows_item import (
+            GetUsageByEndpointResponse200RowsItem,
+        )
+        from ..models.get_usage_by_endpoint_response_200_totals import (
+            GetUsageByEndpointResponse200Totals,
+        )
+
+        d = dict(src_dict)
+        from_ = isoparse(d.pop("from")).date()
+
+        to = isoparse(d.pop("to")).date()
+
+        rows = []
+        _rows = d.pop("rows")
+        for rows_item_data in _rows:
+            rows_item = GetUsageByEndpointResponse200RowsItem.from_dict(rows_item_data)
+
+            rows.append(rows_item)
+
+        totals = GetUsageByEndpointResponse200Totals.from_dict(d.pop("totals"))
+
+        get_usage_by_endpoint_response_200 = cls(
+            from_=from_,
+            to=to,
+            rows=rows,
+            totals=totals,
+        )
+
+        get_usage_by_endpoint_response_200.additional_properties = d
+        return get_usage_by_endpoint_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_by_endpoint_response_200_rows_item.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.get_usage_by_endpoint_response_200_rows_item_endpoint import (
+    GetUsageByEndpointResponse200RowsItemEndpoint,
+)
+
+T = TypeVar("T", bound="GetUsageByEndpointResponse200RowsItem")
+
+
+@_attrs_define
+class GetUsageByEndpointResponse200RowsItem:
+    """
+    Attributes:
+        endpoint (GetUsageByEndpointResponse200RowsItemEndpoint):
+        raw_bytes (int): Raw upstream wire bytes for the endpoint. Screenshot and recording rows created before issue
+            2179 may reflect legacy billable Phase 1 bytes because exact raw totals cannot be recovered after per-job
+            rounding.
+        multiplier (float): Billing multiplier applied to raw bytes (e.g. 1.5 for
+            screenshots/recordings/scrape_md/crawl, 1.0 otherwise).
+        billable_bytes (int): raw_bytes × multiplier, rounded.
+    """
+
+    endpoint: GetUsageByEndpointResponse200RowsItemEndpoint
+    raw_bytes: int
+    multiplier: float
+    billable_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        endpoint = self.endpoint.value
+
+        raw_bytes = self.raw_bytes
+
+        multiplier = self.multiplier
+
+        billable_bytes = self.billable_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "endpoint": endpoint,
+                "raw_bytes": raw_bytes,
+                "multiplier": multiplier,
+                "billable_bytes": billable_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        endpoint = GetUsageByEndpointResponse200RowsItemEndpoint(d.pop("endpoint"))
+
+        raw_bytes = d.pop("raw_bytes")
+
+        multiplier = d.pop("multiplier")
+
+        billable_bytes = d.pop("billable_bytes")
+
+        get_usage_by_endpoint_response_200_rows_item = cls(
+            endpoint=endpoint,
+            raw_bytes=raw_bytes,
+            multiplier=multiplier,
+            billable_bytes=billable_bytes,
+        )
+
+        get_usage_by_endpoint_response_200_rows_item.additional_properties = d
+        return get_usage_by_endpoint_response_200_rows_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_by_endpoint_response_200_rows_item_endpoint.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class GetUsageByEndpointResponse200RowsItemEndpoint(str, Enum):
+    CRAWL = "crawl"
+    CRAWL_LINKS = "crawl_links"
+    FETCH = "fetch"
+    FETCH_MD = "fetch_md"
+    MONITORS = "monitors"
+    RECORDINGS = "recordings"
+    SCRAPE = "scrape"
+    SCRAPE_MD = "scrape_md"
+    SCREENSHOTS = "screenshots"
+    SITEMAP = "sitemap"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/get_usage_by_endpoint_response_200_totals.py

@@ -0,0 +1,67 @@
+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="GetUsageByEndpointResponse200Totals")
+
+
+@_attrs_define
+class GetUsageByEndpointResponse200Totals:
+    """
+    Attributes:
+        raw_bytes (int):
+        billable_bytes (int):
+    """
+
+    raw_bytes: int
+    billable_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        raw_bytes = self.raw_bytes
+
+        billable_bytes = self.billable_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "raw_bytes": raw_bytes,
+                "billable_bytes": billable_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        raw_bytes = d.pop("raw_bytes")
+
+        billable_bytes = d.pop("billable_bytes")
+
+        get_usage_by_endpoint_response_200_totals = cls(
+            raw_bytes=raw_bytes,
+            billable_bytes=billable_bytes,
+        )
+
+        get_usage_by_endpoint_response_200_totals.additional_properties = d
+        return get_usage_by_endpoint_response_200_totals
+
+    @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_daily_response_200.py

@@ -0,0 +1,97 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.get_usage_daily_response_200_data_item import (
+        GetUsageDailyResponse200DataItem,
+    )
+
+
+T = TypeVar("T", bound="GetUsageDailyResponse200")
+
+
+@_attrs_define
+class GetUsageDailyResponse200:
+    """
+    Attributes:
+        from_ (str):
+        to (str):
+        data (list['GetUsageDailyResponse200DataItem']):
+    """
+
+    from_: str
+    to: str
+    data: list["GetUsageDailyResponse200DataItem"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from_ = self.from_
+
+        to = self.to
+
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "from": from_,
+                "to": to,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.get_usage_daily_response_200_data_item import (
+            GetUsageDailyResponse200DataItem,
+        )
+
+        d = dict(src_dict)
+        from_ = d.pop("from")
+
+        to = d.pop("to")
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = GetUsageDailyResponse200DataItem.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        get_usage_daily_response_200 = cls(
+            from_=from_,
+            to=to,
+            data=data,
+        )
+
+        get_usage_daily_response_200.additional_properties = d
+        return get_usage_daily_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