gemx 0.2.0__tar.gz → 0.2.2__tar.gz

{gemx-0.2.0 → gemx-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: gemx
-Version: 0.2.0
+Version: 0.2.2
 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.0 → gemx-0.2.2}/pyproject.toml

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

{gemx-0.2.0 → gemx-0.2.2}/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.0"
+__version__ = "0.2.2"

{gemx-0.2.0 → gemx-0.2.2}/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,17 @@ 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",
+)
+
+
+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"]');
@@ -273,6 +287,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 +332,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 +573,14 @@ class Gemx:
                     current_length,
                     len(best),
                 )
+                if (
+                    stable >= cfg.stable_ticks
+                    and expected_format in (OutputFormat.JSON, OutputFormat.XML)
+                    and is_canned_reply(best)
+                ):
+                    raise ResponseTimeoutError(
+                        f"Gemini returned a canned reply: {best[: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.0 → gemx-0.2.2}/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."""

{gemx-0.2.0 → gemx-0.2.2}/src/gemx/formats.py

@@ -82,6 +82,42 @@ def _clean_json_text(text: str) -> str:
     return text
 
 
+def _first_json_object(text: str) -> str | None:
+    """The first complete top-level ``{...}`` in ``text``, or None.
+
+    ``rfind("}")`` walks past the object into whatever Gemini wrote after it,
+    and on a reply that is still streaming it lands on a nested brace, so the
+    slice it hands back is not the object at all. Depth counting stops at the
+    real end; strings and their escapes are skipped so a brace inside a value
+    does not move the depth.
+    """
+    start = text.find("{")
+    if start == -1:
+        return None
+    depth = 0
+    in_string = False
+    escaped = False
+    for index in range(start, len(text)):
+        char = text[index]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == '"':
+                in_string = False
+            continue
+        if char == '"':
+            in_string = True
+        elif char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                return text[start : index + 1]
+    return None
+
+
 def parse_output(text: str, fmt: OutputFormat) -> Any:
     """Extract a structured value from Gemini's raw reply for ``fmt``.
 
@@ -97,11 +133,14 @@ def parse_output(text: str, fmt: OutputFormat) -> Any:
         return cleaned
 
     if fmt is OutputFormat.JSON:
-        start = cleaned.find("{")
-        end = cleaned.rfind("}") + 1
-        candidate = cleaned[start:end] if start != -1 and end != 0 else cleaned
+        repaired = _clean_json_text(cleaned)
+        candidate = _first_json_object(repaired)
+        if candidate is None:
+            start = repaired.find("{")
+            end = repaired.rfind("}") + 1
+            candidate = repaired[start:end] if start != -1 and end != 0 else repaired
         try:
-            return json.loads(_clean_json_text(candidate))
+            return json.loads(candidate)
         except json.JSONDecodeError as exc:
             raise ValueError(f"Could not parse JSON from response: {exc}") from exc