gemini-ocr-cli 0.3.1__tar.gz → 0.3.2__tar.gz

{gemini_ocr_cli-0.3.1 → gemini_ocr_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-ocr-cli
-Version: 0.3.1
+Version: 0.3.2
 Summary: CLI tool for OCR processing using Google Gemini's vision capabilities
 Project-URL: Homepage, https://github.com/r-uben/gemini-ocr-cli
 Project-URL: Repository, https://github.com/r-uben/gemini-ocr-cli

{gemini_ocr_cli-0.3.1 → gemini_ocr_cli-0.3.2}/gemini_ocr/__init__.py

@@ -1,6 +1,6 @@
 """Gemini OCR CLI - Document processing using Google Gemini's vision capabilities."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 from gemini_ocr.config import Config
 from gemini_ocr.processor import OCRProcessor

{gemini_ocr_cli-0.3.1 → gemini_ocr_cli-0.3.2}/gemini_ocr/processor.py

@@ -115,6 +115,37 @@ class OCRProcessor:
 
         return types.GenerateContentConfig(**kwargs)
 
+    @staticmethod
+    def _extract_text(response: Any) -> str:
+        """Extract text from a GenerateContentResponse by walking parts explicitly.
+
+        The `.text` shortcut returns None when parts include thought summaries,
+        non-text parts, or when finish_reason != STOP — which is common with
+        Gemini 3.x thinking models. Walking parts is the reliable path.
+        """
+        candidates = getattr(response, "candidates", None) or []
+        if not candidates:
+            feedback = getattr(response, "prompt_feedback", None)
+            raise RuntimeError(f"Empty response: no candidates (prompt_feedback={feedback})")
+
+        candidate = candidates[0]
+        content = getattr(candidate, "content", None)
+        parts = getattr(content, "parts", None) or []
+        text = "".join(
+            p.text for p in parts if getattr(p, "text", None) and not getattr(p, "thought", False)
+        ).strip()
+
+        if not text:
+            finish = getattr(candidate, "finish_reason", None)
+            safety = getattr(candidate, "safety_ratings", None)
+            part_types = [type(p).__name__ for p in parts]
+            raise RuntimeError(
+                f"Empty response: finish_reason={finish}, "
+                f"len(parts)={len(parts)}, part_types={part_types}, "
+                f"safety_ratings={safety}"
+            )
+        return text
+
     def _call_with_retry(self, contents: list[Any], prompt: str) -> str:
         """Call generate_content with exponential backoff on transient errors."""
         max_attempts = self.config.max_retries + 1
@@ -128,9 +159,7 @@ class OCRProcessor:
                     contents=[prompt, *contents],
                     config=config,
                 )
-                if response.text:
-                    return response.text.strip()
-                return ""
+                return self._extract_text(response)
             except Exception as e:
                 is_last = attempt == max_attempts - 1
                 if is_last or not self._is_retryable(e):

gemini_ocr_cli-0.3.2/gemini_ocr/retry.py

@@ -0,0 +1,104 @@
+"""Retry logic with exponential backoff for API calls."""
+
+import logging
+import time
+from functools import wraps
+from typing import Callable, Tuple, Type, TypeVar
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class RetryError(Exception):
+    """Raised when all retry attempts are exhausted."""
+
+    def __init__(self, message: str, last_exception: Exception):
+        super().__init__(message)
+        self.last_exception = last_exception
+
+
+def retry(
+    max_attempts: int = 3,
+    backoff_factor: float = 2.0,
+    initial_delay: float = 1.0,
+    max_delay: float = 60.0,
+    exceptions: Tuple[Type[Exception], ...] = (Exception,),
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """Decorator for retrying functions with exponential backoff.
+
+    Args:
+        max_attempts: Maximum number of attempts (including first try)
+        backoff_factor: Multiplier for delay between retries
+        initial_delay: Initial delay in seconds
+        max_delay: Maximum delay in seconds
+        exceptions: Tuple of exception types to catch and retry
+
+    Returns:
+        Decorated function with retry logic
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> T:
+            delay = initial_delay
+            last_exception = None
+
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    if attempt == max_attempts:
+                        logger.error(
+                            f"All {max_attempts} attempts failed for {func.__name__}: {e}"
+                        )
+                        raise RetryError(
+                            f"Failed after {max_attempts} attempts", last_exception
+                        ) from e
+
+                    logger.warning(
+                        f"Attempt {attempt}/{max_attempts} failed for {func.__name__}: {e}. "
+                        f"Retrying in {delay:.1f}s..."
+                    )
+                    time.sleep(delay)
+                    delay = min(delay * backoff_factor, max_delay)
+
+            # Should not reach here, but for type safety
+            raise RetryError(f"Failed after {max_attempts} attempts", last_exception)
+
+        return wrapper
+
+    return decorator
+
+
+def is_retryable_error(error: Exception) -> bool:
+    """Check if an error is retryable.
+
+    Args:
+        error: The exception to check
+
+    Returns:
+        True if the error is typically transient and retryable
+    """
+    error_str = str(error).lower()
+
+    # Rate limit errors
+    if "rate" in error_str and "limit" in error_str:
+        return True
+    if "429" in error_str or "too many requests" in error_str:
+        return True
+
+    # Server errors
+    if "500" in error_str or "502" in error_str or "503" in error_str:
+        return True
+    if "internal" in error_str and "error" in error_str:
+        return True
+
+    # Connection errors
+    if "timeout" in error_str:
+        return True
+    if "connection" in error_str:
+        return True
+
+    return False

{gemini_ocr_cli-0.3.1 → gemini_ocr_cli-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gemini-ocr-cli"
-version = "0.3.1"
+version = "0.3.2"
 description = "CLI tool for OCR processing using Google Gemini's vision capabilities"
 authors = [
     {name = "Ruben Fernandez-Fuertes", email = "fernandezfuertesruben@gmail.com"}