parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/indexeddb/functions.py

@@ -0,0 +1,232 @@
+"""Commands for the IndexedDB domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        DataEntry,
+        DatabaseWithObjectStores,
+        KeyRange,
+    )
+    from ..storage.types import StorageBucket as Storage_StorageBucket
+
+@dataclass
+class RequestDataReturn(DataType):
+    """Return value of :meth:`IndexedDB.request_data`."""
+    object_store_data_entries: List[DataEntry]
+    has_more: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('object_store_data_entries', 'objectStoreDataEntries', False, 'array', inner=FieldMeta('', '', False, 'object', ref='IndexedDB.DataEntry')),
+        FieldMeta('has_more', 'hasMore', False, 'primitive'),
+    )
+
+
+@dataclass
+class GetMetadataReturn(DataType):
+    """Return value of :meth:`IndexedDB.get_metadata`."""
+    entries_count: float
+    key_generator_value: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('entries_count', 'entriesCount', False, 'primitive'),
+        FieldMeta('key_generator_value', 'keyGeneratorValue', False, 'primitive'),
+    )
+
+
+@dataclass
+class RequestDatabaseReturn(DataType):
+    """Return value of :meth:`IndexedDB.request_database`."""
+    database_with_object_stores: DatabaseWithObjectStores
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('database_with_object_stores', 'databaseWithObjectStores', False, 'object', ref='IndexedDB.DatabaseWithObjectStores'),
+    )
+
+
+@dataclass
+class RequestDatabaseNamesReturn(DataType):
+    """Return value of :meth:`IndexedDB.request_database_names`."""
+    database_names: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('database_names', 'databaseNames', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+class IndexedDB:
+    """Commands of the IndexedDB domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def clear_object_store(self, *, database_name: str, object_store_name: str, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> None:
+        """
+        Clears all entries from an object store.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name: Database name.
+        :param object_store_name: Object store name.
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        _params['objectStoreName'] = encode(FieldMeta('', '', False, 'primitive'), object_store_name)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.clearObjectStore', _params)
+        return None
+
+    async def delete_database(self, *, database_name: str, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> None:
+        """
+        Deletes a database.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name: Database name.
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.deleteDatabase', _params)
+        return None
+
+    async def delete_object_store_entries(self, *, database_name: str, object_store_name: str, key_range: KeyRange, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> None:
+        """
+        Delete a range of entries from an object store
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name:
+        :param object_store_name:
+        :param key_range: Range of entry keys to delete
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        _params['objectStoreName'] = encode(FieldMeta('', '', False, 'primitive'), object_store_name)
+        _params['keyRange'] = encode(FieldMeta('', '', False, 'object', ref='IndexedDB.KeyRange'), key_range)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.deleteObjectStoreEntries', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables events from backend."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('IndexedDB.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables events from backend."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('IndexedDB.enable', _params)
+        return None
+
+    async def request_data(self, *, database_name: str, object_store_name: str, skip_count: int, page_size: int, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None, index_name: Optional[str] = None, key_range: Optional[KeyRange] = None) -> RequestDataReturn:
+        """
+        Requests data from object store or index.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name: Database name.
+        :param object_store_name: Object store name.
+        :param index_name: Index name. If not specified, it performs an object store data request.
+        :param skip_count: Number of records to skip.
+        :param page_size: Number of records to fetch.
+        :param key_range: Key range.
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        _params['objectStoreName'] = encode(FieldMeta('', '', False, 'primitive'), object_store_name)
+        _params['skipCount'] = encode(FieldMeta('', '', False, 'primitive'), skip_count)
+        _params['pageSize'] = encode(FieldMeta('', '', False, 'primitive'), page_size)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        if index_name is not None:
+            _params['indexName'] = encode(FieldMeta('', '', False, 'primitive'), index_name)
+        if key_range is not None:
+            _params['keyRange'] = encode(FieldMeta('', '', False, 'object', ref='IndexedDB.KeyRange'), key_range)
+        _result = await self._target.send('IndexedDB.requestData', _params)
+        return RequestDataReturn.from_json(_result)
+
+    async def get_metadata(self, *, database_name: str, object_store_name: str, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> GetMetadataReturn:
+        """
+        Gets metadata of an object store.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name: Database name.
+        :param object_store_name: Object store name.
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        _params['objectStoreName'] = encode(FieldMeta('', '', False, 'primitive'), object_store_name)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.getMetadata', _params)
+        return GetMetadataReturn.from_json(_result)
+
+    async def request_database(self, *, database_name: str, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> RequestDatabaseReturn:
+        """
+        Requests database with given name in given frame.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        :param database_name: Database name.
+        """
+        _params: Dict[str, Any] = {}
+        _params['databaseName'] = encode(FieldMeta('', '', False, 'primitive'), database_name)
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.requestDatabase', _params)
+        return RequestDatabaseReturn.from_json(_result)
+
+    async def request_database_names(self, *, security_origin: Optional[str] = None, storage_key: Optional[str] = None, storage_bucket: Optional[Storage_StorageBucket] = None) -> RequestDatabaseNamesReturn:
+        """
+        Requests database names for given security origin.
+        :param security_origin: At least and at most one of securityOrigin, storageKey, or storageBucket must be specified.
+        Security origin.
+        :param storage_key: Storage key.
+        :param storage_bucket: Storage bucket. If not specified, it uses the default bucket.
+        """
+        _params: Dict[str, Any] = {}
+        if security_origin is not None:
+            _params['securityOrigin'] = encode(FieldMeta('', '', False, 'primitive'), security_origin)
+        if storage_key is not None:
+            _params['storageKey'] = encode(FieldMeta('', '', False, 'primitive'), storage_key)
+        if storage_bucket is not None:
+            _params['storageBucket'] = encode(FieldMeta('', '', False, 'object', ref='Storage.StorageBucket'), storage_bucket)
+        _result = await self._target.send('IndexedDB.requestDatabaseNames', _params)
+        return RequestDatabaseNamesReturn.from_json(_result)

parsek_cdp/cdp/indexeddb/types.py

@@ -0,0 +1,120 @@
+"""Custom types and enums for the IndexedDB domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..runtime.types import RemoteObject as Runtime_RemoteObject
+
+@register("IndexedDB.DatabaseWithObjectStores")
+@dataclass
+class DatabaseWithObjectStores(DataType):
+    """Database with an array of object stores."""
+    name: str
+    version: float
+    object_stores: List[ObjectStore]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('version', 'version', False, 'primitive'),
+        FieldMeta('object_stores', 'objectStores', False, 'array', inner=FieldMeta('', '', False, 'object', ref='IndexedDB.ObjectStore')),
+    )
+
+
+@register("IndexedDB.ObjectStore")
+@dataclass
+class ObjectStore(DataType):
+    """Object store."""
+    name: str
+    key_path: KeyPath
+    auto_increment: bool
+    indexes: List[ObjectStoreIndex]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('key_path', 'keyPath', False, 'object', ref='IndexedDB.KeyPath'),
+        FieldMeta('auto_increment', 'autoIncrement', False, 'primitive'),
+        FieldMeta('indexes', 'indexes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='IndexedDB.ObjectStoreIndex')),
+    )
+
+
+@register("IndexedDB.ObjectStoreIndex")
+@dataclass
+class ObjectStoreIndex(DataType):
+    """Object store index."""
+    name: str
+    key_path: KeyPath
+    unique: bool
+    multi_entry: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('key_path', 'keyPath', False, 'object', ref='IndexedDB.KeyPath'),
+        FieldMeta('unique', 'unique', False, 'primitive'),
+        FieldMeta('multi_entry', 'multiEntry', False, 'primitive'),
+    )
+
+
+@register("IndexedDB.Key")
+@dataclass
+class Key(DataType):
+    """Key."""
+    type_: Literal['number', 'string', 'date', 'array']
+    number: Optional[float] = None
+    string: Optional[str] = None
+    date: Optional[float] = None
+    array: Optional[List[Key]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('number', 'number', True, 'primitive'),
+        FieldMeta('string', 'string', True, 'primitive'),
+        FieldMeta('date', 'date', True, 'primitive'),
+        FieldMeta('array', 'array', True, 'array', inner=FieldMeta('', '', False, 'object', ref='IndexedDB.Key')),
+    )
+
+
+@register("IndexedDB.KeyRange")
+@dataclass
+class KeyRange(DataType):
+    """Key range."""
+    lower_open: bool
+    upper_open: bool
+    lower: Optional[Key] = None
+    upper: Optional[Key] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('lower_open', 'lowerOpen', False, 'primitive'),
+        FieldMeta('upper_open', 'upperOpen', False, 'primitive'),
+        FieldMeta('lower', 'lower', True, 'object', ref='IndexedDB.Key'),
+        FieldMeta('upper', 'upper', True, 'object', ref='IndexedDB.Key'),
+    )
+
+
+@register("IndexedDB.DataEntry")
+@dataclass
+class DataEntry(DataType):
+    """Data entry."""
+    key: Runtime_RemoteObject
+    primary_key: Runtime_RemoteObject
+    value: Runtime_RemoteObject
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('primary_key', 'primaryKey', False, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('value', 'value', False, 'object', ref='Runtime.RemoteObject'),
+    )
+
+
+@register("IndexedDB.KeyPath")
+@dataclass
+class KeyPath(DataType):
+    """Key path."""
+    type_: Literal['null', 'string', 'array']
+    string: Optional[str] = None
+    array: Optional[List[str]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('string', 'string', True, 'primitive'),
+        FieldMeta('array', 'array', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+__all__ = ["DataEntry", "DatabaseWithObjectStores", "Key", "KeyPath", "KeyRange", "ObjectStore", "ObjectStoreIndex"]

parsek_cdp/cdp/input/__init__.py

@@ -0,0 +1,15 @@
+"""The Input CDP domain (generated).
+
+Importing ``Input`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Input.SomeEvent`` /
+``Input.SomeType``); commands run on a target via ``page.cdp.Input``.
+"""
+from . import events, functions, types
+from .functions import Input
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Input,)``).
+DOMAIN = "Input"
+
+__all__ = ["events", "functions", "types", "Input", "DOMAIN"]

parsek_cdp/cdp/input/events.py

@@ -0,0 +1,25 @@
+"""Events for the Input domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import DragData
+
+@register_event("Input.dragIntercepted")
+@dataclass
+class DragIntercepted(Event):
+    """
+    Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to
+    restore normal drag and drop behavior.
+    """
+    data: DragData
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('data', 'data', False, 'object', ref='Input.DragData'),
+    )
+
+__all__ = ["DragIntercepted"]