cdipy 0.4.3__tar.gz

cdipy-0.4.3/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Pilate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cdipy-0.4.3/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: cdipy
+Version: 0.4.3
+Summary: An async Python interface for Chrome Devtools
+Home-page: https://github.com/pilate/cdipy
+Author: Pilate
+Author-email: pilate@pilate.es
+License: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: aiohttp<3.13.0
+Requires-Dist: msgspec<0.20
+Requires-Dist: pyee<13.0.0
+Requires-Dist: websockets<=15
+Dynamic: license-file
+
+# cdipy
+Chrome Devtools Interface that instruments Chrome via the [devtools protocol](https://github.com/ChromeDevTools/devtools-protocol).
+
+Meant to serve as a pythonic version of [chrome-remote-interface](https://github.com/cyrus-and/chrome-remote-interface).
+
+### Example Usage
+```python
+
+import asyncio
+import base64
+import logging
+import sys
+
+from cdipy import ChromeDevTools
+from cdipy import ChromeDevToolsTarget
+from cdipy import ChromeRunner
+
+
+LOGGER = logging.getLogger("cdipy.scripts.screenshot")
+FILENAME = "screenshot.png"
+
+
+async def async_main(url):
+    # Start Chrome
+    chrome = ChromeRunner()
+    await chrome.launch()
+
+    # Connect to devtools websocket
+    cdi = ChromeDevTools(chrome.websocket_uri)
+    await cdi.connect()
+
+    # Create a new target and attach to it
+    target = await cdi.Target.createTarget(url="about:blank")
+    session = await cdi.Target.attachToTarget(targetId=target["targetId"])
+
+    # Create a ChromeDevToolsTarget class to handle target messages
+    cdit = ChromeDevToolsTarget(cdi, session["sessionId"])
+
+    # Enable 'Page' events
+    await cdit.Page.enable()
+
+    # Navigate to URL
+    LOGGER.info("Navigating to %s", url)
+    await cdit.Page.navigate(url=url)
+
+    # Wait for the Page.loadEventFired event
+    # This may not ever fire on some pages, so it's good to set a limit
+    try:
+        await cdit.wait_for("Page.loadEventFired", 10)
+    except asyncio.TimeoutError:
+        print("Loaded event never fired!")
+
+    # Take a screenshot
+    screenshot_response = await cdit.Page.captureScreenshot(format="png")
+    screenshot_bytes = base64.b64decode(screenshot_response["data"])
+
+    with open(FILENAME, "w+b") as fileobj:
+        fileobj.write(screenshot_bytes)
+
+    LOGGER.info("wrote %s", FILENAME)
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+
+    asyncio.run(async_main(sys.argv[1]))
+
+
+if __name__ == "__main__":
+    main()
+
+
+```

cdipy-0.4.3/README.md

@@ -0,0 +1,73 @@
+# cdipy
+Chrome Devtools Interface that instruments Chrome via the [devtools protocol](https://github.com/ChromeDevTools/devtools-protocol).
+
+Meant to serve as a pythonic version of [chrome-remote-interface](https://github.com/cyrus-and/chrome-remote-interface).
+
+### Example Usage
+```python
+
+import asyncio
+import base64
+import logging
+import sys
+
+from cdipy import ChromeDevTools
+from cdipy import ChromeDevToolsTarget
+from cdipy import ChromeRunner
+
+
+LOGGER = logging.getLogger("cdipy.scripts.screenshot")
+FILENAME = "screenshot.png"
+
+
+async def async_main(url):
+    # Start Chrome
+    chrome = ChromeRunner()
+    await chrome.launch()
+
+    # Connect to devtools websocket
+    cdi = ChromeDevTools(chrome.websocket_uri)
+    await cdi.connect()
+
+    # Create a new target and attach to it
+    target = await cdi.Target.createTarget(url="about:blank")
+    session = await cdi.Target.attachToTarget(targetId=target["targetId"])
+
+    # Create a ChromeDevToolsTarget class to handle target messages
+    cdit = ChromeDevToolsTarget(cdi, session["sessionId"])
+
+    # Enable 'Page' events
+    await cdit.Page.enable()
+
+    # Navigate to URL
+    LOGGER.info("Navigating to %s", url)
+    await cdit.Page.navigate(url=url)
+
+    # Wait for the Page.loadEventFired event
+    # This may not ever fire on some pages, so it's good to set a limit
+    try:
+        await cdit.wait_for("Page.loadEventFired", 10)
+    except asyncio.TimeoutError:
+        print("Loaded event never fired!")
+
+    # Take a screenshot
+    screenshot_response = await cdit.Page.captureScreenshot(format="png")
+    screenshot_bytes = base64.b64decode(screenshot_response["data"])
+
+    with open(FILENAME, "w+b") as fileobj:
+        fileobj.write(screenshot_bytes)
+
+    LOGGER.info("wrote %s", FILENAME)
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+
+    asyncio.run(async_main(sys.argv[1]))
+
+
+if __name__ == "__main__":
+    main()
+
+
+```

cdipy-0.4.3/cdipy/__init__.py

@@ -0,0 +1,7 @@
+from .cdipy import ChromeDevTools
+from .cdipy import ChromeDevToolsTarget
+from .cdipy import ResponseErrorException
+from .cdipy import UnknownMessageException
+
+from .chrome import ChromeClosedException
+from .chrome import ChromeRunner

cdipy-0.4.3/cdipy/cdipy.py

@@ -0,0 +1,196 @@
+import asyncio
+import json
+import logging
+import typing
+from itertools import count
+
+import msgspec
+import websockets.asyncio.client
+import websockets.asyncio.connection
+import websockets.exceptions
+from pyee.asyncio import AsyncIOEventEmitter
+
+from .exceptions import ResponseErrorException, UnknownMessageException
+from .protocol import DOMAINS
+
+
+LOGGER = logging.getLogger("cdipy.cdipy")
+
+
+class MessageError(msgspec.Struct):  # pylint: disable=too-few-public-methods
+    message: str
+
+
+class Message(msgspec.Struct):  # pylint: disable=too-few-public-methods
+    id: int = None
+    method: str = None
+    params: typing.Any = None
+    result: typing.Any = None
+    error: MessageError = None
+
+
+MSG_DECODER = msgspec.json.Decoder(type=Message)
+MSG_ENCODER = msgspec.json.Encoder()
+
+
+class DevtoolsEmitter(AsyncIOEventEmitter):
+    def __init__(self):
+        super().__init__()
+
+        self.loop = asyncio.get_event_loop()
+
+    def wait_for(self, event: str, timeout: int = 0) -> asyncio.Future:
+        """
+        Wait for a specific event to fire before returning
+        """
+        future = self.loop.create_future()
+
+        def update_future(*args, **kwargs):
+            future.set_result((args, kwargs))
+
+        self.once(event, update_future)
+        if timeout:
+            return asyncio.wait_for(future, timeout)
+
+        return future
+
+
+class Devtools(DevtoolsEmitter):
+    def __init__(self):
+        super().__init__()
+
+        self.futures = {}
+        self.counter = count()
+
+    def __getattr__(self, attr: str):
+        """
+        Load each domain on demand
+        """
+        if domain := DOMAINS.get(attr):
+            setattr(self, attr, domain(self))
+
+        return super().__getattribute__(attr)
+
+    def format_command(self, method: str, **kwargs) -> dict:
+        """
+        Convert method name + arguments to a devtools command
+        """
+        return {"id": next(self.counter), "method": method, "params": kwargs}
+
+    async def handle_message(self, message: str) -> None:
+        """
+        Match incoming message ids to self.futures
+        Emit events for incoming methods
+        """
+        try:
+            message_obj = MSG_DECODER.decode(message)
+        except msgspec.DecodeError:
+            message_obj = Message(**json.loads(message))
+
+        if message_obj.id is not None:
+            future = self.futures.pop(message_obj.id)
+            if not future.cancelled():
+                if error := message_obj.error:
+                    future.set_exception(ResponseErrorException(error.message))
+                else:
+                    future.set_result(message_obj.result)
+
+        elif message_obj.method:
+            self.emit(message_obj.method, **message_obj.params)
+
+        elif message_obj.error:
+            raise ResponseErrorException(message_obj.error.message)
+
+        else:
+            raise UnknownMessageException(f"Unknown message format: {message_obj}")
+
+    async def execute_method(self, method: str, **kwargs) -> dict:
+        """
+        Called by the add_command wrapper with the method name and validated arguments
+        """
+        command = self.format_command(method, **kwargs)
+
+        result_future = self.loop.create_future()
+        self.futures[command["id"]] = result_future
+
+        await self.send(command)
+
+        return await result_future
+
+    async def send(self, command):
+        raise NotImplementedError
+
+
+class ChromeDevTools(Devtools):
+    def __init__(self, websocket_uri: str):
+        super().__init__()
+
+        self.task: asyncio.Future | None = None
+        self.ws_uri: str | None = websocket_uri
+        self.websocket: websockets.asyncio.connection.Connection = None
+
+    def __del__(self):
+        if task := getattr(self, "task", None):
+            task.cancel()
+
+    async def connect(self, compression: str | None = None) -> None:
+        self.websocket = await websockets.asyncio.client.connect(
+            self.ws_uri,
+            compression=compression,
+            max_size=None,
+            max_queue=None,
+            write_limit=0,
+            ping_interval=None,
+        )
+        self.task = asyncio.create_task(self._recv_loop())
+
+    async def _recv_loop(self):
+        while True:
+            try:
+                recv_data = await self.websocket.recv(decode=None)
+                LOGGER.debug("recv: %s", recv_data)
+
+            except websockets.exceptions.ConnectionClosed:
+                LOGGER.error("Websocket connection closed")
+                break
+
+            await self.handle_message(recv_data)
+
+    async def send(self, command: dict) -> None:
+        LOGGER.debug("send: %s", command)
+        await self.websocket.send(MSG_ENCODER.encode(command), text=True)
+
+
+class ChromeDevToolsTarget(Devtools):  # pylint: disable=abstract-method
+    def __init__(self, devtools: ChromeDevTools, session: str):
+        super().__init__()
+
+        self.devtools = devtools
+        self.devtools.on("Target.receivedMessageFromTarget", self._target_recv)
+
+        self.session = session
+
+    async def _target_recv(
+        self, sessionId, message, **_
+    ):  # pylint: disable=invalid-name
+        if sessionId != self.session:
+            return
+
+        await self.handle_message(message)
+
+    async def execute_method(self, method: str, **kwargs):
+        """
+        Target commands are in the same format, but sent as a parameter to
+        the sendMessageToTarget method
+        """
+        command = self.format_command(method, **kwargs)
+
+        result_future = self.loop.create_future()
+        self.futures[command["id"]] = result_future
+
+        message = MSG_ENCODER.encode(command).decode()
+        await self.devtools.Target.sendMessageToTarget(
+            message=message, sessionId=self.session
+        )
+
+        return await result_future

cdipy-0.4.3/cdipy/chrome.py

@@ -0,0 +1,120 @@
+import asyncio
+import logging
+import os
+import re
+import signal
+from asyncio import subprocess
+from tempfile import TemporaryDirectory
+
+from .exceptions import ChromeClosedException
+
+
+LOGGER = logging.getLogger("cdipy.chrome")
+
+CHROME_PATH = os.environ.get("CDIPY_CHROME_PATH", "/usr/bin/google-chrome-stable")
+CHROME_PARAMS = [
+    "--disable-background-networking",
+    "--enable-features=NetworkService,NetworkServiceInProcess",
+    "--disable-background-timer-throttling",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-breakpad",
+    "--disable-client-side-phishing-detection",
+    "--disable-component-extensions-with-background-pages",
+    "--disable-component-update",
+    "--disable-default-apps",
+    "--disable-domain-reliability",
+    "--disable-extensions",
+    "--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,Translate",
+    "--disable-hang-monitor",
+    "--disable-ipc-flooding-protection",
+    "--disable-popup-blocking",
+    "--disable-prompt-on-repost",
+    "--disable-renderer-backgrounding",
+    "--disable-sync",
+    "--enable-automation",
+    "--force-color-profile=srgb",
+    "--metrics-recording-only",
+    "--no-first-run",
+    "--ash-no-nudges",
+    "--disable-search-engine-choice-screen",
+    "--propagate-iph-for-testing",
+    "--no-default-browser-check",
+    "--password-store=basic",
+    "--remote-debugging-port=0",
+    "--use-mock-keychain",
+    "--enable-blink-features=IdleDetection",
+    "--disable-gpu",
+    "--hide-scrollbars",
+    "--mute-audio",
+]
+if not os.environ.get("CDIPY_USE_SHM"):
+    CHROME_PARAMS.append("--disable-dev-shm-usage")
+
+WS_RE = re.compile(r"listening on (ws://[^ ]*)")
+
+
+class ChromeRunner:
+    def __init__(self, proxy: str = None):
+        super().__init__()
+
+        self.proxy = proxy
+
+        self.data_dir = TemporaryDirectory()  # pylint: disable=consider-using-with
+
+        self.proc = None
+        self.websocket_uri = None
+
+    def __del__(self):
+        """
+        Kill the chrome we launched and all child processes
+        """
+
+        if self.proc and self.proc.pid:
+            try:
+                os.killpg(os.getpgid(self.proc.pid), signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+
+    async def launch(
+        self,
+        chrome_path: str = CHROME_PATH,
+        extra_args: list = None,
+        headless: str = "new",
+    ) -> None:
+        command = [
+            chrome_path,
+            *CHROME_PARAMS,
+            f"--headless={headless}",
+            f"--user-data-dir={self.data_dir.name}",
+        ]
+
+        if extra_args:
+            command.extend(extra_args)
+
+        if self.proxy:
+            command.append(f"--proxy-server={self.proxy}")
+
+        self.proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            preexec_fn=os.setsid,
+        )
+
+        output = ""
+        while True:
+            if self.proc.returncode is not None:
+                stderr = await self.proc.stdout.read()
+                raise ChromeClosedException(
+                    f"Chrome closed unexpectedly; code: {self.proc.returncode} ({stderr})"
+                )
+
+            data = await self.proc.stdout.readline()
+            output += data.decode()
+
+            search = WS_RE.search(output)
+            if search:
+                break
+
+        self.websocket_uri = search.group(1).strip()
+        LOGGER.info("Parsed websocket URI: %s", self.websocket_uri)

cdipy-0.4.3/cdipy/exceptions.py

@@ -0,0 +1,10 @@
+class ResponseErrorException(Exception):
+    pass
+
+
+class UnknownMessageException(Exception):
+    pass
+
+
+class ChromeClosedException(Exception):
+    pass

cdipy-0.4.3/cdipy/protocol.py

@@ -0,0 +1,102 @@
+import asyncio
+import inspect
+import os
+import types
+
+import msgspec.json
+
+from .utils import get_cache_path, update_protocol_data
+
+
+SKIP_VALIDATION = os.environ.get("CDIPY_SKIP_VALIDATION", False)
+
+
+class DomainBase:  # pylint: disable=too-few-public-methods
+    """
+    Template class used for domains (ex: obj.Page)
+    """
+
+    __slots__ = ("devtools",)
+
+    def __init__(self, devtools):
+        self.devtools = devtools
+
+
+def params_to_signature(params):
+    """
+    Creates a function signature based on a list of protocol parameters
+    """
+    new_params = []
+
+    for param in params:
+        default = inspect.Parameter.empty
+        if param.get("optional"):
+            default = None
+
+        new_param = inspect.Parameter(
+            name=param["name"],
+            kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            default=default,
+        )
+
+        new_params.append(new_param)
+
+    new_params.sort(key=lambda p: bool(p.default), reverse=True)
+
+    return inspect.Signature(parameters=new_params)
+
+
+def add_command(domain_class, command):
+    """
+    Creates a new function that can be used as a domain method
+    """
+    command_name = command["name"]
+    command_str = f"{domain_class.__name__}.{command_name}"
+
+    signature = params_to_signature(command.get("parameters", []))
+
+    async def wrapper(self, **kwargs):
+        """
+        Validate method arguments against `signature`
+        Pass validated args to execute_method
+        """
+        if not SKIP_VALIDATION:
+            kwargs = signature.bind(**kwargs).arguments
+
+        return await self.devtools.execute_method(command_str, **kwargs)
+
+    wrapper.__name__ = wrapper.__qualname__ = command_str
+
+    setattr(domain_class, command_name, wrapper)
+
+
+def load_domains():
+    cache_path = get_cache_path()
+
+    if not os.path.exists(cache_path):
+        os.makedirs(cache_path, mode=0o744)
+
+    if not os.listdir(cache_path):
+        asyncio.get_event_loop().run_until_complete(update_protocol_data())
+
+    domains = {}
+    for filename in os.listdir(cache_path):
+        with open(cache_path / filename, "rb") as fp:
+            data = msgspec.json.decode(fp.read())
+
+        for domain in data.get("domains", []):
+            domain_name = domain["domain"]
+
+            # Create a new class for each domain
+            domain_class = types.new_class(domain_name, (DomainBase,))
+
+            # Add each command to the domain class
+            for command in domain.get("commands", []):
+                add_command(domain_class, command)
+
+            domains[domain_name] = domain_class
+
+    return domains
+
+
+DOMAINS = load_domains()

cdipy-0.4.3/cdipy/utils.py

@@ -0,0 +1,53 @@
+import asyncio
+import logging
+import os
+from pathlib import Path
+
+import aiohttp
+
+
+LOGGER = logging.getLogger("cdipy.utils")
+
+ROOT = "https://raw.githubusercontent.com/ChromeDevTools/devtools-protocol/master/json"
+SOURCE_FILES = [f"{ROOT}/browser_protocol.json", f"{ROOT}/js_protocol.json"]
+OS_VAR = "CDIPY_CACHE"
+
+
+def get_cache_path() -> Path:
+    """
+    Search system paths for existing cache
+    """
+    cache_dir = os.environ.get(OS_VAR)
+    if cache_dir:
+        return Path(cache_dir)
+
+    xdg_cache_home = os.getenv("XDG_CACHE_HOME")
+    if not xdg_cache_home:
+        if user_home := os.getenv("HOME"):
+            xdg_cache_home = os.path.join(user_home, ".cache")
+
+    if xdg_cache_home:
+        full_path = os.path.join(xdg_cache_home, "python-cdipy")
+    else:
+        full_path = os.path.join(os.path.dirname(__file__), ".cache")
+
+    os.environ[OS_VAR] = full_path
+    return Path(full_path)
+
+
+async def update_protocol_data() -> None:
+    """
+    Download latest protocol definition
+    """
+    async with aiohttp.ClientSession() as session:
+        requests = []
+        for url in SOURCE_FILES:
+            LOGGER.warning("Downloading %s", url)
+            requests.append(session.get(url))
+
+        responses = await asyncio.gather(*requests)
+        for response in responses:
+            new_path = get_cache_path() / response.url.name
+            with open(new_path, "w+b") as fp:
+                fp.write(await response.read())
+            LOGGER.warning("Wrote %s", new_path)

cdipy-0.4.3/cdipy.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: cdipy
+Version: 0.4.3
+Summary: An async Python interface for Chrome Devtools
+Home-page: https://github.com/pilate/cdipy
+Author: Pilate
+Author-email: pilate@pilate.es
+License: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: aiohttp<3.13.0
+Requires-Dist: msgspec<0.20
+Requires-Dist: pyee<13.0.0
+Requires-Dist: websockets<=15
+Dynamic: license-file
+
+# cdipy
+Chrome Devtools Interface that instruments Chrome via the [devtools protocol](https://github.com/ChromeDevTools/devtools-protocol).
+
+Meant to serve as a pythonic version of [chrome-remote-interface](https://github.com/cyrus-and/chrome-remote-interface).
+
+### Example Usage
+```python
+
+import asyncio
+import base64
+import logging
+import sys
+
+from cdipy import ChromeDevTools
+from cdipy import ChromeDevToolsTarget
+from cdipy import ChromeRunner
+
+
+LOGGER = logging.getLogger("cdipy.scripts.screenshot")
+FILENAME = "screenshot.png"
+
+
+async def async_main(url):
+    # Start Chrome
+    chrome = ChromeRunner()
+    await chrome.launch()
+
+    # Connect to devtools websocket
+    cdi = ChromeDevTools(chrome.websocket_uri)
+    await cdi.connect()
+
+    # Create a new target and attach to it
+    target = await cdi.Target.createTarget(url="about:blank")
+    session = await cdi.Target.attachToTarget(targetId=target["targetId"])
+
+    # Create a ChromeDevToolsTarget class to handle target messages
+    cdit = ChromeDevToolsTarget(cdi, session["sessionId"])
+
+    # Enable 'Page' events
+    await cdit.Page.enable()
+
+    # Navigate to URL
+    LOGGER.info("Navigating to %s", url)
+    await cdit.Page.navigate(url=url)
+
+    # Wait for the Page.loadEventFired event
+    # This may not ever fire on some pages, so it's good to set a limit
+    try:
+        await cdit.wait_for("Page.loadEventFired", 10)
+    except asyncio.TimeoutError:
+        print("Loaded event never fired!")
+
+    # Take a screenshot
+    screenshot_response = await cdit.Page.captureScreenshot(format="png")
+    screenshot_bytes = base64.b64decode(screenshot_response["data"])
+
+    with open(FILENAME, "w+b") as fileobj:
+        fileobj.write(screenshot_bytes)
+
+    LOGGER.info("wrote %s", FILENAME)
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+
+    asyncio.run(async_main(sys.argv[1]))
+
+
+if __name__ == "__main__":
+    main()
+
+
+```

cdipy-0.4.3/cdipy.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.md
+README.md
+pyproject.toml
+setup.cfg
+cdipy/__init__.py
+cdipy/cdipy.py
+cdipy/chrome.py
+cdipy/exceptions.py
+cdipy/protocol.py
+cdipy/utils.py
+cdipy.egg-info/PKG-INFO
+cdipy.egg-info/SOURCES.txt
+cdipy.egg-info/dependency_links.txt
+cdipy.egg-info/requires.txt
+cdipy.egg-info/top_level.txt

cdipy-0.4.3/cdipy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cdipy-0.4.3/cdipy.egg-info/requires.txt

@@ -0,0 +1,4 @@
+aiohttp<3.13.0
+msgspec<0.20
+pyee<13.0.0
+websockets<=15

cdipy-0.4.3/cdipy.egg-info/top_level.txt

@@ -0,0 +1 @@
+cdipy

cdipy-0.4.3/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

cdipy-0.4.3/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+name = cdipy
+version = 0.4.3
+author = Pilate
+author_email = pilate@pilate.es
+url = https://github.com/pilate/cdipy
+description = An async Python interface for Chrome Devtools
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT License
+
+[options]
+packages = find:
+python_requires = >=3.8
+install_requires = 
+	aiohttp<3.13.0
+	msgspec<0.20
+	pyee<13.0.0
+	websockets<=15
+
+[egg_info]
+tag_build = 
+tag_date = 0
+