chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/runtime/types.py

@@ -0,0 +1,194 @@
+"""CDP Runtime Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+ScriptId = str
+"""Unique script identifier."""
+class SerializationOptions(TypedDict, total=True):
+    """Represents options for serialization. Overrides generatePreview and returnByValue."""
+    serialization: 'Literal["deep", "json", "idOnly"]'
+    maxDepth: NotRequired['int']
+    """Deep serialization depth. Default is full depth. Respected only in deep serialization mode."""
+    additionalParameters: NotRequired['Dict[str, Any]']
+    """Embedder-specific parameters. For example if connected to V8 in Chrome these control DOM serialization via maxNodeDepth: integer and includeShadowTree: "none" | "open" | "all". Values can be only of type string or integer."""
+class DeepSerializedValue(TypedDict, total=True):
+    """Represents deep serialized value."""
+    type: 'Literal["undefined", "null", "string", "number", "boolean", "bigint", "regexp", "date", "symbol", "array", "object", "function", "map", "set", "weakmap", "weakset", "error", "proxy", "promise", "typedarray", "arraybuffer", "node", "window", "generator"]'
+    value: NotRequired['Any']
+    objectId: NotRequired['str']
+    weakLocalObjectReference: NotRequired['int']
+    """Set if value reference met more then once during serialization. In such case, value is provided only to one of the serialized values. Unique per value in the scope of one CDP call."""
+RemoteObjectId = str
+"""Unique object identifier."""
+UnserializableValue = str
+"""Primitive value which cannot be JSON-stringified. Includes values -0, NaN, Infinity, -Infinity, and bigint literals."""
+class RemoteObject(TypedDict, total=True):
+    """Mirror object referencing original JavaScript object."""
+    type: 'Literal["object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"]'
+    """Object type."""
+    subtype: NotRequired['Literal["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue", "trustedtype"]']
+    """Object subtype hint. Specified for object type values only. NOTE: If you change anything here, make sure to also update subtype in ObjectPreview and PropertyPreview below."""
+    className: NotRequired['str']
+    """Object class (constructor) name. Specified for object type values only."""
+    value: NotRequired['Any']
+    """Remote object value in case of primitive values or JSON values (if it was requested)."""
+    unserializableValue: NotRequired['UnserializableValue']
+    """Primitive value which can not be JSON-stringified does not have value, but gets this property."""
+    description: NotRequired['str']
+    """String representation of the object."""
+    deepSerializedValue: NotRequired['DeepSerializedValue']
+    """Deep serialized value."""
+    objectId: NotRequired['RemoteObjectId']
+    """Unique object identifier (for non-primitive values)."""
+    preview: NotRequired['ObjectPreview']
+    """Preview containing abbreviated property values. Specified for object type values only."""
+    customPreview: NotRequired['CustomPreview']
+class CustomPreview(TypedDict, total=True):
+    header: 'str'
+    """The JSON-stringified result of formatter.header(object, config) call. It contains json ML array that represents RemoteObject."""
+    bodyGetterId: NotRequired['RemoteObjectId']
+    """If formatter returns true as a result of formatter.hasBody call then bodyGetterId will contain RemoteObjectId for the function that returns result of formatter.body(object, config) call. The result value is json ML array."""
+class ObjectPreview(TypedDict, total=True):
+    """Object containing abbreviated remote object value."""
+    type: 'Literal["object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"]'
+    """Object type."""
+    overflow: 'bool'
+    """True iff some of the properties or entries of the original object did not fit."""
+    properties: 'List[PropertyPreview]'
+    """List of the properties."""
+    subtype: NotRequired['Literal["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue", "trustedtype"]']
+    """Object subtype hint. Specified for object type values only."""
+    description: NotRequired['str']
+    """String representation of the object."""
+    entries: NotRequired['List[EntryPreview]']
+    """List of the entries. Specified for map and set subtype values only."""
+class PropertyPreview(TypedDict, total=True):
+    name: 'str'
+    """Property name."""
+    type: 'Literal["object", "function", "undefined", "string", "number", "boolean", "symbol", "accessor", "bigint"]'
+    """Object type. Accessor means that the property itself is an accessor property."""
+    value: NotRequired['str']
+    """User-friendly property value string."""
+    valuePreview: NotRequired['ObjectPreview']
+    """Nested value preview."""
+    subtype: NotRequired['Literal["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue", "trustedtype"]']
+    """Object subtype hint. Specified for object type values only."""
+class EntryPreview(TypedDict, total=True):
+    value: 'ObjectPreview'
+    """Preview of the value."""
+    key: NotRequired['ObjectPreview']
+    """Preview of the key. Specified for map-like collection entries."""
+class PropertyDescriptor(TypedDict, total=True):
+    """Object property descriptor."""
+    name: 'str'
+    """Property name or symbol description."""
+    configurable: 'bool'
+    """True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object."""
+    enumerable: 'bool'
+    """True if this property shows up during enumeration of the properties on the corresponding object."""
+    value: NotRequired['RemoteObject']
+    """The value associated with the property."""
+    writable: NotRequired['bool']
+    """True if the value associated with the property may be changed (data descriptors only)."""
+    get: NotRequired['RemoteObject']
+    """A function which serves as a getter for the property, or undefined if there is no getter (accessor descriptors only)."""
+    set: NotRequired['RemoteObject']
+    """A function which serves as a setter for the property, or undefined if there is no setter (accessor descriptors only)."""
+    wasThrown: NotRequired['bool']
+    """True if the result was thrown during the evaluation."""
+    isOwn: NotRequired['bool']
+    """True if the property is owned for the object."""
+    symbol: NotRequired['RemoteObject']
+    """Property symbol object, if the property is of the symbol type."""
+class InternalPropertyDescriptor(TypedDict, total=True):
+    """Object internal property descriptor. This property isn't normally visible in JavaScript code."""
+    name: 'str'
+    """Conventional property name."""
+    value: NotRequired['RemoteObject']
+    """The value associated with the property."""
+class PrivatePropertyDescriptor(TypedDict, total=True):
+    """Object private field descriptor."""
+    name: 'str'
+    """Private property name."""
+    value: NotRequired['RemoteObject']
+    """The value associated with the private property."""
+    get: NotRequired['RemoteObject']
+    """A function which serves as a getter for the private property, or undefined if there is no getter (accessor descriptors only)."""
+    set: NotRequired['RemoteObject']
+    """A function which serves as a setter for the private property, or undefined if there is no setter (accessor descriptors only)."""
+class CallArgument(TypedDict, total=False):
+    """Represents function call argument. Either remote object id objectId, primitive value, unserializable primitive value or neither of (for undefined) them should be specified."""
+    value: NotRequired['Any']
+    """Primitive value or serializable javascript object."""
+    unserializableValue: NotRequired['UnserializableValue']
+    """Primitive value which can not be JSON-stringified."""
+    objectId: NotRequired['RemoteObjectId']
+    """Remote object handle."""
+ExecutionContextId = int
+"""Id of an execution context."""
+class ExecutionContextDescription(TypedDict, total=True):
+    """Description of an isolated world."""
+    id: 'ExecutionContextId'
+    """Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed."""
+    origin: 'str'
+    """Execution context origin."""
+    name: 'str'
+    """Human readable name describing given context."""
+    uniqueId: 'str'
+    """A system-unique execution context identifier. Unlike the id, this is unique across multiple processes, so can be reliably used to identify specific context while backend performs a cross-process navigation."""
+    auxData: NotRequired['Dict[str, Any]']
+    """Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}"""
+class ExceptionDetails(TypedDict, total=True):
+    """Detailed information about exception (or error) that was thrown during script compilation or execution."""
+    exceptionId: 'int'
+    """Exception id."""
+    text: 'str'
+    """Exception text, which should be used together with exception object when available."""
+    lineNumber: 'int'
+    """Line number of the exception location (0-based)."""
+    columnNumber: 'int'
+    """Column number of the exception location (0-based)."""
+    scriptId: NotRequired['ScriptId']
+    """Script ID of the exception location."""
+    url: NotRequired['str']
+    """URL of the exception location, to be used when the script was not reported."""
+    stackTrace: NotRequired['StackTrace']
+    """JavaScript stack trace if available."""
+    exception: NotRequired['RemoteObject']
+    """Exception object if available."""
+    executionContextId: NotRequired['ExecutionContextId']
+    """Identifier of the context where exception happened."""
+    exceptionMetaData: NotRequired['Dict[str, Any]']
+    """Dictionary with entries of meta data that the client associated with this exception, such as information about associated network requests, etc."""
+Timestamp = float
+"""Number of milliseconds since epoch."""
+TimeDelta = float
+"""Number of milliseconds."""
+class CallFrame(TypedDict, total=True):
+    """Stack entry for runtime errors and assertions."""
+    functionName: 'str'
+    """JavaScript function name."""
+    scriptId: 'ScriptId'
+    """JavaScript script id."""
+    url: 'str'
+    """JavaScript script name or url."""
+    lineNumber: 'int'
+    """JavaScript script line number (0-based)."""
+    columnNumber: 'int'
+    """JavaScript script column number (0-based)."""
+class StackTrace(TypedDict, total=True):
+    """Call frames for assertions or error messages."""
+    callFrames: 'List[CallFrame]'
+    """JavaScript function name."""
+    description: NotRequired['str']
+    """String label of this stack trace. For async traces this may be a name of the function that initiated the async call."""
+    parent: NotRequired['StackTrace']
+    """Asynchronous JavaScript stack trace that preceded this stack, if available."""
+    parentId: NotRequired['StackTraceId']
+    """Asynchronous JavaScript stack trace that preceded this stack, if available."""
+UniqueDebuggerId = str
+"""Unique identifier of current debugger."""
+class StackTraceId(TypedDict, total=True):
+    """If debuggerId is set stack trace comes from another debugger and can be resolved there. This allows to track cross-debugger calls. See Runtime.StackTrace and Debugger.paused for usages."""
+    id: 'str'
+    debuggerId: NotRequired['UniqueDebuggerId']

cdp/protocol/security/events/service.py

@@ -0,0 +1,29 @@
+"""CDP Security 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 SecurityEvents:
+    """
+    Events for the Security domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Security events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_visible_security_state_changed(self, callback: Callable[[visibleSecurityStateChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    The security state of the page changed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: visibleSecurityStateChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Security.visibleSecurityStateChanged', callback)

cdp/protocol/security/events/types.py

@@ -0,0 +1,11 @@
+"""CDP Security 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.security.types import VisibleSecurityState
+
+class visibleSecurityStateChangedEvent(TypedDict, total=True):
+    visibleSecurityState: 'VisibleSecurityState'
+    """Security state information about the page."""

cdp/protocol/security/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP Security 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 SecurityMethods:
+    """
+    Methods for the Security domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Security methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables tracking security state changes.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="Security.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables tracking security state changes.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Security.enable", params=params,session_id=session_id)
+    async def set_ignore_certificate_errors(self, params: Optional[setIgnoreCertificateErrorsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enable/disable whether all certificate errors should be ignored.    
+        Args:
+            params (setIgnoreCertificateErrorsParameters, optional): Parameters for the setIgnoreCertificateErrors method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setIgnoreCertificateErrors call.
+        """
+        return await self.client.send(method="Security.setIgnoreCertificateErrors", params=params,session_id=session_id)

cdp/protocol/security/methods/types.py

@@ -0,0 +1,9 @@
+"""CDP Security Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+
+
+class setIgnoreCertificateErrorsParameters(TypedDict, total=True):
+    ignore: 'bool'
+    """If true, all certificate errors will be ignored."""

cdp/protocol/security/service.py

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

cdp/protocol/security/types.py

@@ -0,0 +1,102 @@
+"""CDP Security 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
+
+CertificateId = int
+"""An internal certificate ID value."""
+MixedContentType = Literal['blockable','optionally-blockable','none']
+"""A description of mixed content (HTTP resources on HTTPS pages), as defined by https://www.w3.org/TR/mixed-content/#categories"""
+SecurityState = Literal['unknown','neutral','insecure','secure','info','insecure-broken']
+"""The security level of a page or resource."""
+class CertificateSecurityState(TypedDict, total=True):
+    """Details about the security state of the page certificate."""
+    protocol: 'str'
+    """Protocol name (e.g. TLS 1.2 or QUIC)."""
+    keyExchange: 'str'
+    """Key Exchange used by the connection, or the empty string if not applicable."""
+    cipher: 'str'
+    """Cipher name."""
+    certificate: 'List[str]'
+    """Page certificate."""
+    subjectName: 'str'
+    """Certificate subject name."""
+    issuer: 'str'
+    """Name of the issuing CA."""
+    validFrom: 'TimeSinceEpoch'
+    """Certificate valid from date."""
+    validTo: 'TimeSinceEpoch'
+    """Certificate valid to (expiration) date"""
+    certificateHasWeakSignature: 'bool'
+    """True if the certificate uses a weak signature algorithm."""
+    certificateHasSha1Signature: 'bool'
+    """True if the certificate has a SHA1 signature in the chain."""
+    modernSSL: 'bool'
+    """True if modern SSL"""
+    obsoleteSslProtocol: 'bool'
+    """True if the connection is using an obsolete SSL protocol."""
+    obsoleteSslKeyExchange: 'bool'
+    """True if the connection is using an obsolete SSL key exchange."""
+    obsoleteSslCipher: 'bool'
+    """True if the connection is using an obsolete SSL cipher."""
+    obsoleteSslSignature: 'bool'
+    """True if the connection is using an obsolete SSL signature."""
+    keyExchangeGroup: NotRequired['str']
+    """(EC)DH group used by the connection, if applicable."""
+    mac: NotRequired['str']
+    """TLS MAC. Note that AEAD ciphers do not have separate MACs."""
+    certificateNetworkError: NotRequired['str']
+    """The highest priority network error code, if the certificate has an error."""
+SafetyTipStatus = Literal['badReputation','lookalike']
+class SafetyTipInfo(TypedDict, total=True):
+    safetyTipStatus: 'SafetyTipStatus'
+    """Describes whether the page triggers any safety tips or reputation warnings. Default is unknown."""
+    safeUrl: NotRequired['str']
+    """The URL the safety tip suggested ("Did you mean?"). Only filled in for lookalike matches."""
+class VisibleSecurityState(TypedDict, total=True):
+    """Security state information about the page."""
+    securityState: 'SecurityState'
+    """The security level of the page."""
+    securityStateIssueIds: 'List[str]'
+    """Array of security state issues ids."""
+    certificateSecurityState: NotRequired['CertificateSecurityState']
+    """Security state details about the page certificate."""
+    safetyTipInfo: NotRequired['SafetyTipInfo']
+    """The type of Safety Tip triggered on the page. Note that this field will be set even if the Safety Tip UI was not actually shown."""
+class SecurityStateExplanation(TypedDict, total=True):
+    """An explanation of an factor contributing to the security state."""
+    securityState: 'SecurityState'
+    """Security state representing the severity of the factor being explained."""
+    title: 'str'
+    """Title describing the type of factor."""
+    summary: 'str'
+    """Short phrase describing the type of factor."""
+    description: 'str'
+    """Full text explanation of the factor."""
+    mixedContentType: 'MixedContentType'
+    """The type of mixed content described by the explanation."""
+    certificate: 'List[str]'
+    """Page certificate."""
+    recommendations: NotRequired['List[str]']
+    """Recommendations to fix any issues."""
+class InsecureContentStatus(TypedDict, total=True):
+    """Information about insecure content on the page."""
+    ranMixedContent: 'bool'
+    """Always false."""
+    displayedMixedContent: 'bool'
+    """Always false."""
+    containedMixedForm: 'bool'
+    """Always false."""
+    ranContentWithCertErrors: 'bool'
+    """Always false."""
+    displayedContentWithCertErrors: 'bool'
+    """Always false."""
+    ranInsecureContentStyle: 'SecurityState'
+    """Always set to unknown."""
+    displayedInsecureContentStyle: 'SecurityState'
+    """Always set to unknown."""
+CertificateErrorAction = Literal['continue','cancel']
+"""The action to take when a certificate error occurs. continue will continue processing the request and cancel will cancel the request."""

cdp/protocol/service_worker/events/service.py

@@ -0,0 +1,45 @@
+"""CDP ServiceWorker 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 ServiceWorkerEvents:
+    """
+    Events for the ServiceWorker domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the ServiceWorker events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_worker_error_reported(self, callback: Callable[[workerErrorReportedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for workerErrorReported.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: workerErrorReportedEvent, session_id: Optional[str]).
+        """
+        self.client.on('ServiceWorker.workerErrorReported', callback)
+    def on_worker_registration_updated(self, callback: Callable[[workerRegistrationUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for workerRegistrationUpdated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: workerRegistrationUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('ServiceWorker.workerRegistrationUpdated', callback)
+    def on_worker_version_updated(self, callback: Callable[[workerVersionUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for workerVersionUpdated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: workerVersionUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('ServiceWorker.workerVersionUpdated', callback)

cdp/protocol/service_worker/events/types.py

@@ -0,0 +1,16 @@
+"""CDP ServiceWorker 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.service_worker.types import ServiceWorkerErrorMessage
+    from cdp.protocol.service_worker.types import ServiceWorkerRegistration
+    from cdp.protocol.service_worker.types import ServiceWorkerVersion
+
+class workerErrorReportedEvent(TypedDict, total=True):
+    errorMessage: 'ServiceWorkerErrorMessage'
+class workerRegistrationUpdatedEvent(TypedDict, total=True):
+    registrations: 'List[ServiceWorkerRegistration]'
+class workerVersionUpdatedEvent(TypedDict, total=True):
+    versions: 'List[ServiceWorkerVersion]'