parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/media/events.py

@@ -0,0 +1,87 @@
+"""Events for the Media 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 (
+        Player,
+        PlayerError,
+        PlayerEvent,
+        PlayerId,
+        PlayerMessage,
+        PlayerProperty,
+    )
+
+@register_event("Media.playerPropertiesChanged")
+@dataclass
+class PlayerPropertiesChanged(Event):
+    """
+    This can be called multiple times, and can be used to set / override /
+    remove player properties. A null propValue indicates removal.
+    """
+    player_id: PlayerId
+    properties: List[PlayerProperty]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player_id', 'playerId', False, 'primitive'),
+        FieldMeta('properties', 'properties', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerProperty')),
+    )
+
+
+@register_event("Media.playerEventsAdded")
+@dataclass
+class PlayerEventsAdded(Event):
+    """
+    Send events as a list, allowing them to be batched on the browser for less
+    congestion. If batched, events must ALWAYS be in chronological order.
+    """
+    player_id: PlayerId
+    events: List[PlayerEvent]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player_id', 'playerId', False, 'primitive'),
+        FieldMeta('events', 'events', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerEvent')),
+    )
+
+
+@register_event("Media.playerMessagesLogged")
+@dataclass
+class PlayerMessagesLogged(Event):
+    """Send a list of any messages that need to be delivered."""
+    player_id: PlayerId
+    messages: List[PlayerMessage]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player_id', 'playerId', False, 'primitive'),
+        FieldMeta('messages', 'messages', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerMessage')),
+    )
+
+
+@register_event("Media.playerErrorsRaised")
+@dataclass
+class PlayerErrorsRaised(Event):
+    """Send a list of any errors that need to be delivered."""
+    player_id: PlayerId
+    errors: List[PlayerError]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player_id', 'playerId', False, 'primitive'),
+        FieldMeta('errors', 'errors', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerError')),
+    )
+
+
+@register_event("Media.playerCreated")
+@dataclass
+class PlayerCreated(Event):
+    """
+    Called whenever a player is created, or when a new agent joins and receives
+    a list of active players. If an agent is restored, it will receive one
+    event for each active player.
+    """
+    player: Player
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player', 'player', False, 'object', ref='Media.Player'),
+    )
+
+__all__ = ["PlayerCreated", "PlayerErrorsRaised", "PlayerEventsAdded", "PlayerMessagesLogged", "PlayerPropertiesChanged"]

parsek_cdp/cdp/media/functions.py

@@ -0,0 +1,27 @@
+"""Commands for the Media domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+
+class Media:
+    """Commands of the Media domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self) -> None:
+        """Enables the Media domain"""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Media.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables the Media domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Media.disable', _params)
+        return None

parsek_cdp/cdp/media/types.py

@@ -0,0 +1,101 @@
+"""Custom types and enums for the Media 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
+
+type PlayerId = str  # Players will get an ID that is unique within the agent context.
+
+
+type Timestamp = float
+
+
+@register("Media.PlayerMessage")
+@dataclass
+class PlayerMessage(DataType):
+    """
+    Have one type per entry in MediaLogRecord::Type
+    Corresponds to kMessage
+    """
+    level: Literal['error', 'warning', 'info', 'debug']
+    message: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('level', 'level', False, 'primitive'),
+        FieldMeta('message', 'message', False, 'primitive'),
+    )
+
+
+@register("Media.PlayerProperty")
+@dataclass
+class PlayerProperty(DataType):
+    """Corresponds to kMediaPropertyChange"""
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Media.PlayerEvent")
+@dataclass
+class PlayerEvent(DataType):
+    """Corresponds to kMediaEventTriggered"""
+    timestamp: Timestamp
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Media.PlayerErrorSourceLocation")
+@dataclass
+class PlayerErrorSourceLocation(DataType):
+    """
+    Represents logged source line numbers reported in an error.
+    NOTE: file and line are from chromium c++ implementation code, not js.
+    """
+    file: str
+    line: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('file', 'file', False, 'primitive'),
+        FieldMeta('line', 'line', False, 'primitive'),
+    )
+
+
+@register("Media.PlayerError")
+@dataclass
+class PlayerError(DataType):
+    """Corresponds to kMediaError"""
+    error_type: str
+    code: int
+    stack: List[PlayerErrorSourceLocation]
+    cause: List[PlayerError]
+    data: Dict[str, Any]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('error_type', 'errorType', False, 'primitive'),
+        FieldMeta('code', 'code', False, 'primitive'),
+        FieldMeta('stack', 'stack', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerErrorSourceLocation')),
+        FieldMeta('cause', 'cause', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Media.PlayerError')),
+        FieldMeta('data', 'data', False, 'primitive'),
+    )
+
+
+@register("Media.Player")
+@dataclass
+class Player(DataType):
+    player_id: PlayerId
+    dom_node_id: Optional[DOM_BackendNodeId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('player_id', 'playerId', False, 'primitive'),
+        FieldMeta('dom_node_id', 'domNodeId', True, 'primitive'),
+    )
+
+__all__ = ["Player", "PlayerError", "PlayerErrorSourceLocation", "PlayerEvent", "PlayerId", "PlayerMessage", "PlayerProperty", "Timestamp"]

parsek_cdp/cdp/memory/__init__.py

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

parsek_cdp/cdp/memory/events.py

@@ -0,0 +1,13 @@
+"""Events for the Memory domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+
+# This domain defines no events.
+
+__all__ = []

parsek_cdp/cdp/memory/functions.py

@@ -0,0 +1,164 @@
+"""Commands for the Memory 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 (
+        DOMCounter,
+        PressureLevel,
+        SamplingProfile,
+    )
+
+@dataclass
+class GetDOMCountersReturn(DataType):
+    """Return value of :meth:`Memory.get_dom_counters`."""
+    documents: int
+    nodes: int
+    js_event_listeners: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('documents', 'documents', False, 'primitive'),
+        FieldMeta('nodes', 'nodes', False, 'primitive'),
+        FieldMeta('js_event_listeners', 'jsEventListeners', False, 'primitive'),
+    )
+
+
+@dataclass
+class GetDOMCountersForLeakDetectionReturn(DataType):
+    """Return value of :meth:`Memory.get_dom_counters_for_leak_detection`."""
+    counters: List[DOMCounter]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('counters', 'counters', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Memory.DOMCounter')),
+    )
+
+
+@dataclass
+class GetAllTimeSamplingProfileReturn(DataType):
+    """Return value of :meth:`Memory.get_all_time_sampling_profile`."""
+    profile: SamplingProfile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='Memory.SamplingProfile'),
+    )
+
+
+@dataclass
+class GetBrowserSamplingProfileReturn(DataType):
+    """Return value of :meth:`Memory.get_browser_sampling_profile`."""
+    profile: SamplingProfile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='Memory.SamplingProfile'),
+    )
+
+
+@dataclass
+class GetSamplingProfileReturn(DataType):
+    """Return value of :meth:`Memory.get_sampling_profile`."""
+    profile: SamplingProfile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='Memory.SamplingProfile'),
+    )
+
+
+class Memory:
+    """Commands of the Memory domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def get_dom_counters(self) -> GetDOMCountersReturn:
+        """Retruns current DOM object counters."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.getDOMCounters', _params)
+        return GetDOMCountersReturn.from_json(_result)
+
+    async def get_dom_counters_for_leak_detection(self) -> GetDOMCountersForLeakDetectionReturn:
+        """Retruns DOM object counters after preparing renderer for leak detection."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.getDOMCountersForLeakDetection', _params)
+        return GetDOMCountersForLeakDetectionReturn.from_json(_result)
+
+    async def prepare_for_leak_detection(self) -> None:
+        """
+        Prepares for leak detection by terminating workers, stopping spellcheckers,
+        dropping non-essential internal caches, running garbage collections, etc.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.prepareForLeakDetection', _params)
+        return None
+
+    async def forcibly_purge_java_script_memory(self) -> None:
+        """Simulate OomIntervention by purging V8 memory."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.forciblyPurgeJavaScriptMemory', _params)
+        return None
+
+    async def set_pressure_notifications_suppressed(self, *, suppressed: bool) -> None:
+        """
+        Enable/disable suppressing memory pressure notifications in all processes.
+        :param suppressed: If true, memory pressure notifications will be suppressed.
+        """
+        _params: Dict[str, Any] = {}
+        _params['suppressed'] = encode(FieldMeta('', '', False, 'primitive'), suppressed)
+        _result = await self._target.send('Memory.setPressureNotificationsSuppressed', _params)
+        return None
+
+    async def simulate_pressure_notification(self, *, level: PressureLevel) -> None:
+        """
+        Simulate a memory pressure notification in all processes.
+        :param level: Memory pressure level of the notification.
+        """
+        _params: Dict[str, Any] = {}
+        _params['level'] = encode(FieldMeta('', '', False, 'enum', ref='Memory.PressureLevel'), level)
+        _result = await self._target.send('Memory.simulatePressureNotification', _params)
+        return None
+
+    async def start_sampling(self, *, sampling_interval: Optional[int] = None, suppress_randomness: Optional[bool] = None) -> None:
+        """
+        Start collecting native memory profile.
+        :param sampling_interval: Average number of bytes between samples.
+        :param suppress_randomness: Do not randomize intervals between samples.
+        """
+        _params: Dict[str, Any] = {}
+        if sampling_interval is not None:
+            _params['samplingInterval'] = encode(FieldMeta('', '', False, 'primitive'), sampling_interval)
+        if suppress_randomness is not None:
+            _params['suppressRandomness'] = encode(FieldMeta('', '', False, 'primitive'), suppress_randomness)
+        _result = await self._target.send('Memory.startSampling', _params)
+        return None
+
+    async def stop_sampling(self) -> None:
+        """Stop collecting native memory profile."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.stopSampling', _params)
+        return None
+
+    async def get_all_time_sampling_profile(self) -> GetAllTimeSamplingProfileReturn:
+        """
+        Retrieve native memory allocations profile
+        collected since renderer process startup.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.getAllTimeSamplingProfile', _params)
+        return GetAllTimeSamplingProfileReturn.from_json(_result)
+
+    async def get_browser_sampling_profile(self) -> GetBrowserSamplingProfileReturn:
+        """
+        Retrieve native memory allocations profile
+        collected since browser process startup.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.getBrowserSamplingProfile', _params)
+        return GetBrowserSamplingProfileReturn.from_json(_result)
+
+    async def get_sampling_profile(self) -> GetSamplingProfileReturn:
+        """
+        Retrieve native memory allocations profile collected since last
+        `startSampling` call.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Memory.getSamplingProfile', _params)
+        return GetSamplingProfileReturn.from_json(_result)

parsek_cdp/cdp/memory/types.py

@@ -0,0 +1,71 @@
+"""Custom types and enums for the Memory 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("Memory.PressureLevel")
+class PressureLevel(str, Enum):
+    """Memory pressure level."""
+    MODERATE = 'moderate'
+    CRITICAL = 'critical'
+
+
+@register("Memory.SamplingProfileNode")
+@dataclass
+class SamplingProfileNode(DataType):
+    """Heap profile sample."""
+    size: float
+    total: float
+    stack: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('size', 'size', False, 'primitive'),
+        FieldMeta('total', 'total', False, 'primitive'),
+        FieldMeta('stack', 'stack', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("Memory.SamplingProfile")
+@dataclass
+class SamplingProfile(DataType):
+    """Array of heap profile samples."""
+    samples: List[SamplingProfileNode]
+    modules: List[Module]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('samples', 'samples', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Memory.SamplingProfileNode')),
+        FieldMeta('modules', 'modules', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Memory.Module')),
+    )
+
+
+@register("Memory.Module")
+@dataclass
+class Module(DataType):
+    """Executable module information"""
+    name: str
+    uuid: str
+    base_address: str
+    size: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('uuid', 'uuid', False, 'primitive'),
+        FieldMeta('base_address', 'baseAddress', False, 'primitive'),
+        FieldMeta('size', 'size', False, 'primitive'),
+    )
+
+
+@register("Memory.DOMCounter")
+@dataclass
+class DOMCounter(DataType):
+    """DOM object counter data."""
+    name: str
+    count: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('count', 'count', False, 'primitive'),
+    )
+
+__all__ = ["DOMCounter", "Module", "PressureLevel", "SamplingProfile", "SamplingProfileNode"]

parsek_cdp/cdp/mixins/__init__.py

@@ -0,0 +1,21 @@
+from .datatype import (
+    TYPE_REGISTRY,
+    DataType,
+    FieldMeta,
+    decode,
+    encode,
+    register,
+)
+from .event import EVENT_REGISTRY, Event, register_event
+
+__all__ = [
+    "TYPE_REGISTRY",
+    "DataType",
+    "FieldMeta",
+    "decode",
+    "encode",
+    "register",
+    "EVENT_REGISTRY",
+    "Event",
+    "register_event",
+]

parsek_cdp/cdp/mixins/datatype.py

@@ -0,0 +1,123 @@
+"""Base machinery for CDP data types.
+
+A ``DataType`` behaves like a :func:`dataclasses.dataclass` but additionally
+knows how to serialize/deserialize itself to/from the JSON shapes used on the
+wire by the Chrome DevTools Protocol.
+
+Python uses ``snake_case`` identifiers while the protocol uses ``camelCase``
+keys, so a plain ``dataclasses.asdict`` is not enough -- every field carries a
+:class:`FieldMeta` describing both names plus how nested values are encoded.
+
+To avoid import cycles between domains (CDP has many cross-domain references,
+some of them circular) nested enum / object types are resolved lazily at
+runtime through :data:`TYPE_REGISTRY` keyed by the fully-qualified protocol
+name (``"Domain.TypeName"``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Callable, ClassVar, Optional, TypeVar
+
+# Fully-qualified protocol name ("Domain.TypeName") -> python class.
+# Only enums and object data types are registered; aliases to primitives or
+# arrays are resolved at generation time and never need a runtime lookup.
+TYPE_REGISTRY: dict[str, type] = {}
+
+T = TypeVar("T")
+
+
+def register(qualified_name: str) -> Callable[[type[T]], type[T]]:
+    """Class decorator registering ``cls`` under its protocol name.
+
+    The class's concrete type is preserved so type checkers still see its
+    fields after decoration.
+    """
+
+    def deco(cls: type[T]) -> type[T]:
+        TYPE_REGISTRY[qualified_name] = cls
+        return cls
+
+    return deco
+
+
+@dataclass(frozen=True)
+class FieldMeta:
+    """Describes how a single field maps between python and the wire format.
+
+    ``kind`` is one of ``"primitive"``, ``"enum"``, ``"object"`` or
+    ``"array"``.  ``ref`` holds the fully-qualified protocol name for
+    ``enum``/``object`` kinds.  ``inner`` holds the element metadata for
+    ``array`` kinds.
+    """
+
+    py_name: str
+    json_name: str
+    optional: bool
+    kind: str
+    ref: Optional[str] = None
+    inner: Optional["FieldMeta"] = None
+
+
+def decode(meta: FieldMeta, value: Any) -> Any:
+    """Convert a raw JSON ``value`` into its python representation."""
+    if value is None:
+        return None
+    if meta.kind == "primitive":
+        return value
+    if meta.kind == "enum":
+        return TYPE_REGISTRY[meta.ref](value)  # type: ignore[index]
+    if meta.kind == "object":
+        return TYPE_REGISTRY[meta.ref].from_json(value)  # type: ignore[union-attr]
+    if meta.kind == "array":
+        assert meta.inner is not None
+        return [decode(meta.inner, v) for v in value]
+    return value
+
+
+def encode(meta: FieldMeta, value: Any) -> Any:
+    """Convert a python ``value`` into its raw JSON representation."""
+    if value is None:
+        return None
+    if meta.kind == "primitive":
+        return value
+    if meta.kind == "enum":
+        return value.value if isinstance(value, Enum) else value
+    if meta.kind == "object":
+        return value.to_json() if isinstance(value, DataType) else value
+    if meta.kind == "array":
+        assert meta.inner is not None
+        return [encode(meta.inner, v) for v in value]
+    return value
+
+
+class DataType:
+    """Mixin providing JSON (de)serialization driven by :data:`__FIELDS__`."""
+
+    __FIELDS__: ClassVar[tuple[FieldMeta, ...]] = ()
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]):
+        """Build an instance from a raw protocol object.
+
+        Tolerant of protocol drift: a field the running browser omits (e.g. a
+        "required" field renamed in a newer Chrome than the bundled schema) is
+        set to ``None`` instead of raising, and unknown extra keys in ``data``
+        are ignored since only declared :data:`__FIELDS__` are read.
+        """
+        kwargs: dict[str, Any] = {}
+        for fm in cls.__FIELDS__:
+            raw = data.get(fm.json_name)
+            kwargs[fm.py_name] = decode(fm, raw) if raw is not None else None
+        return cls(**kwargs)
+
+    def to_json(self) -> dict[str, Any]:
+        """Serialize to a raw protocol object, dropping unset optionals."""
+        out: dict[str, Any] = {}
+        for fm in self.__FIELDS__:
+            value = getattr(self, fm.py_name)
+            if value is None and fm.optional:
+                continue
+            out[fm.json_name] = encode(fm, value)
+        return out