chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/cache_storage/events/service.py

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

cdp/protocol/cache_storage/events/types.py

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

cdp/protocol/cache_storage/methods/service.py

@@ -0,0 +1,76 @@
+"""CDP CacheStorage 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 CacheStorageMethods:
+    """
+    Methods for the CacheStorage domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the CacheStorage methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def delete_cache(self, params: Optional[deleteCacheParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Deletes a cache.    
+        Args:
+            params (deleteCacheParameters, optional): Parameters for the deleteCache method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deleteCache call.
+        """
+        return await self.client.send(method="CacheStorage.deleteCache", params=params,session_id=session_id)
+    async def delete_entry(self, params: Optional[deleteEntryParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Deletes a cache entry.    
+        Args:
+            params (deleteEntryParameters, optional): Parameters for the deleteEntry method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deleteEntry call.
+        """
+        return await self.client.send(method="CacheStorage.deleteEntry", params=params,session_id=session_id)
+    async def request_cache_names(self, params: Optional[requestCacheNamesParameters]=None,session_id: Optional[str] = None) -> requestCacheNamesReturns:
+        """
+    Requests cache names.    
+        Args:
+            params (requestCacheNamesParameters, optional): Parameters for the requestCacheNames method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestCacheNamesReturns: The result of the requestCacheNames call.
+        """
+        return await self.client.send(method="CacheStorage.requestCacheNames", params=params,session_id=session_id)
+    async def request_cached_response(self, params: Optional[requestCachedResponseParameters]=None,session_id: Optional[str] = None) -> requestCachedResponseReturns:
+        """
+    Fetches cache entry.    
+        Args:
+            params (requestCachedResponseParameters, optional): Parameters for the requestCachedResponse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestCachedResponseReturns: The result of the requestCachedResponse call.
+        """
+        return await self.client.send(method="CacheStorage.requestCachedResponse", params=params,session_id=session_id)
+    async def request_entries(self, params: Optional[requestEntriesParameters]=None,session_id: Optional[str] = None) -> requestEntriesReturns:
+        """
+    Requests data from cache.    
+        Args:
+            params (requestEntriesParameters, optional): Parameters for the requestEntries method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestEntriesReturns: The result of the requestEntries call.
+        """
+        return await self.client.send(method="CacheStorage.requestEntries", params=params,session_id=session_id)

cdp/protocol/cache_storage/methods/types.py

@@ -0,0 +1,57 @@
+"""CDP CacheStorage 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.cache_storage.types import Cache
+    from cdp.protocol.cache_storage.types import CacheId
+    from cdp.protocol.cache_storage.types import CachedResponse
+    from cdp.protocol.cache_storage.types import DataEntry
+    from cdp.protocol.cache_storage.types import Header
+    from cdp.protocol.storage.types import StorageBucket
+
+class deleteCacheParameters(TypedDict, total=True):
+    cacheId: 'CacheId'
+    """Id of cache for deletion."""
+class deleteEntryParameters(TypedDict, total=True):
+    cacheId: 'CacheId'
+    """Id of cache where the entry will be deleted."""
+    request: 'str'
+    """URL spec of the request."""
+class requestCacheNamesParameters(TypedDict, total=False):
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+class requestCachedResponseParameters(TypedDict, total=True):
+    cacheId: 'CacheId'
+    """Id of cache that contains the entry."""
+    requestURL: 'str'
+    """URL spec of the request."""
+    requestHeaders: 'List[Header]'
+    """headers of the request."""
+class requestEntriesParameters(TypedDict, total=True):
+    cacheId: 'CacheId'
+    """ID of cache to get entries from."""
+    skipCount: NotRequired['int']
+    """Number of records to skip."""
+    pageSize: NotRequired['int']
+    """Number of records to fetch."""
+    pathFilter: NotRequired['str']
+    """If present, only return the entries containing this substring in the path"""
+
+
+class requestCacheNamesReturns(TypedDict):
+    caches: 'List[Cache]'
+    """Caches for the security origin."""
+class requestCachedResponseReturns(TypedDict):
+    response: 'CachedResponse'
+    """Response read from the cache."""
+class requestEntriesReturns(TypedDict):
+    cacheDataEntries: 'List[DataEntry]'
+    """Array of object store data entries."""
+    returnCount: 'float'
+    """Count of returned entries from this storage. If pathFilter is empty, it is the count of all entries from this storage."""

cdp/protocol/cache_storage/service.py

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

cdp/protocol/cache_storage/types.py

@@ -0,0 +1,49 @@
+"""CDP CacheStorage 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.storage.types import StorageBucket
+
+CacheId = str
+"""Unique identifier of the Cache object."""
+CachedResponseType = Literal['basic','cors','default','error','opaqueResponse','opaqueRedirect']
+"""type of HTTP response cached"""
+class DataEntry(TypedDict, total=True):
+    """Data entry."""
+    requestURL: 'str'
+    """Request URL."""
+    requestMethod: 'str'
+    """Request method."""
+    requestHeaders: 'List[Header]'
+    """Request headers"""
+    responseTime: 'float'
+    """Number of seconds since epoch."""
+    responseStatus: 'int'
+    """HTTP response status code."""
+    responseStatusText: 'str'
+    """HTTP response status text."""
+    responseType: 'CachedResponseType'
+    """HTTP response type"""
+    responseHeaders: 'List[Header]'
+    """Response headers"""
+class Cache(TypedDict, total=True):
+    """Cache identifier."""
+    cacheId: 'CacheId'
+    """An opaque unique id of the cache."""
+    securityOrigin: 'str'
+    """Security origin of the cache."""
+    storageKey: 'str'
+    """Storage key of the cache."""
+    cacheName: 'str'
+    """The name of the cache."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket of the cache."""
+class Header(TypedDict, total=True):
+    name: 'str'
+    value: 'str'
+class CachedResponse(TypedDict, total=True):
+    """Cached response"""
+    body: 'str'
+    """Entry content, base64-encoded. (Encoded as a base64 string when passed over JSON)"""

cdp/protocol/cast/events/service.py

@@ -0,0 +1,37 @@
+"""CDP Cast 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 CastEvents:
+    """
+    Events for the Cast domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Cast events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_sinks_updated(self, callback: Callable[[sinksUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    This is fired whenever the list of available sinks changes. A sink is a device or a software surface that you can cast to.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: sinksUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Cast.sinksUpdated', callback)
+    def on_issue_updated(self, callback: Callable[[issueUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    This is fired whenever the outstanding issue/error message changes. |issueMessage| is empty if there is no issue.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: issueUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Cast.issueUpdated', callback)

cdp/protocol/cast/events/types.py

@@ -0,0 +1,12 @@
+"""CDP Cast 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.cast.types import Sink
+
+class sinksUpdatedEvent(TypedDict, total=True):
+    sinks: 'List[Sink]'
+class issueUpdatedEvent(TypedDict, total=True):
+    issueMessage: 'str'

cdp/protocol/cast/methods/service.py

@@ -0,0 +1,87 @@
+"""CDP Cast 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 CastMethods:
+    """
+    Methods for the Cast domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Cast methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: Optional[enableParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Starts observing for sinks that can be used for tab mirroring, and if set, sinks compatible with |presentationUrl| as well. When sinks are found, a |sinksUpdated| event is fired. Also starts observing for issue messages. When an issue is added or removed, an |issueUpdated| event is fired.    
+        Args:
+            params (enableParameters, 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="Cast.enable", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Stops observing for sinks and issues.    
+        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="Cast.disable", params=params,session_id=session_id)
+    async def set_sink_to_use(self, params: Optional[setSinkToUseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets a sink to be used when the web page requests the browser to choose a sink via Presentation API, Remote Playback API, or Cast SDK.    
+        Args:
+            params (setSinkToUseParameters, optional): Parameters for the setSinkToUse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setSinkToUse call.
+        """
+        return await self.client.send(method="Cast.setSinkToUse", params=params,session_id=session_id)
+    async def start_desktop_mirroring(self, params: Optional[startDesktopMirroringParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Starts mirroring the desktop to the sink.    
+        Args:
+            params (startDesktopMirroringParameters, optional): Parameters for the startDesktopMirroring method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startDesktopMirroring call.
+        """
+        return await self.client.send(method="Cast.startDesktopMirroring", params=params,session_id=session_id)
+    async def start_tab_mirroring(self, params: Optional[startTabMirroringParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Starts mirroring the tab to the sink.    
+        Args:
+            params (startTabMirroringParameters, optional): Parameters for the startTabMirroring method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startTabMirroring call.
+        """
+        return await self.client.send(method="Cast.startTabMirroring", params=params,session_id=session_id)
+    async def stop_casting(self, params: Optional[stopCastingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Stops the active Cast session on the sink.    
+        Args:
+            params (stopCastingParameters, optional): Parameters for the stopCasting method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopCasting call.
+        """
+        return await self.client.send(method="Cast.stopCasting", params=params,session_id=session_id)

cdp/protocol/cast/methods/types.py

@@ -0,0 +1,15 @@
+"""CDP Cast Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class enableParameters(TypedDict, total=False):
+    presentationUrl: NotRequired['str']
+
+class setSinkToUseParameters(TypedDict, total=True):
+    sinkName: 'str'
+class startDesktopMirroringParameters(TypedDict, total=True):
+    sinkName: 'str'
+class startTabMirroringParameters(TypedDict, total=True):
+    sinkName: 'str'
+class stopCastingParameters(TypedDict, total=True):
+    sinkName: 'str'

cdp/protocol/cast/service.py

@@ -0,0 +1,21 @@
+"""CDP Cast Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import CastMethods
+from .events.service import CastEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Cast(CastMethods, CastEvents):
+    """
+    A domain for interacting with Cast, Presentation API, and Remote Playback API functionalities.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Cast domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        CastMethods.__init__(self, client)
+        CastEvents.__init__(self, client)

cdp/protocol/cast/types.py

@@ -0,0 +1,9 @@
+"""CDP Cast Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class Sink(TypedDict, total=True):
+    name: 'str'
+    id: 'str'
+    session: NotRequired['str']
+    """Text describing the current session. Present only if there is an active session on the sink."""

cdp/protocol/css/events/service.py

@@ -0,0 +1,69 @@
+"""CDP CSS 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 CSSEvents:
+    """
+    Events for the CSS domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the CSS events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_fonts_updated(self, callback: Callable[[fontsUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded web font.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: fontsUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.fontsUpdated', callback)
+    def on_media_query_result_changed(self, callback: Callable[[mediaQueryResultChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: mediaQueryResultChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.mediaQueryResultChanged', callback)
+    def on_style_sheet_added(self, callback: Callable[[styleSheetAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired whenever an active document stylesheet is added.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: styleSheetAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.styleSheetAdded', callback)
+    def on_style_sheet_changed(self, callback: Callable[[styleSheetChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired whenever a stylesheet is changed as a result of the client operation.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: styleSheetChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.styleSheetChanged', callback)
+    def on_style_sheet_removed(self, callback: Callable[[styleSheetRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired whenever an active document stylesheet is removed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: styleSheetRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.styleSheetRemoved', callback)
+    def on_computed_style_updated(self, callback: Callable[[computedStyleUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for computedStyleUpdated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: computedStyleUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('CSS.computedStyleUpdated', callback)

cdp/protocol/css/events/types.py

@@ -0,0 +1,27 @@
+"""CDP CSS 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.css.types import CSSStyleSheetHeader
+    from cdp.protocol.css.types import FontFace
+    from cdp.protocol.dom.types import NodeId
+    from cdp.protocol.dom.types import StyleSheetId
+
+class fontsUpdatedEvent(TypedDict, total=False):
+    font: NotRequired['FontFace']
+    """The web font that has loaded."""
+class mediaQueryResultChangedEvent(TypedDict, total=True):
+    pass
+class styleSheetAddedEvent(TypedDict, total=True):
+    header: 'CSSStyleSheetHeader'
+    """Added stylesheet metainfo."""
+class styleSheetChangedEvent(TypedDict, total=True):
+    styleSheetId: 'StyleSheetId'
+class styleSheetRemovedEvent(TypedDict, total=True):
+    styleSheetId: 'StyleSheetId'
+    """Identifier of the removed stylesheet."""
+class computedStyleUpdatedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """The node id that has updated computed styles."""