parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/autofill/__init__.py

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

parsek_cdp/cdp/autofill/events.py

@@ -0,0 +1,27 @@
+"""Events for the Autofill 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 (
+        AddressUI,
+        FilledField,
+    )
+
+@register_event("Autofill.addressFormFilled")
+@dataclass
+class AddressFormFilled(Event):
+    """Emitted when an address form is filled."""
+    filled_fields: List[FilledField]
+    address_ui: AddressUI
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('filled_fields', 'filledFields', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Autofill.FilledField')),
+        FieldMeta('address_ui', 'addressUi', False, 'object', ref='Autofill.AddressUI'),
+    )
+
+__all__ = ["AddressFormFilled"]

parsek_cdp/cdp/autofill/functions.py

@@ -0,0 +1,64 @@
+"""Commands for the Autofill 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 (
+        Address,
+        CreditCard,
+    )
+    from ..dom.types import BackendNodeId as DOM_BackendNodeId
+    from ..page.types import FrameId as Page_FrameId
+
+class Autofill:
+    """Commands of the Autofill domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def trigger(self, *, field_id: DOM_BackendNodeId, frame_id: Optional[Page_FrameId] = None, card: Optional[CreditCard] = None, address: Optional[Address] = None) -> None:
+        """
+        Trigger autofill on a form identified by the fieldId.
+        If the field and related form cannot be autofilled, returns an error.
+        :param field_id: Identifies a field that serves as an anchor for autofill.
+        :param frame_id: Identifies the frame that field belongs to.
+        :param card: Credit card information to fill out the form. Credit card data is not saved.  Mutually exclusive with `address`.
+        :param address: Address to fill out the form. Address data is not saved. Mutually exclusive with `card`.
+        """
+        _params: Dict[str, Any] = {}
+        _params['fieldId'] = encode(FieldMeta('', '', False, 'primitive'), field_id)
+        if frame_id is not None:
+            _params['frameId'] = encode(FieldMeta('', '', False, 'primitive'), frame_id)
+        if card is not None:
+            _params['card'] = encode(FieldMeta('', '', False, 'object', ref='Autofill.CreditCard'), card)
+        if address is not None:
+            _params['address'] = encode(FieldMeta('', '', False, 'object', ref='Autofill.Address'), address)
+        _result = await self._target.send('Autofill.trigger', _params)
+        return None
+
+    async def set_addresses(self, *, addresses: List[Address]) -> None:
+        """
+        Set addresses so that developers can verify their forms implementation.
+        :param addresses:
+        """
+        _params: Dict[str, Any] = {}
+        _params['addresses'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Autofill.Address')), addresses)
+        _result = await self._target.send('Autofill.setAddresses', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables autofill domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Autofill.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables autofill domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Autofill.enable', _params)
+        return None

parsek_cdp/cdp/autofill/types.py

@@ -0,0 +1,108 @@
+"""Custom types and enums for the Autofill 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 ..dom.types import BackendNodeId as DOM_BackendNodeId
+    from ..page.types import FrameId as Page_FrameId
+
+@register("Autofill.CreditCard")
+@dataclass
+class CreditCard(DataType):
+    number: str
+    name: str
+    expiry_month: str
+    expiry_year: str
+    cvc: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('number', 'number', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('expiry_month', 'expiryMonth', False, 'primitive'),
+        FieldMeta('expiry_year', 'expiryYear', False, 'primitive'),
+        FieldMeta('cvc', 'cvc', False, 'primitive'),
+    )
+
+
+@register("Autofill.AddressField")
+@dataclass
+class AddressField(DataType):
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Autofill.AddressFields")
+@dataclass
+class AddressFields(DataType):
+    """A list of address fields."""
+    fields: List[AddressField]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('fields', 'fields', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Autofill.AddressField')),
+    )
+
+
+@register("Autofill.Address")
+@dataclass
+class Address(DataType):
+    fields: List[AddressField]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('fields', 'fields', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Autofill.AddressField')),
+    )
+
+
+@register("Autofill.AddressUI")
+@dataclass
+class AddressUI(DataType):
+    """
+    Defines how an address can be displayed like in chrome://settings/addresses.
+    Address UI is a two dimensional array, each inner array is an "address information line", and when rendered in a UI surface should be displayed as such.
+    The following address UI for instance:
+    [[{name: "GIVE_NAME", value: "Jon"}, {name: "FAMILY_NAME", value: "Doe"}], [{name: "CITY", value: "Munich"}, {name: "ZIP", value: "81456"}]]
+    should allow the receiver to render:
+    Jon Doe
+    Munich 81456
+    """
+    address_fields: List[AddressFields]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('address_fields', 'addressFields', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Autofill.AddressFields')),
+    )
+
+
+@register("Autofill.FillingStrategy")
+class FillingStrategy(str, Enum):
+    """Specified whether a filled field was done so by using the html autocomplete attribute or autofill heuristics."""
+    AUTOCOMPLETEATTRIBUTE = 'autocompleteAttribute'
+    AUTOFILLINFERRED = 'autofillInferred'
+
+
+@register("Autofill.FilledField")
+@dataclass
+class FilledField(DataType):
+    html_type: str
+    id: str
+    name: str
+    value: str
+    autofill_type: str
+    filling_strategy: FillingStrategy
+    frame_id: Page_FrameId
+    field_id: DOM_BackendNodeId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('html_type', 'htmlType', False, 'primitive'),
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+        FieldMeta('autofill_type', 'autofillType', False, 'primitive'),
+        FieldMeta('filling_strategy', 'fillingStrategy', False, 'enum', ref='Autofill.FillingStrategy'),
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('field_id', 'fieldId', False, 'primitive'),
+    )
+
+__all__ = ["Address", "AddressField", "AddressFields", "AddressUI", "CreditCard", "FilledField", "FillingStrategy"]

parsek_cdp/cdp/backgroundservice/__init__.py

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

parsek_cdp/cdp/backgroundservice/events.py

@@ -0,0 +1,40 @@
+"""Events for the BackgroundService 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 (
+        BackgroundServiceEvent,
+        ServiceName,
+    )
+
+@register_event("BackgroundService.recordingStateChanged")
+@dataclass
+class RecordingStateChanged(Event):
+    """Called when the recording state for the service has been updated."""
+    is_recording: bool
+    service: ServiceName
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('is_recording', 'isRecording', False, 'primitive'),
+        FieldMeta('service', 'service', False, 'enum', ref='BackgroundService.ServiceName'),
+    )
+
+
+@register_event("BackgroundService.backgroundServiceEventReceived")
+@dataclass
+class BackgroundServiceEventReceived(Event):
+    """
+    Called with all existing backgroundServiceEvents when enabled, and all new
+    events afterwards if enabled and recording.
+    """
+    background_service_event: BackgroundServiceEvent
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('background_service_event', 'backgroundServiceEvent', False, 'object', ref='BackgroundService.BackgroundServiceEvent'),
+    )
+
+__all__ = ["BackgroundServiceEventReceived", "RecordingStateChanged"]

parsek_cdp/cdp/backgroundservice/functions.py

@@ -0,0 +1,59 @@
+"""Commands for the BackgroundService 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 ServiceName
+
+class BackgroundService:
+    """Commands of the BackgroundService domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def start_observing(self, *, service: ServiceName) -> None:
+        """
+        Enables event updates for the service.
+        :param service:
+        """
+        _params: Dict[str, Any] = {}
+        _params['service'] = encode(FieldMeta('', '', False, 'enum', ref='BackgroundService.ServiceName'), service)
+        _result = await self._target.send('BackgroundService.startObserving', _params)
+        return None
+
+    async def stop_observing(self, *, service: ServiceName) -> None:
+        """
+        Disables event updates for the service.
+        :param service:
+        """
+        _params: Dict[str, Any] = {}
+        _params['service'] = encode(FieldMeta('', '', False, 'enum', ref='BackgroundService.ServiceName'), service)
+        _result = await self._target.send('BackgroundService.stopObserving', _params)
+        return None
+
+    async def set_recording(self, *, should_record: bool, service: ServiceName) -> None:
+        """
+        Set the recording state for the service.
+        :param should_record:
+        :param service:
+        """
+        _params: Dict[str, Any] = {}
+        _params['shouldRecord'] = encode(FieldMeta('', '', False, 'primitive'), should_record)
+        _params['service'] = encode(FieldMeta('', '', False, 'enum', ref='BackgroundService.ServiceName'), service)
+        _result = await self._target.send('BackgroundService.setRecording', _params)
+        return None
+
+    async def clear_events(self, *, service: ServiceName) -> None:
+        """
+        Clears all stored data for the service.
+        :param service:
+        """
+        _params: Dict[str, Any] = {}
+        _params['service'] = encode(FieldMeta('', '', False, 'enum', ref='BackgroundService.ServiceName'), service)
+        _result = await self._target.send('BackgroundService.clearEvents', _params)
+        return None

parsek_cdp/cdp/backgroundservice/types.py

@@ -0,0 +1,63 @@
+"""Custom types and enums for the BackgroundService 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 ..network.types import TimeSinceEpoch as Network_TimeSinceEpoch
+    from ..serviceworker.types import RegistrationID as ServiceWorker_RegistrationID
+
+@register("BackgroundService.ServiceName")
+class ServiceName(str, Enum):
+    """
+    The Background Service that will be associated with the commands/events.
+    Every Background Service operates independently, but they share the same
+    API.
+    """
+    BACKGROUNDFETCH = 'backgroundFetch'
+    BACKGROUNDSYNC = 'backgroundSync'
+    PUSHMESSAGING = 'pushMessaging'
+    NOTIFICATIONS = 'notifications'
+    PAYMENTHANDLER = 'paymentHandler'
+    PERIODICBACKGROUNDSYNC = 'periodicBackgroundSync'
+
+
+@register("BackgroundService.EventMetadata")
+@dataclass
+class EventMetadata(DataType):
+    """A key-value pair for additional event information to pass along."""
+    key: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("BackgroundService.BackgroundServiceEvent")
+@dataclass
+class BackgroundServiceEvent(DataType):
+    timestamp: Network_TimeSinceEpoch
+    origin: str
+    service_worker_registration_id: ServiceWorker_RegistrationID
+    service: ServiceName
+    event_name: str
+    instance_id: str
+    event_metadata: List[EventMetadata]
+    storage_key: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('origin', 'origin', False, 'primitive'),
+        FieldMeta('service_worker_registration_id', 'serviceWorkerRegistrationId', False, 'primitive'),
+        FieldMeta('service', 'service', False, 'enum', ref='BackgroundService.ServiceName'),
+        FieldMeta('event_name', 'eventName', False, 'primitive'),
+        FieldMeta('instance_id', 'instanceId', False, 'primitive'),
+        FieldMeta('event_metadata', 'eventMetadata', False, 'array', inner=FieldMeta('', '', False, 'object', ref='BackgroundService.EventMetadata')),
+        FieldMeta('storage_key', 'storageKey', False, 'primitive'),
+    )
+
+__all__ = ["BackgroundServiceEvent", "EventMetadata", "ServiceName"]

parsek_cdp/cdp/bluetoothemulation/__init__.py

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

parsek_cdp/cdp/bluetoothemulation/events.py

@@ -0,0 +1,70 @@
+"""Events 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 FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        CharacteristicOperationType,
+        CharacteristicWriteType,
+        DescriptorOperationType,
+        GATTOperationType,
+    )
+
+@register_event("BluetoothEmulation.gattOperationReceived")
+@dataclass
+class GattOperationReceived(Event):
+    """
+    Event for when a GATT operation of |type| to the peripheral with |address|
+    happened.
+    """
+    address: str
+    type_: GATTOperationType
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('address', 'address', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'enum', ref='BluetoothEmulation.GATTOperationType'),
+    )
+
+
+@register_event("BluetoothEmulation.characteristicOperationReceived")
+@dataclass
+class CharacteristicOperationReceived(Event):
+    """
+    Event for when a characteristic operation of |type| to the characteristic
+    respresented by |characteristicId| happened. |data| and |writeType| is
+    expected to exist when |type| is write.
+    """
+    characteristic_id: str
+    type_: CharacteristicOperationType
+    data: Optional[str] = None
+    write_type: Optional[CharacteristicWriteType] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('characteristic_id', 'characteristicId', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'enum', ref='BluetoothEmulation.CharacteristicOperationType'),
+        FieldMeta('data', 'data', True, 'primitive'),
+        FieldMeta('write_type', 'writeType', True, 'enum', ref='BluetoothEmulation.CharacteristicWriteType'),
+    )
+
+
+@register_event("BluetoothEmulation.descriptorOperationReceived")
+@dataclass
+class DescriptorOperationReceived(Event):
+    """
+    Event for when a descriptor operation of |type| to the descriptor
+    respresented by |descriptorId| happened. |data| is expected to exist when
+    |type| is write.
+    """
+    descriptor_id: str
+    type_: DescriptorOperationType
+    data: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('descriptor_id', 'descriptorId', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'enum', ref='BluetoothEmulation.DescriptorOperationType'),
+        FieldMeta('data', 'data', True, 'primitive'),
+    )
+
+__all__ = ["CharacteristicOperationReceived", "DescriptorOperationReceived", "GattOperationReceived"]