parsek-cdp 0.1.1__tar.gz → 0.1.2__tar.gz

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parsek-cdp
-Version: 0.1.1
+Version: 0.1.2
 Summary: Chrome DevTools Protocol client — generated protocol layer + async runtime (client scope).
 Author: xa1era
 License-Expression: Apache-2.0

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp/core/browser.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import json
 import urllib.parse
 import urllib.request
-from typing import ClassVar, List, Optional
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Dict, List, Optional
 
 from ..cdp import CDP
 from ..cdp import Target as TargetDomain
@@ -23,6 +25,32 @@ from .target import (
 )
 
 
+@dataclass
+class LaunchOptions:
+    """How to start the browser.
+
+    Plain internal config, not a CDP wire type -- ``to_json``/``from_json`` are
+    hand-rolled here (rather than via :class:`DataType`, whose ``__FIELDS__``
+    machinery is driven by protocol codegen and fills any field absent from the
+    payload with ``None``, clobbering these fields' non-``None`` defaults).
+    """
+
+    executable: Optional[str] = None  # autodetect if None
+    headless: bool = True
+    port: int = 0
+    user_data_dir: Optional[str] = None
+    extra_args: List[str] = field(default_factory=list)
+    use_default_args: bool = True
+
+    def to_json(self) -> Dict[str, Any]:
+        return dataclasses.asdict(self)
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> "LaunchOptions":
+        allowed = {f.name for f in dataclasses.fields(cls)}
+        return cls(**{k: v for k, v in data.items() if k in allowed})
+
+
 class Browser[T: Page](Target, PagableTarget[T]):
     """The browser endpoint.
 
@@ -109,7 +137,7 @@ class Browser[T: Page](Target, PagableTarget[T]):
         *,
         features: Optional[tuple] = None,
         page_class: Optional[type] = None,
-        **launch,
+        launch_options: LaunchOptions = LaunchOptions(),
     ) -> "Browser[T]":
         """Create a browser on a parsek-cdp-server and return it, connected.
 
@@ -133,7 +161,7 @@ class Browser[T: Page](Target, PagableTarget[T]):
         )
         query = "&".join(f"feature={urllib.parse.quote(f.__name__)}" for f in feats)
         url = f"{server.rstrip('/')}/browsers" + (f"?{query}" if query else "")
-        payload = json.dumps(launch).encode()
+        payload = json.dumps(launch_options.to_json()).encode()
         # Run the blocking HTTP POST off the event loop so it never stalls it
         # (notably when client and server share one loop in tests).
         info = await asyncio.to_thread(cls._post_json, url, payload)

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp/core/feature.py

@@ -43,6 +43,7 @@ import dataclasses
 import typing
 from enum import Enum
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     ClassVar,
@@ -57,6 +58,9 @@ from typing import (
 
 from ..cdp.mixins.datatype import DataType, FieldMeta, register
 
+if TYPE_CHECKING:
+    from .page import Page
+
 __all__ = ["Feature", "FeatureHost", "parsek_type", "on", "emit"]
 
 # python class -> its registered qualified protocol name, for nested-ref resolution.
@@ -177,7 +181,7 @@ class Feature:
     #: client passthrough.
     domains: tuple = ()
 
-    def __init__(self, host: Any, *, role: str = "client") -> None:
+    def __init__(self, host: Page, *, role: str = "client") -> None:
         self.host = host
         self.role = role
         #: cdp method -> (event class, bound handler, emits class | None)

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp/core/frame.py

@@ -73,8 +73,19 @@ class Frame:
         self._dom_generation = 0
         self._head_elem = None
 
+        self._bind_frame_tracking()
         self._bind_dom_tracking()
 
+    def _bind_frame_tracking(self) -> None:
+        self.target.on(Page.FrameAttached, self._on_page_attach_frame)
+        self.target.on(Page.FrameNavigated, self._on_page_navigated_frame)
+        self.target.on(Page.FrameDetached, self._on_page_dettached_frame)
+
+    def _unbind_frame_tracking(self) -> None:
+        self.target.off(Page.FrameAttached, self._on_page_attach_frame)
+        self.target.off(Page.FrameNavigated, self._on_page_navigated_frame)
+        self.target.off(Page.FrameDetached, self._on_page_dettached_frame)
+
     def _bind_dom_tracking(self) -> None:
         """Track every event that invalidates this frame's ``nodeId`` map.
 
@@ -98,14 +109,15 @@ class Frame:
         self._dom_generation += 1
 
     def dispose(self) -> None:
-        """Unregister this frame's (and its subtree's) DOM-tracking handlers.
+        """Unregister this frame's (and its subtree's) target-level handlers.
 
         Same-origin frames share one target, so the handlers bound in
-        :meth:`_bind_dom_tracking` outlive the frame unless removed explicitly.
-        Call this whenever a frame leaves the tree (see :meth:`detach_frame` /
-        :meth:`refresh_frame`) so recreated frames don't pile up dead handlers on
-        the target.
+        :meth:`_bind_dom_tracking` / :meth:`_bind_frame_tracking` outlive the
+        frame unless removed explicitly.  Call this whenever a frame leaves the
+        tree (see :meth:`detach_frame` / :meth:`refresh_frame`) so recreated
+        frames don't pile up dead handlers on the target.
         """
+        self._unbind_frame_tracking()
         self._unbind_dom_tracking()
         for child in list(self._frames.values()):
             child.dispose()
@@ -336,6 +348,18 @@ class Frame:
             return visible, element
         return not visible, element
 
+    async def _on_page_attach_frame(self, event: Page.FrameAttached):
+        if event.parent_frame_id == self.id:
+            await self.refresh_frame()
+
+    def _on_page_navigated_frame(self, event: Page.FrameNavigated):
+        if event.frame.id == self.id:
+            self._frame = event.frame
+
+    def _on_page_dettached_frame(self, event: Page.FrameDetached):
+        if event.frame_id in self._frames:
+            self._frames.pop(event.frame_id, None)
+
     def attach_frame(self, frame: Frame):
         self._frames[frame.id] = frame
 

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp/core/target.py

@@ -386,13 +386,13 @@ class Target(CDPConnection):
         ``parent_frame_id``; a popup under its ``opener_id``), rooting at this
         target.  Existing :class:`Target` objects are reused -- preserving their
         identity and any open websocket -- and targets gone from the snapshot are
-        dropped.  Returns this target's direct children.
+        dropped and closed.  Returns this target's direct children.
         """
         infos = (await self.cdp.Target.get_targets()).target_infos
-        self._rebuild_tree(infos)
+        await self._rebuild_tree(infos)
         return self.targets
 
-    def _rebuild_tree(self, infos: list[TargetDomain.TargetInfo]) -> None:
+    async def _rebuild_tree(self, infos: list[TargetDomain.TargetInfo]) -> None:
         # ``getTargets`` is browser-wide, so group children by their parent and
         # then walk only the subtree rooted at *this* target -- a page must not
         # adopt unrelated top-level targets (other tabs, extensions, ...).
@@ -419,6 +419,7 @@ class Target(CDPConnection):
         self._targets = {}
 
         root_key = None if self.type_ == "browser" else self.id
+        attached: set[str] = set()
 
         def attach(parent: Target, key: Optional[str], seen: set[str]) -> None:
             for info in children_of.get(key, ()):
@@ -426,6 +427,7 @@ class Target(CDPConnection):
                 if tid in seen:  # guard against cyclic parent links
                     continue
                 seen.add(tid)
+                attached.add(tid)
                 node = known.get(tid) or Target(info, parent)
                 node._target = info
                 node._parent = parent
@@ -434,6 +436,12 @@ class Target(CDPConnection):
 
         attach(self, root_key, set())
 
+        # Nodes gone from the fresh snapshot aren't reattached above -- close
+        # them explicitly so their websocket and receive loop don't leak.
+        for tid, node in known.items():
+            if tid not in attached:
+                await node.close()
+
     async def _on_target_created(self, event: TargetDomain.TargetCreated):
         info = event.target_info
         parent_id = info.opener_id or info.parent_frame_id

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp/features/request_listener/__init__.py

@@ -126,9 +126,7 @@ class RequestListener(Feature):
                 old._completed.set()
             self._requests.clear()
             keep = data.request_id
-            self._pending = (
-                {keep: self._pending[keep]} if keep in self._pending else {}
-            )
+            self._pending = {keep: self._pending[keep]} if keep in self._pending else {}
             self._resp = {keep: self._resp[keep]} if keep in self._resp else {}
             self._emitted = {keep} if keep in self._emitted else set()
             self._served_from_cache = (

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/parsek_cdp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parsek-cdp
-Version: 0.1.1
+Version: 0.1.2
 Summary: Chrome DevTools Protocol client — generated protocol layer + async runtime (client scope).
 Author: xa1era
 License-Expression: Apache-2.0

{parsek_cdp-0.1.1 → parsek_cdp-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "parsek-cdp"
-version = "0.1.1"
+version = "0.1.2"
 description = "Chrome DevTools Protocol client — generated protocol layer + async runtime (client scope)."
 readme = "README.md"
 requires-python = ">=3.13"