chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/target/methods/service.py

@@ -0,0 +1,219 @@
+"""CDP Target 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 TargetMethods:
+    """
+    Methods for the Target domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Target methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def activate_target(self, params: Optional[activateTargetParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Activates (focuses) the target.    
+        Args:
+            params (activateTargetParameters, optional): Parameters for the activateTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the activateTarget call.
+        """
+        return await self.client.send(method="Target.activateTarget", params=params,session_id=session_id)
+    async def attach_to_target(self, params: Optional[attachToTargetParameters]=None,session_id: Optional[str] = None) -> attachToTargetReturns:
+        """
+    Attaches to the target with given id.    
+        Args:
+            params (attachToTargetParameters, optional): Parameters for the attachToTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    attachToTargetReturns: The result of the attachToTarget call.
+        """
+        return await self.client.send(method="Target.attachToTarget", params=params,session_id=session_id)
+    async def attach_to_browser_target(self, params: None=None,session_id: Optional[str] = None) -> attachToBrowserTargetReturns:
+        """
+    Attaches to the browser target, only uses flat sessionId mode.    
+        Args:
+            params (None, optional): Parameters for the attachToBrowserTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    attachToBrowserTargetReturns: The result of the attachToBrowserTarget call.
+        """
+        return await self.client.send(method="Target.attachToBrowserTarget", params=params,session_id=session_id)
+    async def close_target(self, params: Optional[closeTargetParameters]=None,session_id: Optional[str] = None) -> closeTargetReturns:
+        """
+    Closes the target. If the target is a page that gets closed too.    
+        Args:
+            params (closeTargetParameters, optional): Parameters for the closeTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    closeTargetReturns: The result of the closeTarget call.
+        """
+        return await self.client.send(method="Target.closeTarget", params=params,session_id=session_id)
+    async def expose_dev_tools_protocol(self, params: Optional[exposeDevToolsProtocolParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Inject object to the target's main frame that provides a communication channel with browser target.  Injected object will be available as `window[bindingName]`.  The object has the following API: - `binding.send(json)` - a method to send messages over the remote debugging protocol - `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses.    
+        Args:
+            params (exposeDevToolsProtocolParameters, optional): Parameters for the exposeDevToolsProtocol method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the exposeDevToolsProtocol call.
+        """
+        return await self.client.send(method="Target.exposeDevToolsProtocol", params=params,session_id=session_id)
+    async def create_browser_context(self, params: Optional[createBrowserContextParameters]=None,session_id: Optional[str] = None) -> createBrowserContextReturns:
+        """
+    Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than one.    
+        Args:
+            params (createBrowserContextParameters, optional): Parameters for the createBrowserContext method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    createBrowserContextReturns: The result of the createBrowserContext call.
+        """
+        return await self.client.send(method="Target.createBrowserContext", params=params,session_id=session_id)
+    async def get_browser_contexts(self, params: None=None,session_id: Optional[str] = None) -> getBrowserContextsReturns:
+        """
+    Returns all browser contexts created with `Target.createBrowserContext` method.    
+        Args:
+            params (None, optional): Parameters for the getBrowserContexts method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getBrowserContextsReturns: The result of the getBrowserContexts call.
+        """
+        return await self.client.send(method="Target.getBrowserContexts", params=params,session_id=session_id)
+    async def create_target(self, params: Optional[createTargetParameters]=None,session_id: Optional[str] = None) -> createTargetReturns:
+        """
+    Creates a new page.    
+        Args:
+            params (createTargetParameters, optional): Parameters for the createTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    createTargetReturns: The result of the createTarget call.
+        """
+        return await self.client.send(method="Target.createTarget", params=params,session_id=session_id)
+    async def detach_from_target(self, params: Optional[detachFromTargetParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Detaches session with given id.    
+        Args:
+            params (detachFromTargetParameters, optional): Parameters for the detachFromTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the detachFromTarget call.
+        """
+        return await self.client.send(method="Target.detachFromTarget", params=params,session_id=session_id)
+    async def dispose_browser_context(self, params: Optional[disposeBrowserContextParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Deletes a BrowserContext. All the belonging pages will be closed without calling their beforeunload hooks.    
+        Args:
+            params (disposeBrowserContextParameters, optional): Parameters for the disposeBrowserContext method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disposeBrowserContext call.
+        """
+        return await self.client.send(method="Target.disposeBrowserContext", params=params,session_id=session_id)
+    async def get_target_info(self, params: Optional[getTargetInfoParameters]=None,session_id: Optional[str] = None) -> getTargetInfoReturns:
+        """
+    Returns information about a target.    
+        Args:
+            params (getTargetInfoParameters, optional): Parameters for the getTargetInfo method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getTargetInfoReturns: The result of the getTargetInfo call.
+        """
+        return await self.client.send(method="Target.getTargetInfo", params=params,session_id=session_id)
+    async def get_targets(self, params: Optional[getTargetsParameters]=None,session_id: Optional[str] = None) -> getTargetsReturns:
+        """
+    Retrieves a list of available targets.    
+        Args:
+            params (getTargetsParameters, optional): Parameters for the getTargets method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getTargetsReturns: The result of the getTargets call.
+        """
+        return await self.client.send(method="Target.getTargets", params=params,session_id=session_id)
+    async def set_auto_attach(self, params: Optional[setAutoAttachParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Controls whether to automatically attach to new targets which are considered to be directly related to this one (for example, iframes or workers). When turned on, attaches to all existing related targets as well. When turned off, automatically detaches from all currently attached targets. This also clears all targets added by `autoAttachRelated` from the list of targets to watch for creation of related targets. You might want to call this recursively for auto-attached targets to attach to all available targets.    
+        Args:
+            params (setAutoAttachParameters, optional): Parameters for the setAutoAttach method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setAutoAttach call.
+        """
+        return await self.client.send(method="Target.setAutoAttach", params=params,session_id=session_id)
+    async def auto_attach_related(self, params: Optional[autoAttachRelatedParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Adds the specified target to the list of targets that will be monitored for any related target creation (such as child frames, child workers and new versions of service worker) and reported through `attachedToTarget`. The specified target is also auto-attached. This cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent `setAutoAttach`. Only available at the Browser target.    
+        Args:
+            params (autoAttachRelatedParameters, optional): Parameters for the autoAttachRelated method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the autoAttachRelated call.
+        """
+        return await self.client.send(method="Target.autoAttachRelated", params=params,session_id=session_id)
+    async def set_discover_targets(self, params: Optional[setDiscoverTargetsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Controls whether to discover available targets and notify via `targetCreated/targetInfoChanged/targetDestroyed` events.    
+        Args:
+            params (setDiscoverTargetsParameters, optional): Parameters for the setDiscoverTargets method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setDiscoverTargets call.
+        """
+        return await self.client.send(method="Target.setDiscoverTargets", params=params,session_id=session_id)
+    async def set_remote_locations(self, params: Optional[setRemoteLocationsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables target discovery for the specified locations, when `setDiscoverTargets` was set to `true`.    
+        Args:
+            params (setRemoteLocationsParameters, optional): Parameters for the setRemoteLocations method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setRemoteLocations call.
+        """
+        return await self.client.send(method="Target.setRemoteLocations", params=params,session_id=session_id)
+    async def get_dev_tools_target(self, params: Optional[getDevToolsTargetParameters]=None,session_id: Optional[str] = None) -> getDevToolsTargetReturns:
+        """
+    Gets the targetId of the DevTools page target opened for the given target (if any).    
+        Args:
+            params (getDevToolsTargetParameters, optional): Parameters for the getDevToolsTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getDevToolsTargetReturns: The result of the getDevToolsTarget call.
+        """
+        return await self.client.send(method="Target.getDevToolsTarget", params=params,session_id=session_id)
+    async def open_dev_tools(self, params: Optional[openDevToolsParameters]=None,session_id: Optional[str] = None) -> openDevToolsReturns:
+        """
+    Opens a DevTools window for the target.    
+        Args:
+            params (openDevToolsParameters, optional): Parameters for the openDevTools method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    openDevToolsReturns: The result of the openDevTools call.
+        """
+        return await self.client.send(method="Target.openDevTools", params=params,session_id=session_id)

cdp/protocol/target/methods/types.py

@@ -0,0 +1,148 @@
+"""CDP Target 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.browser.types import BrowserContextID
+    from cdp.protocol.target.types import RemoteLocation
+    from cdp.protocol.target.types import SessionID
+    from cdp.protocol.target.types import TargetFilter
+    from cdp.protocol.target.types import TargetID
+    from cdp.protocol.target.types import TargetInfo
+    from cdp.protocol.target.types import WindowState
+
+class activateTargetParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+class attachToTargetParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+    flatten: NotRequired['bool']
+    """Enables "flat" access to the session via specifying sessionId attribute in the commands. We plan to make this the default, deprecate non-flattened mode, and eventually retire it. See crbug.com/991325."""
+
+class closeTargetParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+class exposeDevToolsProtocolParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+    bindingName: NotRequired['str']
+    """Binding name, 'cdp' if not specified."""
+    inheritPermissions: NotRequired['bool']
+    """If true, inherits the current root session's permissions (default: false)."""
+class createBrowserContextParameters(TypedDict, total=False):
+    disposeOnDetach: NotRequired['bool']
+    """If specified, disposes this context when debugging session disconnects."""
+    proxyServer: NotRequired['str']
+    """Proxy server, similar to the one passed to --proxy-server"""
+    proxyBypassList: NotRequired['str']
+    """Proxy bypass list, similar to the one passed to --proxy-bypass-list"""
+    originsWithUniversalNetworkAccess: NotRequired['List[str]']
+    """An optional list of origins to grant unlimited cross-origin access to. Parts of the URL other than those constituting origin are ignored."""
+
+class createTargetParameters(TypedDict, total=True):
+    url: 'str'
+    """The initial URL the page will be navigated to. An empty string indicates about:blank."""
+    left: NotRequired['int']
+    """Frame left origin in DIP (requires newWindow to be true or headless shell)."""
+    top: NotRequired['int']
+    """Frame top origin in DIP (requires newWindow to be true or headless shell)."""
+    width: NotRequired['int']
+    """Frame width in DIP (requires newWindow to be true or headless shell)."""
+    height: NotRequired['int']
+    """Frame height in DIP (requires newWindow to be true or headless shell)."""
+    windowState: NotRequired['WindowState']
+    """Frame window state (requires newWindow to be true or headless shell). Default is normal."""
+    browserContextId: NotRequired['BrowserContextID']
+    """The browser context to create the page in."""
+    enableBeginFrameControl: NotRequired['bool']
+    """Whether BeginFrames for this target will be controlled via DevTools (headless shell only, not supported on MacOS yet, false by default)."""
+    newWindow: NotRequired['bool']
+    """Whether to create a new Window or Tab (false by default, not supported by headless shell)."""
+    background: NotRequired['bool']
+    """Whether to create the target in background or foreground (false by default, not supported by headless shell)."""
+    forTab: NotRequired['bool']
+    """Whether to create the target of type "tab"."""
+    hidden: NotRequired['bool']
+    """Whether to create a hidden target. The hidden target is observable via protocol, but not present in the tab UI strip. Cannot be created with forTab: true, newWindow: true or background: false. The life-time of the tab is limited to the life-time of the session."""
+    focus: NotRequired['bool']
+    """If specified, the option is used to determine if the new target should be focused or not. By default, the focus behavior depends on the value of the background field. For example, background=false and focus=false will result in the target tab being opened but the browser window remain unchanged (if it was in the background, it will remain in the background) and background=false with focus=undefined will result in the window being focused. Using background: true and focus: true is not supported and will result in an error."""
+class detachFromTargetParameters(TypedDict, total=False):
+    sessionId: NotRequired['SessionID']
+    """Session to detach."""
+    targetId: NotRequired['TargetID']
+    """Deprecated."""
+class disposeBrowserContextParameters(TypedDict, total=True):
+    browserContextId: 'BrowserContextID'
+class getTargetInfoParameters(TypedDict, total=False):
+    targetId: NotRequired['TargetID']
+class getTargetsParameters(TypedDict, total=False):
+    filter: NotRequired['TargetFilter']
+    """Only targets matching filter will be reported. If filter is not specified and target discovery is currently enabled, a filter used for target discovery is used for consistency."""
+class setAutoAttachParameters(TypedDict, total=True):
+    autoAttach: 'bool'
+    """Whether to auto-attach to related targets."""
+    waitForDebuggerOnStart: 'bool'
+    """Whether to pause new targets when attaching to them. Use Runtime.runIfWaitingForDebugger to run paused targets."""
+    flatten: NotRequired['bool']
+    """Enables "flat" access to the session via specifying sessionId attribute in the commands. We plan to make this the default, deprecate non-flattened mode, and eventually retire it. See crbug.com/991325."""
+    filter: NotRequired['TargetFilter']
+    """Only targets matching filter will be attached."""
+class autoAttachRelatedParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+    waitForDebuggerOnStart: 'bool'
+    """Whether to pause new targets when attaching to them. Use Runtime.runIfWaitingForDebugger to run paused targets."""
+    filter: NotRequired['TargetFilter']
+    """Only targets matching filter will be attached."""
+class setDiscoverTargetsParameters(TypedDict, total=True):
+    discover: 'bool'
+    """Whether to discover available targets."""
+    filter: NotRequired['TargetFilter']
+    """Only targets matching filter will be attached. If discover is false, filter must be omitted or empty."""
+class setRemoteLocationsParameters(TypedDict, total=True):
+    locations: 'List[RemoteLocation]'
+    """List of remote locations."""
+class getDevToolsTargetParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+    """Page or tab target ID."""
+class openDevToolsParameters(TypedDict, total=True):
+    targetId: 'TargetID'
+    """This can be the page or tab target ID."""
+    panelId: NotRequired['str']
+    """The id of the panel we want DevTools to open initially. Currently supported panels are elements, console, network, sources, resources and performance."""
+
+class attachToTargetReturns(TypedDict):
+    sessionId: 'SessionID'
+    """Id assigned to the session."""
+class attachToBrowserTargetReturns(TypedDict):
+    sessionId: 'SessionID'
+    """Id assigned to the session."""
+class closeTargetReturns(TypedDict):
+    success: 'bool'
+    """Always set to true. If an error occurs, the response indicates protocol error."""
+
+class createBrowserContextReturns(TypedDict):
+    browserContextId: 'BrowserContextID'
+    """The id of the context created."""
+class getBrowserContextsReturns(TypedDict):
+    browserContextIds: 'List[BrowserContextID]'
+    """An array of browser context ids."""
+    defaultBrowserContextId: 'BrowserContextID'
+    """The id of the default browser context if available."""
+class createTargetReturns(TypedDict):
+    targetId: 'TargetID'
+    """The id of the page opened."""
+
+
+class getTargetInfoReturns(TypedDict):
+    targetInfo: 'TargetInfo'
+class getTargetsReturns(TypedDict):
+    targetInfos: 'List[TargetInfo]'
+    """The list of targets."""
+
+
+
+
+class getDevToolsTargetReturns(TypedDict):
+    targetId: 'TargetID'
+    """The targetId of DevTools page target if exists."""
+class openDevToolsReturns(TypedDict):
+    targetId: 'TargetID'
+    """The targetId of DevTools page target."""

cdp/protocol/target/service.py

@@ -0,0 +1,21 @@
+"""CDP Target Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import TargetMethods
+from .events.service import TargetEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Target(TargetMethods, TargetEvents):
+    """
+    Supports additional targets discovery and allows to attach to them.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Target domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        TargetMethods.__init__(self, client)
+        TargetEvents.__init__(self, client)

cdp/protocol/target/types.py

@@ -0,0 +1,44 @@
+"""CDP Target 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.browser.types import BrowserContextID
+    from cdp.protocol.page.types import FrameId
+
+TargetID = str
+SessionID = str
+"""Unique identifier of attached debugging session."""
+class TargetInfo(TypedDict, total=True):
+    targetId: 'TargetID'
+    type: 'str'
+    """List of types: https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypeTab%5B%5D%22"""
+    title: 'str'
+    url: 'str'
+    attached: 'bool'
+    """Whether the target has an attached client."""
+    canAccessOpener: 'bool'
+    """Whether the target has access to the originating window."""
+    openerId: NotRequired['TargetID']
+    """Opener target Id"""
+    openerFrameId: NotRequired['FrameId']
+    """Frame id of originating window (is only set if target has an opener)."""
+    parentFrameId: NotRequired['FrameId']
+    """Id of the parent frame, only present for the "iframe" targets."""
+    browserContextId: NotRequired['BrowserContextID']
+    subtype: NotRequired['str']
+    """Provides additional details for specific target types. For example, for the type of "page", this may be set to "prerender"."""
+class FilterEntry(TypedDict, total=False):
+    """A filter used by target query/discovery/auto-attach operations."""
+    exclude: NotRequired['bool']
+    """If set, causes exclusion of matching targets from the list."""
+    type: NotRequired['str']
+    """If not present, matches any type."""
+TargetFilter = List['FilterEntry']
+"""The entries in TargetFilter are matched sequentially against targets and the first entry that matches determines if the target is included or not, depending on the value of exclude field in the entry. If filter is not specified, the one assumed is [{type: "browser", exclude: true}, {type: "tab", exclude: true}, {}] (i.e. include everything but browser and tab)."""
+class RemoteLocation(TypedDict, total=True):
+    host: 'str'
+    port: 'int'
+WindowState = Literal['normal','minimized','maximized','fullscreen']
+"""The state of the target window."""

cdp/protocol/tethering/events/service.py

@@ -0,0 +1,29 @@
+"""CDP Tethering 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 TetheringEvents:
+    """
+    Events for the Tethering domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tethering events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_accepted(self, callback: Callable[[acceptedEvent,Optional[str]], None]=None) -> None:
+        """
+    Informs that port was successfully bound and got a specified connection id.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: acceptedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Tethering.accepted', callback)

cdp/protocol/tethering/events/types.py

@@ -0,0 +1,9 @@
+"""CDP Tethering Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class acceptedEvent(TypedDict, total=True):
+    port: 'int'
+    """Port number that was successfully bound."""
+    connectionId: 'str'
+    """Connection id to be used."""

cdp/protocol/tethering/methods/service.py

@@ -0,0 +1,43 @@
+"""CDP Tethering 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 TetheringMethods:
+    """
+    Methods for the Tethering domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tethering methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def bind(self, params: Optional[bindParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Request browser port binding.    
+        Args:
+            params (bindParameters, optional): Parameters for the bind method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the bind call.
+        """
+        return await self.client.send(method="Tethering.bind", params=params,session_id=session_id)
+    async def unbind(self, params: Optional[unbindParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Request browser port unbinding.    
+        Args:
+            params (unbindParameters, optional): Parameters for the unbind method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the unbind call.
+        """
+        return await self.client.send(method="Tethering.unbind", params=params,session_id=session_id)

cdp/protocol/tethering/methods/types.py

@@ -0,0 +1,10 @@
+"""CDP Tethering Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class bindParameters(TypedDict, total=True):
+    port: 'int'
+    """Port number to bind."""
+class unbindParameters(TypedDict, total=True):
+    port: 'int'
+    """Port number to unbind."""

cdp/protocol/tethering/service.py

@@ -0,0 +1,21 @@
+"""CDP Tethering Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import TetheringMethods
+from .events.service import TetheringEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Tethering(TetheringMethods, TetheringEvents):
+    """
+    The Tethering domain defines methods and events for browser port binding.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tethering domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        TetheringMethods.__init__(self, client)
+        TetheringEvents.__init__(self, client)

cdp/protocol/tethering/types.py

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

cdp/protocol/tracing/events/service.py

@@ -0,0 +1,45 @@
+"""CDP Tracing 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 TracingEvents:
+    """
+    Events for the Tracing domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tracing events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_buffer_usage(self, callback: Callable[[bufferUsageEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for bufferUsage.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: bufferUsageEvent, session_id: Optional[str]).
+        """
+        self.client.on('Tracing.bufferUsage', callback)
+    def on_data_collected(self, callback: Callable[[dataCollectedEvent,Optional[str]], None]=None) -> None:
+        """
+    Contains a bucket of collected trace events. When tracing is stopped collected events will be sent as a sequence of dataCollected events followed by tracingComplete event.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: dataCollectedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Tracing.dataCollected', callback)
+    def on_tracing_complete(self, callback: Callable[[tracingCompleteEvent,Optional[str]], None]=None) -> None:
+        """
+    Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: tracingCompleteEvent, session_id: Optional[str]).
+        """
+        self.client.on('Tracing.tracingComplete', callback)

cdp/protocol/tracing/events/types.py

@@ -0,0 +1,28 @@
+"""CDP Tracing 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.io.types import StreamHandle
+    from cdp.protocol.tracing.types import StreamCompression
+    from cdp.protocol.tracing.types import StreamFormat
+
+class bufferUsageEvent(TypedDict, total=False):
+    percentFull: NotRequired['float']
+    """A number in range [0..1] that indicates the used size of event buffer as a fraction of its total size."""
+    eventCount: NotRequired['float']
+    """An approximate number of events in the trace log."""
+    value: NotRequired['float']
+    """A number in range [0..1] that indicates the used size of event buffer as a fraction of its total size."""
+class dataCollectedEvent(TypedDict, total=True):
+    value: 'List[Dict[str, Any]]'
+class tracingCompleteEvent(TypedDict, total=True):
+    dataLossOccurred: 'bool'
+    """Indicates whether some trace data is known to have been lost, e.g. because the trace ring buffer wrapped around."""
+    stream: NotRequired['StreamHandle']
+    """A handle of the stream that holds resulting trace data."""
+    traceFormat: NotRequired['StreamFormat']
+    """Trace data format of returned stream."""
+    streamCompression: NotRequired['StreamCompression']
+    """Compression format of returned stream."""