chromedeveloperprotocol-client 0.1.0__tar.gz → 0.1.1__tar.gz

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chromedeveloperprotocol-client
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python wrapper for Chrome DevTools Protocol
 Requires-Python: >=3.13
 Requires-Dist: httpx>=0.28.1

chromedeveloperprotocol_client-0.1.1/main.py

@@ -0,0 +1,109 @@
+import asyncio
+import logging
+import sys
+import httpx
+import subprocess
+import os
+import time
+
+from cdp import Client
+
+async def launch_browser(port=9222):
+    """
+    Launch MS Edge or Google Chrome with remote debugging enabled.
+    """
+    # Common paths for Edge and Chrome on Windows
+    paths = [
+        r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
+        r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
+        r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+        r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+    ]
+    
+    exe_path = next((p for p in paths if os.path.exists(p)), None)
+    if not exe_path:
+        # Try finding it in PATH if not in standard locations
+        try:
+            exe_path = subprocess.check_output(["where", "msedge"]).decode().splitlines()[0]
+        except:
+            try:
+                exe_path = subprocess.check_output(["where", "chrome"]).decode().splitlines()[0]
+            except:
+                raise Exception("Compatible browser (Edge or Chrome) not found in standard paths or PATH.")
+
+    print(f"Launching browser: {exe_path}")
+    
+    # Launch the process
+    # Using a detached process so it keeps running even if our script restarts
+    process = subprocess.Popen([
+        exe_path,
+        f"--remote-debugging-port={port}",
+        "--headless",
+        "--disable-gpu",
+        "--remote-allow-origins=*",
+        "--user-data-dir=" + os.path.join(os.getcwd(), "cdp_user_data")
+    ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    
+    # Poll for the debugger endpoint to become available
+    print(f"Waiting for debugger on port {port}...")
+    async with httpx.AsyncClient() as http:
+        for _ in range(20): # Try for up to 10 seconds
+            try:
+                resp = await http.get(f"http://localhost:{port}/json/version")
+                if resp.status_code == 200:
+                    data = resp.json()
+                    print("Browser launched and debugger ready.")
+                    return process, data['webSocketDebuggerUrl']
+            except (httpx.ConnectError, httpx.HTTPError):
+                await asyncio.sleep(0.5)
+                
+    raise Exception("Timed out waiting for browser to start.")
+
+async def main():
+    logging.basicConfig(level=logging.INFO)
+    
+    port = 9222
+    ws_url = None
+    browser_process = None
+
+    print("Checking for existing browser session...")
+    try:
+        async with httpx.AsyncClient() as http:
+            resp = await http.get(f"http://localhost:{port}/json/version")
+            data = resp.json()
+            ws_url = data['webSocketDebuggerUrl']
+            print(f"Found existing session at: {ws_url}")
+    except Exception:
+        print("No existing session found. Launching new browser...")
+        try:
+            browser_process, ws_url = await launch_browser(port)
+        except Exception as e:
+            print(f"FAILED to launch browser: {e}")
+            return
+
+    try:
+        async with Client(ws_url) as client:
+            print("Connected! Getting target list...")
+            targets = await client.target.get_targets({})
+            print(f"Found {len(targets['targetInfos'])} targets")
+            
+            # Create a new page
+            print("Creating new target...")
+            target = await client.target.create_target({"url": "https://www.google.com"})
+            target_id = target['targetId']
+            print(f"Created new target: {target_id}")
+            
+            # Get browser info
+            version = await client.browser.get_version({})
+            print(f"Browser Version: {version['product']}")
+            
+            print("\nSUCCESS! CDP interaction verified.")
+    finally:
+        if browser_process:
+            print("Closing the browser process...")
+            # Optional: You can keep it running by NOT calling terminate()
+            # browser_process.terminate()
+            # print("Browser process terminated.")
+
+if __name__ == "__main__":
+    asyncio.run(main())

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chromedeveloperprotocol-client"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python wrapper for Chrome DevTools Protocol"
 readme = "README.md"
 requires-python = ">=3.13"

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/generator/domain_generator.py

@@ -5,6 +5,7 @@ from .event_generator import EventGenerator
 
 METHODS_SERVICE_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Domain Methods\"\"\"
+from __future__ import annotations
 {% for import_ in imports %}
 {{ import_ }}
 {% endfor %}
@@ -16,12 +17,12 @@ class {{ class_name }}:
     \"\"\"
     Methods for the {{ domain_name }} domain.
     \"\"\"
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         \"\"\"
         Initialize the {{ domain_name }} methods.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            client (Client): The parent CDP client instance.
         \"\"\"
         self.client = client
 
@@ -32,6 +33,7 @@ class {{ class_name }}:
 
 EVENTS_SERVICE_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Domain Events\"\"\"
+from __future__ import annotations
 {% for import_ in imports %}
 {{ import_ }}
 {% endfor %}
@@ -43,12 +45,12 @@ class {{ class_name }}:
     \"\"\"
     Events for the {{ domain_name }} domain.
     \"\"\"
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         \"\"\"
         Initialize the {{ domain_name }} events.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            client (Client): The parent CDP client instance.
         \"\"\"
         self.client = client
 
@@ -59,6 +61,7 @@ class {{ class_name }}:
 
 DOMAIN_SERVICE_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Domain\"\"\"
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from .methods.service import {{ domain_name }}Methods
 from .events.service import {{ domain_name }}Events
@@ -70,12 +73,12 @@ class {{ domain_name }}({{ domain_name }}Methods, {{ domain_name }}Events):
     \"\"\"
     {{ domain_description | replace("\\n", " ") }}
     \"\"\"
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         \"\"\"
         Initialize the {{ domain_name }} domain.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            client (Client): The parent CDP client instance.
         \"\"\"
         {{ domain_name }}Methods.__init__(self, client)
         {{ domain_name }}Events.__init__(self, client)

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/generator/event_generator.py

@@ -4,15 +4,18 @@ import inflection
 
 EVENT_SERVICES_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Events\"\"\"
+from __future__ import annotations
+from typing import TypedDict, Optional, Callable, TYPE_CHECKING
+from .service import Client
+from .events.types import *
 
-from client.service import CDPClient
-from typing import TypedDict, Optional, Callable
-from protocol.{{ domain_name | to_snake }}.events.types import *
+if TYPE_CHECKING:
+    from ....service import Client
 
 class {{ domain_name }}Events:
     {% if event_implementations | length > 0 %}
-    def __init__(self,client:CDPClient):
-        self.client=client
+    def __init__(self, client: Client):
+        self.client = client
     {% for implementation in event_implementations %}
     {{ implementation | indent(4) }}
     {% endfor %}
@@ -22,20 +25,20 @@ class {{ domain_name }}Events:
 """
 
 EVENT_IMPLEMENTATION_TEMPLATE = """\
-def on_{{ event_name | to_snake }}(self, callback: Callable[[{{ event_name }}Event,Optional[str]], None]=None) -> None:
+def on_{{ event_name | to_snake }}(self, callback: Callable[[{{ event_name }}Event, str | None], None] | None = None) -> None:
     \"\"\"
     {% if event_description %}{{ event_description | replace("\\n", " ") }}{% else %}No description available for {{ event_name }}.{% endif %}
     
     Args:
         callback (callable, optional): Function called when the event is fired. 
-            The callback receives (params: {{ event_name }}Event, session_id: Optional[str]).
+            The callback receives (params: {{ event_name }}Event, session_id: str | None).
     \"\"\"
     self.client.on('{{ domain_name }}.{{ event_name }}', callback)
 """
 
 EVENT_TYPES_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Events\"\"\"
-
+from __future__ import annotations
 {% for import_ in imports %}
 {{ import_ }}
 {% endfor %}
@@ -60,7 +63,7 @@ class {{event_name}}Event(TypedDict, total={{total}}):
     {% else %}
     {% if required_parameters %}
     {% for parameter in required_parameters %}
-    {{ parameter['name'] }}: '{{ parameter['type'] }}'
+    {{ parameter['name'] }}: {{ parameter['type'] }}
     {% if parameter['description'] %}
     \"\"\"{{ parameter['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}
@@ -68,7 +71,7 @@ class {{event_name}}Event(TypedDict, total={{total}}):
     {% endif %}
     {% if optional_parameters %}
     {% for parameter in optional_parameters %}
-    {{ parameter['name'] }}: NotRequired['{{ parameter['type'] }}']
+    {{ parameter['name'] }}: NotRequired[{{ parameter['type'] }}]
     {% if parameter['description'] %}
     \"\"\"{{ parameter['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/generator/method_generator.py

@@ -3,23 +3,23 @@ from jinja2 import Environment
 import inflection
 
 METHOD_IMPLEMENTATION_TEMPLATE = """\
-async def {{ method_name | to_snake }}(self, params: {% if parameters|length > 0 %}Optional[{{ method_name }}Parameters]{% else %}None{% endif %}=None,session_id: Optional[str] = None) -> {% if return_parameters|length > 0 %}{{ method_name }}Returns{% else %}Dict[str, Any]{% endif %}:
+async def {{ method_name | to_snake }}(self, params: {{ method_name }}Parameters | None = None, session_id: str | None = None) -> {% if return_parameters|length > 0 %}{{ method_name }}Returns{% else %}Dict[str, Any]{% endif %}:
     \"\"\"
     {% if method_description %}{{ method_description | replace("\\n", " ") }}{% else %}No description available for {{ method_name }}.{% endif %}
     
     Args:
-        params ({% if parameters|length > 0 %}{{ method_name }}Parameters{% else %}None{% endif %}, optional): Parameters for the {{ method_name }} method.
+        params ({{ method_name }}Parameters, optional): Parameters for the {{ method_name }} method.
         session_id (str, optional): Target session ID for flat protocol usage.
         
     Returns:
         {% if return_parameters|length > 0 %}{{ method_name }}Returns{% else %}Dict[str, Any]{% endif %}: The result of the {{ method_name }} call.
     \"\"\"
-    return await self.client.send(method="{{ domain_name }}.{{ method_name }}", params=params,session_id=session_id)
+    return await self.client.send(method="{{ domain_name }}.{{ method_name }}", params=params, session_id=session_id)
 """
 
 METHOD_TYPES_TEMPLATE = """\
 \"\"\"CDP {{ domain_name }} Methods Types\"\"\"
-
+from __future__ import annotations
 {% for import_ in imports %}
 {{ import_ }}
 {% endfor %}
@@ -47,7 +47,7 @@ class {{ method_name }}Parameters(TypedDict, total={{ total }}):
     {% else %}
     {% if required_parameters %}
     {% for parameter in required_parameters %}
-    {{ parameter['name'] }}: '{{ parameter['type'] }}'
+    {{ parameter['name'] }}: {{ parameter['type'] }}
     {% if parameter['description'] %}
     \"\"\"{{ parameter['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}
@@ -55,7 +55,7 @@ class {{ method_name }}Parameters(TypedDict, total={{ total }}):
     {% endif %}
     {% if optional_parameters %}
     {% for parameter in optional_parameters %}
-    {{ parameter['name'] }}: NotRequired['{{ parameter['type'] }}']
+    {{ parameter['name'] }}: NotRequired[{{ parameter['type'] }}]
     {% if parameter['description'] %}
     \"\"\"{{ parameter['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}
@@ -70,7 +70,7 @@ class {{ method_name }}Returns(TypedDict):
     pass
     {% else %}
     {% for return_parameter in return_parameters %}
-    {{ return_parameter['name'] }}: '{{ return_parameter['type'] }}'
+    {{ return_parameter['name'] }}: {{ return_parameter['type'] }}
     {% if return_parameter['description'] %}
     \"\"\"{{ return_parameter['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/generator/type_generator.py

@@ -4,7 +4,7 @@ import inflection
 
 TYPES_TEMPLATE = """\
 \"\"\"CDP {{ current_domain }} Types\"\"\"
-
+from __future__ import annotations
 {% for import_ in imports %}
 {{ import_ }}
 {% endfor %}
@@ -23,7 +23,7 @@ if TYPE_CHECKING:
 """
 
 ARRAY_TYPE_TEMPLATE = """\
-{{ type_name }} = List['{{ type_type }}']
+{{ type_name }} = List[{{ type_type }}]
 {% if type_description %}
 \"\"\"{{ type_description | replace('\\n', ' ') | replace('`', '') }}\"\"\"
 {% endif %}
@@ -53,7 +53,7 @@ class {{ type_name }}(TypedDict, total={{ total }}):
     {% else %}
     {% if required_properties %}
     {% for property in required_properties %}
-    {{ property['name'] }}: '{{ property['type'] }}'
+    {{ property['name'] }}: {{ property['type'] }}
     {% if property.get('description') %}
     \"\"\"{{ property['description'] | replace('\\n', ' ') | replace('\\\"', '') | replace('`','') }}\"\"\"
     {% endif %}
@@ -61,7 +61,7 @@ class {{ type_name }}(TypedDict, total={{ total }}):
     {% endif %}
     {% if optional_properties %}
     {% for property in optional_properties %}
-    {{ property['name'] }}: NotRequired['{{ property['type'] }}']
+    {{ property['name'] }}: NotRequired[{{ property['type'] }}]
     {% if property.get('description') %}
     \"\"\"{{ property['description'] | replace('\\n', ' ') | replace('`', '') }}\"\"\"
     {% endif %}

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/protocol/accessibility/events/service.py

@@ -1,4 +1,5 @@
 """CDP Accessibility Domain Events"""
+from __future__ import annotations
 from ..types import *
 from .types import *
 from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
@@ -10,28 +11,28 @@ class AccessibilityEvents:
     """
     Events for the Accessibility domain.
     """
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         """
         Initialize the Accessibility events.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            client (Client): The parent CDP client instance.
         """
         self.client = client
 
-    def on_load_complete(self, callback: Callable[[loadCompleteEvent,Optional[str]], None]=None) -> None:
+    def on_load_complete(self, callback: Callable[[loadCompleteEvent, str | None], None] | None = None) -> None:
         """
     The loadComplete event mirrors the load complete event sent by the browser to assistive technology when the web page has finished loading.    
         Args:
             callback (callable, optional): Function called when the event is fired. 
-                The callback receives (params: loadCompleteEvent, session_id: Optional[str]).
+                The callback receives (params: loadCompleteEvent, session_id: str | None).
         """
         self.client.on('Accessibility.loadComplete', callback)
-    def on_nodes_updated(self, callback: Callable[[nodesUpdatedEvent,Optional[str]], None]=None) -> None:
+    def on_nodes_updated(self, callback: Callable[[nodesUpdatedEvent, str | None], None] | None = None) -> None:
         """
     The nodesUpdated event is sent every time a previously requested node has changed the in tree.    
         Args:
             callback (callable, optional): Function called when the event is fired. 
-                The callback receives (params: nodesUpdatedEvent, session_id: Optional[str]).
+                The callback receives (params: nodesUpdatedEvent, session_id: str | None).
         """
         self.client.on('Accessibility.nodesUpdated', callback)

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/protocol/accessibility/events/types.py

@@ -1,5 +1,5 @@
 """CDP Accessibility Events"""
-
+from __future__ import annotations
 from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
 
 from typing import TYPE_CHECKING
@@ -7,8 +7,8 @@ if TYPE_CHECKING:
     from cdp.protocol.accessibility.types import AXNode
 
 class loadCompleteEvent(TypedDict, total=True):
-    root: 'AXNode'
+    root: AXNode
     """New document root node."""
 class nodesUpdatedEvent(TypedDict, total=True):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
     """Updated node data."""

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/protocol/accessibility/methods/service.py

@@ -1,4 +1,5 @@
 """CDP Accessibility Domain Methods"""
+from __future__ import annotations
 from ..types import *
 from .types import *
 from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
@@ -10,38 +11,38 @@ class AccessibilityMethods:
     """
     Methods for the Accessibility domain.
     """
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         """
         Initialize the Accessibility methods.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            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]:
+    async def disable(self, params: disableParameters | None = None, session_id: str | None = None) -> Dict[str, Any]:
         """
     Disables the accessibility domain.    
         Args:
-            params (None, optional): Parameters for the disable method.
+            params (disableParameters, 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="Accessibility.disable", params=params,session_id=session_id)
-    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.client.send(method="Accessibility.disable", params=params, session_id=session_id)
+    async def enable(self, params: enableParameters | None = None, session_id: str | None = None) -> Dict[str, Any]:
         """
     Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls. This turns on accessibility for the page, which can impact performance until accessibility is disabled.    
         Args:
-            params (None, optional): Parameters for the enable method.
+            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="Accessibility.enable", params=params,session_id=session_id)
-    async def get_partial_ax_tree(self, params: Optional[getPartialAXTreeParameters]=None,session_id: Optional[str] = None) -> getPartialAXTreeReturns:
+        return await self.client.send(method="Accessibility.enable", params=params, session_id=session_id)
+    async def get_partial_ax_tree(self, params: getPartialAXTreeParameters | None = None, session_id: str | None = None) -> getPartialAXTreeReturns:
         """
     Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.    
         Args:
@@ -51,8 +52,8 @@ class AccessibilityMethods:
         Returns:
     getPartialAXTreeReturns: The result of the getPartialAXTree call.
         """
-        return await self.client.send(method="Accessibility.getPartialAXTree", params=params,session_id=session_id)
-    async def get_full_ax_tree(self, params: Optional[getFullAXTreeParameters]=None,session_id: Optional[str] = None) -> getFullAXTreeReturns:
+        return await self.client.send(method="Accessibility.getPartialAXTree", params=params, session_id=session_id)
+    async def get_full_ax_tree(self, params: getFullAXTreeParameters | None = None, session_id: str | None = None) -> getFullAXTreeReturns:
         """
     Fetches the entire accessibility tree for the root Document    
         Args:
@@ -62,8 +63,8 @@ class AccessibilityMethods:
         Returns:
     getFullAXTreeReturns: The result of the getFullAXTree call.
         """
-        return await self.client.send(method="Accessibility.getFullAXTree", params=params,session_id=session_id)
-    async def get_root_ax_node(self, params: Optional[getRootAXNodeParameters]=None,session_id: Optional[str] = None) -> getRootAXNodeReturns:
+        return await self.client.send(method="Accessibility.getFullAXTree", params=params, session_id=session_id)
+    async def get_root_ax_node(self, params: getRootAXNodeParameters | None = None, session_id: str | None = None) -> getRootAXNodeReturns:
         """
     Fetches the root node. Requires `enable()` to have been called previously.    
         Args:
@@ -73,8 +74,8 @@ class AccessibilityMethods:
         Returns:
     getRootAXNodeReturns: The result of the getRootAXNode call.
         """
-        return await self.client.send(method="Accessibility.getRootAXNode", params=params,session_id=session_id)
-    async def get_ax_node_and_ancestors(self, params: Optional[getAXNodeAndAncestorsParameters]=None,session_id: Optional[str] = None) -> getAXNodeAndAncestorsReturns:
+        return await self.client.send(method="Accessibility.getRootAXNode", params=params, session_id=session_id)
+    async def get_ax_node_and_ancestors(self, params: getAXNodeAndAncestorsParameters | None = None, session_id: str | None = None) -> getAXNodeAndAncestorsReturns:
         """
     Fetches a node and all ancestors up to and including the root. Requires `enable()` to have been called previously.    
         Args:
@@ -84,8 +85,8 @@ class AccessibilityMethods:
         Returns:
     getAXNodeAndAncestorsReturns: The result of the getAXNodeAndAncestors call.
         """
-        return await self.client.send(method="Accessibility.getAXNodeAndAncestors", params=params,session_id=session_id)
-    async def get_child_ax_nodes(self, params: Optional[getChildAXNodesParameters]=None,session_id: Optional[str] = None) -> getChildAXNodesReturns:
+        return await self.client.send(method="Accessibility.getAXNodeAndAncestors", params=params, session_id=session_id)
+    async def get_child_ax_nodes(self, params: getChildAXNodesParameters | None = None, session_id: str | None = None) -> getChildAXNodesReturns:
         """
     Fetches a particular accessibility node by AXNodeId. Requires `enable()` to have been called previously.    
         Args:
@@ -95,8 +96,8 @@ class AccessibilityMethods:
         Returns:
     getChildAXNodesReturns: The result of the getChildAXNodes call.
         """
-        return await self.client.send(method="Accessibility.getChildAXNodes", params=params,session_id=session_id)
-    async def query_ax_tree(self, params: Optional[queryAXTreeParameters]=None,session_id: Optional[str] = None) -> queryAXTreeReturns:
+        return await self.client.send(method="Accessibility.getChildAXNodes", params=params, session_id=session_id)
+    async def query_ax_tree(self, params: queryAXTreeParameters | None = None, session_id: str | None = None) -> queryAXTreeReturns:
         """
     Query a DOM node's accessibility subtree for accessible name and role. This command computes the name and role for all nodes in the subtree, including those that are ignored for accessibility, and returns those that match the specified name and role. If no DOM node is specified, or the DOM node does not exist, the command returns an error. If neither `accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.    
         Args:
@@ -106,4 +107,4 @@ class AccessibilityMethods:
         Returns:
     queryAXTreeReturns: The result of the queryAXTree call.
         """
-        return await self.client.send(method="Accessibility.queryAXTree", params=params,session_id=session_id)
+        return await self.client.send(method="Accessibility.queryAXTree", params=params, session_id=session_id)

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/protocol/accessibility/methods/types.py

@@ -1,5 +1,5 @@
 """CDP Accessibility Methods Types"""
-
+from __future__ import annotations
 from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
 
 from typing import TYPE_CHECKING
@@ -14,57 +14,57 @@ if TYPE_CHECKING:
 
 
 class getPartialAXTreeParameters(TypedDict, total=False):
-    nodeId: NotRequired['NodeId']
+    nodeId: NotRequired[NodeId]
     """Identifier of the node to get the partial accessibility tree for."""
-    backendNodeId: NotRequired['BackendNodeId']
+    backendNodeId: NotRequired[BackendNodeId]
     """Identifier of the backend node to get the partial accessibility tree for."""
-    objectId: NotRequired['RemoteObjectId']
+    objectId: NotRequired[RemoteObjectId]
     """JavaScript object id of the node wrapper to get the partial accessibility tree for."""
-    fetchRelatives: NotRequired['bool']
+    fetchRelatives: NotRequired[bool]
     """Whether to fetch this node's ancestors, siblings and children. Defaults to true."""
 class getFullAXTreeParameters(TypedDict, total=False):
-    depth: NotRequired['int']
+    depth: NotRequired[int]
     """The maximum depth at which descendants of the root node should be retrieved. If omitted, the full tree is returned."""
-    frameId: NotRequired['FrameId']
+    frameId: NotRequired[FrameId]
     """The frame for whose document the AX tree should be retrieved. If omitted, the root frame is used."""
 class getRootAXNodeParameters(TypedDict, total=False):
-    frameId: NotRequired['FrameId']
+    frameId: NotRequired[FrameId]
     """The frame in whose document the node resides. If omitted, the root frame is used."""
 class getAXNodeAndAncestorsParameters(TypedDict, total=False):
-    nodeId: NotRequired['NodeId']
+    nodeId: NotRequired[NodeId]
     """Identifier of the node to get."""
-    backendNodeId: NotRequired['BackendNodeId']
+    backendNodeId: NotRequired[BackendNodeId]
     """Identifier of the backend node to get."""
-    objectId: NotRequired['RemoteObjectId']
+    objectId: NotRequired[RemoteObjectId]
     """JavaScript object id of the node wrapper to get."""
 class getChildAXNodesParameters(TypedDict, total=True):
-    id: 'AXNodeId'
-    frameId: NotRequired['FrameId']
+    id: AXNodeId
+    frameId: NotRequired[FrameId]
     """The frame in whose document the node resides. If omitted, the root frame is used."""
 class queryAXTreeParameters(TypedDict, total=False):
-    nodeId: NotRequired['NodeId']
+    nodeId: NotRequired[NodeId]
     """Identifier of the node for the root to query."""
-    backendNodeId: NotRequired['BackendNodeId']
+    backendNodeId: NotRequired[BackendNodeId]
     """Identifier of the backend node for the root to query."""
-    objectId: NotRequired['RemoteObjectId']
+    objectId: NotRequired[RemoteObjectId]
     """JavaScript object id of the node wrapper for the root to query."""
-    accessibleName: NotRequired['str']
+    accessibleName: NotRequired[str]
     """Find nodes with this computed name."""
-    role: NotRequired['str']
+    role: NotRequired[str]
     """Find nodes with this computed role."""
 
 
 class getPartialAXTreeReturns(TypedDict):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
     """The Accessibility.AXNode for this DOM node, if it exists, plus its ancestors, siblings and children, if requested."""
 class getFullAXTreeReturns(TypedDict):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
 class getRootAXNodeReturns(TypedDict):
-    node: 'AXNode'
+    node: AXNode
 class getAXNodeAndAncestorsReturns(TypedDict):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
 class getChildAXNodesReturns(TypedDict):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
 class queryAXTreeReturns(TypedDict):
-    nodes: 'List[AXNode]'
+    nodes: List[AXNode]
     """A list of Accessibility.AXNode matching the specified attributes, including nodes that are ignored for accessibility."""

{chromedeveloperprotocol_client-0.1.0 → chromedeveloperprotocol_client-0.1.1}/src/cdp/protocol/accessibility/service.py

@@ -1,4 +1,5 @@
 """CDP Accessibility Domain"""
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from .methods.service import AccessibilityMethods
 from .events.service import AccessibilityEvents
@@ -10,12 +11,12 @@ class Accessibility(AccessibilityMethods, AccessibilityEvents):
     """
     Access the Accessibility domain.
     """
-    def __init__(self, client: "Client"):
+    def __init__(self, client: Client):
         """
         Initialize the Accessibility domain.
         
         Args:
-            client ("Client"): The parent CDP client instance.
+            client (Client): The parent CDP client instance.
         """
         AccessibilityMethods.__init__(self, client)
         AccessibilityEvents.__init__(self, client)