s-librarykit 0.5.0__tar.gz → 0.5.2__tar.gz

{s_librarykit-0.5.0 → s_librarykit-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s-librarykit
-Version: 0.5.0
+Version: 0.5.2
 Summary: Жирный КОРЕНЬ китов: единая error-иерархия, config/retry/paths-утили, checkpoint/resume, транспорт/auth/sessions — общий код для clikit, adapterkit и доменных пакетов.
 Author: Dmitry
 License: MIT

{s_librarykit-0.5.0 → s_librarykit-0.5.2}/librarykit/browser/capture_tap.py

@@ -206,6 +206,8 @@ class _PlaywrightAdapter(_BaseAdapter):
         self._context = page.context
         # Request-объект → стабильный request_id (для сшивки request/response/failed).
         self._ids: "weakref.WeakKeyDictionary[Any, str]" = weakref.WeakKeyDictionary()
+        self._drain_stop: asyncio.Event | None = None
+        self._drain_task: Any = None
 
     def _id_for(self, request: Any) -> str:
         rid = self._ids.get(request)
@@ -222,6 +224,10 @@ class _PlaywrightAdapter(_BaseAdapter):
                 await ctx.expose_binding(self._binding, self._on_binding)
             with contextlib.suppress(Exception):
                 await ctx.add_init_script(self._init_script)
+            # Дренаж очереди — fallback для движков, где binding не виден из мира init-script
+            # (CamouFox/Firefox гонят его в изолированном мире). На chromium очередь пуста.
+            self._drain_stop = asyncio.Event()
+            self._drain_task = asyncio.ensure_future(self._drain_queue_loop())
         if self._h.on_request is not None:
             ctx.on("request", lambda r: self._spawn(self._handle_request(r)))
         if self._h.on_response is not None:
@@ -282,7 +288,11 @@ class _PlaywrightAdapter(_BaseAdapter):
             if self._body_filter(response.url, rtype, mime):
                 try:
                     raw = await response.body()
-                    body = raw[: self._max_body_bytes] if raw else raw
+                    # Дропаем СЛИШКОМ большие тела (не пишем битый обрезок как «captured»):
+                    if raw is not None and len(raw) > self._max_body_bytes:
+                        body_error = f"body too large: {len(raw)} > {self._max_body_bytes}"
+                    else:
+                        body = raw
                 except Exception as err:  # noqa: BLE001
                     body_error = f"{type(err).__name__}: {err}"[:160]
             await self._emit(self._h.on_response, NormalizedResponse(
@@ -303,7 +313,42 @@ class _PlaywrightAdapter(_BaseAdapter):
             return await self._context.storage_state()
         return {"cookies": [], "origins": []}
 
+    async def _drain_queue_loop(self) -> None:
+        """Периодически дренит globalThis.__captureTraceQueue → on_action (fallback CamouFox)."""
+        assert self._drain_stop is not None
+        while not self._drain_stop.is_set():
+            try:
+                await asyncio.wait_for(self._drain_stop.wait(), timeout=0.3)
+                break
+            except asyncio.TimeoutError:
+                pass
+            await self._drain_queue_once()
+
+    async def _drain_queue_once(self) -> None:
+        try:
+            items = await self._page.evaluate(
+                "() => { const q = globalThis.__captureTraceQueue || [];"
+                " globalThis.__captureTraceQueue = []; return q; }"
+            )
+        except Exception:
+            return
+        for s in items or []:
+            try:
+                payload = json.loads(s) if isinstance(s, str) else s
+            except Exception:
+                continue
+            await self._emit(self._h.on_action, NormalizedAction(raw=payload))
+
     async def detach(self) -> None:
+        # Остановить дренаж очереди trace (CamouFox-fallback) + финальный дренаж.
+        if self._drain_stop is not None:
+            self._drain_stop.set()
+            with contextlib.suppress(Exception):
+                await self._drain_queue_once()
+            if self._drain_task is not None:
+                self._drain_task.cancel()
+                with contextlib.suppress(Exception, asyncio.CancelledError):
+                    await self._drain_task
         # Слушатели не снимаем поимённо (Playwright требует ссылку на сам хендлер):
         # контекст всё равно закрывает backend.aclose() сразу после detach. Здесь —
         # только дренаж фоновых задач нормализации, чтобы не потерять последние тела.
@@ -315,11 +360,23 @@ class _CdpAdapter(_BaseAdapter):
 
     family = "cdp"
 
+    # Cap на незакрытые rid: SSE/стриминг/зависшие соединения не эмитят
+    # LoadingFinished/Failed, иначе _pending/_resp_meta растут всю сессию.
+    _MAX_INFLIGHT = 4096
+
     def __init__(self, tab: Any, handlers: _Handlers, **kw: Any) -> None:
         super().__init__(tab, handlers, **kw)
         self._tab = tab
         self._pending: dict[str, dict[str, Any]] = {}
         self._resp_meta: dict[str, dict[str, Any]] = {}
+        self._ws_urls: dict[str, str] = {}  # rid → реальный wss:// URL (из WebSocketCreated)
+
+    def _evict_stale(self) -> None:
+        """FIFO-эвикция самых старых висящих rid при переполнении (dict хранит порядок)."""
+        while len(self._pending) > self._MAX_INFLIGHT:
+            old = next(iter(self._pending))
+            self._pending.pop(old, None)
+            self._resp_meta.pop(old, None)
 
     async def attach(self) -> None:
         from nodriver import cdp  # type: ignore[import-not-found]
@@ -332,6 +389,8 @@ class _CdpAdapter(_BaseAdapter):
             self._tab.add_handler(cdp.network.LoadingFinished, self._on_fin)
             self._tab.add_handler(cdp.network.LoadingFailed, self._on_failed)
         if self._capture_ws and self._h.on_ws is not None:
+            # WebSocketCreated несёт реальный URL (Frame*-события — только request_id).
+            self._tab.add_handler(cdp.network.WebSocketCreated, self._on_ws_created)
             self._tab.add_handler(cdp.network.WebSocketFrameSent, self._on_ws_sent)
             self._tab.add_handler(cdp.network.WebSocketFrameReceived, self._on_ws_recv)
         if self._h.on_action is not None and self._init_script:
@@ -348,7 +407,24 @@ class _CdpAdapter(_BaseAdapter):
 
     async def _on_req(self, ev: Any, *_: Any) -> None:
         rid = str(ev.request_id)
-        entry = self._pending.setdefault(rid, {"id": self._next_id()})
+        # Chrome переиспользует тот же CDP requestId для цепочки редиректов и отдаёт
+        # промежуточный 3xx в ev.redirect_response (отдельного ResponseReceived НЕТ).
+        # Флашим завершённый хоп отдельной записью под его id — паритет с Playwright.
+        redirect = getattr(ev, "redirect_response", None)
+        if redirect is not None:
+            prev = self._pending.pop(rid, None)
+            self._resp_meta.pop(rid, None)
+            if prev is not None:
+                await self._emit(self._h.on_response, NormalizedResponse(
+                    request_id=prev["id"], status=int(getattr(redirect, "status", 0) or 0),
+                    status_text=getattr(redirect, "status_text", "") or "",
+                    headers=_lower_headers(getattr(redirect, "headers", {}) or {}),
+                    mime_type=getattr(redirect, "mime_type", "") or "", body=None, body_error=None,
+                ))
+        entry = self._pending.get(rid)
+        if entry is None:
+            entry = {"id": self._next_id()}
+            self._pending[rid] = entry
         req = ev.request
         post = None
         pd = getattr(req, "post_data", None)
@@ -360,6 +436,7 @@ class _CdpAdapter(_BaseAdapter):
             frame_url=ev.document_url or "", post_data=post,
         )
         await self._emit(self._h.on_request, entry["norm"])
+        self._evict_stale()
 
     async def _on_resp(self, ev: Any, *_: Any) -> None:
         rid = str(ev.request_id)
@@ -372,6 +449,7 @@ class _CdpAdapter(_BaseAdapter):
             "mime": getattr(resp, "mime_type", "") or "",
             "rtype": self._rtype(ev.type_),
         }
+        self._evict_stale()
 
     async def _on_fin(self, ev: Any, *_: Any) -> None:
         rid = str(ev.request_id)
@@ -392,7 +470,10 @@ class _CdpAdapter(_BaseAdapter):
                 try:
                     raw, b64 = await self._tab.send(self._cdp.network.get_response_body(ev.request_id))
                     data = _b64.b64decode(raw) if b64 else (raw or "").encode("utf-8", "replace")
-                    body = data[: self._max_body_bytes]
+                    if len(data) > self._max_body_bytes:
+                        body_error = f"body too large: {len(data)} > {self._max_body_bytes}"
+                    else:
+                        body = data
                     last_err = None
                     break
                 except Exception as err:  # noqa: BLE001
@@ -414,6 +495,10 @@ class _CdpAdapter(_BaseAdapter):
         err = getattr(ev, "error_text", "") or ("canceled" if getattr(ev, "canceled", False) else "failed")
         await self._emit(self._h.on_failure, NormalizedFailure(request_id=entry["id"], error_text=str(err)))
 
+    async def _on_ws_created(self, ev: Any, *_: Any) -> None:
+        # Единственное CDP-событие WS с реальным URL — запоминаем rid→url.
+        self._ws_urls[str(getattr(ev, "request_id", ""))] = getattr(ev, "url", "") or ""
+
     async def _on_ws_sent(self, ev: Any, *_: Any) -> None:
         await self._ws(ev, "sent")
 
@@ -424,8 +509,9 @@ class _CdpAdapter(_BaseAdapter):
         resp = getattr(ev, "response", None)
         payload = getattr(resp, "payload_data", "") if resp is not None else ""
         opcode = getattr(resp, "opcode", None) if resp is not None else None
+        rid = str(getattr(ev, "request_id", ""))
         await self._emit(self._h.on_ws, NormalizedWsFrame(
-            url=str(getattr(ev, "request_id", "")), direction=direction,
+            url=self._ws_urls.get(rid, ""), direction=direction,
             payload=payload, opcode=int(opcode) if opcode is not None else None,
         ))
 
@@ -450,7 +536,7 @@ class _CdpAdapter(_BaseAdapter):
                 "path": getattr(c, "path", "/"), "expires": float(getattr(c, "expires", -1) or -1),
                 "httpOnly": bool(getattr(c, "http_only", False)),
                 "secure": bool(getattr(c, "secure", False)),
-                "sameSite": (str(getattr(c, "same_site", "") or "").capitalize() or "Lax"),
+                "sameSite": (getattr(getattr(c, "same_site", None), "value", None) or "Lax"),
             })
         return {"cookies": cookies, "origins": []}
 

{s_librarykit-0.5.0 → s_librarykit-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "s-librarykit"
-version = "0.5.0"
+version = "0.5.2"
 description = "Жирный КОРЕНЬ китов: единая error-иерархия, config/retry/paths-утили, checkpoint/resume, транспорт/auth/sessions — общий код для clikit, adapterkit и доменных пакетов."
 readme = "README.md"
 license = { text = "MIT" }

{s_librarykit-0.5.0 → s_librarykit-0.5.2}/tests/test_capture_tap.py

@@ -106,10 +106,15 @@ class _MockContext:
 class _MockPage:
     def __init__(self, context):
         self.context = context
+        self.queue_items: list[str] = []
 
     def on(self, *_a):
         pass
 
+    async def evaluate(self, _script):
+        items, self.queue_items = self.queue_items, []
+        return items
+
 
 class _MockBackend:
     def __init__(self, page):
@@ -183,3 +188,22 @@ def test_attach_tap_playwright_flow():
     assert got_resp[0].status == 200 and got_resp[0].body == b'{"ok":true}'
     # request_id сшит между request и response
     assert got_req[0].request_id == got_resp[0].request_id
+
+
+def test_attach_tap_drain_queue_fallback():
+    """CamouFox-fallback: событие из globalThis.__captureTraceQueue дренится page.evaluate → on_action."""
+    ctx = _MockContext()
+    page = _MockPage(ctx)
+    page.queue_items = ['{"kind":"action","type":"click"}', '{"kind":"mutation"}']
+    backend = _MockBackend(page)
+    got: list = []
+
+    async def run():
+        handle = await attach_capture_tap(
+            backend, on_action=got.append, init_script="/*trace*/", action_binding="__t",
+        )
+        await handle.detach()  # финальный дренаж соберёт очередь
+
+    asyncio.run(run())
+    kinds = {a.raw.get("kind") for a in got}
+    assert kinds == {"action", "mutation"}