bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/account_session_response.py

@@ -0,0 +1,164 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.account_session_response_notifications import (
+        AccountSessionResponseNotifications,
+    )
+    from ..models.account_session_response_plan import AccountSessionResponsePlan
+
+
+T = TypeVar("T", bound="AccountSessionResponse")
+
+
+@_attrs_define
+class AccountSessionResponse:
+    """Minimal account shape returned by GET /v1/account when authenticated with a Clerk session JWT. Omits api_key,
+    subscription, and auto_topup.
+
+        Attributes:
+            id (str):
+            email (str):
+            name (Union[None, str]):
+            plan (AccountSessionResponsePlan):
+            owner_user_id (Union[None, str]): Prefixed user id of the calling admin user. Null for non-admin members.
+            notifications (AccountSessionResponseNotifications): Account notification preferences (bandwidth alerts).
+            terms_version (str): The Terms of Service version this account has accepted. An empty string means the account
+                predates clickwrap acceptance (issue #1025). The dashboard diffs this against the published current version to
+                decide whether to show the re-acceptance prompt.
+            created_at (datetime.datetime):
+            has_activity (bool): True once the account has ever recorded billable activity (any successful
+                scrape/screenshot/fetch/… request, regardless of whether it was authenticated with a Clerk session or an API
+                key). Powers the dashboard onboarding gate — the app shows the guided onboarding flow until this is true, then
+                the dashboard.
+    """
+
+    id: str
+    email: str
+    name: Union[None, str]
+    plan: "AccountSessionResponsePlan"
+    owner_user_id: Union[None, str]
+    notifications: "AccountSessionResponseNotifications"
+    terms_version: str
+    created_at: datetime.datetime
+    has_activity: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        email = self.email
+
+        name: Union[None, str]
+        name = self.name
+
+        plan = self.plan.to_dict()
+
+        owner_user_id: Union[None, str]
+        owner_user_id = self.owner_user_id
+
+        notifications = self.notifications.to_dict()
+
+        terms_version = self.terms_version
+
+        created_at = self.created_at.isoformat()
+
+        has_activity = self.has_activity
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "email": email,
+                "name": name,
+                "plan": plan,
+                "owner_user_id": owner_user_id,
+                "notifications": notifications,
+                "terms_version": terms_version,
+                "created_at": created_at,
+                "has_activity": has_activity,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.account_session_response_notifications import (
+            AccountSessionResponseNotifications,
+        )
+        from ..models.account_session_response_plan import AccountSessionResponsePlan
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        email = d.pop("email")
+
+        def _parse_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        name = _parse_name(d.pop("name"))
+
+        plan = AccountSessionResponsePlan.from_dict(d.pop("plan"))
+
+        def _parse_owner_user_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        owner_user_id = _parse_owner_user_id(d.pop("owner_user_id"))
+
+        notifications = AccountSessionResponseNotifications.from_dict(
+            d.pop("notifications")
+        )
+
+        terms_version = d.pop("terms_version")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        has_activity = d.pop("has_activity")
+
+        account_session_response = cls(
+            id=id,
+            email=email,
+            name=name,
+            plan=plan,
+            owner_user_id=owner_user_id,
+            notifications=notifications,
+            terms_version=terms_version,
+            created_at=created_at,
+            has_activity=has_activity,
+        )
+
+        account_session_response.additional_properties = d
+        return account_session_response
+
+    @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/account_session_response_notifications.py

@@ -0,0 +1,51 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="AccountSessionResponseNotifications")
+
+
+@_attrs_define
+class AccountSessionResponseNotifications:
+    """Account notification preferences (bandwidth alerts).
+
+    Attributes:
+        bandwidth_80_enabled (bool): Whether the account admin wants an email when bandwidth reaches 80 % of the plan
+            limit.
+        bandwidth_100_enabled (bool): Whether the account admin wants an email when bandwidth reaches 100 % of the plan
+            limit.
+    """
+
+    bandwidth_80_enabled: bool
+    bandwidth_100_enabled: bool
+
+    def to_dict(self) -> dict[str, Any]:
+        bandwidth_80_enabled = self.bandwidth_80_enabled
+
+        bandwidth_100_enabled = self.bandwidth_100_enabled
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "bandwidth_80_enabled": bandwidth_80_enabled,
+                "bandwidth_100_enabled": bandwidth_100_enabled,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        bandwidth_80_enabled = d.pop("bandwidth_80_enabled")
+
+        bandwidth_100_enabled = d.pop("bandwidth_100_enabled")
+
+        account_session_response_notifications = cls(
+            bandwidth_80_enabled=bandwidth_80_enabled,
+            bandwidth_100_enabled=bandwidth_100_enabled,
+        )
+
+        return account_session_response_notifications

bytekit/models/account_session_response_plan.py

@@ -0,0 +1,150 @@
+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="AccountSessionResponsePlan")
+
+
+@_attrs_define
+class AccountSessionResponsePlan:
+    """
+    Attributes:
+        id (str):
+        slug (str):
+        name (str):
+        included_screenshots (int):
+        has_overage (bool):
+        overage_price_cents (Union[None, int]):
+        max_concurrency (int):
+        rate_limit_per_sec (int):
+        max_bulk_size (int):
+        max_monitors (int):
+        retention_days (int):
+    """
+
+    id: str
+    slug: str
+    name: str
+    included_screenshots: int
+    has_overage: bool
+    overage_price_cents: Union[None, int]
+    max_concurrency: int
+    rate_limit_per_sec: int
+    max_bulk_size: int
+    max_monitors: int
+    retention_days: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        slug = self.slug
+
+        name = self.name
+
+        included_screenshots = self.included_screenshots
+
+        has_overage = self.has_overage
+
+        overage_price_cents: Union[None, int]
+        overage_price_cents = self.overage_price_cents
+
+        max_concurrency = self.max_concurrency
+
+        rate_limit_per_sec = self.rate_limit_per_sec
+
+        max_bulk_size = self.max_bulk_size
+
+        max_monitors = self.max_monitors
+
+        retention_days = self.retention_days
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "slug": slug,
+                "name": name,
+                "included_screenshots": included_screenshots,
+                "has_overage": has_overage,
+                "overage_price_cents": overage_price_cents,
+                "max_concurrency": max_concurrency,
+                "rate_limit_per_sec": rate_limit_per_sec,
+                "max_bulk_size": max_bulk_size,
+                "max_monitors": max_monitors,
+                "retention_days": retention_days,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        slug = d.pop("slug")
+
+        name = d.pop("name")
+
+        included_screenshots = d.pop("included_screenshots")
+
+        has_overage = d.pop("has_overage")
+
+        def _parse_overage_price_cents(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        overage_price_cents = _parse_overage_price_cents(d.pop("overage_price_cents"))
+
+        max_concurrency = d.pop("max_concurrency")
+
+        rate_limit_per_sec = d.pop("rate_limit_per_sec")
+
+        max_bulk_size = d.pop("max_bulk_size")
+
+        max_monitors = d.pop("max_monitors")
+
+        retention_days = d.pop("retention_days")
+
+        account_session_response_plan = cls(
+            id=id,
+            slug=slug,
+            name=name,
+            included_screenshots=included_screenshots,
+            has_overage=has_overage,
+            overage_price_cents=overage_price_cents,
+            max_concurrency=max_concurrency,
+            rate_limit_per_sec=rate_limit_per_sec,
+            max_bulk_size=max_bulk_size,
+            max_monitors=max_monitors,
+            retention_days=retention_days,
+        )
+
+        account_session_response_plan.additional_properties = d
+        return account_session_response_plan
+
+    @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/bandwidth_balance.py

@@ -0,0 +1,91 @@
+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="BandwidthBalance")
+
+
+@_attrs_define
+class BandwidthBalance:
+    """
+    Attributes:
+        used_bytes (int):
+        limit_bytes (int):
+        remaining_bytes (int):
+        topup_bytes (int):
+        rollover_bytes (int):
+    """
+
+    used_bytes: int
+    limit_bytes: int
+    remaining_bytes: int
+    topup_bytes: int
+    rollover_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        used_bytes = self.used_bytes
+
+        limit_bytes = self.limit_bytes
+
+        remaining_bytes = self.remaining_bytes
+
+        topup_bytes = self.topup_bytes
+
+        rollover_bytes = self.rollover_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "used_bytes": used_bytes,
+                "limit_bytes": limit_bytes,
+                "remaining_bytes": remaining_bytes,
+                "topup_bytes": topup_bytes,
+                "rollover_bytes": rollover_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        used_bytes = d.pop("used_bytes")
+
+        limit_bytes = d.pop("limit_bytes")
+
+        remaining_bytes = d.pop("remaining_bytes")
+
+        topup_bytes = d.pop("topup_bytes")
+
+        rollover_bytes = d.pop("rollover_bytes")
+
+        bandwidth_balance = cls(
+            used_bytes=used_bytes,
+            limit_bytes=limit_bytes,
+            remaining_bytes=remaining_bytes,
+            topup_bytes=topup_bytes,
+            rollover_bytes=rollover_bytes,
+        )
+
+        bandwidth_balance.additional_properties = d
+        return bandwidth_balance
+
+    @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/capture_response.py

@@ -0,0 +1,216 @@
+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.capture_response_outcome import CaptureResponseOutcome
+
+T = TypeVar("T", bound="CaptureResponse")
+
+
+@_attrs_define
+class CaptureResponse:
+    """
+    Attributes:
+        id (str):
+        monitor_id (str):
+        screenshot_id (Union[None, str]):
+        scrape_id (Union[None, str]):
+        image_url (Union[None, str]):
+        content_hash (Union[None, str]):
+        previous_hash (Union[None, str]):
+        hash_distance (Union[None, int]):
+        change_pct (Union[None, str]):
+        has_change (bool):
+        title_changed (Union[None, bool]):
+        outcome (CaptureResponseOutcome): Per-cycle terminal state. `captured` = the page was fetched and a
+            screenshot/scrape was stored (screenshot_id or scrape_id non-null). `preflight_unchanged` = the page was
+            unchanged since the previous check, so no new capture was taken (both target ids null). `preflight_failed` = the
+            check could not complete (the target returned an error or timed out); both target ids null. Defaults to
+            `captured` for older rows.
+        captured_at (datetime.datetime):
+    """
+
+    id: str
+    monitor_id: str
+    screenshot_id: Union[None, str]
+    scrape_id: Union[None, str]
+    image_url: Union[None, str]
+    content_hash: Union[None, str]
+    previous_hash: Union[None, str]
+    hash_distance: Union[None, int]
+    change_pct: Union[None, str]
+    has_change: bool
+    title_changed: Union[None, bool]
+    outcome: CaptureResponseOutcome
+    captured_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        monitor_id = self.monitor_id
+
+        screenshot_id: Union[None, str]
+        screenshot_id = self.screenshot_id
+
+        scrape_id: Union[None, str]
+        scrape_id = self.scrape_id
+
+        image_url: Union[None, str]
+        image_url = self.image_url
+
+        content_hash: Union[None, str]
+        content_hash = self.content_hash
+
+        previous_hash: Union[None, str]
+        previous_hash = self.previous_hash
+
+        hash_distance: Union[None, int]
+        hash_distance = self.hash_distance
+
+        change_pct: Union[None, str]
+        change_pct = self.change_pct
+
+        has_change = self.has_change
+
+        title_changed: Union[None, bool]
+        title_changed = self.title_changed
+
+        outcome = self.outcome.value
+
+        captured_at = self.captured_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "monitor_id": monitor_id,
+                "screenshot_id": screenshot_id,
+                "scrape_id": scrape_id,
+                "image_url": image_url,
+                "content_hash": content_hash,
+                "previous_hash": previous_hash,
+                "hash_distance": hash_distance,
+                "change_pct": change_pct,
+                "has_change": has_change,
+                "title_changed": title_changed,
+                "outcome": outcome,
+                "captured_at": captured_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        monitor_id = d.pop("monitor_id")
+
+        def _parse_screenshot_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        screenshot_id = _parse_screenshot_id(d.pop("screenshot_id"))
+
+        def _parse_scrape_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        scrape_id = _parse_scrape_id(d.pop("scrape_id"))
+
+        def _parse_image_url(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        image_url = _parse_image_url(d.pop("image_url"))
+
+        def _parse_content_hash(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        content_hash = _parse_content_hash(d.pop("content_hash"))
+
+        def _parse_previous_hash(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        previous_hash = _parse_previous_hash(d.pop("previous_hash"))
+
+        def _parse_hash_distance(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        hash_distance = _parse_hash_distance(d.pop("hash_distance"))
+
+        def _parse_change_pct(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        change_pct = _parse_change_pct(d.pop("change_pct"))
+
+        has_change = d.pop("has_change")
+
+        def _parse_title_changed(data: object) -> Union[None, bool]:
+            if data is None:
+                return data
+            return cast(Union[None, bool], data)
+
+        title_changed = _parse_title_changed(d.pop("title_changed"))
+
+        outcome = CaptureResponseOutcome(d.pop("outcome"))
+
+        captured_at = isoparse(d.pop("captured_at"))
+
+        capture_response = cls(
+            id=id,
+            monitor_id=monitor_id,
+            screenshot_id=screenshot_id,
+            scrape_id=scrape_id,
+            image_url=image_url,
+            content_hash=content_hash,
+            previous_hash=previous_hash,
+            hash_distance=hash_distance,
+            change_pct=change_pct,
+            has_change=has_change,
+            title_changed=title_changed,
+            outcome=outcome,
+            captured_at=captured_at,
+        )
+
+        capture_response.additional_properties = d
+        return capture_response
+
+    @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/capture_response_outcome.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CaptureResponseOutcome(str, Enum):
+    CAPTURED = "captured"
+    PREFLIGHT_FAILED = "preflight_failed"
+    PREFLIGHT_UNCHANGED = "preflight_unchanged"
+
+    def __str__(self) -> str:
+        return str(self.value)