parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/cachestorage/types.py

@@ -0,0 +1,89 @@
+"""Custom types and enums for the CacheStorage 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 ..storage.types import StorageBucket as Storage_StorageBucket
+
+type CacheId = str  # Unique identifier of the Cache object.
+
+
+@register("CacheStorage.CachedResponseType")
+class CachedResponseType(str, Enum):
+    """type of HTTP response cached"""
+    BASIC = 'basic'
+    CORS = 'cors'
+    DEFAULT = 'default'
+    ERROR = 'error'
+    OPAQUERESPONSE = 'opaqueResponse'
+    OPAQUEREDIRECT = 'opaqueRedirect'
+
+
+@register("CacheStorage.DataEntry")
+@dataclass
+class DataEntry(DataType):
+    """Data entry."""
+    request_url: str
+    request_method: str
+    request_headers: List[Header]
+    response_time: float
+    response_status: int
+    response_status_text: str
+    response_type: CachedResponseType
+    response_headers: List[Header]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('request_url', 'requestURL', False, 'primitive'),
+        FieldMeta('request_method', 'requestMethod', False, 'primitive'),
+        FieldMeta('request_headers', 'requestHeaders', False, 'array', inner=FieldMeta('', '', False, 'object', ref='CacheStorage.Header')),
+        FieldMeta('response_time', 'responseTime', False, 'primitive'),
+        FieldMeta('response_status', 'responseStatus', False, 'primitive'),
+        FieldMeta('response_status_text', 'responseStatusText', False, 'primitive'),
+        FieldMeta('response_type', 'responseType', False, 'enum', ref='CacheStorage.CachedResponseType'),
+        FieldMeta('response_headers', 'responseHeaders', False, 'array', inner=FieldMeta('', '', False, 'object', ref='CacheStorage.Header')),
+    )
+
+
+@register("CacheStorage.Cache")
+@dataclass
+class Cache(DataType):
+    """Cache identifier."""
+    cache_id: CacheId
+    security_origin: str
+    storage_key: str
+    cache_name: str
+    storage_bucket: Optional[Storage_StorageBucket] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('cache_id', 'cacheId', False, 'primitive'),
+        FieldMeta('security_origin', 'securityOrigin', False, 'primitive'),
+        FieldMeta('storage_key', 'storageKey', False, 'primitive'),
+        FieldMeta('cache_name', 'cacheName', False, 'primitive'),
+        FieldMeta('storage_bucket', 'storageBucket', True, 'object', ref='Storage.StorageBucket'),
+    )
+
+
+@register("CacheStorage.Header")
+@dataclass
+class Header(DataType):
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("CacheStorage.CachedResponse")
+@dataclass
+class CachedResponse(DataType):
+    """Cached response"""
+    body: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('body', 'body', False, 'primitive'),
+    )
+
+__all__ = ["Cache", "CacheId", "CachedResponse", "CachedResponseType", "DataEntry", "Header"]

parsek_cdp/cdp/cast/__init__.py

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

parsek_cdp/cdp/cast/events.py

@@ -0,0 +1,38 @@
+"""Events for the Cast 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 Sink
+
+@register_event("Cast.sinksUpdated")
+@dataclass
+class SinksUpdated(Event):
+    """
+    This is fired whenever the list of available sinks changes. A sink is a
+    device or a software surface that you can cast to.
+    """
+    sinks: List[Sink]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('sinks', 'sinks', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Cast.Sink')),
+    )
+
+
+@register_event("Cast.issueUpdated")
+@dataclass
+class IssueUpdated(Event):
+    """
+    This is fired whenever the outstanding issue/error message changes.
+    |issueMessage| is empty if there is no issue.
+    """
+    issue_message: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('issue_message', 'issueMessage', False, 'primitive'),
+    )
+
+__all__ = ["IssueUpdated", "SinksUpdated"]

parsek_cdp/cdp/cast/functions.py

@@ -0,0 +1,77 @@
+"""Commands for the Cast 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 Cast:
+    """Commands of the Cast domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self, *, presentation_url: Optional[str] = None) -> None:
+        """
+        Starts observing for sinks that can be used for tab mirroring, and if set,
+        sinks compatible with |presentationUrl| as well. When sinks are found, a
+        |sinksUpdated| event is fired.
+        Also starts observing for issue messages. When an issue is added or removed,
+        an |issueUpdated| event is fired.
+        :param presentation_url:
+        """
+        _params: Dict[str, Any] = {}
+        if presentation_url is not None:
+            _params['presentationUrl'] = encode(FieldMeta('', '', False, 'primitive'), presentation_url)
+        _result = await self._target.send('Cast.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Stops observing for sinks and issues."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Cast.disable', _params)
+        return None
+
+    async def set_sink_to_use(self, *, sink_name: str) -> None:
+        """
+        Sets a sink to be used when the web page requests the browser to choose a
+        sink via Presentation API, Remote Playback API, or Cast SDK.
+        :param sink_name:
+        """
+        _params: Dict[str, Any] = {}
+        _params['sinkName'] = encode(FieldMeta('', '', False, 'primitive'), sink_name)
+        _result = await self._target.send('Cast.setSinkToUse', _params)
+        return None
+
+    async def start_desktop_mirroring(self, *, sink_name: str) -> None:
+        """
+        Starts mirroring the desktop to the sink.
+        :param sink_name:
+        """
+        _params: Dict[str, Any] = {}
+        _params['sinkName'] = encode(FieldMeta('', '', False, 'primitive'), sink_name)
+        _result = await self._target.send('Cast.startDesktopMirroring', _params)
+        return None
+
+    async def start_tab_mirroring(self, *, sink_name: str) -> None:
+        """
+        Starts mirroring the tab to the sink.
+        :param sink_name:
+        """
+        _params: Dict[str, Any] = {}
+        _params['sinkName'] = encode(FieldMeta('', '', False, 'primitive'), sink_name)
+        _result = await self._target.send('Cast.startTabMirroring', _params)
+        return None
+
+    async def stop_casting(self, *, sink_name: str) -> None:
+        """
+        Stops the active Cast session on the sink.
+        :param sink_name:
+        """
+        _params: Dict[str, Any] = {}
+        _params['sinkName'] = encode(FieldMeta('', '', False, 'primitive'), sink_name)
+        _result = await self._target.send('Cast.stopCasting', _params)
+        return None

parsek_cdp/cdp/cast/types.py

@@ -0,0 +1,23 @@
+"""Custom types and enums for the Cast 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("Cast.Sink")
+@dataclass
+class Sink(DataType):
+    name: str
+    id: str
+    session: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('session', 'session', True, 'primitive'),
+    )
+
+__all__ = ["Sink"]

parsek_cdp/cdp/console/__init__.py

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

parsek_cdp/cdp/console/events.py

@@ -0,0 +1,22 @@
+"""Events for the Console 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 ConsoleMessage
+
+@register_event("Console.messageAdded")
+@dataclass
+class MessageAdded(Event):
+    """Issued when new console message is added."""
+    message: ConsoleMessage
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('message', 'message', False, 'object', ref='Console.ConsoleMessage'),
+    )
+
+__all__ = ["MessageAdded"]

parsek_cdp/cdp/console/functions.py

@@ -0,0 +1,36 @@
+"""Commands for the Console 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 Console:
+    """Commands of the Console domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def clear_messages(self) -> None:
+        """Does nothing."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Console.clearMessages', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables console domain, prevents further console messages from being reported to the client."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Console.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """
+        Enables console domain, sends the messages collected so far to the client by means of the
+        `messageAdded` notification.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Console.enable', _params)
+        return None

parsek_cdp/cdp/console/types.py

@@ -0,0 +1,30 @@
+"""Custom types and enums for the Console 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("Console.ConsoleMessage")
+@dataclass
+class ConsoleMessage(DataType):
+    """Console message."""
+    source: Literal['xml', 'javascript', 'network', 'console-api', 'storage', 'appcache', 'rendering', 'security', 'other', 'deprecation', 'worker']
+    level: Literal['log', 'warning', 'error', 'debug', 'info']
+    text: str
+    url: Optional[str] = None
+    line: Optional[int] = None
+    column: Optional[int] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('source', 'source', False, 'primitive'),
+        FieldMeta('level', 'level', False, 'primitive'),
+        FieldMeta('text', 'text', False, 'primitive'),
+        FieldMeta('url', 'url', True, 'primitive'),
+        FieldMeta('line', 'line', True, 'primitive'),
+        FieldMeta('column', 'column', True, 'primitive'),
+    )
+
+__all__ = ["ConsoleMessage"]

parsek_cdp/cdp/css/__init__.py

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

parsek_cdp/cdp/css/events.py

@@ -0,0 +1,79 @@
+"""Events for the CSS 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 (
+        CSSStyleSheetHeader,
+        FontFace,
+    )
+    from ..dom.types import NodeId as DOM_NodeId
+    from ..dom.types import StyleSheetId as DOM_StyleSheetId
+
+@register_event("CSS.fontsUpdated")
+@dataclass
+class FontsUpdated(Event):
+    """
+    Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded
+    web font.
+    """
+    font: Optional[FontFace] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('font', 'font', True, 'object', ref='CSS.FontFace'),
+    )
+
+
+@register_event("CSS.mediaQueryResultChanged")
+@dataclass
+class MediaQueryResultChanged(Event):
+    """
+    Fires whenever a MediaQuery result changes (for example, after a browser window has been
+    resized.) The current implementation considers only viewport-dependent media features.
+    """
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("CSS.styleSheetAdded")
+@dataclass
+class StyleSheetAdded(Event):
+    """Fired whenever an active document stylesheet is added."""
+    header: CSSStyleSheetHeader
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('header', 'header', False, 'object', ref='CSS.CSSStyleSheetHeader'),
+    )
+
+
+@register_event("CSS.styleSheetChanged")
+@dataclass
+class StyleSheetChanged(Event):
+    """Fired whenever a stylesheet is changed as a result of the client operation."""
+    style_sheet_id: DOM_StyleSheetId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('style_sheet_id', 'styleSheetId', False, 'primitive'),
+    )
+
+
+@register_event("CSS.styleSheetRemoved")
+@dataclass
+class StyleSheetRemoved(Event):
+    """Fired whenever an active document stylesheet is removed."""
+    style_sheet_id: DOM_StyleSheetId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('style_sheet_id', 'styleSheetId', False, 'primitive'),
+    )
+
+
+@register_event("CSS.computedStyleUpdated")
+@dataclass
+class ComputedStyleUpdated(Event):
+    node_id: DOM_NodeId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+    )
+
+__all__ = ["ComputedStyleUpdated", "FontsUpdated", "MediaQueryResultChanged", "StyleSheetAdded", "StyleSheetChanged", "StyleSheetRemoved"]