chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/log/types.py

@@ -0,0 +1,40 @@
+"""CDP Log 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 RequestId
+    from cdp.protocol.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import StackTrace
+    from cdp.protocol.runtime.types import Timestamp
+
+class LogEntry(TypedDict, total=True):
+    """Log entry."""
+    source: 'Literal["xml", "javascript", "network", "storage", "appcache", "rendering", "security", "deprecation", "worker", "violation", "intervention", "recommendation", "other"]'
+    """Log entry source."""
+    level: 'Literal["verbose", "info", "warning", "error"]'
+    """Log entry severity."""
+    text: 'str'
+    """Logged text."""
+    timestamp: 'Timestamp'
+    """Timestamp when this entry was added."""
+    category: NotRequired['Literal["cors"]']
+    url: NotRequired['str']
+    """URL of the resource if known."""
+    lineNumber: NotRequired['int']
+    """Line number in the resource."""
+    stackTrace: NotRequired['StackTrace']
+    """JavaScript stack trace."""
+    networkRequestId: NotRequired['RequestId']
+    """Identifier of the network request associated with this entry."""
+    workerId: NotRequired['str']
+    """Identifier of the worker associated with this entry."""
+    args: NotRequired['List[RemoteObject]']
+    """Call arguments."""
+class ViolationSetting(TypedDict, total=True):
+    """Violation configuration setting."""
+    name: 'Literal["longTask", "longLayout", "blockedEvent", "blockedParser", "discouragedAPIUse", "handler", "recurringHandler"]'
+    """Violation type."""
+    threshold: 'float'
+    """Time threshold to trigger upon."""

cdp/protocol/media/events/service.py

@@ -0,0 +1,61 @@
+"""CDP Media 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 MediaEvents:
+    """
+    Events for the Media domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Media events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_player_properties_changed(self, callback: Callable[[playerPropertiesChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    This can be called multiple times, and can be used to set / override / remove player properties. A null propValue indicates removal.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: playerPropertiesChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Media.playerPropertiesChanged', callback)
+    def on_player_events_added(self, callback: Callable[[playerEventsAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    Send events as a list, allowing them to be batched on the browser for less congestion. If batched, events must ALWAYS be in chronological order.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: playerEventsAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Media.playerEventsAdded', callback)
+    def on_player_messages_logged(self, callback: Callable[[playerMessagesLoggedEvent,Optional[str]], None]=None) -> None:
+        """
+    Send a list of any messages that need to be delivered.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: playerMessagesLoggedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Media.playerMessagesLogged', callback)
+    def on_player_errors_raised(self, callback: Callable[[playerErrorsRaisedEvent,Optional[str]], None]=None) -> None:
+        """
+    Send a list of any errors that need to be delivered.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: playerErrorsRaisedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Media.playerErrorsRaised', callback)
+    def on_player_created(self, callback: Callable[[playerCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called whenever a player is created, or when a new agent joins and receives a list of active players. If an agent is restored, it will receive one event for each active player.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: playerCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Media.playerCreated', callback)

cdp/protocol/media/events/types.py

@@ -0,0 +1,27 @@
+"""CDP Media 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.media.types import Player
+    from cdp.protocol.media.types import PlayerError
+    from cdp.protocol.media.types import PlayerEvent
+    from cdp.protocol.media.types import PlayerId
+    from cdp.protocol.media.types import PlayerMessage
+    from cdp.protocol.media.types import PlayerProperty
+
+class playerPropertiesChangedEvent(TypedDict, total=True):
+    playerId: 'PlayerId'
+    properties: 'List[PlayerProperty]'
+class playerEventsAddedEvent(TypedDict, total=True):
+    playerId: 'PlayerId'
+    events: 'List[PlayerEvent]'
+class playerMessagesLoggedEvent(TypedDict, total=True):
+    playerId: 'PlayerId'
+    messages: 'List[PlayerMessage]'
+class playerErrorsRaisedEvent(TypedDict, total=True):
+    playerId: 'PlayerId'
+    errors: 'List[PlayerError]'
+class playerCreatedEvent(TypedDict, total=True):
+    player: 'Player'

cdp/protocol/media/methods/service.py

@@ -0,0 +1,43 @@
+"""CDP Media 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 MediaMethods:
+    """
+    Methods for the Media domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Media methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables the Media domain    
+        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="Media.enable", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables the Media domain.    
+        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="Media.disable", params=params,session_id=session_id)

cdp/protocol/media/methods/types.py

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

cdp/protocol/media/service.py

@@ -0,0 +1,21 @@
+"""CDP Media Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import MediaMethods
+from .events.service import MediaEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Media(MediaMethods, MediaEvents):
+    """
+    This domain allows detailed inspection of media elements.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Media domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        MediaMethods.__init__(self, client)
+        MediaEvents.__init__(self, client)

cdp/protocol/media/types.py

@@ -0,0 +1,42 @@
+"""CDP Media 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.dom.types import BackendNodeId
+
+PlayerId = str
+"""Players will get an ID that is unique within the agent context."""
+Timestamp = float
+class PlayerMessage(TypedDict, total=True):
+    """Have one type per entry in MediaLogRecord::Type Corresponds to kMessage"""
+    level: 'Literal["error", "warning", "info", "debug"]'
+    """Keep in sync with MediaLogMessageLevel We are currently keeping the message level 'error' separate from the PlayerError type because right now they represent different things, this one being a DVLOG(ERROR) style log message that gets printed based on what log level is selected in the UI, and the other is a representation of a media::PipelineStatus object. Soon however we're going to be moving away from using PipelineStatus for errors and introducing a new error type which should hopefully let us integrate the error log level into the PlayerError type."""
+    message: 'str'
+class PlayerProperty(TypedDict, total=True):
+    """Corresponds to kMediaPropertyChange"""
+    name: 'str'
+    value: 'str'
+class PlayerEvent(TypedDict, total=True):
+    """Corresponds to kMediaEventTriggered"""
+    timestamp: 'Timestamp'
+    value: 'str'
+class PlayerErrorSourceLocation(TypedDict, total=True):
+    """Represents logged source line numbers reported in an error. NOTE: file and line are from chromium c++ implementation code, not js."""
+    file: 'str'
+    line: 'int'
+class PlayerError(TypedDict, total=True):
+    """Corresponds to kMediaError"""
+    errorType: 'str'
+    code: 'int'
+    """Code is the numeric enum entry for a specific set of error codes, such as PipelineStatusCodes in media/base/pipeline_status.h"""
+    stack: 'List[PlayerErrorSourceLocation]'
+    """A trace of where this error was caused / where it passed through."""
+    cause: 'List[PlayerError]'
+    """Errors potentially have a root cause error, ie, a DecoderError might be caused by an WindowsError"""
+    data: 'Dict[str, Any]'
+    """Extra data attached to an error, such as an HRESULT, Video Codec, etc."""
+class Player(TypedDict, total=True):
+    playerId: 'PlayerId'
+    domNodeId: NotRequired['BackendNodeId']

cdp/protocol/memory/events/service.py

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

cdp/protocol/memory/events/types.py

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

cdp/protocol/memory/methods/service.py

@@ -0,0 +1,142 @@
+"""CDP Memory 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 MemoryMethods:
+    """
+    Methods for the Memory domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Memory methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def get_dom_counters(self, params: None=None,session_id: Optional[str] = None) -> getDOMCountersReturns:
+        """
+    Retruns current DOM object counters.    
+        Args:
+            params (None, optional): Parameters for the getDOMCounters method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getDOMCountersReturns: The result of the getDOMCounters call.
+        """
+        return await self.client.send(method="Memory.getDOMCounters", params=params,session_id=session_id)
+    async def get_dom_counters_for_leak_detection(self, params: None=None,session_id: Optional[str] = None) -> getDOMCountersForLeakDetectionReturns:
+        """
+    Retruns DOM object counters after preparing renderer for leak detection.    
+        Args:
+            params (None, optional): Parameters for the getDOMCountersForLeakDetection method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getDOMCountersForLeakDetectionReturns: The result of the getDOMCountersForLeakDetection call.
+        """
+        return await self.client.send(method="Memory.getDOMCountersForLeakDetection", params=params,session_id=session_id)
+    async def prepare_for_leak_detection(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Prepares for leak detection by terminating workers, stopping spellcheckers, dropping non-essential internal caches, running garbage collections, etc.    
+        Args:
+            params (None, optional): Parameters for the prepareForLeakDetection method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the prepareForLeakDetection call.
+        """
+        return await self.client.send(method="Memory.prepareForLeakDetection", params=params,session_id=session_id)
+    async def forcibly_purge_java_script_memory(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulate OomIntervention by purging V8 memory.    
+        Args:
+            params (None, optional): Parameters for the forciblyPurgeJavaScriptMemory method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the forciblyPurgeJavaScriptMemory call.
+        """
+        return await self.client.send(method="Memory.forciblyPurgeJavaScriptMemory", params=params,session_id=session_id)
+    async def set_pressure_notifications_suppressed(self, params: Optional[setPressureNotificationsSuppressedParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enable/disable suppressing memory pressure notifications in all processes.    
+        Args:
+            params (setPressureNotificationsSuppressedParameters, optional): Parameters for the setPressureNotificationsSuppressed method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setPressureNotificationsSuppressed call.
+        """
+        return await self.client.send(method="Memory.setPressureNotificationsSuppressed", params=params,session_id=session_id)
+    async def simulate_pressure_notification(self, params: Optional[simulatePressureNotificationParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulate a memory pressure notification in all processes.    
+        Args:
+            params (simulatePressureNotificationParameters, optional): Parameters for the simulatePressureNotification method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulatePressureNotification call.
+        """
+        return await self.client.send(method="Memory.simulatePressureNotification", params=params,session_id=session_id)
+    async def start_sampling(self, params: Optional[startSamplingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Start collecting native memory profile.    
+        Args:
+            params (startSamplingParameters, optional): Parameters for the startSampling method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startSampling call.
+        """
+        return await self.client.send(method="Memory.startSampling", params=params,session_id=session_id)
+    async def stop_sampling(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Stop collecting native memory profile.    
+        Args:
+            params (None, optional): Parameters for the stopSampling method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopSampling call.
+        """
+        return await self.client.send(method="Memory.stopSampling", params=params,session_id=session_id)
+    async def get_all_time_sampling_profile(self, params: None=None,session_id: Optional[str] = None) -> getAllTimeSamplingProfileReturns:
+        """
+    Retrieve native memory allocations profile collected since renderer process startup.    
+        Args:
+            params (None, optional): Parameters for the getAllTimeSamplingProfile method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getAllTimeSamplingProfileReturns: The result of the getAllTimeSamplingProfile call.
+        """
+        return await self.client.send(method="Memory.getAllTimeSamplingProfile", params=params,session_id=session_id)
+    async def get_browser_sampling_profile(self, params: None=None,session_id: Optional[str] = None) -> getBrowserSamplingProfileReturns:
+        """
+    Retrieve native memory allocations profile collected since browser process startup.    
+        Args:
+            params (None, optional): Parameters for the getBrowserSamplingProfile method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getBrowserSamplingProfileReturns: The result of the getBrowserSamplingProfile call.
+        """
+        return await self.client.send(method="Memory.getBrowserSamplingProfile", params=params,session_id=session_id)
+    async def get_sampling_profile(self, params: None=None,session_id: Optional[str] = None) -> getSamplingProfileReturns:
+        """
+    Retrieve native memory allocations profile collected since last `startSampling` call.    
+        Args:
+            params (None, optional): Parameters for the getSamplingProfile method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getSamplingProfileReturns: The result of the getSamplingProfile call.
+        """
+        return await self.client.send(method="Memory.getSamplingProfile", params=params,session_id=session_id)

cdp/protocol/memory/methods/types.py

@@ -0,0 +1,48 @@
+"""CDP Memory 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.memory.types import DOMCounter
+    from cdp.protocol.memory.types import PressureLevel
+    from cdp.protocol.memory.types import SamplingProfile
+
+
+
+
+
+class setPressureNotificationsSuppressedParameters(TypedDict, total=True):
+    suppressed: 'bool'
+    """If true, memory pressure notifications will be suppressed."""
+class simulatePressureNotificationParameters(TypedDict, total=True):
+    level: 'PressureLevel'
+    """Memory pressure level of the notification."""
+class startSamplingParameters(TypedDict, total=False):
+    samplingInterval: NotRequired['int']
+    """Average number of bytes between samples."""
+    suppressRandomness: NotRequired['bool']
+    """Do not randomize intervals between samples."""
+
+
+
+
+class getDOMCountersReturns(TypedDict):
+    documents: 'int'
+    nodes: 'int'
+    jsEventListeners: 'int'
+class getDOMCountersForLeakDetectionReturns(TypedDict):
+    counters: 'List[DOMCounter]'
+    """DOM object counters."""
+
+
+
+
+
+
+class getAllTimeSamplingProfileReturns(TypedDict):
+    profile: 'SamplingProfile'
+class getBrowserSamplingProfileReturns(TypedDict):
+    profile: 'SamplingProfile'
+class getSamplingProfileReturns(TypedDict):
+    profile: 'SamplingProfile'

cdp/protocol/memory/service.py

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

cdp/protocol/memory/types.py

@@ -0,0 +1,34 @@
+"""CDP Memory Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+PressureLevel = Literal['moderate','critical']
+"""Memory pressure level."""
+class SamplingProfileNode(TypedDict, total=True):
+    """Heap profile sample."""
+    size: 'float'
+    """Size of the sampled allocation."""
+    total: 'float'
+    """Total bytes attributed to this sample."""
+    stack: 'List[str]'
+    """Execution stack at the point of allocation."""
+class SamplingProfile(TypedDict, total=True):
+    """Array of heap profile samples."""
+    samples: 'List[SamplingProfileNode]'
+    modules: 'List[Module]'
+class Module(TypedDict, total=True):
+    """Executable module information"""
+    name: 'str'
+    """Name of the module."""
+    uuid: 'str'
+    """UUID of the module."""
+    baseAddress: 'str'
+    """Base address where the module is loaded into memory. Encoded as a decimal or hexadecimal (0x prefixed) string."""
+    size: 'float'
+    """Size of the module in bytes."""
+class DOMCounter(TypedDict, total=True):
+    """DOM object counter data."""
+    name: 'str'
+    """Object name. Note: object names should be presumed volatile and clients should not expect the returned names to be consistent across runs."""
+    count: 'int'
+    """Object count."""