chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/fetch/methods/types.py

@@ -0,0 +1,85 @@
+"""CDP Fetch 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.fetch.types import AuthChallengeResponse
+    from cdp.protocol.fetch.types import HeaderEntry
+    from cdp.protocol.fetch.types import RequestId
+    from cdp.protocol.fetch.types import RequestPattern
+    from cdp.protocol.io.types import StreamHandle
+    from cdp.protocol.network.types import ErrorReason
+
+
+class enableParameters(TypedDict, total=False):
+    patterns: NotRequired['List[RequestPattern]']
+    """If specified, only requests matching any of these patterns will produce fetchRequested event and will be paused until clients response. If not set, all requests will be affected."""
+    handleAuthRequests: NotRequired['bool']
+    """If true, authRequired events will be issued and requests will be paused expecting a call to continueWithAuth."""
+class failRequestParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """An id the client received in requestPaused event."""
+    errorReason: 'ErrorReason'
+    """Causes the request to fail with the given reason."""
+class fulfillRequestParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """An id the client received in requestPaused event."""
+    responseCode: 'int'
+    """An HTTP response code."""
+    responseHeaders: NotRequired['List[HeaderEntry]']
+    """Response headers."""
+    binaryResponseHeaders: NotRequired['str']
+    """Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)"""
+    body: NotRequired['str']
+    """A response body. If absent, original response body will be used if the request is intercepted at the response stage and empty body will be used if the request is intercepted at the request stage. (Encoded as a base64 string when passed over JSON)"""
+    responsePhrase: NotRequired['str']
+    """A textual representation of responseCode. If absent, a standard phrase matching responseCode is used."""
+class continueRequestParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """An id the client received in requestPaused event."""
+    url: NotRequired['str']
+    """If set, the request url will be modified in a way that's not observable by page."""
+    method: NotRequired['str']
+    """If set, the request method is overridden."""
+    postData: NotRequired['str']
+    """If set, overrides the post data in the request. (Encoded as a base64 string when passed over JSON)"""
+    headers: NotRequired['List[HeaderEntry]']
+    """If set, overrides the request headers. Note that the overrides do not extend to subsequent redirect hops, if a redirect happens. Another override may be applied to a different request produced by a redirect."""
+    interceptResponse: NotRequired['bool']
+    """If set, overrides response interception behavior for this request."""
+class continueWithAuthParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """An id the client received in authRequired event."""
+    authChallengeResponse: 'AuthChallengeResponse'
+    """Response to  with an authChallenge."""
+class continueResponseParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """An id the client received in requestPaused event."""
+    responseCode: NotRequired['int']
+    """An HTTP response code. If absent, original response code will be used."""
+    responsePhrase: NotRequired['str']
+    """A textual representation of responseCode. If absent, a standard phrase matching responseCode is used."""
+    responseHeaders: NotRequired['List[HeaderEntry]']
+    """Response headers. If absent, original response headers will be used."""
+    binaryResponseHeaders: NotRequired['str']
+    """Alternative way of specifying response headers as a \0-separated series of name: value pairs. Prefer the above method unless you need to represent some non-UTF8 values that can't be transmitted over the protocol as text. (Encoded as a base64 string when passed over JSON)"""
+class getResponseBodyParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier for the intercepted request to get body for."""
+class takeResponseBodyAsStreamParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+
+
+
+
+
+
+
+class getResponseBodyReturns(TypedDict):
+    body: 'str'
+    """Response body."""
+    base64Encoded: 'bool'
+    """True, if content was sent as base64."""
+class takeResponseBodyAsStreamReturns(TypedDict):
+    stream: 'StreamHandle'

cdp/protocol/fetch/service.py

@@ -0,0 +1,21 @@
+"""CDP Fetch Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import FetchMethods
+from .events.service import FetchEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Fetch(FetchMethods, FetchEvents):
+    """
+    A domain for letting clients substitute browser's network layer with client code.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Fetch domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        FetchMethods.__init__(self, client)
+        FetchEvents.__init__(self, client)

cdp/protocol/fetch/types.py

@@ -0,0 +1,41 @@
+"""CDP Fetch 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.network.types import ResourceType
+
+RequestId = str
+"""Unique request identifier. Note that this does not identify individual HTTP requests that are part of a network request."""
+RequestStage = Literal['Request','Response']
+"""Stages of the request to handle. Request will intercept before the request is sent. Response will intercept after the response is received (but before response body is received)."""
+class RequestPattern(TypedDict, total=False):
+    urlPattern: NotRequired['str']
+    """Wildcards ('*' -> zero or more, '?' -> exactly one) are allowed. Escape character is backslash. Omitting is equivalent to "*"."""
+    resourceType: NotRequired['ResourceType']
+    """If set, only requests for matching resource types will be intercepted."""
+    requestStage: NotRequired['RequestStage']
+    """Stage at which to begin intercepting requests. Default is Request."""
+class HeaderEntry(TypedDict, total=True):
+    """Response HTTP header entry"""
+    name: 'str'
+    value: 'str'
+class AuthChallenge(TypedDict, total=True):
+    """Authorization challenge for HTTP status code 401 or 407."""
+    origin: 'str'
+    """Origin of the challenger."""
+    scheme: 'str'
+    """The authentication scheme used, such as basic or digest"""
+    realm: 'str'
+    """The realm of the challenge. May be empty."""
+    source: NotRequired['Literal["Server", "Proxy"]']
+    """Source of the authentication challenge."""
+class AuthChallengeResponse(TypedDict, total=True):
+    """Response to an AuthChallenge."""
+    response: 'Literal["Default", "CancelAuth", "ProvideCredentials"]'
+    """The decision on what to do in response to the authorization challenge.  Default means deferring to the default behavior of the net stack, which will likely either the Cancel authentication or display a popup dialog box."""
+    username: NotRequired['str']
+    """The username to provide, possibly empty. Should only be set if response is ProvideCredentials."""
+    password: NotRequired['str']
+    """The password to provide, possibly empty. Should only be set if response is ProvideCredentials."""

cdp/protocol/file_system/events/service.py

@@ -0,0 +1,20 @@
+"""CDP FileSystem 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 FileSystemEvents:
+    """
+    Events for the FileSystem domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FileSystem events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/file_system/events/types.py

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

cdp/protocol/file_system/methods/service.py

@@ -0,0 +1,32 @@
+"""CDP FileSystem 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 FileSystemMethods:
+    """
+    Methods for the FileSystem domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FileSystem methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def get_directory(self, params: Optional[getDirectoryParameters]=None,session_id: Optional[str] = None) -> getDirectoryReturns:
+        """
+    No description available for getDirectory.    
+        Args:
+            params (getDirectoryParameters, optional): Parameters for the getDirectory method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getDirectoryReturns: The result of the getDirectory call.
+        """
+        return await self.client.send(method="FileSystem.getDirectory", params=params,session_id=session_id)

cdp/protocol/file_system/methods/types.py

@@ -0,0 +1,14 @@
+"""CDP FileSystem 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.file_system.types import BucketFileSystemLocator
+    from cdp.protocol.file_system.types import Directory
+
+class getDirectoryParameters(TypedDict, total=True):
+    bucketFileSystemLocator: 'BucketFileSystemLocator'
+class getDirectoryReturns(TypedDict):
+    directory: 'Directory'
+    """Returns the directory object at the path."""

cdp/protocol/file_system/service.py

@@ -0,0 +1,21 @@
+"""CDP FileSystem Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import FileSystemMethods
+from .events.service import FileSystemEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class FileSystem(FileSystemMethods, FileSystemEvents):
+    """
+    Access the FileSystem domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FileSystem domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        FileSystemMethods.__init__(self, client)
+        FileSystemEvents.__init__(self, client)

cdp/protocol/file_system/types.py

@@ -0,0 +1,28 @@
+"""CDP FileSystem 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.network.types import TimeSinceEpoch
+    from cdp.protocol.storage.types import SerializedStorageKey
+
+class File(TypedDict, total=True):
+    name: 'str'
+    lastModified: 'TimeSinceEpoch'
+    """Timestamp"""
+    size: 'float'
+    """Size in bytes"""
+    type: 'str'
+class Directory(TypedDict, total=True):
+    name: 'str'
+    nestedDirectories: 'List[str]'
+    nestedFiles: 'List[File]'
+    """Files that are directly nested under this directory."""
+class BucketFileSystemLocator(TypedDict, total=True):
+    storageKey: 'SerializedStorageKey'
+    """Storage key"""
+    pathComponents: 'List[str]'
+    """Path to the directory using each path component as an array item."""
+    bucketName: NotRequired['str']
+    """Bucket name. Not passing a bucketName will retrieve the default Bucket. (https://developer.mozilla.org/en-US/docs/Web/API/Storage_API#storage_buckets)"""

cdp/protocol/headless_experimental/events/service.py

@@ -0,0 +1,20 @@
+"""CDP HeadlessExperimental 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 HeadlessExperimentalEvents:
+    """
+    Events for the HeadlessExperimental domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the HeadlessExperimental events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/headless_experimental/events/types.py

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

cdp/protocol/headless_experimental/methods/service.py

@@ -0,0 +1,32 @@
+"""CDP HeadlessExperimental 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 HeadlessExperimentalMethods:
+    """
+    Methods for the HeadlessExperimental domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the HeadlessExperimental methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def begin_frame(self, params: Optional[beginFrameParameters]=None,session_id: Optional[str] = None) -> beginFrameReturns:
+        """
+    Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a screenshot from the resulting frame. Requires that the target was created with enabled BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also https://goo.gle/chrome-headless-rendering for more background.    
+        Args:
+            params (beginFrameParameters, optional): Parameters for the beginFrame method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    beginFrameReturns: The result of the beginFrame call.
+        """
+        return await self.client.send(method="HeadlessExperimental.beginFrame", params=params,session_id=session_id)

cdp/protocol/headless_experimental/methods/types.py

@@ -0,0 +1,22 @@
+"""CDP HeadlessExperimental 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.headless_experimental.types import ScreenshotParams
+
+class beginFrameParameters(TypedDict, total=False):
+    frameTimeTicks: NotRequired['float']
+    """Timestamp of this BeginFrame in Renderer TimeTicks (milliseconds of uptime). If not set, the current time will be used."""
+    interval: NotRequired['float']
+    """The interval between BeginFrames that is reported to the compositor, in milliseconds. Defaults to a 60 frames/second interval, i.e. about 16.666 milliseconds."""
+    noDisplayUpdates: NotRequired['bool']
+    """Whether updates should not be committed and drawn onto the display. False by default. If true, only side effects of the BeginFrame will be run, such as layout and animations, but any visual updates may not be visible on the display or in screenshots."""
+    screenshot: NotRequired['ScreenshotParams']
+    """If set, a screenshot of the frame will be captured and returned in the response. Otherwise, no screenshot will be captured. Note that capturing a screenshot can fail, for example, during renderer initialization. In such a case, no screenshot data will be returned."""
+class beginFrameReturns(TypedDict):
+    hasDamage: 'bool'
+    """Whether the BeginFrame resulted in damage and, thus, a new frame was committed to the display. Reported for diagnostic uses, may be removed in the future."""
+    screenshotData: 'str'
+    """Base64-encoded image data of the screenshot, if one was requested and successfully taken. (Encoded as a base64 string when passed over JSON)"""

cdp/protocol/headless_experimental/service.py

@@ -0,0 +1,21 @@
+"""CDP HeadlessExperimental Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import HeadlessExperimentalMethods
+from .events.service import HeadlessExperimentalEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class HeadlessExperimental(HeadlessExperimentalMethods, HeadlessExperimentalEvents):
+    """
+    This domain provides experimental commands only supported in headless mode.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the HeadlessExperimental domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        HeadlessExperimentalMethods.__init__(self, client)
+        HeadlessExperimentalEvents.__init__(self, client)

cdp/protocol/headless_experimental/types.py

@@ -0,0 +1,12 @@
+"""CDP HeadlessExperimental Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class ScreenshotParams(TypedDict, total=False):
+    """Encoding options for a screenshot."""
+    format: NotRequired['Literal["jpeg", "png", "webp"]']
+    """Image compression format (defaults to png)."""
+    quality: NotRequired['int']
+    """Compression quality from range [0..100] (jpeg and webp only)."""
+    optimizeForSpeed: NotRequired['bool']
+    """Optimize image encoding for speed, not for resulting size (defaults to false)"""

cdp/protocol/heap_profiler/events/service.py

@@ -0,0 +1,61 @@
+"""CDP HeapProfiler 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 HeapProfilerEvents:
+    """
+    Events for the HeapProfiler domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the HeapProfiler events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_add_heap_snapshot_chunk(self, callback: Callable[[addHeapSnapshotChunkEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for addHeapSnapshotChunk.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: addHeapSnapshotChunkEvent, session_id: Optional[str]).
+        """
+        self.client.on('HeapProfiler.addHeapSnapshotChunk', callback)
+    def on_heap_stats_update(self, callback: Callable[[heapStatsUpdateEvent,Optional[str]], None]=None) -> None:
+        """
+    If heap objects tracking has been started then backend may send update for one or more fragments    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: heapStatsUpdateEvent, session_id: Optional[str]).
+        """
+        self.client.on('HeapProfiler.heapStatsUpdate', callback)
+    def on_last_seen_object_id(self, callback: Callable[[lastSeenObjectIdEvent,Optional[str]], None]=None) -> None:
+        """
+    If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: lastSeenObjectIdEvent, session_id: Optional[str]).
+        """
+        self.client.on('HeapProfiler.lastSeenObjectId', callback)
+    def on_report_heap_snapshot_progress(self, callback: Callable[[reportHeapSnapshotProgressEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for reportHeapSnapshotProgress.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: reportHeapSnapshotProgressEvent, session_id: Optional[str]).
+        """
+        self.client.on('HeapProfiler.reportHeapSnapshotProgress', callback)
+    def on_reset_profiles(self, callback: Callable[[resetProfilesEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for resetProfiles.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: resetProfilesEvent, session_id: Optional[str]).
+        """
+        self.client.on('HeapProfiler.resetProfiles', callback)

cdp/protocol/heap_profiler/events/types.py

@@ -0,0 +1,18 @@
+"""CDP HeapProfiler Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class addHeapSnapshotChunkEvent(TypedDict, total=True):
+    chunk: 'str'
+class heapStatsUpdateEvent(TypedDict, total=True):
+    statsUpdate: 'List[int]'
+    """An array of triplets. Each triplet describes a fragment. The first integer is the fragment index, the second integer is a total count of objects for the fragment, the third integer is a total size of the objects for the fragment."""
+class lastSeenObjectIdEvent(TypedDict, total=True):
+    lastSeenObjectId: 'int'
+    timestamp: 'float'
+class reportHeapSnapshotProgressEvent(TypedDict, total=True):
+    done: 'int'
+    total: 'int'
+    finished: NotRequired['bool']
+class resetProfilesEvent(TypedDict, total=True):
+    pass