gemx 0.2.1__tar.gz → 0.2.3__tar.gz

{gemx-0.2.1 → gemx-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: gemx
-Version: 0.2.1
+Version: 0.2.3
 Summary: Drive the Gemini web UI from Python via Playwright
 Project-URL: Homepage, https://github.com/ra0x3/gemx
 Project-URL: Repository, https://github.com/ra0x3/gemx

{gemx-0.2.1 → gemx-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gemx"
-version = "0.2.1"
+version = "0.2.3"
 description = "Drive the Gemini web UI from Python via Playwright"
 readme = "README.md"
 requires-python = ">=3.12"

{gemx-0.2.1 → gemx-0.2.3}/src/gemx/__init__.py

@@ -9,6 +9,7 @@ from .client import Gemx, GemxConfig
 from .errors import (
     GemxError,
     InputError,
+    ProfileBusyError,
     ResponseParseError,
     ResponseTimeoutError,
 )
@@ -20,10 +21,11 @@ __all__ = [
     "GemxError",
     "InputError",
     "OutputFormat",
+    "ProfileBusyError",
     "ResponseParseError",
     "ResponseTimeoutError",
     "format_instruction",
     "parse_output",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{gemx-0.2.1 → gemx-0.2.3}/src/gemx/client.py

@@ -16,15 +16,18 @@ if it were an API. The non-obvious parts (and why this exists):
 from __future__ import annotations
 
 import asyncio
+import fcntl
 import logging
+import time
+from contextlib import asynccontextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, AsyncIterator
 
 from playwright.async_api import Page, async_playwright
 
-from .errors import InputError, ResponseTimeoutError
+from .errors import InputError, ProfileBusyError, ResponseTimeoutError
 from .formats import OutputFormat, format_instruction, parse_output
 
 logger = logging.getLogger("gemx")
@@ -88,6 +91,18 @@ RESPONSE_SELECTORS = (
     ".model-response-text",
     ".markdown",
 )
+CANNED_REPLIES = (
+    "i'm having a hard time fulfilling your request",
+    "i seem to be encountering an error",
+    "i encountered an error doing what you asked",
+    "something went wrong. please try your request again",
+)
+
+
+def is_canned_reply(text: str) -> bool:
+    """True when ``text`` is one of Gemini's stock refusal or error replies."""
+    lowered = text.lower().replace("’", "'")
+    return len(lowered) < 300 and any(phrase in lowered for phrase in CANNED_REPLIES)
 
 _INSERT_TEXT_JS = """(text) => {
     const editor = document.querySelector('.ql-editor[contenteditable="true"]');
@@ -166,6 +181,20 @@ _LONGEST_RESPONSE_JS = """(args) => {
     return { text: best, selector, length: best.length };
 }"""
 
+_LIVE_RESPONSES_JS = """(args) => {
+    const [selectors, initialCounts] = args;
+    const texts = [];
+    selectors.forEach(sel => {
+        const els = Array.from(document.querySelectorAll(sel));
+        const initial = initialCounts[sel] || 0;
+        els.slice(initial).forEach(el => {
+            const t = el.innerText || el.textContent || '';
+            if (t) texts.push(t);
+        });
+    });
+    return texts;
+}"""
+
 _PAGE_ELEMENTS_JS = """() => {
     return {
         hasTextarea: document.querySelector('textarea') !== null,
@@ -273,6 +302,8 @@ class GemxConfig:  # pylint: disable=too-many-instance-attributes
     # How often (seconds) to emit page diagnostics while waiting for the response
     # node to appear.
     diagnostics_interval_s: int = 10
+    # How long to wait for another session to release the browser profile.
+    lock_timeout_s: int = 900
 
 
 class Gemx:
@@ -316,24 +347,56 @@ class Gemx:
         """
         token = _ACTIVE_LOG_LEVEL.set(self._log_level)
         try:
-            attempts = max(0, self._config.max_retries) + 1
-            for attempt in range(1, attempts + 1):
-                try:
-                    return await self._ask_raw_once(prompt, expected_format)
-                except ResponseTimeoutError:
-                    if attempt >= attempts:
-                        raise
-                    logger.warning(
-                        "Gemini attempt %d/%d failed; retrying",
-                        attempt,
-                        attempts,
-                        exc_info=True,
-                    )
+            async with self._profile_lock():
+                attempts = max(0, self._config.max_retries) + 1
+                for attempt in range(1, attempts + 1):
+                    try:
+                        return await self._ask_raw_once(prompt, expected_format)
+                    except ResponseTimeoutError:
+                        if attempt >= attempts:
+                            raise
+                        logger.warning(
+                            "Gemini attempt %d/%d failed; retrying",
+                            attempt,
+                            attempts,
+                            exc_info=True,
+                        )
         finally:
             _ACTIVE_LOG_LEVEL.reset(token)
 
         raise ResponseTimeoutError("Gemini retry loop exited without a result")
 
+    @asynccontextmanager
+    async def _profile_lock(self) -> AsyncIterator[None]:
+        """Hold the browser profile for one whole request, retries included.
+
+        Chromium refuses a persistent profile another process has open, so
+        every job sharing a profile takes turns through a lockfile beside it.
+
+        Raises:
+            ProfileBusyError: If the profile stayed held past ``lock_timeout_s``.
+        """
+        profile = self._config.profile_dir.expanduser()
+        path = profile.with_name(f"{profile.name}.gemx.lock")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        deadline = time.monotonic() + self._config.lock_timeout_s
+        with path.open("w") as handle:
+            while True:
+                try:
+                    fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    break
+                except BlockingIOError:
+                    if time.monotonic() >= deadline:
+                        raise ProfileBusyError(
+                            f"profile {profile} still in use after "
+                            f"{self._config.lock_timeout_s}s"
+                        ) from None
+                    await asyncio.sleep(2)
+            try:
+                yield
+            finally:
+                fcntl.flock(handle, fcntl.LOCK_UN)
+
     async def _ask_raw_once(
         self, prompt: str, expected_format: OutputFormat | None = None
     ) -> str:
@@ -525,6 +588,20 @@ class Gemx:
                     current_length,
                     len(best),
                 )
+                if stable >= cfg.stable_ticks and expected_format in (
+                    OutputFormat.JSON,
+                    OutputFormat.XML,
+                ):
+                    live = await page.evaluate(
+                        _LIVE_RESPONSES_JS, [list(RESPONSE_SELECTORS), initial_counts]
+                    )
+                    canned = next(
+                        (t for t in [best, *live] if is_canned_reply(t)), None
+                    )
+                    if canned is not None:
+                        raise ResponseTimeoutError(
+                            f"Gemini returned a canned reply: {canned[:200]!r}"
+                        )
                 if stable >= cfg.stable_ticks and len(best) > cfg.min_response_chars:
                     if expected_format in (OutputFormat.JSON, OutputFormat.XML):
                         try:

{gemx-0.2.1 → gemx-0.2.3}/src/gemx/errors.py

@@ -17,3 +17,7 @@ class ResponseTimeoutError(GemxError):
 
 class ResponseParseError(GemxError):
     """Gemini responded, but the payload could not be parsed for the format."""
+
+
+class ProfileBusyError(GemxError):
+    """Another Gemx session held the browser profile past the lock timeout."""