parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/performance/__init__.py

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

parsek_cdp/cdp/performance/events.py

@@ -0,0 +1,24 @@
+"""Events for the Performance 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 Metric
+
+@register_event("Performance.metrics")
+@dataclass
+class Metrics(Event):
+    """Current values of the metrics."""
+    metrics: List[Metric]
+    title: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('metrics', 'metrics', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Performance.Metric')),
+        FieldMeta('title', 'title', False, 'primitive'),
+    )
+
+__all__ = ["Metrics"]

parsek_cdp/cdp/performance/functions.py

@@ -0,0 +1,63 @@
+"""Commands for the Performance 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 Metric
+
+@dataclass
+class GetMetricsReturn(DataType):
+    """Return value of :meth:`Performance.get_metrics`."""
+    metrics: List[Metric]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('metrics', 'metrics', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Performance.Metric')),
+    )
+
+
+class Performance:
+    """Commands of the Performance domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disable collecting and reporting metrics."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Performance.disable', _params)
+        return None
+
+    async def enable(self, *, time_domain: Optional[Literal['timeTicks', 'threadTicks']] = None) -> None:
+        """
+        Enable collecting and reporting metrics.
+        :param time_domain: Time domain to use for collecting and reporting duration metrics.
+        """
+        _params: Dict[str, Any] = {}
+        if time_domain is not None:
+            _params['timeDomain'] = encode(FieldMeta('', '', False, 'primitive'), time_domain)
+        _result = await self._target.send('Performance.enable', _params)
+        return None
+
+    async def set_time_domain(self, *, time_domain: Literal['timeTicks', 'threadTicks']) -> None:
+        """
+        Sets time domain to use for collecting and reporting duration metrics.
+        Note that this must be called before enabling metrics collection. Calling
+        this method while metrics collection is enabled returns an error.
+        
+        .. deprecated::
+        :param time_domain: Time domain
+        """
+        _params: Dict[str, Any] = {}
+        _params['timeDomain'] = encode(FieldMeta('', '', False, 'primitive'), time_domain)
+        _result = await self._target.send('Performance.setTimeDomain', _params)
+        return None
+
+    async def get_metrics(self) -> GetMetricsReturn:
+        """Retrieve current values of run-time metrics."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Performance.getMetrics', _params)
+        return GetMetricsReturn.from_json(_result)

parsek_cdp/cdp/performance/types.py

@@ -0,0 +1,22 @@
+"""Custom types and enums for the Performance 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("Performance.Metric")
+@dataclass
+class Metric(DataType):
+    """Run-time execution metric."""
+    name: str
+    value: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+__all__ = ["Metric"]

parsek_cdp/cdp/performancetimeline/__init__.py

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

parsek_cdp/cdp/performancetimeline/events.py

@@ -0,0 +1,22 @@
+"""Events for the PerformanceTimeline 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 TimelineEvent
+
+@register_event("PerformanceTimeline.timelineEventAdded")
+@dataclass
+class TimelineEventAdded(Event):
+    """Sent when a performance timeline event is added. See reportPerformanceTimeline method."""
+    event: TimelineEvent
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('event', 'event', False, 'object', ref='PerformanceTimeline.TimelineEvent'),
+    )
+
+__all__ = ["TimelineEventAdded"]

parsek_cdp/cdp/performancetimeline/functions.py

@@ -0,0 +1,30 @@
+"""Commands for the PerformanceTimeline 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 PerformanceTimeline:
+    """Commands of the PerformanceTimeline domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self, *, event_types: List[str]) -> None:
+        """
+        Previously buffered events would be reported before method returns.
+        See also: timelineEventAdded
+        :param event_types: The types of event to report, as specified in
+        https://w3c.github.io/performance-timeline/#dom-performanceentry-entrytype
+        The specified filter overrides any previous filters, passing empty
+        filter disables recording.
+        Note that not all types exposed to the web platform are currently supported.
+        """
+        _params: Dict[str, Any] = {}
+        _params['eventTypes'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), event_types)
+        _result = await self._target.send('PerformanceTimeline.enable', _params)
+        return None

parsek_cdp/cdp/performancetimeline/types.py

@@ -0,0 +1,85 @@
+"""Custom types and enums for the PerformanceTimeline 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 ..dom.types import Rect as DOM_Rect
+    from ..network.types import TimeSinceEpoch as Network_TimeSinceEpoch
+    from ..page.types import FrameId as Page_FrameId
+
+@register("PerformanceTimeline.LargestContentfulPaint")
+@dataclass
+class LargestContentfulPaint(DataType):
+    """See https://github.com/WICG/LargestContentfulPaint and largest_contentful_paint.idl"""
+    render_time: Network_TimeSinceEpoch
+    load_time: Network_TimeSinceEpoch
+    size: float
+    element_id: Optional[str] = None
+    url: Optional[str] = None
+    node_id: Optional[DOM_BackendNodeId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('render_time', 'renderTime', False, 'primitive'),
+        FieldMeta('load_time', 'loadTime', False, 'primitive'),
+        FieldMeta('size', 'size', False, 'primitive'),
+        FieldMeta('element_id', 'elementId', True, 'primitive'),
+        FieldMeta('url', 'url', True, 'primitive'),
+        FieldMeta('node_id', 'nodeId', True, 'primitive'),
+    )
+
+
+@register("PerformanceTimeline.LayoutShiftAttribution")
+@dataclass
+class LayoutShiftAttribution(DataType):
+    previous_rect: DOM_Rect
+    current_rect: DOM_Rect
+    node_id: Optional[DOM_BackendNodeId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('previous_rect', 'previousRect', False, 'object', ref='DOM.Rect'),
+        FieldMeta('current_rect', 'currentRect', False, 'object', ref='DOM.Rect'),
+        FieldMeta('node_id', 'nodeId', True, 'primitive'),
+    )
+
+
+@register("PerformanceTimeline.LayoutShift")
+@dataclass
+class LayoutShift(DataType):
+    """See https://wicg.github.io/layout-instability/#sec-layout-shift and layout_shift.idl"""
+    value: float
+    had_recent_input: bool
+    last_input_time: Network_TimeSinceEpoch
+    sources: List[LayoutShiftAttribution]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('value', 'value', False, 'primitive'),
+        FieldMeta('had_recent_input', 'hadRecentInput', False, 'primitive'),
+        FieldMeta('last_input_time', 'lastInputTime', False, 'primitive'),
+        FieldMeta('sources', 'sources', False, 'array', inner=FieldMeta('', '', False, 'object', ref='PerformanceTimeline.LayoutShiftAttribution')),
+    )
+
+
+@register("PerformanceTimeline.TimelineEvent")
+@dataclass
+class TimelineEvent(DataType):
+    frame_id: Page_FrameId
+    type_: str
+    name: str
+    time: Network_TimeSinceEpoch
+    duration: Optional[float] = None
+    lcp_details: Optional[LargestContentfulPaint] = None
+    layout_shift_details: Optional[LayoutShift] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('time', 'time', False, 'primitive'),
+        FieldMeta('duration', 'duration', True, 'primitive'),
+        FieldMeta('lcp_details', 'lcpDetails', True, 'object', ref='PerformanceTimeline.LargestContentfulPaint'),
+        FieldMeta('layout_shift_details', 'layoutShiftDetails', True, 'object', ref='PerformanceTimeline.LayoutShift'),
+    )
+
+__all__ = ["LargestContentfulPaint", "LayoutShift", "LayoutShiftAttribution", "TimelineEvent"]

parsek_cdp/cdp/preload/__init__.py

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

parsek_cdp/cdp/preload/events.py

@@ -0,0 +1,116 @@
+"""Events for the Preload 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 (
+        PrefetchStatus,
+        PreloadPipelineId,
+        PreloadingAttemptKey,
+        PreloadingAttemptSource,
+        PreloadingStatus,
+        PrerenderFinalStatus,
+        PrerenderMismatchedHeaders,
+        RuleSet,
+        RuleSetId,
+    )
+    from ..network.types import LoaderId as Network_LoaderId
+    from ..network.types import RequestId as Network_RequestId
+    from ..page.types import FrameId as Page_FrameId
+
+@register_event("Preload.ruleSetUpdated")
+@dataclass
+class RuleSetUpdated(Event):
+    """Upsert. Currently, it is only emitted when a rule set added."""
+    rule_set: RuleSet
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('rule_set', 'ruleSet', False, 'object', ref='Preload.RuleSet'),
+    )
+
+
+@register_event("Preload.ruleSetRemoved")
+@dataclass
+class RuleSetRemoved(Event):
+    id: RuleSetId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+    )
+
+
+@register_event("Preload.preloadEnabledStateUpdated")
+@dataclass
+class PreloadEnabledStateUpdated(Event):
+    """Fired when a preload enabled state is updated."""
+    disabled_by_preference: bool
+    disabled_by_data_saver: bool
+    disabled_by_battery_saver: bool
+    disabled_by_holdback_prefetch_speculation_rules: bool
+    disabled_by_holdback_prerender_speculation_rules: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('disabled_by_preference', 'disabledByPreference', False, 'primitive'),
+        FieldMeta('disabled_by_data_saver', 'disabledByDataSaver', False, 'primitive'),
+        FieldMeta('disabled_by_battery_saver', 'disabledByBatterySaver', False, 'primitive'),
+        FieldMeta('disabled_by_holdback_prefetch_speculation_rules', 'disabledByHoldbackPrefetchSpeculationRules', False, 'primitive'),
+        FieldMeta('disabled_by_holdback_prerender_speculation_rules', 'disabledByHoldbackPrerenderSpeculationRules', False, 'primitive'),
+    )
+
+
+@register_event("Preload.prefetchStatusUpdated")
+@dataclass
+class PrefetchStatusUpdated(Event):
+    """Fired when a prefetch attempt is updated."""
+    key: PreloadingAttemptKey
+    pipeline_id: PreloadPipelineId
+    initiating_frame_id: Page_FrameId
+    prefetch_url: str
+    status: PreloadingStatus
+    prefetch_status: PrefetchStatus
+    request_id: Network_RequestId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'object', ref='Preload.PreloadingAttemptKey'),
+        FieldMeta('pipeline_id', 'pipelineId', False, 'primitive'),
+        FieldMeta('initiating_frame_id', 'initiatingFrameId', False, 'primitive'),
+        FieldMeta('prefetch_url', 'prefetchUrl', False, 'primitive'),
+        FieldMeta('status', 'status', False, 'enum', ref='Preload.PreloadingStatus'),
+        FieldMeta('prefetch_status', 'prefetchStatus', False, 'enum', ref='Preload.PrefetchStatus'),
+        FieldMeta('request_id', 'requestId', False, 'primitive'),
+    )
+
+
+@register_event("Preload.prerenderStatusUpdated")
+@dataclass
+class PrerenderStatusUpdated(Event):
+    """Fired when a prerender attempt is updated."""
+    key: PreloadingAttemptKey
+    pipeline_id: PreloadPipelineId
+    status: PreloadingStatus
+    prerender_status: Optional[PrerenderFinalStatus] = None
+    disallowed_mojo_interface: Optional[str] = None
+    mismatched_headers: Optional[List[PrerenderMismatchedHeaders]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'object', ref='Preload.PreloadingAttemptKey'),
+        FieldMeta('pipeline_id', 'pipelineId', False, 'primitive'),
+        FieldMeta('status', 'status', False, 'enum', ref='Preload.PreloadingStatus'),
+        FieldMeta('prerender_status', 'prerenderStatus', True, 'enum', ref='Preload.PrerenderFinalStatus'),
+        FieldMeta('disallowed_mojo_interface', 'disallowedMojoInterface', True, 'primitive'),
+        FieldMeta('mismatched_headers', 'mismatchedHeaders', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Preload.PrerenderMismatchedHeaders')),
+    )
+
+
+@register_event("Preload.preloadingAttemptSourcesUpdated")
+@dataclass
+class PreloadingAttemptSourcesUpdated(Event):
+    """Send a list of sources for all preloading attempts in a document."""
+    loader_id: Network_LoaderId
+    preloading_attempt_sources: List[PreloadingAttemptSource]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('loader_id', 'loaderId', False, 'primitive'),
+        FieldMeta('preloading_attempt_sources', 'preloadingAttemptSources', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Preload.PreloadingAttemptSource')),
+    )
+
+__all__ = ["PrefetchStatusUpdated", "PreloadEnabledStateUpdated", "PreloadingAttemptSourcesUpdated", "PrerenderStatusUpdated", "RuleSetRemoved", "RuleSetUpdated"]

parsek_cdp/cdp/preload/functions.py

@@ -0,0 +1,25 @@
+"""Commands for the Preload 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 Preload:
+    """Commands of the Preload domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Preload.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Preload.disable', _params)
+        return None