chrome-lens-py 1.0.0__tar.gz

chrome_lens_py-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bropines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chrome_lens_py-1.0.0/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.1
+Name: chrome_lens_py
+Version: 1.0.0
+Summary: Library to use Google Lens OCR via API used in Chromium.
+Home-page: https://github.com/bropines/chrome-lens-py
+Author: Bropines
+Author-email: bropines@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: Pillow
+Requires-Dist: filetype
+Requires-Dist: lxml
+Requires-Dist: json5
+Requires-Dist: rich
+
+# Chrome Lens API for Python
+
+[English](/README.md) | [Русский](/README_RU.md)
+
+This project provides a Python library and CLI tool for interacting with Google Lens's OCR functionality via the API used in Chromium. This allows you to process images and extract text data, including full text, coordinates, and stitched text using various methods.
+
+## Features
+
+- **Full Text Extraction**: Extract the complete text from an image.
+- **Coordinates Extraction**: Extract text along with its coordinates.
+- **Stitched Text**: Reconstruct text from blocks using various methods:
+  - **Default Full Text**: Basic method for stitching text blocks.
+  - **Old Method**: Sequential text stitching.
+  - **New Method**: Enhanced text stitching.
+
+PS. Lens has a problem with the way it displays full text, which is why methods have been added that stitch text from coordinates.
+
+## Installation
+
+You can install the package using `pip`:
+
+### From PyPI (SOON)
+
+```bash
+pip install chrome-lens-py
+```
+
+### From GIT
+
+```bash
+pip install git+https://github.com/bropines/chrome-lens-py.git
+```
+
+### From source
+
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/bropines/chrome-lens-api-py.git
+cd chrome-lens-api-py
+pip install -r requirements.txt
+pip install .
+```
+
+## Usage
+
+You can use the `lens_scan` command from the CLI to process images and extract text data, or you can use the Python API to integrate this functionality into your own projects.
+
+### CLI Usage
+
+```bash
+lens_scan <image_file> <data_type>
+```
+
+#### Data Types
+
+- **all**: Get all data (full text, coordinates, and stitched text using both methods).
+- **full_text_default**: Get only the default full text.
+- **full_text_old_method**: Get stitched text using the old sequential method.
+- **full_text_new_method**: Get stitched text using the new enhanced method.
+- **coordinates**: Get text along with coordinates.
+
+#### Example 
+
+To extract text using the new method for stitching:
+
+```bash
+lens_scan path/to/image.jpg full_text_new_method
+```
+
+To get all available data:
+
+```bash
+lens_scan path/to/image.jpg all
+```
+
+#### CLI Help
+
+You can use the `-h` or `--help` option to display usage information:
+
+```bash
+lens_scan -h
+```
+
+### Programmatic API Usage
+
+In addition to the CLI tool, this project provides a Python API that can be used in your scripts.
+
+#### Basic Programmatic Usage
+
+First, import the `LensAPI` class:
+
+```python
+from chrome_lens_py import LensAPI
+```
+
+#### Example Programmatic Usage
+
+1. **Instantiate the API**:
+
+    ```python
+    api = LensAPI()
+    ```
+
+2. **Process an image**:
+
+    - **Get all data**:
+  
+        ```python
+        result = api.get_all_data('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get the default full text**:
+  
+        ```python
+        result = api.get_full_text('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the old method**:
+  
+        ```python
+        result = api.get_stitched_text_sequential('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the new method**:
+  
+        ```python
+        result = api.get_stitched_text_smart('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get text with coordinates**:
+  
+        ```python
+        result = api.get_text_with_coordinates('path/to/image.jpg')
+        print(result)
+        ```
+
+#### Programmatic API Methods
+
+- **`get_all_data(image_path)`**: Returns all available data for the given image.
+- **`get_full_text(image_path)`**: Returns only the full text from the image.
+- **`get_text_with_coordinates(image_path)`**: Returns text along with its coordinates in JSON format.
+- **`get_stitched_text_smart(image_path)`**: Returns stitched text using the enhanced method.
+- **`get_stitched_text_sequential(image_path)`**: Returns stitched text using the basic sequential method.
+
+## Project Structure
+
+```
+/chrome-lens-api-py
+│
+├── /src
+│   ├── /chrome_lens_py
+│   │   ├── __init__.py           # Package initialization
+│   │   ├── constants.py          # Constants used in the project
+│   │   ├── utils.py              # Utility functions
+│   │   ├── image_processing.py   # Image processing module
+│   │   ├── request_handler.py    # API request handling module
+│   │   ├── text_processing.py    # Text processing module
+│   │   ├── lens_api.py           # API interface for use in other scripts
+│   │   └── main.py               # CLI tool entry point
+│
+├── setup.py                      # Installation setup
+├── README.md                     # Project description and usage guide
+└── requirements.txt              # Project dependencies
+```
+
+## Acknowledgments
+
+Special thanks to [dimdenGD](https://github.com/dimdenGD) for the method of text extraction used in this project. You can check out their work on the [chrome-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr) repository. This project is inspired by their approach to leveraging Google Lens OCR functionality.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Disclaimer
+
+This project is intended for educational purposes only. The use of Google Lens OCR functionality must comply with Google's Terms of Service. The author of this project is not responsible for any misuse of this software or for any consequences arising from its use. Users are solely responsible for ensuring that their use of this software complies with all applicable laws and regulations.
+
+## Author
+
+### Bropines  - [Mail](mailto:bropines@gmail.com) / [Telegram](https://t.me/bropines)

chrome_lens_py-1.0.0/README.md

@@ -0,0 +1,185 @@
+# Chrome Lens API for Python
+
+[English](/README.md) | [Русский](/README_RU.md)
+
+This project provides a Python library and CLI tool for interacting with Google Lens's OCR functionality via the API used in Chromium. This allows you to process images and extract text data, including full text, coordinates, and stitched text using various methods.
+
+## Features
+
+- **Full Text Extraction**: Extract the complete text from an image.
+- **Coordinates Extraction**: Extract text along with its coordinates.
+- **Stitched Text**: Reconstruct text from blocks using various methods:
+  - **Default Full Text**: Basic method for stitching text blocks.
+  - **Old Method**: Sequential text stitching.
+  - **New Method**: Enhanced text stitching.
+
+PS. Lens has a problem with the way it displays full text, which is why methods have been added that stitch text from coordinates.
+
+## Installation
+
+You can install the package using `pip`:
+
+### From PyPI (SOON)
+
+```bash
+pip install chrome-lens-py
+```
+
+### From GIT
+
+```bash
+pip install git+https://github.com/bropines/chrome-lens-py.git
+```
+
+### From source
+
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/bropines/chrome-lens-api-py.git
+cd chrome-lens-api-py
+pip install -r requirements.txt
+pip install .
+```
+
+## Usage
+
+You can use the `lens_scan` command from the CLI to process images and extract text data, or you can use the Python API to integrate this functionality into your own projects.
+
+### CLI Usage
+
+```bash
+lens_scan <image_file> <data_type>
+```
+
+#### Data Types
+
+- **all**: Get all data (full text, coordinates, and stitched text using both methods).
+- **full_text_default**: Get only the default full text.
+- **full_text_old_method**: Get stitched text using the old sequential method.
+- **full_text_new_method**: Get stitched text using the new enhanced method.
+- **coordinates**: Get text along with coordinates.
+
+#### Example 
+
+To extract text using the new method for stitching:
+
+```bash
+lens_scan path/to/image.jpg full_text_new_method
+```
+
+To get all available data:
+
+```bash
+lens_scan path/to/image.jpg all
+```
+
+#### CLI Help
+
+You can use the `-h` or `--help` option to display usage information:
+
+```bash
+lens_scan -h
+```
+
+### Programmatic API Usage
+
+In addition to the CLI tool, this project provides a Python API that can be used in your scripts.
+
+#### Basic Programmatic Usage
+
+First, import the `LensAPI` class:
+
+```python
+from chrome_lens_py import LensAPI
+```
+
+#### Example Programmatic Usage
+
+1. **Instantiate the API**:
+
+    ```python
+    api = LensAPI()
+    ```
+
+2. **Process an image**:
+
+    - **Get all data**:
+  
+        ```python
+        result = api.get_all_data('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get the default full text**:
+  
+        ```python
+        result = api.get_full_text('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the old method**:
+  
+        ```python
+        result = api.get_stitched_text_sequential('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the new method**:
+  
+        ```python
+        result = api.get_stitched_text_smart('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get text with coordinates**:
+  
+        ```python
+        result = api.get_text_with_coordinates('path/to/image.jpg')
+        print(result)
+        ```
+
+#### Programmatic API Methods
+
+- **`get_all_data(image_path)`**: Returns all available data for the given image.
+- **`get_full_text(image_path)`**: Returns only the full text from the image.
+- **`get_text_with_coordinates(image_path)`**: Returns text along with its coordinates in JSON format.
+- **`get_stitched_text_smart(image_path)`**: Returns stitched text using the enhanced method.
+- **`get_stitched_text_sequential(image_path)`**: Returns stitched text using the basic sequential method.
+
+## Project Structure
+
+```
+/chrome-lens-api-py
+│
+├── /src
+│   ├── /chrome_lens_py
+│   │   ├── __init__.py           # Package initialization
+│   │   ├── constants.py          # Constants used in the project
+│   │   ├── utils.py              # Utility functions
+│   │   ├── image_processing.py   # Image processing module
+│   │   ├── request_handler.py    # API request handling module
+│   │   ├── text_processing.py    # Text processing module
+│   │   ├── lens_api.py           # API interface for use in other scripts
+│   │   └── main.py               # CLI tool entry point
+│
+├── setup.py                      # Installation setup
+├── README.md                     # Project description and usage guide
+└── requirements.txt              # Project dependencies
+```
+
+## Acknowledgments
+
+Special thanks to [dimdenGD](https://github.com/dimdenGD) for the method of text extraction used in this project. You can check out their work on the [chrome-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr) repository. This project is inspired by their approach to leveraging Google Lens OCR functionality.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Disclaimer
+
+This project is intended for educational purposes only. The use of Google Lens OCR functionality must comply with Google's Terms of Service. The author of this project is not responsible for any misuse of this software or for any consequences arising from its use. Users are solely responsible for ensuring that their use of this software complies with all applicable laws and regulations.
+
+## Author
+
+### Bropines  - [Mail](mailto:bropines@gmail.com) / [Telegram](https://t.me/bropines)

chrome_lens_py-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chrome_lens_py-1.0.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+import pathlib
+
+# The directory containing this file
+HERE = pathlib.Path(__file__).parent
+
+# The text of the README file
+README = (HERE / "README.md").read_text()
+
+setup(
+    name='chrome_lens_py',
+    version='1.0.0',
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        'requests',
+        'Pillow',
+        'filetype',
+        'lxml',
+        'json5',
+        'rich',
+    ],
+    entry_points={
+        'console_scripts': [
+            'lens_scan=chrome_lens_py.main:main',
+        ],
+    },
+    description='Library to use Google Lens OCR via API used in Chromium.',
+    long_description=README,
+    long_description_content_type='text/markdown',  # Указание типа содержимого
+    author='Bropines',
+    author_email='bropines@gmail.com',
+    url='https://github.com/bropines/chrome-lens-py',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+)

chrome_lens_py-1.0.0/src/chrome_lens_py/__init__.py

@@ -0,0 +1 @@
+from .lens_api import LensAPI

chrome_lens_py-1.0.0/src/chrome_lens_py/constants.py

@@ -0,0 +1,49 @@
+# constants.py
+
+LENS_ENDPOINT = 'https://lens.google.com/v3/upload'
+
+SUPPORTED_MIMES = [
+    'image/x-icon',
+    'image/bmp',
+    'image/jpeg',
+    'image/png',
+    'image/tiff',
+    'image/webp',
+    'image/heic'
+]
+
+MIME_TO_EXT = {
+    'image/x-icon': 'ico',
+    'image/bmp': 'bmp',
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/tiff': 'tiff',
+    'image/webp': 'webp',
+    'image/heic': 'heic'
+}
+
+HEADERS = {
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+    'Accept-Encoding': 'gzip, deflate, br',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'Cache-Control': 'max-age=0',
+    'Origin': 'https://lens.google.com',
+    'Referer': 'https://lens.google.com/',
+    'Sec-Ch-Ua': '"Not A(Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"',
+    'Sec-Ch-Ua-Arch': '"x86"',
+    'Sec-Ch-Ua-Bitness': '"64"',
+    'Sec-Ch-Ua-Full-Version': '"91.0.4472.124"',
+    'Sec-Ch-Ua-Full-Version-List': '"Not A(Brand";v="99.0.0.0", "Google Chrome";v="91", "Chromium";v="91"',
+    'Sec-Ch-Ua-Mobile': '?0',
+    'Sec-Ch-Ua-Model': '""',
+    'Sec-Ch-Ua-Platform': '"Windows"',
+    'Sec-Ch-Ua-Platform-Version': '"15.0.0"',
+    'Sec-Ch-Ua-Wow64': '?0',
+    'Sec-Fetch-Dest': 'document',
+    'Sec-Fetch-Mode': 'navigate',
+    'Sec-Fetch-Site': 'same-origin',
+    'Sec-Fetch-User': '?1',
+    'Upgrade-Insecure-Requests': '1',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'X-Client-Data': 'CIW2yQEIorbJAQipncoBCIH+ygEIlaHLAQj1mM0BCIWgzQEI3ezNAQji+s0BCOmFzgEIponOAQj1ic4BCIeLzgEY1d3NARjS/s0BGNiGzgE='
+}

chrome_lens_py-1.0.0/src/chrome_lens_py/image_processing.py

@@ -0,0 +1,16 @@
+# image_processing.py
+
+import io
+from PIL import Image
+from .utils import is_supported_mime
+from .constants import MIME_TO_EXT
+
+def resize_image(image_path, max_size=(1000, 1000)):
+    """Изменяет размер изображения и конвертирует его в формат без альфа-канала."""
+    with Image.open(image_path) as img:
+        img.thumbnail(max_size)
+        if img.mode == 'RGBA':
+            img = img.convert('RGB')
+        buffer = io.BytesIO()
+        img.save(buffer, format="JPEG")
+        return buffer.getvalue(), img.size

chrome_lens_py-1.0.0/src/chrome_lens_py/lens_api.py

@@ -0,0 +1,36 @@
+# lens_api.py
+
+from .request_handler import Lens
+from .text_processing import simplify_output, extract_full_text, stitch_text_smart, stitch_text_sequential
+
+class LensAPI:
+    def __init__(self, config=None, sleep_time=1000):
+        self.lens = Lens(config=config, sleep_time=sleep_time)
+
+    def get_all_data(self, file_path):
+        """Возвращает все данные для изображения"""
+        result = self.lens.scan_by_file(file_path)
+        return simplify_output(result)
+
+    def get_full_text(self, file_path):
+        """Возвращает полный текст"""
+        result = self.lens.scan_by_file(file_path)
+        return extract_full_text(result['data'])
+
+    def get_text_with_coordinates(self, file_path):
+        """Возвращает текст с координатами в формате JSON"""
+        result = self.lens.scan_by_file(file_path)
+        simplified_result = simplify_output(result)
+        return simplified_result['text_with_coordinates']
+
+    def get_stitched_text_smart(self, file_path):
+        """Возвращает сшитый текст (умный метод)"""
+        result = self.lens.scan_by_file(file_path)
+        simplified_result = simplify_output(result)
+        return simplified_result['stitched_text_smart']
+
+    def get_stitched_text_sequential(self, file_path):
+        """Возвращает сшитый текст (последовательный метод)"""
+        result = self.lens.scan_by_file(file_path)
+        simplified_result = simplify_output(result)
+        return simplified_result['stitched_text_sequential']

chrome_lens_py-1.0.0/src/chrome_lens_py/main.py

@@ -0,0 +1,59 @@
+import sys
+import json
+import argparse
+from .lens_api import LensAPI
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+def print_help():
+    console.print("Usage: [b]lens_scan [options] <image_file> <data_type>[/b]")
+    console.print("\nOptions:")
+    console.print("[b]-h, --help[/b]          Show this help message and exit")
+    console.print("[b]<data_type>[/b] options:")
+    console.print("[b]all[/b]                      Get all data (full text, coordinates, and stitched text)")
+    console.print("[b]full_text_default[/b]        Get only the default full text")
+    console.print("[b]full_text_old_method[/b]     Get stitched text using the old method")
+    console.print("[b]full_text_new_method[/b]     Get stitched text using the new method")
+    console.print("[b]coordinates[/b]              Get text with coordinates")
+
+def main():
+    parser = argparse.ArgumentParser(description="Process images with Google Lens API and extract text data.", add_help=False)
+    parser.add_argument('image_file', nargs='?', help="Path to the image file")
+    parser.add_argument('data_type', nargs='?', choices=['all', 'full_text_default', 'full_text_old_method', 'full_text_new_method', 'coordinates'], help="Type of data to extract")
+    parser.add_argument('-h', '--help', action='store_true', help="Show this help message and exit")
+
+    args = parser.parse_args()
+
+    if args.help or not args.image_file or not args.data_type:
+        print_help()
+        sys.exit(1)
+
+    image_file = args.image_file
+    data_type = args.data_type
+
+    try:
+        api = LensAPI()
+
+        if data_type == "all":
+            result = api.get_all_data(image_file)
+        elif data_type == "full_text_default":
+            result = api.get_full_text(image_file)
+        elif data_type == "full_text_old_method":
+            result = api.get_stitched_text_sequential(image_file)
+        elif data_type == "full_text_new_method":
+            result = api.get_stitched_text_smart(image_file)
+        elif data_type == "coordinates":
+            result = api.get_text_with_coordinates(image_file)
+        else:
+            console.print("Invalid data_type option", style="bold red")
+            sys.exit(1)
+
+        console.print(json.dumps(result, indent=2), style="bold white")
+
+    except Exception as e:
+        console.print(f"Error: {e}", style="bold red")
+
+if __name__ == '__main__':
+    main()

chrome_lens_py-1.0.0/src/chrome_lens_py/request_handler.py

@@ -0,0 +1,108 @@
+# request_handler.py
+
+import requests
+import io
+import os
+import time
+import http.cookiejar as cookielib
+import lxml.html
+import json5
+import filetype
+from PIL import Image
+from .constants import LENS_ENDPOINT, HEADERS, MIME_TO_EXT, SUPPORTED_MIMES
+from .utils import sleep, is_supported_mime
+from .image_processing import resize_image
+
+class LensError(Exception):
+    """Класс для обработки ошибок."""
+    def __init__(self, message, code=None, headers=None, body=None):
+        super().__init__(message)
+        self.code = code
+        self.headers = headers
+        self.body = body
+
+class LensCore:
+    """Базовый класс для работы с Google Lens API."""
+    def __init__(self, config=None, sleep_time=1000):
+        self.config = config if config else {}
+        self.cookies = {}
+        self.sleep_time = sleep_time
+        self.parse_cookies()
+
+    def parse_cookies(self):
+        """Инициализирует куки."""
+        self.cookies = {
+            'NID': {
+                'name': 'NID',
+                'value': '511=b-iPvznEQOKO1rDvyj7vkLrfe9i-PQiN0z_nhNv7lg-3_0YpQf2ZSKikTrlpu4W3mko4n2RAfYMho9NJqDEsmO-4BZG_iOqmufFZIzW4jiGJMmnaE1S3crNWwUL1HNnDqVUZZjRYkK_S-wsDWCuVul3Q_sCjucSvJ-CTN63GSjY',
+                'expires': 1707050670000
+            }
+        }
+
+    def generate_cookie_header(self, headers):
+        """Добавляет куки в заголовки запроса."""
+        if self.cookies:
+            self.cookies = {k: v for k, v in self.cookies.items() if v['expires'] > time.time() * 1000}
+            headers['Cookie'] = '; '.join([f"{cookie['name']}={cookie['value']}" for cookie in self.cookies.values()])
+
+    def scan_by_data(self, data, mime, dimensions):
+        """Отправляет изображение на анализ в Google Lens API."""
+        headers = HEADERS.copy()
+        self.generate_cookie_header(headers)
+
+        session = requests.Session()
+        session.cookies = cookielib.CookieJar()
+        print(f"Sending data to {LENS_ENDPOINT}")
+
+        file_name = f"image.{MIME_TO_EXT[mime]}"
+        files = {
+            'encoded_image': (file_name, data, mime),
+            'original_width': (None, str(dimensions[0])),
+            'original_height': (None, str(dimensions[1])),
+            'processed_image_dimensions': (None, f"{dimensions[0]},{dimensions[1]}")
+        }
+
+        # Используем кастомное время задержки
+        sleep(self.sleep_time)
+
+        response = session.post(LENS_ENDPOINT, headers=headers, files=files)
+        print(f"Response status code: {response.status_code}")
+
+        if response.status_code != 200:
+            print(f"Response headers: {response.headers}")
+            print(f"Response body: {response.text}")
+            raise LensError("Failed to upload image", response.status_code, response.headers, response.text)
+
+        buffer_text = io.StringIO(response.text)
+        tree = lxml.html.parse(buffer_text)
+
+        r = tree.xpath("//script[@class='ds:1']")
+        return json5.loads(r[0].text[len("AF_initDataCallback("):-2])
+
+class Lens(LensCore):
+    """Класс для работы с Google Lens API, предоставляющий удобные методы."""
+    def __init__(self, config=None, sleep_time=1000):
+        super().__init__(config, sleep_time)
+
+    def scan_by_file(self, file_path):
+        """Сканирует изображение по пути к файлу и возвращает результаты."""
+        if not os.path.isfile(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        if not is_supported_mime(file_path):
+            raise ValueError("Unsupported file type")
+        img_data, dimensions = resize_image(file_path)
+        return self.scan_by_data(img_data, 'image/jpeg', dimensions)
+
+    def scan_by_buffer(self, buffer):
+        """Сканирует изображение из буфера и возвращает результаты."""
+        kind = filetype.guess(buffer)
+        if not kind or kind.mime not in SUPPORTED_MIMES:
+            raise ValueError("Unsupported file type")
+        img = Image.open(io.BytesIO(buffer))
+        img.thumbnail((1000, 1000))
+        if img.mode == 'RGBA':
+            img = img.convert('RGB')
+        img_buffer = io.BytesIO()
+        img.save(img_buffer, format="JPEG")
+        img_data = img_buffer.getvalue()
+        return self.scan_by_data(img_data, 'image/jpeg', img.size)

chrome_lens_py-1.0.0/src/chrome_lens_py/text_processing.py

@@ -0,0 +1,116 @@
+# text_processing.py
+
+import re
+
+def stitch_text_from_coordinates(text_with_coords):
+    """Сшивает текст из координат по строкам и позициям."""
+    sorted_elements = sorted(text_with_coords, key=lambda x: (round(x['coordinates'][1], 2), x['coordinates'][0]))
+
+    stitched_text = ""
+    current_y = None
+    current_line = []
+
+    for element in sorted_elements:
+        if current_y is None or abs(element['coordinates'][1] - current_y) > 0.05:
+            if current_line:
+                stitched_text += " ".join(current_line) + "\n"
+                current_line = []
+            current_y = element['coordinates'][1]
+        current_line.append(element['text'])
+
+    if current_line:
+        stitched_text += " ".join(current_line)
+
+    stitched_text = re.sub(r'\s+([,?.!])', r'\1', stitched_text)
+
+    return stitched_text.strip()
+
+def stitch_text_smart(text_with_coords):
+    """Сшивает текст из координат умным методом."""
+    transformed_coords = [{'text': item['text'], 'coordinates': [item['coordinates'][1], item['coordinates'][0]]} for item in text_with_coords]
+    sorted_elements = sorted(transformed_coords, key=lambda x: (round(x['coordinates'][1], 2), x['coordinates'][0]))
+
+    stitched_text = []
+    current_y = None
+    current_line = []
+    word_threshold = 0.02
+
+    for element in sorted_elements:
+        if current_y is None or abs(element['coordinates'][1] - current_y) > 0.05:
+            if current_line:
+                stitched_text.append(" ".join(current_line))
+                current_line = []
+            current_y = element['coordinates'][1]
+
+        if element['text'] in [',', '.', '!', '?', ';', ':'] and current_line:
+            current_line[-1] += element['text']
+        else:
+            current_line.append(element['text'])
+
+    if current_line:
+        stitched_text.append(" ".join(current_line))
+
+    return "\n".join(stitched_text).strip()
+
+def stitch_text_sequential(text_with_coords):
+    """Сшивает текст в последовательности, как он был распознан."""
+    stitched_text = " ".join([element['text'] for element in text_with_coords])
+    stitched_text = re.sub(r'\s+([,?.!])', r'\1', stitched_text)
+    
+    return stitched_text.strip()
+
+def extract_text_and_coordinates(data):
+    """Извлекает текст и координаты из структуры данных."""
+    text_with_coords = []
+    if isinstance(data, list):
+        for item in data:
+            if isinstance(item, list):
+                for sub_item in item:
+                    if isinstance(sub_item, list) and len(sub_item) > 1 and isinstance(sub_item[0], str):
+                        word = sub_item[0]
+                        coords = sub_item[1]
+                        if isinstance(coords, list) and all(isinstance(coord, (int, float)) for coord in coords):
+                            text_with_coords.append({"text": word, "coordinates": coords})
+                    else:
+                        text_with_coords.extend(extract_text_and_coordinates(sub_item))
+            else:
+                text_with_coords.extend(extract_text_and_coordinates(item))
+    elif isinstance(data, dict):
+        for value in data.values():
+            text_with_coords.extend(extract_text_and_coordinates(value))
+    return text_with_coords
+
+def extract_full_text(data):
+    """Извлекает полный текст из структуры данных."""
+    try:
+        text_data = data[3][4][0][0]
+        if isinstance(text_data, list):
+            return "\n".join(text_data)
+        return text_data
+    except (IndexError, TypeError):
+        return "Full text not found in expected structure"
+
+def simplify_output(result):
+    """Упрощает структуру данных, извлекая ключевые элементы."""
+    simplified = {}
+    
+    try:
+        if 'data' in result and isinstance(result['data'], list) and len(result['data']) > 3:
+            if isinstance(result['data'][3], list) and len(result['data'][3]) > 3:
+                simplified['language'] = result['data'][3][3]
+            else:
+                simplified['language'] = "Language not found in expected structure"
+        
+        simplified['full_text'] = extract_full_text(result['data'])
+        
+        if 'data' in result and isinstance(result['data'], list):
+            text_with_coords = extract_text_and_coordinates(result['data'])
+            simplified['text_with_coordinates'] = text_with_coords
+            
+            simplified['stitched_text_smart'] = stitch_text_smart(text_with_coords)
+            simplified['stitched_text_sequential'] = stitch_text_sequential(text_with_coords)
+    except Exception as e:
+        print(f"Error in simplify_output: {e}")
+        simplified['error'] = str(e)
+    
+    return simplified

chrome_lens_py-1.0.0/src/chrome_lens_py/utils.py

@@ -0,0 +1,15 @@
+# utils.py
+
+import filetype
+import time
+
+from .constants import SUPPORTED_MIMES
+
+def is_supported_mime(file_path):
+    """Проверяет, поддерживается ли MIME-тип файла."""
+    kind = filetype.guess(file_path)
+    return kind and kind.mime in SUPPORTED_MIMES
+
+def sleep(ms):
+    """Функция ожидания."""
+    time.sleep(ms / 1000)

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.1
+Name: chrome_lens_py
+Version: 1.0.0
+Summary: Library to use Google Lens OCR via API used in Chromium.
+Home-page: https://github.com/bropines/chrome-lens-py
+Author: Bropines
+Author-email: bropines@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: Pillow
+Requires-Dist: filetype
+Requires-Dist: lxml
+Requires-Dist: json5
+Requires-Dist: rich
+
+# Chrome Lens API for Python
+
+[English](/README.md) | [Русский](/README_RU.md)
+
+This project provides a Python library and CLI tool for interacting with Google Lens's OCR functionality via the API used in Chromium. This allows you to process images and extract text data, including full text, coordinates, and stitched text using various methods.
+
+## Features
+
+- **Full Text Extraction**: Extract the complete text from an image.
+- **Coordinates Extraction**: Extract text along with its coordinates.
+- **Stitched Text**: Reconstruct text from blocks using various methods:
+  - **Default Full Text**: Basic method for stitching text blocks.
+  - **Old Method**: Sequential text stitching.
+  - **New Method**: Enhanced text stitching.
+
+PS. Lens has a problem with the way it displays full text, which is why methods have been added that stitch text from coordinates.
+
+## Installation
+
+You can install the package using `pip`:
+
+### From PyPI (SOON)
+
+```bash
+pip install chrome-lens-py
+```
+
+### From GIT
+
+```bash
+pip install git+https://github.com/bropines/chrome-lens-py.git
+```
+
+### From source
+
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/bropines/chrome-lens-api-py.git
+cd chrome-lens-api-py
+pip install -r requirements.txt
+pip install .
+```
+
+## Usage
+
+You can use the `lens_scan` command from the CLI to process images and extract text data, or you can use the Python API to integrate this functionality into your own projects.
+
+### CLI Usage
+
+```bash
+lens_scan <image_file> <data_type>
+```
+
+#### Data Types
+
+- **all**: Get all data (full text, coordinates, and stitched text using both methods).
+- **full_text_default**: Get only the default full text.
+- **full_text_old_method**: Get stitched text using the old sequential method.
+- **full_text_new_method**: Get stitched text using the new enhanced method.
+- **coordinates**: Get text along with coordinates.
+
+#### Example 
+
+To extract text using the new method for stitching:
+
+```bash
+lens_scan path/to/image.jpg full_text_new_method
+```
+
+To get all available data:
+
+```bash
+lens_scan path/to/image.jpg all
+```
+
+#### CLI Help
+
+You can use the `-h` or `--help` option to display usage information:
+
+```bash
+lens_scan -h
+```
+
+### Programmatic API Usage
+
+In addition to the CLI tool, this project provides a Python API that can be used in your scripts.
+
+#### Basic Programmatic Usage
+
+First, import the `LensAPI` class:
+
+```python
+from chrome_lens_py import LensAPI
+```
+
+#### Example Programmatic Usage
+
+1. **Instantiate the API**:
+
+    ```python
+    api = LensAPI()
+    ```
+
+2. **Process an image**:
+
+    - **Get all data**:
+  
+        ```python
+        result = api.get_all_data('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get the default full text**:
+  
+        ```python
+        result = api.get_full_text('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the old method**:
+  
+        ```python
+        result = api.get_stitched_text_sequential('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get stitched text using the new method**:
+  
+        ```python
+        result = api.get_stitched_text_smart('path/to/image.jpg')
+        print(result)
+        ```
+
+    - **Get text with coordinates**:
+  
+        ```python
+        result = api.get_text_with_coordinates('path/to/image.jpg')
+        print(result)
+        ```
+
+#### Programmatic API Methods
+
+- **`get_all_data(image_path)`**: Returns all available data for the given image.
+- **`get_full_text(image_path)`**: Returns only the full text from the image.
+- **`get_text_with_coordinates(image_path)`**: Returns text along with its coordinates in JSON format.
+- **`get_stitched_text_smart(image_path)`**: Returns stitched text using the enhanced method.
+- **`get_stitched_text_sequential(image_path)`**: Returns stitched text using the basic sequential method.
+
+## Project Structure
+
+```
+/chrome-lens-api-py
+│
+├── /src
+│   ├── /chrome_lens_py
+│   │   ├── __init__.py           # Package initialization
+│   │   ├── constants.py          # Constants used in the project
+│   │   ├── utils.py              # Utility functions
+│   │   ├── image_processing.py   # Image processing module
+│   │   ├── request_handler.py    # API request handling module
+│   │   ├── text_processing.py    # Text processing module
+│   │   ├── lens_api.py           # API interface for use in other scripts
+│   │   └── main.py               # CLI tool entry point
+│
+├── setup.py                      # Installation setup
+├── README.md                     # Project description and usage guide
+└── requirements.txt              # Project dependencies
+```
+
+## Acknowledgments
+
+Special thanks to [dimdenGD](https://github.com/dimdenGD) for the method of text extraction used in this project. You can check out their work on the [chrome-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr) repository. This project is inspired by their approach to leveraging Google Lens OCR functionality.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Disclaimer
+
+This project is intended for educational purposes only. The use of Google Lens OCR functionality must comply with Google's Terms of Service. The author of this project is not responsible for any misuse of this software or for any consequences arising from its use. Users are solely responsible for ensuring that their use of this software complies with all applicable laws and regulations.
+
+## Author
+
+### Bropines  - [Mail](mailto:bropines@gmail.com) / [Telegram](https://t.me/bropines)

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.py
+src/chrome_lens_py/__init__.py
+src/chrome_lens_py/constants.py
+src/chrome_lens_py/image_processing.py
+src/chrome_lens_py/lens_api.py
+src/chrome_lens_py/main.py
+src/chrome_lens_py/request_handler.py
+src/chrome_lens_py/text_processing.py
+src/chrome_lens_py/utils.py
+src/chrome_lens_py.egg-info/PKG-INFO
+src/chrome_lens_py.egg-info/SOURCES.txt
+src/chrome_lens_py.egg-info/dependency_links.txt
+src/chrome_lens_py.egg-info/entry_points.txt
+src/chrome_lens_py.egg-info/requires.txt
+src/chrome_lens_py.egg-info/top_level.txt

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lens_scan = chrome_lens_py.main:main

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests
+Pillow
+filetype
+lxml
+json5
+rich

chrome_lens_py-1.0.0/src/chrome_lens_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+chrome_lens_py