chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/profiler/types.py

@@ -0,0 +1,65 @@
+"""CDP Profiler Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.runtime.types import CallFrame
+    from cdp.protocol.runtime.types import ScriptId
+
+class ProfileNode(TypedDict, total=True):
+    """Profile node. Holds callsite information, execution statistics and child nodes."""
+    id: 'int'
+    """Unique id of the node."""
+    callFrame: 'CallFrame'
+    """Function location."""
+    hitCount: NotRequired['int']
+    """Number of samples where this node was on top of the call stack."""
+    children: NotRequired['List[int]']
+    """Child node ids."""
+    deoptReason: NotRequired['str']
+    """The reason of being not optimized. The function may be deoptimized or marked as don't optimize."""
+    positionTicks: NotRequired['List[PositionTickInfo]']
+    """An array of source position ticks."""
+class Profile(TypedDict, total=True):
+    """Profile."""
+    nodes: 'List[ProfileNode]'
+    """The list of profile nodes. First item is the root node."""
+    startTime: 'float'
+    """Profiling start timestamp in microseconds."""
+    endTime: 'float'
+    """Profiling end timestamp in microseconds."""
+    samples: NotRequired['List[int]']
+    """Ids of samples top nodes."""
+    timeDeltas: NotRequired['List[int]']
+    """Time intervals between adjacent samples in microseconds. The first delta is relative to the profile startTime."""
+class PositionTickInfo(TypedDict, total=True):
+    """Specifies a number of samples attributed to a certain source position."""
+    line: 'int'
+    """Source line number (1-based)."""
+    ticks: 'int'
+    """Number of samples attributed to the source line."""
+class CoverageRange(TypedDict, total=True):
+    """Coverage data for a source range."""
+    startOffset: 'int'
+    """JavaScript script source offset for the range start."""
+    endOffset: 'int'
+    """JavaScript script source offset for the range end."""
+    count: 'int'
+    """Collected execution count of the source range."""
+class FunctionCoverage(TypedDict, total=True):
+    """Coverage data for a JavaScript function."""
+    functionName: 'str'
+    """JavaScript function name."""
+    ranges: 'List[CoverageRange]'
+    """Source ranges inside the function with coverage data."""
+    isBlockCoverage: 'bool'
+    """Whether coverage data for this function has block granularity."""
+class ScriptCoverage(TypedDict, total=True):
+    """Coverage data for a JavaScript script."""
+    scriptId: 'ScriptId'
+    """JavaScript script id."""
+    url: 'str'
+    """JavaScript script name or url."""
+    functions: 'List[FunctionCoverage]'
+    """Functions contained in the script that has coverage data."""

cdp/protocol/pwa/events/service.py

@@ -0,0 +1,20 @@
+"""CDP PWA Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class PWAEvents:
+    """
+    Events for the PWA domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the PWA events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/pwa/events/types.py

@@ -0,0 +1,3 @@
+"""CDP PWA Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/pwa/methods/service.py

@@ -0,0 +1,98 @@
+"""CDP PWA Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class PWAMethods:
+    """
+    Methods for the PWA domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the PWA methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def get_os_app_state(self, params: Optional[getOsAppStateParameters]=None,session_id: Optional[str] = None) -> getOsAppStateReturns:
+        """
+    Returns the following OS state for the given manifest id.    
+        Args:
+            params (getOsAppStateParameters, optional): Parameters for the getOsAppState method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getOsAppStateReturns: The result of the getOsAppState call.
+        """
+        return await self.client.send(method="PWA.getOsAppState", params=params,session_id=session_id)
+    async def install(self, params: Optional[installParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    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.    
+        Args:
+            params (installParameters, optional): Parameters for the install method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the install call.
+        """
+        return await self.client.send(method="PWA.install", params=params,session_id=session_id)
+    async def uninstall(self, params: Optional[uninstallParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Uninstalls the given manifest_id and closes any opened app windows.    
+        Args:
+            params (uninstallParameters, optional): Parameters for the uninstall method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the uninstall call.
+        """
+        return await self.client.send(method="PWA.uninstall", params=params,session_id=session_id)
+    async def launch(self, params: Optional[launchParameters]=None,session_id: Optional[str] = None) -> launchReturns:
+        """
+    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.    
+        Args:
+            params (launchParameters, optional): Parameters for the launch method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    launchReturns: The result of the launch call.
+        """
+        return await self.client.send(method="PWA.launch", params=params,session_id=session_id)
+    async def launch_files_in_app(self, params: Optional[launchFilesInAppParameters]=None,session_id: Optional[str] = None) -> launchFilesInAppReturns:
+        """
+    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.    
+        Args:
+            params (launchFilesInAppParameters, optional): Parameters for the launchFilesInApp method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    launchFilesInAppReturns: The result of the launchFilesInApp call.
+        """
+        return await self.client.send(method="PWA.launchFilesInApp", params=params,session_id=session_id)
+    async def open_current_page_in_app(self, params: Optional[openCurrentPageInAppParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    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.    
+        Args:
+            params (openCurrentPageInAppParameters, optional): Parameters for the openCurrentPageInApp method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the openCurrentPageInApp call.
+        """
+        return await self.client.send(method="PWA.openCurrentPageInApp", params=params,session_id=session_id)
+    async def change_app_user_settings(self, params: Optional[changeAppUserSettingsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    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.    
+        Args:
+            params (changeAppUserSettingsParameters, optional): Parameters for the changeAppUserSettings method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the changeAppUserSettings call.
+        """
+        return await self.client.send(method="PWA.changeAppUserSettings", params=params,session_id=session_id)

cdp/protocol/pwa/methods/types.py

@@ -0,0 +1,43 @@
+"""CDP PWA Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.pwa.types import DisplayMode
+    from cdp.protocol.pwa.types import FileHandler
+    from cdp.protocol.target.types import TargetID
+
+class getOsAppStateParameters(TypedDict, total=True):
+    manifestId: 'str'
+    """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."""
+class installParameters(TypedDict, total=True):
+    manifestId: 'str'
+    installUrlOrBundleUrl: NotRequired['str']
+    """The location of the app or bundle overriding the one derived from the manifestId."""
+class uninstallParameters(TypedDict, total=True):
+    manifestId: 'str'
+class launchParameters(TypedDict, total=True):
+    manifestId: 'str'
+    url: NotRequired['str']
+class launchFilesInAppParameters(TypedDict, total=True):
+    manifestId: 'str'
+    files: 'List[str]'
+class openCurrentPageInAppParameters(TypedDict, total=True):
+    manifestId: 'str'
+class changeAppUserSettingsParameters(TypedDict, total=True):
+    manifestId: 'str'
+    linkCapturing: NotRequired['bool']
+    """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."""
+    displayMode: NotRequired['DisplayMode']
+class getOsAppStateReturns(TypedDict):
+    badgeCount: 'int'
+    fileHandlers: 'List[FileHandler]'
+
+
+class launchReturns(TypedDict):
+    targetId: 'TargetID'
+    """ID of the tab target created as a result."""
+class launchFilesInAppReturns(TypedDict):
+    targetIds: 'List[TargetID]'
+    """IDs of the tab targets created as the result."""

cdp/protocol/pwa/service.py

@@ -0,0 +1,21 @@
+"""CDP PWA Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import PWAMethods
+from .events.service import PWAEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class PWA(PWAMethods, PWAEvents):
+    """
+    This domain allows interacting with the browser to control PWAs.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the PWA domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        PWAMethods.__init__(self, client)
+        PWAEvents.__init__(self, client)

cdp/protocol/pwa/types.py

@@ -0,0 +1,15 @@
+"""CDP PWA Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class FileHandlerAccept(TypedDict, total=True):
+    """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"""
+    mediaType: 'str'
+    """New name of the mimetype according to https://www.iana.org/assignments/media-types/media-types.xhtml"""
+    fileExtensions: 'List[str]'
+class FileHandler(TypedDict, total=True):
+    action: 'str'
+    accepts: 'List[FileHandlerAccept]'
+    displayName: 'str'
+DisplayMode = Literal['standalone','browser']
+"""If user prefers opening the app in browser or an app window."""

cdp/protocol/runtime/events/service.py

@@ -0,0 +1,85 @@
+"""CDP Runtime Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class RuntimeEvents:
+    """
+    Events for the Runtime domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Runtime events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_binding_called(self, callback: Callable[[bindingCalledEvent,Optional[str]], None]=None) -> None:
+        """
+    Notification is issued every time when binding is called.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: bindingCalledEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.bindingCalled', callback)
+    def on_console_api_called(self, callback: Callable[[consoleAPICalledEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when console API was called.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: consoleAPICalledEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.consoleAPICalled', callback)
+    def on_exception_revoked(self, callback: Callable[[exceptionRevokedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when unhandled exception was revoked.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: exceptionRevokedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.exceptionRevoked', callback)
+    def on_exception_thrown(self, callback: Callable[[exceptionThrownEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when exception was thrown and unhandled.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: exceptionThrownEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.exceptionThrown', callback)
+    def on_execution_context_created(self, callback: Callable[[executionContextCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when new execution context is created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: executionContextCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.executionContextCreated', callback)
+    def on_execution_context_destroyed(self, callback: Callable[[executionContextDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when execution context is destroyed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: executionContextDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.executionContextDestroyed', callback)
+    def on_execution_contexts_cleared(self, callback: Callable[[executionContextsClearedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when all executionContexts were cleared in browser    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: executionContextsClearedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.executionContextsCleared', callback)
+    def on_inspect_requested(self, callback: Callable[[inspectRequestedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when object should be inspected (for example, as a result of inspect() command line API call).    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: inspectRequestedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Runtime.inspectRequested', callback)

cdp/protocol/runtime/events/types.py

@@ -0,0 +1,55 @@
+"""CDP Runtime Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.runtime.types import ExceptionDetails
+    from cdp.protocol.runtime.types import ExecutionContextDescription
+    from cdp.protocol.runtime.types import ExecutionContextId
+    from cdp.protocol.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import StackTrace
+    from cdp.protocol.runtime.types import Timestamp
+
+class bindingCalledEvent(TypedDict, total=True):
+    name: 'str'
+    payload: 'str'
+    executionContextId: 'ExecutionContextId'
+    """Identifier of the context where the call was made."""
+class consoleAPICalledEvent(TypedDict, total=True):
+    type: 'Literal["log", "debug", "info", "error", "warning", "dir", "dirxml", "table", "trace", "clear", "startGroup", "startGroupCollapsed", "endGroup", "assert", "profile", "profileEnd", "count", "timeEnd"]'
+    """Type of the call."""
+    args: 'List[RemoteObject]'
+    """Call arguments."""
+    executionContextId: 'ExecutionContextId'
+    """Identifier of the context where the call was made."""
+    timestamp: 'Timestamp'
+    """Call timestamp."""
+    stackTrace: NotRequired['StackTrace']
+    """Stack trace captured when the call was made. The async stack chain is automatically reported for the following call types: assert, error, trace, warning. For other types the async call chain can be retrieved using Debugger.getStackTrace and stackTrace.parentId field."""
+    context: NotRequired['str']
+    """Console context descriptor for calls on non-default console context (not console.*): 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call on named context."""
+class exceptionRevokedEvent(TypedDict, total=True):
+    reason: 'str'
+    """Reason describing why exception was revoked."""
+    exceptionId: 'int'
+    """The id of revoked exception, as reported in exceptionThrown."""
+class exceptionThrownEvent(TypedDict, total=True):
+    timestamp: 'Timestamp'
+    """Timestamp of the exception."""
+    exceptionDetails: 'ExceptionDetails'
+class executionContextCreatedEvent(TypedDict, total=True):
+    context: 'ExecutionContextDescription'
+    """A newly created execution context."""
+class executionContextDestroyedEvent(TypedDict, total=True):
+    executionContextId: 'ExecutionContextId'
+    """Id of the destroyed context"""
+    executionContextUniqueId: 'str'
+    """Unique Id of the destroyed context"""
+class executionContextsClearedEvent(TypedDict, total=True):
+    pass
+class inspectRequestedEvent(TypedDict, total=True):
+    object: 'RemoteObject'
+    hints: 'Dict[str, Any]'
+    executionContextId: NotRequired['ExecutionContextId']
+    """Identifier of the context where the call was made."""