# Lens_OCR_exp.py # https://github.com/AuroraWright/owocr import re import numpy as np import time import random from typing import List, Dict, Any, Tuple, Optional, Union from math import sqrt import io import os import json import requests from PIL import Image, ImageFile import betterproto try: from .utils.lens_betterproto import * except ImportError: try: from .utils.lens_betterproto import * except ImportError: raise ImportError( "Could not import lens_betterproto. " "Make sure lens_betterproto.py exists." ) from None try: from .base import register_OCR, OCRBase, TextBlock except ImportError: class OCRBase: def __init__(self, **params): self.params = params self.debug_mode = int(os.environ.get("OCR_DEBUG", 0)) # Basic logger implementation if run standalone import logging self.logger = logging.getLogger(__name__) if not self.logger.hasHandlers(): handler = logging.StreamHandler() formatter = logging.Formatter( "[%(levelname)-5s] %(name)s:%(funcName)s:%(lineno)d - %(message)s" ) handler.setFormatter(formatter) self.logger.addHandler(handler) self.logger.setLevel(logging.DEBUG if self.debug_mode else logging.INFO) self.logger.info( "Running Lens_OCR_exp without .base module. Using placeholder classes." ) def get_param_value(self, key): return self.params.get(key) def updateParam(self, key, value): self.params[key] = value def register_OCR(name): return lambda cls: cls class TextBlock: def __init__(self): self.xyxy = (0, 0, 0, 0) self.text = "" ImageFile.LOAD_TRUNCATED_IMAGES = True try: import fpng_py OPTIMIZED_PNG_ENCODE = True except ImportError: OPTIMIZED_PNG_ENCODE = False def _pil_image_to_bytes( img: Image.Image, img_format="png", png_compression=6, jpeg_quality=80, optimize=False, ) -> bytes: """Converts PIL Image object to bytes of the specified format.""" if img_format == "png" and OPTIMIZED_PNG_ENCODE and not optimize: try: rgba_img = img.convert("RGBA") raw_data = rgba_img.tobytes() image_bytes = fpng_py.fpng_encode_image_to_memory( raw_data, img.width, img.height ) return image_bytes except Exception: pass # Fallback to PIL image_bytes_io = io.BytesIO() save_kwargs = {} img_to_save = img if img_format == "jpeg": if img.mode == "RGBA" or (img.mode == "P" and "transparency" in img.info): background = Image.new("RGB", img.size, (255, 255, 255)) try: background.paste(img, mask=img.split()[3]) except IndexError: background.paste(img) img_to_save = background elif img.mode != "RGB": img_to_save = img.convert("RGB") save_kwargs["quality"] = jpeg_quality save_kwargs["subsampling"] = 0 save_kwargs["optimize"] = optimize elif img_format == "png": save_kwargs["compress_level"] = png_compression save_kwargs["optimize"] = optimize img_to_save.save(image_bytes_io, format=img_format.upper(), **save_kwargs) return image_bytes_io.getvalue() def _preprocess_image_for_lens(img: Image.Image) -> Tuple[Optional[bytes], int, int]: """Prepares image for Google Lens Protobuf API.""" try: original_width, original_height = img.size max_pixels = 3_000_000 if original_width * original_height > max_pixels: aspect_ratio = original_width / original_height new_w = int(sqrt(max_pixels * aspect_ratio)) new_h = int(new_w / aspect_ratio) img_to_process = ( img.resize((new_w, new_h), Image.Resampling.LANCZOS) if new_w > 0 and new_h > 0 else img ) else: img_to_process = img img_bytes = _pil_image_to_bytes(img_to_process, img_format="png") return (img_bytes, img_to_process.width, img_to_process.height) except Exception as e: # Use print for safety if logger isn't available reliably print(f"ERROR: Image preprocessing failed: {e}") return (None, 0, 0) @register_OCR("google_lens_exp") class OCRLensAPI_exp(OCRBase): """ OCR using the experimental Google Lens Protobuf API (using requests). Requires 'betterproto', 'requests', and 'lens_betterproto.py'. """ params = { "delay": 1.5, "newline_handling": { "type": "selector", "options": ["preserve", "remove"], "value": "preserve", "description": "Handle newline characters in the final OCR string.", }, "no_uppercase": { "type": "checkbox", "value": False, "description": "Convert text to lowercase except first letter of sentences.", }, "target_language": { "value": "ja", "description": "Target language code (e.g., 'ja', 'en', 'ru').", }, "proxy": { "value": "", "description": 'Proxy (requests format: e.g., http://user:pass@host:port or {"http": ..., "https": ...})', }, "description": "OCR using Google Lens Protobuf API (requests backend)", } @property def request_delay(self) -> float: delay_val = self.get_param_value("delay") try: return max(0.0, float(delay_val)) except (ValueError, TypeError, AttributeError): return 1.0 @property def newline_handling(self) -> str: handling = self.get_param_value("newline_handling") return handling if handling in ["preserve", "remove"] else "preserve" @property def no_uppercase(self) -> bool: no_upper = self.get_param_value("no_uppercase") return bool(no_upper) if no_upper is not None else False @property def target_language(self) -> str: lang = self.get_param_value("target_language") return lang if isinstance(lang, str) and len(lang) >= 2 else "ja" @property def proxy(self) -> Optional[Dict[str, str]]: val = self.get_param_value("proxy") proxies_dict = None if isinstance(val, str) and val.strip().startswith("{"): try: parsed_dict = json.loads(val) if isinstance(parsed_dict, dict): proxies_dict = {} # Ensure keys are 'http' and 'https' for requests http_key = next( ( k for k in parsed_dict if k.lower() == "http" or k.lower() == "http://" ), None, ) https_key = next( ( k for k in parsed_dict if k.lower() == "https" or k.lower() == "https://" ), None, ) if http_key: proxies_dict["http"] = parsed_dict[http_key] if https_key: proxies_dict["https"] = parsed_dict[https_key] return proxies_dict if proxies_dict else None except Exception: if val.strip(): proxies_dict = {"http": val.strip(), "https": val.strip()} else: return None elif isinstance(val, str) and val.strip(): proxies_dict = {"http": val.strip(), "https": val.strip()} elif isinstance(val, dict) and val: # Assume dict is already in {'http': ..., 'https': ...} format proxies_dict = val return proxies_dict if proxies_dict else None def __init__(self, **params) -> None: super().__init__(**params) self.last_request_time: float = 0 self._api_url = "https://lensfrontend-pa.googleapis.com/v1/crupload" self._api_key = "AIzaSyDr2UxVnv_U85AbhhY8XSHSIavUW0DC-sY" self._api_headers = { "Host": "lensfrontend-pa.googleapis.com", "Connection": "keep-alive", "Content-Type": "application/x-protobuf", "X-Goog-Api-Key": self._api_key, "Sec-Fetch-Site": "none", "Sec-Fetch-Mode": "no-cors", "Sec-Fetch-Dest": "empty", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", "Accept-Encoding": "gzip, deflate, br", "Accept-Language": "en-US,en;q=0.9", } def _prepare_protobuf_request( self, image_bytes: bytes, width: int, height: int ) -> Optional[bytes]: """Creates and serializes the Protobuf request.""" try: request = LensOverlayServerRequest() req_id = request.objects_request.request_context.request_id client_ctx = request.objects_request.request_context.client_context locale_ctx = client_ctx.locale_context img_data = request.objects_request.image_data req_id.uuid = random.randint(0, 2**64 - 1) req_id.sequence_id = 1 req_id.image_sequence_id = 1 req_id.analytics_id = random.randbytes(16) client_ctx.platform = Platform.WEB client_ctx.surface = Surface.CHROMIUM locale_ctx.language = self.target_language locale_ctx.region = "JP" locale_ctx.time_zone = "Asia/Tokyo" filter_obj = AppliedFilter(filter_type=LensOverlayFilterType.AUTO_FILTER) client_ctx.client_filters.filter.append(filter_obj) img_data.payload.image_bytes = image_bytes img_data.image_metadata.width = width img_data.image_metadata.height = height return bytes(request) except Exception as e: self.logger.error( f"Failed to prepare Protobuf request: {e}", exc_info=self.debug_mode ) return None def _parse_protobuf_response( self, response_proto: LensOverlayServerResponse ) -> str: """Extracts text from Protobuf response, ignoring non-critical error Type=0.""" extracted_text = "" has_error_type_0 = False try: if response_proto.error: err_type = response_proto.error.error_type if ( err_type != LensOverlayServerErrorErrorType.UNKNOWN_TYPE ): # Check against enum value 0 error_type_name = LensOverlayServerErrorErrorType(err_type).name self.logger.error( f"Lens server returned critical error: Type={err_type} ({error_type_name})" ) return "" else: self.logger.debug( "Lens server returned non-critical error: Type=0 (UNKNOWN_TYPE)." " Attempting to extract text anyway." ) has_error_type_0 = True text_layout = getattr( getattr(response_proto, "objects_response", None), "text", None ) paragraphs = getattr( getattr(text_layout, "text_layout", None), "paragraphs", None ) if paragraphs: paragraph_texts = [] for paragraph in paragraphs: para_text_builder = io.StringIO() for line in getattr(paragraph, "lines", []): for word in getattr(line, "words", []): para_text_builder.write(getattr(word, "plain_text", "")) separator = getattr(word, "text_separator", None) if separator is not None: para_text_builder.write(separator) paragraph_texts.append(para_text_builder.getvalue()) para_text_builder.close() extracted_text = "".join(paragraph_texts).strip() extracted_text = re.sub(r"\s+", " ", extracted_text).strip() if self.debug_mode and has_error_type_0: self.logger.debug( "Successfully extracted text despite non-critical error Type=0." ) elif not has_error_type_0: if self.debug_mode: self.logger.debug( "Text layout not found in Protobuf structure (and no error reported)." ) except Exception as e: self.logger.error( f"Failed to parse Protobuf response structure: {e}", exc_info=self.debug_mode, ) return "" return extracted_text def _execute_ocr_request( self, image_bytes: bytes, width: int, height: int ) -> Optional[LensOverlayServerResponse]: """Sends prepared request via requests and returns deserialized response.""" payload = self._prepare_protobuf_request(image_bytes, width, height) if not payload: return None self._respect_delay() response_proto = None session = requests.Session() current_proxy = self.proxy if current_proxy: session.proxies = current_proxy if self.debug_mode: self.logger.debug( f"Using requests proxy configuration: {current_proxy}" ) # Determine SSL verification skip_ssl_verify = os.environ.get("OCR_SKIP_SSL_VERIFY", "false").lower() in ( "true", "1", "yes", ) ssl_verify = not skip_ssl_verify try: if self.debug_mode: self.logger.debug( f"Sending Protobuf request ({len(payload)} bytes) via requests " f"to lens api (SSL Verify: {ssl_verify})" ) response = session.post( self._api_url, data=payload, headers=self._api_headers, timeout=(10.0, 30.0), verify=ssl_verify, ) self.last_request_time = time.time() if self.debug_mode: self.logger.debug( f"Received requests response status: {response.status_code}" ) response.raise_for_status() response_proto = LensOverlayServerResponse().parse(response.content) if self.debug_mode: self.logger.debug("Protobuf response parsed successfully (requests).") except requests.exceptions.SSLError as e: self.logger.error( f"SSL Error connecting to Lens API (requests): {e}. " f"If using a proxy or corporate network, check its configuration. " f"You might need to trust a custom CA or set OCR_SKIP_SSL_VERIFY=true (unsafe).", exc_info=self.debug_mode, ) except requests.exceptions.HTTPError as e: response_text = getattr(e.response, "text", "N/A")[:500] self.logger.error( f"HTTP error from Lens API (requests): {e.response.status_code}. " f"Response: {response_text}", exc_info=self.debug_mode, ) except requests.exceptions.RequestException as e: self.logger.error( f"Request error connecting to Lens API (requests): {e}", exc_info=self.debug_mode, ) except (betterproto.Error, ValueError, TypeError) as e: self.logger.error( f"Failed to parse Protobuf response (requests): {e}", exc_info=self.debug_mode, ) if "response" in locals() and hasattr(response, "content"): self.logger.debug( f"Raw response content (first 500 bytes): {response.content[:500]}" ) except Exception as e: self.logger.error( f"Unexpected error during OCR request (requests): {e}", exc_info=self.debug_mode, ) finally: session.close() return response_proto def ocr(self, img: np.ndarray) -> str: """Main OCR method for a single image (numpy array).""" if self.debug_mode > 1: self.logger.debug( f"Starting OCR (Lens Protobuf / requests) on image shape: {img.shape}" ) if img is None or img.size == 0: if self.debug_mode: self.logger.warning("Empty image provided") return "" full_text = "" try: pil_img = Image.fromarray(img) processed_bytes, width, height = _preprocess_image_for_lens(pil_img) if not processed_bytes: self.logger.error("Image preprocessing failed.") return "" if self.debug_mode > 1: self.logger.debug( f"Preprocessed image: {width}x{height}, {len(processed_bytes)} bytes" ) response_proto = self._execute_ocr_request(processed_bytes, width, height) if response_proto: full_text = self._parse_protobuf_response(response_proto) if self.debug_mode and full_text: self.logger.debug(f"Parsed text preview: '{full_text[:100]}...'") if self.newline_handling == "remove": full_text = re.sub(r"\s+", " ", full_text).strip() full_text = self._apply_punctuation_and_spacing(full_text) if self.no_uppercase: full_text = self._apply_no_uppercase(full_text) else: self.logger.warning( "OCR request did not return a valid response object." ) except Exception as e: self.logger.error( f"Unexpected error in OCR process: {e}", exc_info=self.debug_mode ) return "" return str(full_text) if full_text is not None else "" def ocr_img(self, img: np.ndarray) -> str: if self.debug_mode > 1: self.logger.debug(f"ocr_img shape: {img.shape}") return self.ocr(img) def _ocr_blk_list( self, img: np.ndarray, blk_list: List[TextBlock], *args, **kwargs ): """Processes a list of text blocks on the image.""" im_h, im_w = img.shape[:2] if self.debug_mode: self.logger.debug( f"Image size: {im_h}x{im_w}. Processing {len(blk_list)} blocks." ) for i, blk in enumerate(blk_list): x1, y1, x2, y2 = blk.xyxy if self.debug_mode > 1: self.logger.debug( f"Processing block {i+1}/{len(blk_list)}: ({x1, y1, x2, y2})" ) y1c, y2c = max(0, y1), min(im_h, y2) x1c, x2c = max(0, x1), min(im_w, x2) if y1c < y2c and x1c < x2c: try: cropped_img = img[y1c:y2c, x1c:x2c] if cropped_img.size > 0: blk.text = self.ocr(cropped_img) else: if self.debug_mode: self.logger.warning(f"Empty cropped image for block {i+1}.") blk.text = "" except Exception as crop_err: self.logger.error( f"Error cropping/processing block {i+1}: {crop_err}", exc_info=self.debug_mode, ) blk.text = "" else: if self.debug_mode: self.logger.warning( f"Invalid/zero-area bbox {blk.xyxy} (clamped: {x1c,y1c,x2c,y2c})" ) blk.text = "" def _apply_no_uppercase(self, text: str) -> str: """Applies lowercase except for first letter of sentences.""" def process_sentence(sentence): sentence = sentence.strip() return sentence[0].upper() + sentence[1:].lower() if sentence else "" if self.target_language.lower().startswith("ja"): return text # No case change for Japanese sentences = re.split(r"(?<=[.!?…])\s+", text) return " ".join(process_sentence(s) for s in sentences if s) def _apply_punctuation_and_spacing(self, text: str) -> str: """Corrects spacing around punctuation.""" text = re.sub(r"\s+([,.!?…:;])", r"\1", text) text = re.sub(r"([,.!?…:;])(?=[^\s,.!?…:;])", r"\1 ", text) text = re.sub(r"\s+", " ", text) return text.strip() def _respect_delay(self): """Ensures minimum delay between requests.""" current_time = time.time() time_since_last = current_time - self.last_request_time required_delay = self.request_delay if time_since_last < required_delay: sleep_time = required_delay - time_since_last if self.debug_mode: self.logger.info(f"Delay: Sleeping for {sleep_time:.3f}s") time.sleep(sleep_time) def updateParam(self, param_key: str, param_content: Any): """Updates a parameter.""" # No client re-initialization needed for requests on proxy change if param_key == "delay": try: param_content = max(0.0, float(param_content)) except (ValueError, TypeError): param_content = 1.0 super().updateParam(param_key, param_content)