parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/bluetoothemulation/functions.py

@@ -0,0 +1,247 @@
+"""Commands for the BluetoothEmulation 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 (
+        CentralState,
+        CharacteristicOperationType,
+        CharacteristicProperties,
+        DescriptorOperationType,
+        GATTOperationType,
+        ManufacturerData,
+        ScanEntry,
+    )
+
+@dataclass
+class AddServiceReturn(DataType):
+    """Return value of :meth:`BluetoothEmulation.add_service`."""
+    service_id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('service_id', 'serviceId', False, 'primitive'),
+    )
+
+
+@dataclass
+class AddCharacteristicReturn(DataType):
+    """Return value of :meth:`BluetoothEmulation.add_characteristic`."""
+    characteristic_id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('characteristic_id', 'characteristicId', False, 'primitive'),
+    )
+
+
+@dataclass
+class AddDescriptorReturn(DataType):
+    """Return value of :meth:`BluetoothEmulation.add_descriptor`."""
+    descriptor_id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('descriptor_id', 'descriptorId', False, 'primitive'),
+    )
+
+
+class BluetoothEmulation:
+    """Commands of the BluetoothEmulation domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self, *, state: CentralState, le_supported: bool) -> None:
+        """
+        Enable the BluetoothEmulation domain.
+        :param state: State of the simulated central.
+        :param le_supported: If the simulated central supports low-energy.
+        """
+        _params: Dict[str, Any] = {}
+        _params['state'] = encode(FieldMeta('', '', False, 'enum', ref='BluetoothEmulation.CentralState'), state)
+        _params['leSupported'] = encode(FieldMeta('', '', False, 'primitive'), le_supported)
+        _result = await self._target.send('BluetoothEmulation.enable', _params)
+        return None
+
+    async def set_simulated_central_state(self, *, state: CentralState) -> None:
+        """
+        Set the state of the simulated central.
+        :param state: State of the simulated central.
+        """
+        _params: Dict[str, Any] = {}
+        _params['state'] = encode(FieldMeta('', '', False, 'enum', ref='BluetoothEmulation.CentralState'), state)
+        _result = await self._target.send('BluetoothEmulation.setSimulatedCentralState', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disable the BluetoothEmulation domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('BluetoothEmulation.disable', _params)
+        return None
+
+    async def simulate_preconnected_peripheral(self, *, address: str, name: str, manufacturer_data: List[ManufacturerData], known_service_uuids: List[str]) -> None:
+        """
+        Simulates a peripheral with |address|, |name| and |knownServiceUuids|
+        that has already been connected to the system.
+        :param address:
+        :param name:
+        :param manufacturer_data:
+        :param known_service_uuids:
+        """
+        _params: Dict[str, Any] = {}
+        _params['address'] = encode(FieldMeta('', '', False, 'primitive'), address)
+        _params['name'] = encode(FieldMeta('', '', False, 'primitive'), name)
+        _params['manufacturerData'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='BluetoothEmulation.ManufacturerData')), manufacturer_data)
+        _params['knownServiceUuids'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), known_service_uuids)
+        _result = await self._target.send('BluetoothEmulation.simulatePreconnectedPeripheral', _params)
+        return None
+
+    async def simulate_advertisement(self, *, entry: ScanEntry) -> None:
+        """
+        Simulates an advertisement packet described in |entry| being received by
+        the central.
+        :param entry:
+        """
+        _params: Dict[str, Any] = {}
+        _params['entry'] = encode(FieldMeta('', '', False, 'object', ref='BluetoothEmulation.ScanEntry'), entry)
+        _result = await self._target.send('BluetoothEmulation.simulateAdvertisement', _params)
+        return None
+
+    async def simulate_gatt_operation_response(self, *, address: str, type_: GATTOperationType, code: int) -> None:
+        """
+        Simulates the response code from the peripheral with |address| for a
+        GATT operation of |type|. The |code| value follows the HCI Error Codes from
+        Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.
+        :param address:
+        :param type_:
+        :param code:
+        """
+        _params: Dict[str, Any] = {}
+        _params['address'] = encode(FieldMeta('', '', False, 'primitive'), address)
+        _params['type'] = encode(FieldMeta('', '', False, 'enum', ref='BluetoothEmulation.GATTOperationType'), type_)
+        _params['code'] = encode(FieldMeta('', '', False, 'primitive'), code)
+        _result = await self._target.send('BluetoothEmulation.simulateGATTOperationResponse', _params)
+        return None
+
+    async def simulate_characteristic_operation_response(self, *, characteristic_id: str, type_: CharacteristicOperationType, code: int, data: Optional[str] = None) -> None:
+        """
+        Simulates the response from the characteristic with |characteristicId| for a
+        characteristic operation of |type|. The |code| value follows the Error
+        Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+        The |data| is expected to exist when simulating a successful read operation
+        response.
+        :param characteristic_id:
+        :param type_:
+        :param code:
+        :param data:
+        """
+        _params: Dict[str, Any] = {}
+        _params['characteristicId'] = encode(FieldMeta('', '', False, 'primitive'), characteristic_id)
+        _params['type'] = encode(FieldMeta('', '', False, 'enum', ref='BluetoothEmulation.CharacteristicOperationType'), type_)
+        _params['code'] = encode(FieldMeta('', '', False, 'primitive'), code)
+        if data is not None:
+            _params['data'] = encode(FieldMeta('', '', False, 'primitive'), data)
+        _result = await self._target.send('BluetoothEmulation.simulateCharacteristicOperationResponse', _params)
+        return None
+
+    async def simulate_descriptor_operation_response(self, *, descriptor_id: str, type_: DescriptorOperationType, code: int, data: Optional[str] = None) -> None:
+        """
+        Simulates the response from the descriptor with |descriptorId| for a
+        descriptor operation of |type|. The |code| value follows the Error
+        Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+        The |data| is expected to exist when simulating a successful read operation
+        response.
+        :param descriptor_id:
+        :param type_:
+        :param code:
+        :param data:
+        """
+        _params: Dict[str, Any] = {}
+        _params['descriptorId'] = encode(FieldMeta('', '', False, 'primitive'), descriptor_id)
+        _params['type'] = encode(FieldMeta('', '', False, 'enum', ref='BluetoothEmulation.DescriptorOperationType'), type_)
+        _params['code'] = encode(FieldMeta('', '', False, 'primitive'), code)
+        if data is not None:
+            _params['data'] = encode(FieldMeta('', '', False, 'primitive'), data)
+        _result = await self._target.send('BluetoothEmulation.simulateDescriptorOperationResponse', _params)
+        return None
+
+    async def add_service(self, *, address: str, service_uuid: str) -> AddServiceReturn:
+        """
+        Adds a service with |serviceUuid| to the peripheral with |address|.
+        :param address:
+        :param service_uuid:
+        """
+        _params: Dict[str, Any] = {}
+        _params['address'] = encode(FieldMeta('', '', False, 'primitive'), address)
+        _params['serviceUuid'] = encode(FieldMeta('', '', False, 'primitive'), service_uuid)
+        _result = await self._target.send('BluetoothEmulation.addService', _params)
+        return AddServiceReturn.from_json(_result)
+
+    async def remove_service(self, *, service_id: str) -> None:
+        """
+        Removes the service respresented by |serviceId| from the simulated central.
+        :param service_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['serviceId'] = encode(FieldMeta('', '', False, 'primitive'), service_id)
+        _result = await self._target.send('BluetoothEmulation.removeService', _params)
+        return None
+
+    async def add_characteristic(self, *, service_id: str, characteristic_uuid: str, properties: CharacteristicProperties) -> AddCharacteristicReturn:
+        """
+        Adds a characteristic with |characteristicUuid| and |properties| to the
+        service represented by |serviceId|.
+        :param service_id:
+        :param characteristic_uuid:
+        :param properties:
+        """
+        _params: Dict[str, Any] = {}
+        _params['serviceId'] = encode(FieldMeta('', '', False, 'primitive'), service_id)
+        _params['characteristicUuid'] = encode(FieldMeta('', '', False, 'primitive'), characteristic_uuid)
+        _params['properties'] = encode(FieldMeta('', '', False, 'object', ref='BluetoothEmulation.CharacteristicProperties'), properties)
+        _result = await self._target.send('BluetoothEmulation.addCharacteristic', _params)
+        return AddCharacteristicReturn.from_json(_result)
+
+    async def remove_characteristic(self, *, characteristic_id: str) -> None:
+        """
+        Removes the characteristic respresented by |characteristicId| from the
+        simulated central.
+        :param characteristic_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['characteristicId'] = encode(FieldMeta('', '', False, 'primitive'), characteristic_id)
+        _result = await self._target.send('BluetoothEmulation.removeCharacteristic', _params)
+        return None
+
+    async def add_descriptor(self, *, characteristic_id: str, descriptor_uuid: str) -> AddDescriptorReturn:
+        """
+        Adds a descriptor with |descriptorUuid| to the characteristic respresented
+        by |characteristicId|.
+        :param characteristic_id:
+        :param descriptor_uuid:
+        """
+        _params: Dict[str, Any] = {}
+        _params['characteristicId'] = encode(FieldMeta('', '', False, 'primitive'), characteristic_id)
+        _params['descriptorUuid'] = encode(FieldMeta('', '', False, 'primitive'), descriptor_uuid)
+        _result = await self._target.send('BluetoothEmulation.addDescriptor', _params)
+        return AddDescriptorReturn.from_json(_result)
+
+    async def remove_descriptor(self, *, descriptor_id: str) -> None:
+        """
+        Removes the descriptor with |descriptorId| from the simulated central.
+        :param descriptor_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['descriptorId'] = encode(FieldMeta('', '', False, 'primitive'), descriptor_id)
+        _result = await self._target.send('BluetoothEmulation.removeDescriptor', _params)
+        return None
+
+    async def simulate_gatt_disconnection(self, *, address: str) -> None:
+        """
+        Simulates a GATT disconnection from the peripheral with |address|.
+        :param address:
+        """
+        _params: Dict[str, Any] = {}
+        _params['address'] = encode(FieldMeta('', '', False, 'primitive'), address)
+        _result = await self._target.send('BluetoothEmulation.simulateGATTDisconnection', _params)
+        return None

parsek_cdp/cdp/bluetoothemulation/types.py

@@ -0,0 +1,120 @@
+"""Custom types and enums for the BluetoothEmulation domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+
+@register("BluetoothEmulation.CentralState")
+class CentralState(str, Enum):
+    """Indicates the various states of Central."""
+    ABSENT = 'absent'
+    POWERED_OFF = 'powered-off'
+    POWERED_ON = 'powered-on'
+
+
+@register("BluetoothEmulation.GATTOperationType")
+class GATTOperationType(str, Enum):
+    """Indicates the various types of GATT event."""
+    CONNECTION = 'connection'
+    DISCOVERY = 'discovery'
+
+
+@register("BluetoothEmulation.CharacteristicWriteType")
+class CharacteristicWriteType(str, Enum):
+    """Indicates the various types of characteristic write."""
+    WRITE_DEFAULT_DEPRECATED = 'write-default-deprecated'
+    WRITE_WITH_RESPONSE = 'write-with-response'
+    WRITE_WITHOUT_RESPONSE = 'write-without-response'
+
+
+@register("BluetoothEmulation.CharacteristicOperationType")
+class CharacteristicOperationType(str, Enum):
+    """Indicates the various types of characteristic operation."""
+    READ = 'read'
+    WRITE = 'write'
+    SUBSCRIBE_TO_NOTIFICATIONS = 'subscribe-to-notifications'
+    UNSUBSCRIBE_FROM_NOTIFICATIONS = 'unsubscribe-from-notifications'
+
+
+@register("BluetoothEmulation.DescriptorOperationType")
+class DescriptorOperationType(str, Enum):
+    """Indicates the various types of descriptor operation."""
+    READ = 'read'
+    WRITE = 'write'
+
+
+@register("BluetoothEmulation.ManufacturerData")
+@dataclass
+class ManufacturerData(DataType):
+    """Stores the manufacturer data"""
+    key: int
+    data: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'primitive'),
+        FieldMeta('data', 'data', False, 'primitive'),
+    )
+
+
+@register("BluetoothEmulation.ScanRecord")
+@dataclass
+class ScanRecord(DataType):
+    """Stores the byte data of the advertisement packet sent by a Bluetooth device."""
+    name: Optional[str] = None
+    uuids: Optional[List[str]] = None
+    appearance: Optional[int] = None
+    tx_power: Optional[int] = None
+    manufacturer_data: Optional[List[ManufacturerData]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', True, 'primitive'),
+        FieldMeta('uuids', 'uuids', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('appearance', 'appearance', True, 'primitive'),
+        FieldMeta('tx_power', 'txPower', True, 'primitive'),
+        FieldMeta('manufacturer_data', 'manufacturerData', True, 'array', inner=FieldMeta('', '', False, 'object', ref='BluetoothEmulation.ManufacturerData')),
+    )
+
+
+@register("BluetoothEmulation.ScanEntry")
+@dataclass
+class ScanEntry(DataType):
+    """Stores the advertisement packet information that is sent by a Bluetooth device."""
+    device_address: str
+    rssi: int
+    scan_record: ScanRecord
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('device_address', 'deviceAddress', False, 'primitive'),
+        FieldMeta('rssi', 'rssi', False, 'primitive'),
+        FieldMeta('scan_record', 'scanRecord', False, 'object', ref='BluetoothEmulation.ScanRecord'),
+    )
+
+
+@register("BluetoothEmulation.CharacteristicProperties")
+@dataclass
+class CharacteristicProperties(DataType):
+    """
+    Describes the properties of a characteristic. This follows Bluetooth Core
+    Specification BT 4.2 Vol 3 Part G 3.3.1. Characteristic Properties.
+    """
+    broadcast: Optional[bool] = None
+    read: Optional[bool] = None
+    write_without_response: Optional[bool] = None
+    write: Optional[bool] = None
+    notify: Optional[bool] = None
+    indicate: Optional[bool] = None
+    authenticated_signed_writes: Optional[bool] = None
+    extended_properties: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('broadcast', 'broadcast', True, 'primitive'),
+        FieldMeta('read', 'read', True, 'primitive'),
+        FieldMeta('write_without_response', 'writeWithoutResponse', True, 'primitive'),
+        FieldMeta('write', 'write', True, 'primitive'),
+        FieldMeta('notify', 'notify', True, 'primitive'),
+        FieldMeta('indicate', 'indicate', True, 'primitive'),
+        FieldMeta('authenticated_signed_writes', 'authenticatedSignedWrites', True, 'primitive'),
+        FieldMeta('extended_properties', 'extendedProperties', True, 'primitive'),
+    )
+
+__all__ = ["CentralState", "CharacteristicOperationType", "CharacteristicProperties", "CharacteristicWriteType", "DescriptorOperationType", "GATTOperationType", "ManufacturerData", "ScanEntry", "ScanRecord"]

parsek_cdp/cdp/browser/__init__.py

@@ -0,0 +1,15 @@
+"""The Browser CDP domain (generated).
+
+Importing ``Browser`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Browser.SomeEvent`` /
+``Browser.SomeType``); commands run on a target via ``page.cdp.Browser``.
+"""
+from . import events, functions, types
+from .functions import Browser
+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=(Browser,)``).
+DOMAIN = "Browser"
+
+__all__ = ["events", "functions", "types", "Browser", "DOMAIN"]

parsek_cdp/cdp/browser/events.py

@@ -0,0 +1,46 @@
+"""Events for the Browser 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 ..page.types import FrameId as Page_FrameId
+
+@register_event("Browser.downloadWillBegin")
+@dataclass
+class DownloadWillBegin(Event):
+    """Fired when page is about to start a download."""
+    frame_id: Page_FrameId
+    guid: str
+    url: str
+    suggested_filename: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('guid', 'guid', False, 'primitive'),
+        FieldMeta('url', 'url', False, 'primitive'),
+        FieldMeta('suggested_filename', 'suggestedFilename', False, 'primitive'),
+    )
+
+
+@register_event("Browser.downloadProgress")
+@dataclass
+class DownloadProgress(Event):
+    """Fired when download makes progress. Last call has |done| == true."""
+    guid: str
+    total_bytes: float
+    received_bytes: float
+    state: Literal['inProgress', 'completed', 'canceled']
+    file_path: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('guid', 'guid', False, 'primitive'),
+        FieldMeta('total_bytes', 'totalBytes', False, 'primitive'),
+        FieldMeta('received_bytes', 'receivedBytes', False, 'primitive'),
+        FieldMeta('state', 'state', False, 'primitive'),
+        FieldMeta('file_path', 'filePath', True, 'primitive'),
+    )
+
+__all__ = ["DownloadProgress", "DownloadWillBegin"]