parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/pwa/functions.py

@@ -0,0 +1,196 @@
+"""Commands for the PWA 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 (
+        DisplayMode,
+        FileHandler,
+    )
+    from ..target.types import TargetID as Target_TargetID
+
+@dataclass
+class GetOsAppStateReturn(DataType):
+    """Return value of :meth:`PWA.get_os_app_state`."""
+    badge_count: int
+    file_handlers: List[FileHandler]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('badge_count', 'badgeCount', False, 'primitive'),
+        FieldMeta('file_handlers', 'fileHandlers', False, 'array', inner=FieldMeta('', '', False, 'object', ref='PWA.FileHandler')),
+    )
+
+
+@dataclass
+class LaunchReturn(DataType):
+    """Return value of :meth:`PWA.launch`."""
+    target_id: Target_TargetID
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('target_id', 'targetId', False, 'primitive'),
+    )
+
+
+@dataclass
+class LaunchFilesInAppReturn(DataType):
+    """Return value of :meth:`PWA.launch_files_in_app`."""
+    target_ids: List[Target_TargetID]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('target_ids', 'targetIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+class PWA:
+    """Commands of the PWA domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def get_os_app_state(self, *, manifest_id: str) -> GetOsAppStateReturn:
+        """
+        Returns the following OS state for the given manifest id.
+        :param manifest_id: The id from the webapp's manifest file, commonly it's the url of the
+        site installing the webapp. See
+        https://web.dev/learn/pwa/web-app-manifest.
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        _result = await self._target.send('PWA.getOsAppState', _params)
+        return GetOsAppStateReturn.from_json(_result)
+
+    async def install(self, *, manifest_id: str, install_url_or_bundle_url: Optional[str] = None) -> None:
+        """
+        Installs the given manifest identity, optionally using the given installUrlOrBundleUrl
+        
+        IWA-specific install description:
+        manifestId corresponds to isolated-app:// + web_package::SignedWebBundleId
+        
+        File installation mode:
+        The installUrlOrBundleUrl can be either file:// or http(s):// pointing
+        to a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to
+        The .swbn file's signing key.
+        
+        Dev proxy installation mode:
+        installUrlOrBundleUrl must be http(s):// that serves dev mode IWA.
+        web_package::SignedWebBundleId must be of type dev proxy.
+        
+        The advantage of dev proxy mode is that all changes to IWA
+        automatically will be reflected in the running app without
+        reinstallation.
+        
+        To generate bundle id for proxy mode:
+        1. Generate 32 random bytes.
+        2. Add a specific suffix at the end following the documentation
+           https://github.com/WICG/isolated-web-apps/blob/main/Scheme.md#suffix
+        3. Encode the entire sequence using Base32 without padding.
+        
+        If Chrome is not in IWA dev
+        mode, the installation will fail, regardless of the state of the allowlist.
+        :param manifest_id:
+        :param install_url_or_bundle_url: The location of the app or bundle overriding the one derived from the
+        manifestId.
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        if install_url_or_bundle_url is not None:
+            _params['installUrlOrBundleUrl'] = encode(FieldMeta('', '', False, 'primitive'), install_url_or_bundle_url)
+        _result = await self._target.send('PWA.install', _params)
+        return None
+
+    async def uninstall(self, *, manifest_id: str) -> None:
+        """
+        Uninstalls the given manifest_id and closes any opened app windows.
+        :param manifest_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        _result = await self._target.send('PWA.uninstall', _params)
+        return None
+
+    async def launch(self, *, manifest_id: str, url: Optional[str] = None) -> LaunchReturn:
+        """
+        Launches the installed web app, or an url in the same web app instead of the
+        default start url if it is provided. Returns a page Target.TargetID which
+        can be used to attach to via Target.attachToTarget or similar APIs.
+        :param manifest_id:
+        :param url:
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        if url is not None:
+            _params['url'] = encode(FieldMeta('', '', False, 'primitive'), url)
+        _result = await self._target.send('PWA.launch', _params)
+        return LaunchReturn.from_json(_result)
+
+    async def launch_files_in_app(self, *, manifest_id: str, files: List[str]) -> LaunchFilesInAppReturn:
+        """
+        Opens one or more local files from an installed web app identified by its
+        manifestId. The web app needs to have file handlers registered to process
+        the files. The API returns one or more page Target.TargetIDs which can be
+        used to attach to via Target.attachToTarget or similar APIs.
+        If some files in the parameters cannot be handled by the web app, they will
+        be ignored. If none of the files can be handled, this API returns an error.
+        If no files are provided as the parameter, this API also returns an error.
+        
+        According to the definition of the file handlers in the manifest file, one
+        Target.TargetID may represent a page handling one or more files. The order
+        of the returned Target.TargetIDs is not guaranteed.
+        
+        TODO(crbug.com/339454034): Check the existences of the input files.
+        :param manifest_id:
+        :param files:
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        _params['files'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), files)
+        _result = await self._target.send('PWA.launchFilesInApp', _params)
+        return LaunchFilesInAppReturn.from_json(_result)
+
+    async def open_current_page_in_app(self, *, manifest_id: str) -> None:
+        """
+        Opens the current page in its web app identified by the manifest id, needs
+        to be called on a page target. This function returns immediately without
+        waiting for the app to finish loading.
+        :param manifest_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        _result = await self._target.send('PWA.openCurrentPageInApp', _params)
+        return None
+
+    async def change_app_user_settings(self, *, manifest_id: str, link_capturing: Optional[bool] = None, display_mode: Optional[DisplayMode] = None) -> None:
+        """
+        Changes user settings of the web app identified by its manifestId. If the
+        app was not installed, this command returns an error. Unset parameters will
+        be ignored; unrecognized values will cause an error.
+        
+        Unlike the ones defined in the manifest files of the web apps, these
+        settings are provided by the browser and controlled by the users, they
+        impact the way the browser handling the web apps.
+        
+        See the comment of each parameter.
+        :param manifest_id:
+        :param link_capturing: If user allows the links clicked on by the user in the app's scope, or
+        extended scope if the manifest has scope extensions and the flags
+        `DesktopPWAsLinkCapturingWithScopeExtensions` and
+        `WebAppEnableScopeExtensions` are enabled.
+        
+        Note, the API does not support resetting the linkCapturing to the
+        initial value, uninstalling and installing the web app again will reset
+        it.
+        
+        TODO(crbug.com/339453269): Setting this value on ChromeOS is not
+        supported yet.
+        :param display_mode:
+        """
+        _params: Dict[str, Any] = {}
+        _params['manifestId'] = encode(FieldMeta('', '', False, 'primitive'), manifest_id)
+        if link_capturing is not None:
+            _params['linkCapturing'] = encode(FieldMeta('', '', False, 'primitive'), link_capturing)
+        if display_mode is not None:
+            _params['displayMode'] = encode(FieldMeta('', '', False, 'enum', ref='PWA.DisplayMode'), display_mode)
+        _result = await self._target.send('PWA.changeAppUserSettings', _params)
+        return None

parsek_cdp/cdp/pwa/types.py

@@ -0,0 +1,45 @@
+"""Custom types and enums for the PWA 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("PWA.FileHandlerAccept")
+@dataclass
+class FileHandlerAccept(DataType):
+    """
+    The following types are the replica of
+    https://crsrc.org/c/chrome/browser/web_applications/proto/web_app_os_integration_state.proto;drc=9910d3be894c8f142c977ba1023f30a656bc13fc;l=67
+    """
+    media_type: str
+    file_extensions: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('media_type', 'mediaType', False, 'primitive'),
+        FieldMeta('file_extensions', 'fileExtensions', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("PWA.FileHandler")
+@dataclass
+class FileHandler(DataType):
+    action: str
+    accepts: List[FileHandlerAccept]
+    display_name: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('action', 'action', False, 'primitive'),
+        FieldMeta('accepts', 'accepts', False, 'array', inner=FieldMeta('', '', False, 'object', ref='PWA.FileHandlerAccept')),
+        FieldMeta('display_name', 'displayName', False, 'primitive'),
+    )
+
+
+@register("PWA.DisplayMode")
+class DisplayMode(str, Enum):
+    """If user prefers opening the app in browser or an app window."""
+    STANDALONE = 'standalone'
+    BROWSER = 'browser'
+
+__all__ = ["DisplayMode", "FileHandler", "FileHandlerAccept"]

parsek_cdp/cdp/runtime/__init__.py

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

parsek_cdp/cdp/runtime/events.py

@@ -0,0 +1,123 @@
+"""Events for the Runtime 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 (
+        ExceptionDetails,
+        ExecutionContextDescription,
+        ExecutionContextId,
+        RemoteObject,
+        StackTrace,
+        Timestamp,
+    )
+
+@register_event("Runtime.bindingCalled")
+@dataclass
+class BindingCalled(Event):
+    """Notification is issued every time when binding is called."""
+    name: str
+    payload: str
+    execution_context_id: ExecutionContextId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('payload', 'payload', False, 'primitive'),
+        FieldMeta('execution_context_id', 'executionContextId', False, 'primitive'),
+    )
+
+
+@register_event("Runtime.consoleAPICalled")
+@dataclass
+class ConsoleAPICalled(Event):
+    """Issued when console API was called."""
+    type_: Literal['log', 'debug', 'info', 'error', 'warning', 'dir', 'dirxml', 'table', 'trace', 'clear', 'startGroup', 'startGroupCollapsed', 'endGroup', 'assert', 'profile', 'profileEnd', 'count', 'timeEnd']
+    args: List[RemoteObject]
+    execution_context_id: ExecutionContextId
+    timestamp: Timestamp
+    stack_trace: Optional[StackTrace] = None
+    context: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('args', 'args', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Runtime.RemoteObject')),
+        FieldMeta('execution_context_id', 'executionContextId', False, 'primitive'),
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('stack_trace', 'stackTrace', True, 'object', ref='Runtime.StackTrace'),
+        FieldMeta('context', 'context', True, 'primitive'),
+    )
+
+
+@register_event("Runtime.exceptionRevoked")
+@dataclass
+class ExceptionRevoked(Event):
+    """Issued when unhandled exception was revoked."""
+    reason: str
+    exception_id: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('reason', 'reason', False, 'primitive'),
+        FieldMeta('exception_id', 'exceptionId', False, 'primitive'),
+    )
+
+
+@register_event("Runtime.exceptionThrown")
+@dataclass
+class ExceptionThrown(Event):
+    """Issued when exception was thrown and unhandled."""
+    timestamp: Timestamp
+    exception_details: ExceptionDetails
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('exception_details', 'exceptionDetails', False, 'object', ref='Runtime.ExceptionDetails'),
+    )
+
+
+@register_event("Runtime.executionContextCreated")
+@dataclass
+class ExecutionContextCreated(Event):
+    """Issued when new execution context is created."""
+    context: ExecutionContextDescription
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context', 'context', False, 'object', ref='Runtime.ExecutionContextDescription'),
+    )
+
+
+@register_event("Runtime.executionContextDestroyed")
+@dataclass
+class ExecutionContextDestroyed(Event):
+    """Issued when execution context is destroyed."""
+    execution_context_id: ExecutionContextId
+    execution_context_unique_id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('execution_context_id', 'executionContextId', False, 'primitive'),
+        FieldMeta('execution_context_unique_id', 'executionContextUniqueId', False, 'primitive'),
+    )
+
+
+@register_event("Runtime.executionContextsCleared")
+@dataclass
+class ExecutionContextsCleared(Event):
+    """Issued when all executionContexts were cleared in browser"""
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("Runtime.inspectRequested")
+@dataclass
+class InspectRequested(Event):
+    """
+    Issued when object should be inspected (for example, as a result of inspect() command line API
+    call).
+    """
+    object: RemoteObject
+    hints: Dict[str, Any]
+    execution_context_id: Optional[ExecutionContextId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('object', 'object', False, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('hints', 'hints', False, 'primitive'),
+        FieldMeta('execution_context_id', 'executionContextId', True, 'primitive'),
+    )
+
+__all__ = ["BindingCalled", "ConsoleAPICalled", "ExceptionRevoked", "ExceptionThrown", "ExecutionContextCreated", "ExecutionContextDestroyed", "ExecutionContextsCleared", "InspectRequested"]