From 7048729191c7dba372554fbff204839043c74195 Mon Sep 17 00:00:00 2001 From: Jakub Zenon Kujawa Date: Wed, 18 Dec 2024 17:04:50 +0100 Subject: [PATCH] refactor(services): modernize Python services architecture Comprehensive refactoring of document processing microservices to improve reliability, maintainability, and type safety: * Update Docker configurations to use uv for better dependency management * Enhance error handling with explicit exception hierarchies * Add comprehensive type hints and improve code organization * Implement better logging practices across services * Update model configurations for more robust service communication * Standardize configuration handling across services * Improve language detection and processing capabilities BREAKING CHANGE * Changed dependency management from requirements.txt to pyproject.toml * Updated service initialization and configuration patterns * Modified Docker container builds to use uv instead of pip --- .gitdiff | 3830 +++++++++++++++++ .gitignore | 5 +- Dockerfile.ocr | 42 +- Dockerfile.predictor | 42 +- Dockerfile.processor | 36 +- Dockerfile.summarizer | 36 +- docker-compose.yml | 16 +- init-ollama.sh | 27 +- pdm.lock | 1848 -------- pyproject.toml | 49 +- requirements.txt | 25 - setup-services.sh | 4 +- src/configs/model_config.py | 28 +- src/configs/ocr_config.py | 6 +- src/configs/summarization_config.py | 6 +- src/database/__init__.py | 16 +- src/database/connections.py | 23 +- src/database/dependencies.py | 2 +- src/database/exceptions.py | 25 +- src/database/models.py | 28 +- src/database/repository.py | 108 +- src/database/schemas.py | 19 +- src/ocr/__init__.py | 1 + .../{optimized_ocr.py => easy_ocr_wrapper.py} | 22 +- src/ocr/ocr.py | 155 +- .../{tesseract.py => tesseract_wrapper.py} | 74 +- src/payload/model_models.py | 39 - src/payload/ocr_models.py | 25 +- src/payload/predictor_models.py | 14 + src/payload/processor_models.py | 55 +- src/payload/shared_models.py | 51 + src/payload/summarizer_models.py | 13 +- src/predictor/layoutlm_wrapper.py | 139 + src/predictor/llm_model.py | 352 ++ src/predictor/model.py | 264 -- src/predictor/predictor.py | 271 ++ src/processor/dataset.py | 89 +- src/processor/processor.py | 133 +- src/summarization/summarizer.py | 393 +- src/utils/utils.py | 46 +- uv.lock | 2084 +++++++++ 41 files changed, 7743 insertions(+), 2698 deletions(-) create mode 100644 .gitdiff delete mode 100644 pdm.lock delete mode 100644 requirements.txt create mode 100644 src/ocr/__init__.py rename src/ocr/{optimized_ocr.py => easy_ocr_wrapper.py} (85%) rename src/ocr/{tesseract.py => tesseract_wrapper.py} (72%) delete mode 100644 src/payload/model_models.py create mode 100644 src/payload/predictor_models.py create mode 100644 src/payload/shared_models.py create mode 100644 src/predictor/layoutlm_wrapper.py create mode 100644 src/predictor/llm_model.py delete mode 100644 src/predictor/model.py create mode 100644 src/predictor/predictor.py create mode 100644 uv.lock diff --git a/.gitdiff b/.gitdiff new file mode 100644 index 0000000..abbde63 --- /dev/null +++ b/.gitdiff @@ -0,0 +1,3830 @@ +diff --git a/Dockerfile.ocr b/Dockerfile.ocr +index 7efe618..a4130c0 100644 +--- a/Dockerfile.ocr ++++ b/Dockerfile.ocr +@@ -1,39 +1,43 @@ +-FROM ghcr.io/astral-sh/uv:latest AS builder +-FROM python:3.12-slim-bullseye AS final +- +-LABEL authors="codeplayer" +- +-ENV VIRTUAL_ENV=/opt/venv +-ENV PYTHONUNBUFFERED=1 +-ENV PYTHONDONTWRITEBYTECODE=1 ++FROM python:3.12-slim-bullseye ++ ++COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ ++ ++ENV UV_PYTHON_DOWNLOADS=never ++# Location of the virtual environment ++ENV UV_PROJECT_ENVIRONMENT="/venv" ++# Location of the python installation via uv ++ENV UV_PYTHON_INSTALL_DIR="/python" ++# Byte compile the python files on installation ++ENV UV_COMPILE_BYTECODE=1 ++# Python verision to use ++ENV UV_PYTHON=python3.12 ++# Tweaking the PATH variable for easier use ++ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" + + WORKDIR /app + + # Install only required runtime dependencies + RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- poppler-utils tesseract-ocr libtesseract-dev \ +- && rm -rf /var/lib/apt/lists/* +- +-# Create and activate virtual environment +-RUN python -m venv $VIRTUAL_ENV +-ENV PATH="$VIRTUAL_ENV/bin:$PATH" ++ apt-get install -y --no-install-recommends \ ++ poppler-utils tesseract-ocr libtesseract-dev \ ++ && rm -rf /var/lib/apt/lists/* + + # Install dependencies using uv +-COPY --from=builder /uv /uv +-COPY requirements.txt . + RUN --mount=type=cache,target=/root/.cache/uv \ +- /uv pip install --no-cache-dir -r requirements.txt ++ --mount=type=bind,source=uv.lock,target=uv.lock \ ++ --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ ++ uv sync --frozen --no-install-project --no-editable + + # Copy only necessary files + COPY src/ocr/ /app/code/ + COPY src/configs/ocr_config.py /app/code/configs/ + COPY src/configs/database_config.py /app/code/configs/ + COPY src/payload/ocr_models.py /app/code/payload/ ++COPY src/payload/shared_models.py /app/code/payload/ + COPY src/database/ /app/code/database/ + COPY src/utils/ /app/code/utils/ + COPY .env /app/code/ + + WORKDIR /app/code/ + +-CMD ["python", "-m", "uvicorn", "ocr:app", "--host", "0.0.0.0", "--port", "8080"] +\ No newline at end of file ++CMD ["uv", "run", "uvicorn", "ocr:app", "--host", "0.0.0.0", "--port", "8080"] +diff --git a/Dockerfile.predictor b/Dockerfile.predictor +index 3dd20d5..efcbb6c 100644 +--- a/Dockerfile.predictor ++++ b/Dockerfile.predictor +@@ -1,36 +1,42 @@ +-FROM ghcr.io/astral-sh/uv:latest AS builder +-FROM python:3.12-slim-bullseye AS final +- +-ENV VIRTUAL_ENV=/opt/venv +-ENV PYTHONUNBUFFERED=1 +-ENV PYTHONDONTWRITEBYTECODE=1 ++FROM python:3.12-slim-bullseye ++ ++COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ ++ ++ENV UV_PYTHON_DOWNLOADS=never ++# Location of the virtual environment ++ENV UV_PROJECT_ENVIRONMENT="/venv" ++# Location of the python installation via uv ++ENV UV_PYTHON_INSTALL_DIR="/python" ++# Byte compile the python files on installation ++ENV UV_COMPILE_BYTECODE=1 ++# Python verision to use ++ENV UV_PYTHON=python3.12 ++# Tweaking the PATH variable for easier use ++ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" + + WORKDIR /app + + # Install minimal required dependencies + RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- git \ +- && rm -rf /var/lib/apt/lists/* +- +-# Create and activate virtual environment +-RUN python -m venv $VIRTUAL_ENV +-ENV PATH="$VIRTUAL_ENV/bin:$PATH" ++ apt-get install -y --no-install-recommends \ ++ git \ ++ && rm -rf /var/lib/apt/lists/* + + # Install dependencies using uv +-COPY --from=builder /uv /uv +-COPY requirements.txt . + RUN --mount=type=cache,target=/root/.cache/uv \ +- /uv pip install --no-cache-dir -r requirements.txt ++ --mount=type=bind,source=uv.lock,target=uv.lock \ ++ --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ ++ uv sync --frozen --no-install-project --no-editable + + # Copy only necessary files + COPY src/predictor/ /app/code/ + COPY src/configs/model_config.py /app/code/configs/ + COPY src/configs/database_config.py /app/code/configs/ +-COPY src/payload/model_models.py /app/code/payload/ ++COPY src/payload/predictor_models.py /app/code/payload/ ++COPY src/payload/shared_models.py /app/code/payload/ + COPY src/database/ /app/code/database/ + COPY .env /app/code/ + + WORKDIR /app/code/ + +-CMD ["python", "-m", "uvicorn", "model:app", "--host", "0.0.0.0", "--port", "7070"] +\ No newline at end of file ++CMD ["uv", "run", "uvicorn", "predictor:app", "--host", "0.0.0.0", "--port", "7070"] +diff --git a/Dockerfile.processor b/Dockerfile.processor +index 2e0d56c..db257bc 100644 +--- a/Dockerfile.processor ++++ b/Dockerfile.processor +@@ -1,33 +1,39 @@ +-FROM ghcr.io/astral-sh/uv:latest AS builder + FROM python:3.12-slim-bullseye AS final + +-ENV VIRTUAL_ENV=/opt/venv +-ENV PYTHONUNBUFFERED=1 +-ENV PYTHONDONTWRITEBYTECODE=1 ++COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv ++ ++ENV UV_PYTHON_DOWNLOADS=never ++# Location of the virtual environment ++ENV UV_PROJECT_ENVIRONMENT="/venv" ++# Location of the python installation via uv ++ENV UV_PYTHON_INSTALL_DIR="/python" ++# Byte compile the python files on installation ++ENV UV_COMPILE_BYTECODE=1 ++# Python verision to use ++ENV UV_PYTHON=python3.12 ++# Tweaking the PATH variable for easier use ++ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" + + WORKDIR /app + + # Install minimal required dependencies + RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- git \ +- && rm -rf /var/lib/apt/lists/* +- +-# Create and activate virtual environment +-RUN python -m venv $VIRTUAL_ENV +-ENV PATH="$VIRTUAL_ENV/bin:$PATH" ++ apt-get install -y --no-install-recommends \ ++ git \ ++ && rm -rf /var/lib/apt/lists/* + + # Install dependencies using uv +-COPY --from=builder /uv /uv +-COPY requirements.txt . + RUN --mount=type=cache,target=/root/.cache/uv \ +- /uv pip install --no-cache-dir -r requirements.txt ++ --mount=type=bind,source=uv.lock,target=uv.lock \ ++ --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ ++ uv sync --frozen --no-install-project --no-editable + + # Copy only necessary files + COPY src/processor/ /app/code/ + COPY src/configs/processor_config.py /app/code/configs/ + COPY src/payload/processor_models.py /app/code/payload/ ++COPY src/payload/shared_models.py /app/code/payload/ + + WORKDIR /app/code/ + +-CMD ["python", "-m", "uvicorn", "processor:app", "--host", "0.0.0.0", "--port", "9090"] +\ No newline at end of file ++CMD ["uv", "run", "uvicorn", "processor:app", "--host", "0.0.0.0", "--port", "9090"] +diff --git a/Dockerfile.summarizer b/Dockerfile.summarizer +index 9737cb1..310227f 100644 +--- a/Dockerfile.summarizer ++++ b/Dockerfile.summarizer +@@ -1,30 +1,42 @@ +-FROM ghcr.io/astral-sh/uv:latest AS builder +-FROM python:3.12-slim-bullseye AS final ++FROM python:3.12-slim-bullseye + +-ENV VIRTUAL_ENV=/opt/venv +-ENV PYTHONUNBUFFERED=1 +-ENV PYTHONDONTWRITEBYTECODE=1 ++COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ ++ ++ENV UV_PYTHON_DOWNLOADS=never ++# Location of the virtual environment ++ENV UV_PROJECT_ENVIRONMENT="/venv" ++# Location of the python installation via uv ++ENV UV_PYTHON_INSTALL_DIR="/python" ++# Byte compile the python files on installation ++ENV UV_COMPILE_BYTECODE=1 ++# Python verision to use ++ENV UV_PYTHON=python3.12 ++# Tweaking the PATH variable for easier use ++ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" + + WORKDIR /app + +-# Create and activate virtual environment +-RUN python -m venv $VIRTUAL_ENV +-ENV PATH="$VIRTUAL_ENV/bin:$PATH" ++# Install minimal required dependencies ++RUN apt-get update && \ ++ apt-get install -y --no-install-recommends \ ++ git \ ++ && rm -rf /var/lib/apt/lists/* + + # Install dependencies using uv +-COPY --from=builder /uv /uv +-COPY requirements.txt . + RUN --mount=type=cache,target=/root/.cache/uv \ +- /uv pip install --no-cache-dir -r requirements.txt ++ --mount=type=bind,source=uv.lock,target=uv.lock \ ++ --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ ++ uv sync --frozen --no-install-project --no-editable + + # Copy only necessary files + COPY src/summarization/ /app/code/ + COPY src/configs/summarization_config.py /app/code/configs/ + COPY src/configs/database_config.py /app/code/configs/ + COPY src/payload/summarizer_models.py /app/code/payload/ ++COPY src/payload/shared_models.py /app/code/payload/ + COPY src/database/ /app/code/database/ + COPY .env /app/code/ + + WORKDIR /app/code/ + +-CMD ["python", "-m", "uvicorn", "summarizer:app", "--host", "0.0.0.0", "--port", "6060"] +\ No newline at end of file ++CMD ["uv", "run", "uvicorn", "summarizer:app", "--host", "0.0.0.0", "--port", "6060"] +diff --git a/docker-compose.yml b/docker-compose.yml +index 5bfd449..62ce144 100644 +--- a/docker-compose.yml ++++ b/docker-compose.yml +@@ -4,13 +4,13 @@ services: + image: postgres:latest + restart: unless-stopped + healthcheck: +- test: [ "CMD-SHELL", "pg_isready -U postgres" ] +- interval: 5s ++ test: ["CMD-SHELL", "pg_isready -U postgres"] ++ interval: 120s + timeout: 5s + retries: 5 + environment: + POSTGRES_USER: postgres +- POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD environment variable is required} ++ POSTGRES_PASSWORD: postgres + POSTGRES_DB: document_classification + TZ: Europe/Warsaw + ports: +@@ -85,6 +85,7 @@ services: + depends_on: + - processor + - database ++ - ollama + volumes: + - type: bind + source: logs +@@ -111,13 +112,14 @@ services: + source: init-ollama.sh + target: /app/init-ollama.sh + healthcheck: +- test: ollama ps || exit 1 +- interval: 5s +- timeout: 5s ++ test: "ollama --version && ollama ps || exit 1" ++ interval: 120s ++ timeout: 10s + retries: 5 ++ start_period: 30s + networks: + - document-classification +- entrypoint: [ "/usr/bin/bash", "/app/init-ollama.sh" ] ++ entrypoint: ["/usr/bin/bash", "/app/init-ollama.sh"] + + summarizer: + container_name: summarizer_service +diff --git a/init-ollama.sh b/init-ollama.sh +index 83a0451..e6aa7fa 100755 +--- a/init-ollama.sh ++++ b/init-ollama.sh +@@ -1,16 +1,27 @@ + #!/bin/bash + ++# Selected model. ++MODEL=llama3.2:3b ++# MODEL=gemma2:2b ++ + # Start Ollama in the background. +-/bin/ollama serve & +-# Record Process ID. +-pid=$! ++echo "Starting Ollama server..." ++ollama serve & ++SERVE_PID=$! ++ ++echo "Waiting for Ollama server to be active..." ++while ! ollama list | grep -q 'NAME'; do ++ sleep 1 ++done + +-# Pause for Ollama to start. +-sleep 5 ++echo "🔴 Retrieve ${MODEL} model..." ++ollama pull ${MODEL} ++echo "🟢 Done!" + +-echo "🔴 Retrieve LLAMA3.2 3B model..." +-ollama pull llama3.2:3b ++# Preload the model. ++echo "🔴 Preload ${MODEL} model..." ++ollama run ${MODEL} "" + echo "🟢 Done!" + + # Wait for Ollama process to finish. +-wait $pid +\ No newline at end of file ++wait $SERVE_PID +diff --git a/pyproject.toml b/pyproject.toml +index 01dd4b2..f24f248 100644 +--- a/pyproject.toml ++++ b/pyproject.toml +@@ -1,38 +1,29 @@ + [project] +-name = "DocumentClassification" ++name = "documentclassification" + version = "0.1.0" +-description = "Default template for PDM package" +-authors = [ +- { name = "Jakub Zenon Kujawa", email = "ZK_Jakub@proton.me" }, +-] ++description = "Add your description here" ++readme = "README.md" ++requires-python = ">=3.12" + dependencies = [ +- "torch>=2.5.0", +- "torchvision>=0.20.0", +- "torchaudio>=2.5.0", ++ "aiofiles>=24.1.0", ++ "asyncpg>=0.30.0", ++ "datasets>=3.1.0", + "easyocr>=1.7.2", ++ "fastapi[standard]>=0.115.5", ++ "lightning>=2.4.0", ++ "lingua-language-detector>=2.0.2", ++ "numpy>=2.1.3", + "pdf2image>=1.17.0", +- "fastapi[standard]>=0.115.3", +- "python-multipart>=0.0.16", + "pillow>=11.0.0", +- "numpy>=2.1.2", +- "rich>=13.9.3", +- "transformers>=4.46.0", +- "lightning>=2.4.0", +- "datasets>=3.1.0", +- "python-dotenv>=1.0.1", ++ "psutil>=6.1.0", + "psycopg2-binary>=2.9.10", +- "sqlalchemy[asyncio]>=2.0.36", +- "asyncpg>=0.30.0", + "pytesseract>=0.3.13", +- "langchain>=0.3.9", +- "langchain-ollama>=0.2.0", +- "psutil>=6.1.0", +- "aiofiles>=24.1.0", ++ "python-dotenv>=1.0.1", ++ "python-multipart>=0.0.18", ++ "rich>=13.9.4", ++ "sqlalchemy[asyncio]>=2.0.36", ++ "torch>=2.5.1", ++ "torchaudio>=2.5.1", ++ "torchvision>=0.20.1", ++ "transformers>=4.46.3", + ] +-requires-python = ">=3.12,<3.13" +-readme = "README.md" +-license = { text = "MIT" } +- +- +-[tool.pdm] +-distribution = false +diff --git a/setup-services.sh b/setup-services.sh +index 9253d8c..0c23d15 100755 +--- a/setup-services.sh ++++ b/setup-services.sh +@@ -5,7 +5,7 @@ usage() { + echo "Usage: $0 [-f|--force] [-d|--detach] [-p|--password PASSWORD] [-r|--rebuild]" + echo "Options:" + echo " -f, --force Remove existing models and clone again" +- echo " -d, --detach Run in detached mode" ++ echo " -d, --detach Run in detached mode" + echo " -p, --password Set PostgreSQL password" + echo " -r, --rebuild Rebuild docker images" + echo " -h, --help Display this help message" +@@ -77,4 +77,4 @@ elif [ "$REBUILD" = false ]; then + else + echo "Starting services..." + docker-compose up +-fi +\ No newline at end of file ++fi +diff --git a/src/configs/model_config.py b/src/configs/model_config.py +index 3f96599..c923311 100644 +--- a/src/configs/model_config.py ++++ b/src/configs/model_config.py +@@ -1,6 +1,8 @@ + from dataclasses import dataclass, field + from pathlib import Path + ++import psutil ++ + + @dataclass(frozen=True) + class ModelConfig: +@@ -26,7 +28,31 @@ class ModelConfig: + "questionnaire", + "resume", + "memo", +- ] ++ ], + ) + + SUMMARIZER_URL: str = "http://summarizer:6060/summarize" ++ ++ # LLM specific parameters ++ ++ # Ollama configuration ++ OLLAMA_BASE_URL: str = "http://ollama:11434" ++ MODEL_NAME: str = "llama3.2:3b" ++ ++ # Summary constraints ++ MAX_INPUT_LENGTH: int = 10000 ++ DEFAULT_MAX_LENGTH: int = 200 ++ DEFAULT_MIN_LENGTH: int = 50 ++ ++ # Model parameters ++ TEMPERATURE: float = 0.7 ++ TOP_P: float = 0.9 ++ FREQUENCY_PENALTY: float = 0.0 ++ PRESENCE_PENALTY: float = 0.0 ++ ++ # Llama specific parameters ++ NUM_CTX: int = 4096 # Context window size ++ NUM_GPU: int = 0 ++ NUM_THREAD: int = field( ++ default_factory=lambda: psutil.cpu_count(logical=False) or 1, ++ ) +diff --git a/src/configs/ocr_config.py b/src/configs/ocr_config.py +index 636eb25..c15cab6 100644 +--- a/src/configs/ocr_config.py ++++ b/src/configs/ocr_config.py +@@ -1,6 +1,6 @@ + from dataclasses import dataclass + from pathlib import Path +-from typing import Final, Set ++from typing import Final + + BYTE_MEGABYTE: Final[int] = 1024 * 1024 + +@@ -14,14 +14,14 @@ class OCRConfig: + TARGET_SIZE: int = 1240 + MAX_WORKERS: int = 4 + LOG_DIR: Path = Path("/app/data/logs/ocr") +- ACCEPTED_FILE_TYPES: Set[str] = frozenset( ++ ACCEPTED_FILE_TYPES: frozenset[str] = frozenset( + { + "image/jpeg", + "image/png", + "image/jpg", + "image/webp", + "application/pdf", +- } ++ }, + ) + PROCESSOR_URL: str = "http://processor:9090/text-preprocess" + UPLOAD_DIR: Path = Path("/app/data/uploads") +diff --git a/src/configs/summarization_config.py b/src/configs/summarization_config.py +index cd7da42..8462c6d 100644 +--- a/src/configs/summarization_config.py ++++ b/src/configs/summarization_config.py +@@ -1,4 +1,4 @@ +-from dataclasses import dataclass ++from dataclasses import dataclass, field + from pathlib import Path + + import psutil +@@ -29,4 +29,6 @@ class SummarizationConfig: + # Llama specific parameters + NUM_CTX: int = 4096 # Context window size + NUM_GPU: int = 0 +- NUM_THREAD: int = psutil.cpu_count(logical=False) # Number of CPU threads to use ++ NUM_THREAD: int = field( ++ default_factory=lambda: psutil.cpu_count(logical=False) or 1, ++ ) +diff --git a/src/database/__init__.py b/src/database/__init__.py +index 66d9651..663661f 100644 +--- a/src/database/__init__.py ++++ b/src/database/__init__.py +@@ -20,20 +20,20 @@ from .schemas import ( + ) + + __all__ = [ ++ "Base", ++ "ConnectionError", + "DatabaseConfig", + "DatabaseConnection", + "DatabaseError", +- "ConnectionError", +- "DocumentError", +- "DocumentNotFoundError", +- "DocumentSaveError", +- "DocumentUpdateError", +- "Base", + "Document", +- "DocumentRepository", + "DocumentBase", + "DocumentCreate", +- "DocumentUpdate", ++ "DocumentError", ++ "DocumentNotFoundError", ++ "DocumentRepository", + "DocumentResponse", ++ "DocumentSaveError", ++ "DocumentUpdate", ++ "DocumentUpdateError", + "get_repository", + ] +diff --git a/src/database/connections.py b/src/database/connections.py +index ef063c5..f66c68d 100644 +--- a/src/database/connections.py ++++ b/src/database/connections.py +@@ -1,7 +1,7 @@ + import logging ++from collections.abc import AsyncGenerator + from contextlib import asynccontextmanager + from datetime import datetime +-from typing import AsyncGenerator + + from sqlalchemy import text + from sqlalchemy.engine import URL +@@ -14,7 +14,7 @@ from sqlalchemy.ext.asyncio import ( + + from configs.database_config import DatabaseConfig + +-from .exceptions import ConnectionError ++from .exceptions import ConnectionError as DBConnectionError + + config = DatabaseConfig.from_env() + config.LOG_DIR.mkdir(parents=True, exist_ok=True) +@@ -25,7 +25,8 @@ logging.basicConfig( + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", + ), + logging.StreamHandler(), + ], +@@ -37,7 +38,7 @@ logger = logging.getLogger(__name__) + class DatabaseConnection: + """Manages database connection and session creation.""" + +- def __init__(self): ++ def __init__(self) -> None: + """Initialize database connection manager.""" + self.engine = self._create_engine() + self.async_session_maker = async_sessionmaker( +@@ -69,8 +70,9 @@ class DatabaseConnection: + ) + + except Exception as e: +- logger.error("Failed to create database engine: %s", str(e)) +- raise ConnectionError("Failed to establish database connection") from e ++ logger.exception("Failed to create database engine") ++ error_msg = "Failed to establish database connection" ++ raise DBConnectionError(error_msg) from e + + async def verify_connection(self) -> None: + """Verify database connection.""" +@@ -79,8 +81,9 @@ class DatabaseConnection: + await conn.execute(text("SELECT 1")) + logger.info("Database connection verified successfully") + except Exception as e: +- logger.error("Failed to verify database connection: %s", str(e)) +- raise ConnectionError("Failed to verify database connection") from e ++ logger.exception("Failed to verify database connection") ++ error_msg = "Failed to verify database connection" ++ raise DBConnectionError(error_msg) from e + + @asynccontextmanager + async def get_session(self) -> AsyncGenerator[AsyncSession, None]: +@@ -88,9 +91,9 @@ class DatabaseConnection: + async with self.async_session_maker() as session: + try: + yield session +- except Exception as e: ++ except Exception: + await session.rollback() +- logger.error("Database session error: %s", str(e)) ++ logger.exception("Database session error") + raise + finally: + await session.close() +diff --git a/src/database/dependencies.py b/src/database/dependencies.py +index 95c7dc6..a1d6a82 100644 +--- a/src/database/dependencies.py ++++ b/src/database/dependencies.py +@@ -1,4 +1,4 @@ +-from typing import AsyncGenerator ++from collections.abc import AsyncGenerator + + from fastapi import Depends + from sqlalchemy.ext.asyncio import AsyncSession +diff --git a/src/database/exceptions.py b/src/database/exceptions.py +index a261b33..b2375ad 100644 +--- a/src/database/exceptions.py ++++ b/src/database/exceptions.py +@@ -1,10 +1,21 @@ +-from typing import Optional ++from __future__ import annotations + + + class DatabaseError(Exception): + """Base exception for database operations.""" + +- def __init__(self, message: str, original_error: Optional[Exception] = None): ++ def __init__( ++ self, ++ message: str, ++ original_error: Exception | None = None, ++ ) -> None: ++ """Initialize DatabaseError exception. ++ ++ Args: ++ message: Error message to display ++ original_error: Original exception that caused this error, if any ++ ++ """ + super().__init__(message) + self.original_error = original_error + +@@ -12,28 +23,18 @@ class DatabaseError(Exception): + class ConnectionError(DatabaseError): + """Raised when database connection fails.""" + +- pass +- + + class DocumentError(DatabaseError): + """Base exception for document-related operations.""" + +- pass +- + + class DocumentNotFoundError(DocumentError): + """Raised when a document is not found.""" + +- pass +- + + class DocumentSaveError(DocumentError): + """Raised when saving a document fails.""" + +- pass +- + + class DocumentUpdateError(DocumentError): + """Raised when updating a document fails.""" +- +- pass +diff --git a/src/database/models.py b/src/database/models.py +index 6a1c935..f21b7fc 100644 +--- a/src/database/models.py ++++ b/src/database/models.py +@@ -1,5 +1,6 @@ ++from __future__ import annotations ++ + from datetime import datetime +-from typing import Optional + + from sqlalchemy import TIMESTAMP, Integer, String + from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column +@@ -8,8 +9,6 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column + class Base(DeclarativeBase): + """Base class for all database models.""" + +- pass +- + + class Document(Base): + """Document model with improved type hints and validation.""" +@@ -17,13 +16,26 @@ class Document(Base): + __tablename__ = "documents" + + id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True) +- file_name: Mapped[str] = mapped_column(String(255), nullable=False, unique=True) +- file_path: Mapped[str] = mapped_column(String(255), nullable=False, unique=True) ++ file_name: Mapped[str] = mapped_column( ++ String(255), ++ nullable=False, ++ unique=True, ++ ) ++ file_path: Mapped[str] = mapped_column( ++ String(255), ++ nullable=False, ++ unique=True, ++ ) + created_at: Mapped[datetime] = mapped_column( +- TIMESTAMP, nullable=False, default=datetime.utcnow ++ TIMESTAMP, ++ nullable=False, ++ default=datetime.utcnow, ++ ) ++ classification: Mapped[str | None] = mapped_column( ++ String(255), ++ nullable=True, + ) +- classification: Mapped[Optional[str]] = mapped_column(String(255), nullable=True) +- summary: Mapped[Optional[str]] = mapped_column(String, nullable=True) ++ summary: Mapped[str | None] = mapped_column(String, nullable=True) + + def to_dict(self) -> dict: + """Convert document to dictionary.""" +diff --git a/src/database/repository.py b/src/database/repository.py +index 8c46b46..a56f9f4 100644 +--- a/src/database/repository.py ++++ b/src/database/repository.py +@@ -1,9 +1,10 @@ ++from __future__ import annotations ++ + from datetime import datetime +-from typing import Sequence ++from typing import TYPE_CHECKING + + from sqlalchemy import select + from sqlalchemy.exc import SQLAlchemyError +-from sqlalchemy.ext.asyncio import AsyncSession + + from .exceptions import ( + DocumentError, +@@ -12,23 +13,30 @@ from .exceptions import ( + DocumentUpdateError, + ) + from .models import Document +-from .schemas import DocumentCreate, DocumentUpdate ++ ++if TYPE_CHECKING: ++ from collections.abc import Sequence ++ ++ from sqlalchemy.ext.asyncio import AsyncSession ++ ++ from .schemas import DocumentCreate, DocumentUpdate + + + class DocumentRepository: + """Repository for document-related database operations.""" + +- def __init__(self, session: AsyncSession): ++ def __init__(self, session: AsyncSession) -> None: + """Initialize repository with database session.""" + self.session = session + + async def create(self, document: DocumentCreate) -> Document: + """Create a new document record.""" + try: ++ now = datetime.now().astimezone() + db_document = Document( + file_name=document.file_name, + file_path=document.file_path, +- created_at=document.created_at or datetime.now(datetime.timezone.utc), ++ created_at=document.created_at or now, + classification=document.classification, + summary=document.summary, + ) +@@ -37,12 +45,15 @@ class DocumentRepository: + await self.session.commit() + await self.session.refresh(db_document) + +- return db_document +- + except SQLAlchemyError as e: ++ error_msg = f"Failed to save document {document.file_name}" + raise DocumentSaveError( +- f"Failed to save document {document.file_name}", original_error=e +- ) ++ error_msg, ++ original_error=e, ++ ) from e ++ ++ else: ++ return db_document + + async def get_by_id(self, document_id: int) -> Document: + """Retrieve document by ID.""" +@@ -51,11 +62,15 @@ class DocumentRepository: + document = result.scalar_one_or_none() + + if not document: +- raise DocumentNotFoundError(f"Document with ID {document_id} not found") ++ error_msg = f"Document with ID {document_id} not found" ++ raise DocumentNotFoundError(error_msg) + return document + + async def get_by_filename( +- self, file_name: str, *, return_bool: bool = False ++ self, ++ file_name: str, ++ *, ++ return_bool: bool = False, + ) -> Document | bool: + """Retrieve document by filename.""" + query = select(Document).filter(Document.file_name == file_name) +@@ -65,7 +80,8 @@ class DocumentRepository: + if not document: + if return_bool: + return False +- raise DocumentNotFoundError(f"Document {file_name} not found") ++ error_msg = f"Document {file_name} not found" ++ raise DocumentNotFoundError(error_msg) + + return document + +@@ -75,7 +91,11 @@ class DocumentRepository: + result = await self.session.execute(query) + return result.scalars().all() + +- async def update(self, document_id: int, update_data: DocumentUpdate) -> Document: ++ async def update( ++ self, ++ document_id: int, ++ update_data: DocumentUpdate, ++ ) -> Document: + """Update document attributes.""" + try: + document = await self.get_by_id(document_id) +@@ -87,46 +107,72 @@ class DocumentRepository: + await self.session.commit() + await self.session.refresh(document) + +- return document +- + except SQLAlchemyError as e: ++ error_msg = f"Failed to update document {document_id}" + raise DocumentUpdateError( +- f"Failed to update document {document_id}", original_error=e +- ) ++ error_msg, ++ original_error=e, ++ ) from e ++ ++ else: ++ return document + + async def update_classification( +- self, file_name: str, classification: str ++ self, ++ file_name: str, ++ classification: str, + ) -> Document: + """Update document classification.""" + try: +- document = await self.get_by_filename(file_name) ++ document = await self.get_by_filename( ++ file_name, ++ return_bool=False, ++ ) ++ ++ if not isinstance(document, Document): ++ error_msg = f"Document {file_name} not found" ++ raise DocumentNotFoundError(error_msg) ++ + document.classification = classification + + await self.session.commit() + await self.session.refresh(document) + +- return document +- + except SQLAlchemyError as e: ++ error_msg = f"Failed to update classification for {file_name}" + raise DocumentUpdateError( +- f"Failed to update classification for {file_name}", original_error=e +- ) ++ error_msg, ++ original_error=e, ++ ) from e ++ ++ else: ++ return document + + async def update_summary(self, file_name: str, summary: str) -> Document: + """Update document summary.""" + try: +- document = await self.get_by_filename(file_name) ++ document = await self.get_by_filename( ++ file_name, ++ return_bool=False, ++ ) ++ if not isinstance(document, Document): ++ error_msg = f"Document {file_name} not found" ++ raise DocumentNotFoundError(error_msg) ++ + document.summary = summary + + await self.session.commit() + await self.session.refresh(document) + +- return document +- + except SQLAlchemyError as e: ++ error_msg = f"Failed to update summary for {file_name}" + raise DocumentUpdateError( +- f"Failed to update summary for {file_name}", original_error=e +- ) ++ error_msg, ++ original_error=e, ++ ) from e ++ ++ else: ++ return document + + async def delete(self, document_id: int) -> None: + """Delete document by ID.""" +@@ -136,6 +182,8 @@ class DocumentRepository: + await self.session.commit() + + except SQLAlchemyError as e: ++ error_msg = f"Failed to delete document {document_id}" + raise DocumentError( +- f"Failed to delete document {document_id}", original_error=e +- ) ++ error_msg, ++ original_error=e, ++ ) from e +diff --git a/src/database/schemas.py b/src/database/schemas.py +index 4a90c39..c32a171 100644 +--- a/src/database/schemas.py ++++ b/src/database/schemas.py +@@ -1,5 +1,6 @@ ++from __future__ import annotations ++ + from datetime import datetime +-from typing import Optional + + from pydantic import BaseModel, Field + +@@ -10,25 +11,25 @@ class DocumentBase(BaseModel): + file_name: str = Field(..., description="Name of the document file") + file_path: str = Field(..., description="Path to the document file") + created_at: datetime = Field( +- default_factory=datetime.utcnow, description="Document creation timestamp" ++ default_factory=datetime.utcnow, ++ description="Document creation timestamp", + ) +- classification: Optional[str] = Field( +- None, description="Document classification category" ++ classification: str | None = Field( ++ None, ++ description="Document classification category", + ) +- summary: Optional[str] = Field(None, description="Document summary text") ++ summary: str | None = Field(None, description="Document summary text") + + + class DocumentCreate(DocumentBase): + """Schema for creating a new document.""" + +- pass +- + + class DocumentUpdate(BaseModel): + """Schema for updating document attributes.""" + +- classification: Optional[str] = None +- summary: Optional[str] = None ++ classification: str | None = None ++ summary: str | None = None + + + class DocumentResponse(DocumentBase): +diff --git a/src/ocr/__init__.py b/src/ocr/__init__.py +new file mode 100644 +index 0000000..705c02d +--- /dev/null ++++ b/src/ocr/__init__.py +@@ -0,0 +1 @@ ++# src/ocr/__init__.py +diff --git a/src/ocr/optimized_ocr.py b/src/ocr/easy_ocr_wrapper.py +similarity index 85% +rename from src/ocr/optimized_ocr.py +rename to src/ocr/easy_ocr_wrapper.py +index 757b3f1..2c55582 100644 +--- a/src/ocr/optimized_ocr.py ++++ b/src/ocr/easy_ocr_wrapper.py +@@ -7,13 +7,20 @@ from numpy.typing import NDArray + from PIL import Image + + from configs.ocr_config import OCRConfig +-from payload.ocr_models import OCRResponse, OCRResult ++from payload.ocr_models import OCRResponse ++from payload.shared_models import OCRResult + + + class ImagePreprocessor: + """Handle image preprocessing operations.""" + + def __init__(self, target_size: int) -> None: ++ """Initialize the image preprocessor. ++ ++ Args: ++ target_size: Maximum dimension size to resize images to ++ ++ """ + self.target_size = target_size + self._clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) + +@@ -24,15 +31,15 @@ class ImagePreprocessor: + + width, height = image.size + scale = min(self.target_size / width, self.target_size / height) +- new_size = tuple(int(dim * scale) for dim in (width, height)) ++ new_size = (int(width * scale), int(height * scale)) + + return image.resize(new_size, resample=Image.Resampling.LANCZOS) + + def enhance_image(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]: + """Apply image enhancement techniques.""" + enhanced = self._clahe.apply(image) +- +- return cv2.fastNlMeansDenoising(enhanced) ++ denoised = cv2.fastNlMeansDenoising(enhanced) ++ return np.array(denoised, dtype=np.uint8) + + def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: + """Complete image preprocessing pipeline.""" +@@ -45,7 +52,7 @@ class ImagePreprocessor: + return self.enhance_image(image_array) + + +-class OptimizedOCR: ++class EasyOCRWrapper: + """Optimized OCR processing with performance enhancements.""" + + def __init__(self, config: OCRConfig) -> None: +@@ -83,11 +90,12 @@ class OptimizedOCR: + for bbox, word, _ in results + ] + except Exception as e: +- logging.error("Error processing image: %s", str(e)) ++ logging.exception("Error processing image: %s", str(e)) + return [] + + def process_batch( +- self, images: list[Image.Image] ++ self, ++ images: list[Image.Image], + ) -> tuple[OCRResponse, list[Image.Image]]: + """Process multiple images in optimized batch.""" + processed = [self.preprocessor.preprocess(image) for image in images] +diff --git a/src/ocr/ocr.py b/src/ocr/ocr.py +index 8f6fe17..cfec679 100644 +--- a/src/ocr/ocr.py ++++ b/src/ocr/ocr.py +@@ -1,23 +1,40 @@ ++from __future__ import annotations ++ + import base64 + import io + import logging + from datetime import datetime + from pathlib import Path +-from typing import AsyncGenerator, Optional ++from typing import TYPE_CHECKING + + import aiofiles +-import requests +-from fastapi import Depends, FastAPI, HTTPException, UploadFile, status ++import aiohttp ++from fastapi import ( ++ Depends, ++ FastAPI, ++ HTTPException, ++ UploadFile, ++ status, ++) + from pdf2image import convert_from_bytes + from pdf2image.exceptions import PDFPageCountError + from PIL import Image +-from tesseract import TesseractOCR ++from tesseract_wrapper import TesseractWrapper + + from configs.ocr_config import OCRConfig +-from database import DocumentCreate, DocumentError, DocumentRepository, get_repository +-from database.models import Document ++from database import ( ++ DocumentCreate, ++ DocumentError, ++ DocumentRepository, ++ get_repository, ++) + from utils.utils import get_unique_filename + ++if TYPE_CHECKING: ++ from collections.abc import AsyncGenerator ++ ++ from database.models import Document ++ + config = OCRConfig() + config.LOG_DIR.mkdir(parents=True, exist_ok=True) + config.UPLOAD_DIR.mkdir(parents=True, exist_ok=True) +@@ -29,7 +46,8 @@ logging.basicConfig( + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" ++ config.LOG_DIR / f"{datetime.now(tz=datetime.UTC):%Y-%m-%d}.log", ++ mode="a", + ), + logging.StreamHandler(), + ], +@@ -38,25 +56,39 @@ logging.basicConfig( + logger = logging.getLogger(__name__) + + app = FastAPI() +-# optimizer = OptimizedOCR(config=config) +-optimizer = TesseractOCR(config=config) ++# optimizer = EasyOCRWrapper(config=config) ++optimizer = TesseractWrapper(config=config) + + + class OCRProcessor: + """Handle OCR processing operations.""" + +- def __init__(self, document_repository: DocumentRepository): ++ def __init__(self, document_repository: DocumentRepository) -> None: + """Initialize OCR processor with repository.""" + self.repository = document_repository + +- async def validate_file(self, file: UploadFile) -> Optional[str]: ++ async def validate_file(self, file: UploadFile) -> str: + """Validate uploaded file against constraints.""" + logger.info("Validating file: %s", file.filename) ++ if not file.filename: ++ raise HTTPException( ++ status_code=status.HTTP_400_BAD_REQUEST, ++ detail="Filename is required", ++ ) + new_filename = file.filename + +- if await self.repository.get_by_filename(file.filename, return_bool=True): +- logger.info("File already exists: %s, making it unique", file.filename) +- new_filename = await get_unique_filename(file.filename, self.repository) ++ if await self.repository.get_by_filename( ++ file.filename, ++ return_bool=True, ++ ): ++ logger.info( ++ "File already exists: %s, making it unique", ++ file.filename, ++ ) ++ new_filename = await get_unique_filename( ++ file.filename, ++ self.repository, ++ ) + logger.info("New unique filename: %s", new_filename) + + if file.content_type not in config.ACCEPTED_FILE_TYPES: +@@ -66,6 +98,12 @@ class OCRProcessor: + detail="Unsupported file type", + ) + ++ if not file.size: ++ raise HTTPException( ++ status_code=status.HTTP_400_BAD_REQUEST, ++ detail="Empty file", ++ ) ++ + if file.size > config.FILE_SIZE_LIMIT: + logger.error("File size too large: %s bytes", file.size) + raise HTTPException( +@@ -82,12 +120,12 @@ class OCRProcessor: + status_code=status.HTTP_400_BAD_REQUEST, + detail=f"PDF exceeds {config.MAX_PDF_PAGES} pages", + ) +- except PDFPageCountError as e: +- logger.error("PDF processing error: %s", str(e)) ++ except PDFPageCountError as err: ++ logger.exception("PDF processing error") + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Invalid or corrupted PDF file", +- ) from e ++ ) from err + finally: + file.file.seek(0) + +@@ -109,11 +147,12 @@ class OCRProcessor: + encoded_images = [] + + for img in images: +- if img.mode in ("RGBA", "P"): +- img = img.convert("RGB") ++ converted_img = img ++ if converted_img.mode in ("RGBA", "P"): ++ converted_img = converted_img.convert("RGB") + + with io.BytesIO() as buffer: +- img.save(buffer, format="JPEG") ++ converted_img.save(buffer, format="JPEG") + img_byte_arr = buffer.getvalue() + + encoded = base64.b64encode(img_byte_arr).decode("utf-8") +@@ -124,31 +163,34 @@ class OCRProcessor: + async def save_document(self, file_name: str) -> Document: + """Save document metadata to database.""" + try: +- document = await self.repository.create( ++ return await self.repository.create( + DocumentCreate( + file_name=file_name, + file_path=str(config.UPLOAD_DIR / file_name), +- ) ++ classification="", ++ summary="", ++ ), + ) +- return document +- except DocumentError as e: +- logger.error("Failed to save document: %s", str(e)) ++ except DocumentError as err: ++ logger.exception("Failed to save document") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Failed to save document", +- ) from e ++ ) from err + + + @app.get("/documents") + async def get_docs( +- repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), ++ repository: AsyncGenerator[DocumentRepository, None] = Depends( ++ get_repository, ++ ), + ) -> list[dict]: + """Get all documents.""" + try: + documents = await repository.get_all() + return [doc.to_dict() for doc in documents] + except DocumentError as e: +- logger.error("Failed to retrieve documents: %s", str(e)) ++ logger.exception("Failed to retrieve documents: %s", str(e)) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Failed to retrieve documents", +@@ -158,7 +200,9 @@ async def get_docs( + @app.post("/ocr") + async def process_document( + file: UploadFile, +- repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), ++ repository: AsyncGenerator[DocumentRepository, None] = Depends( ++ get_repository, ++ ), + ) -> dict[str, str]: + """Process document for OCR and forward results.""" + logger.info("Processing document: %s", file.filename) +@@ -194,54 +238,55 @@ async def process_document( + + # Forward to processor service + try: +- response = requests.post( +- config.PROCESSOR_URL, +- json={ +- "ocr_result": ocr_response.model_dump(exclude={"page_count"})[ +- "results" +- ], +- "images": encoded_images, +- "file_name": file.filename, +- }, +- timeout=300, +- ) +- +- # If processor request fails, raises HTTPException +- response.raise_for_status() +- +- return response.json() +- +- except (requests.RequestException, HTTPException) as e: ++ timeout = aiohttp.ClientTimeout(total=480) ++ async with ( ++ aiohttp.ClientSession() as session, ++ session.post( ++ config.PROCESSOR_URL, ++ json={ ++ "ocr_result": ocr_response.model_dump( ++ exclude={"page_count"}, ++ )["results"], ++ "images": encoded_images, ++ "file_name": file.filename, ++ }, ++ timeout=timeout, ++ ) as response, ++ ): ++ response.raise_for_status() ++ return await response.json() ++ ++ except (aiohttp.ClientError, HTTPException) as e: + await cleanup(repository, document_id, output_file) +- logger.error("Downstream processing failed: %s", str(e)) ++ logger.exception("Downstream processing failed") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Document processing failed in downstream service", +- ) ++ ) from e + + except Exception as e: + await cleanup(repository, document_id, output_file) +- logger.error("Processing error: %s", str(e)) ++ logger.exception("Processing error") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Document processing failed", +- ) ++ ) from e + + + async def cleanup( + repository: DocumentRepository, +- document_id: Optional[int], +- output_file: Optional[Path], ++ document_id: int | None, ++ output_file: Path | None, + ) -> None: + """Clean up resources on error.""" + if document_id: + try: + await repository.delete(document_id) + except DocumentError as e: +- logger.error("Failed to delete document: %s", str(e)) ++ logger.exception("Failed to delete document: %s", str(e)) + + if output_file and output_file.exists(): + try: + output_file.unlink() + except OSError as e: +- logger.error("Failed to delete file: %s", str(e)) ++ logger.exception("Failed to delete file: %s", str(e)) +diff --git a/src/ocr/tesseract.py b/src/ocr/tesseract_wrapper.py +similarity index 72% +rename from src/ocr/tesseract.py +rename to src/ocr/tesseract_wrapper.py +index 35ca7fd..43c347a 100644 +--- a/src/ocr/tesseract.py ++++ b/src/ocr/tesseract_wrapper.py +@@ -1,19 +1,32 @@ ++from __future__ import annotations ++ + import logging ++from typing import TYPE_CHECKING + + import cv2 + import numpy as np + import pytesseract +-from numpy.typing import NDArray + from PIL import Image + +-from configs.ocr_config import OCRConfig +-from payload.ocr_models import OCRResponse, OCRResult ++from payload.ocr_models import OCRResponse ++from payload.shared_models import OCRResult ++ ++if TYPE_CHECKING: ++ from numpy.typing import NDArray ++ ++ from configs.ocr_config import OCRConfig + + + class ImagePreprocessor: + """Handle image preprocessing operations.""" + + def __init__(self, target_size: int) -> None: ++ """Initialize image preprocessor. ++ ++ Args: ++ target_size: Maximum size for image dimension. ++ ++ """ + self.target_size = target_size + self._clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) + +@@ -24,15 +37,19 @@ class ImagePreprocessor: + + width, height = image.size + scale = min(self.target_size / width, self.target_size / height) +- new_size = tuple(int(dim * scale) for dim in (width, height)) ++ new_size = (int(width * scale), int(height * scale)) + + return image.resize(new_size, resample=Image.Resampling.LANCZOS) + + def enhance_image(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]: + """Apply image enhancement techniques.""" + # Convert to grayscale if not already +- if len(image.shape) == 3: +- image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) ++ CHANNELS_RGB = 3 ++ if len(image.shape) == CHANNELS_RGB: ++ image = np.asarray( ++ cv2.cvtColor(image, cv2.COLOR_RGB2GRAY), ++ dtype=np.uint8, ++ ) + + # Apply CLAHE for contrast enhancement + enhanced = self._clahe.apply(image) +@@ -41,9 +58,14 @@ class ImagePreprocessor: + denoised = cv2.fastNlMeansDenoising(enhanced) + + # Binarization using Otsu's method +- _, binary = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) ++ _, binary = cv2.threshold( ++ denoised, ++ 0, ++ 255, ++ cv2.THRESH_BINARY + cv2.THRESH_OTSU, ++ ) + +- return binary ++ return np.asarray(binary, dtype=np.uint8) + + def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: + """Complete image preprocessing pipeline.""" +@@ -57,7 +79,7 @@ class ImagePreprocessor: + return self.enhance_image(image_array) + + +-class TesseractOCR: ++class TesseractWrapper: + """OCR processing with Tesseract.""" + + def __init__(self, config: OCRConfig) -> None: +@@ -79,28 +101,33 @@ class TesseractOCR: + + Returns: + list[int]: Standardized bounding box [x_min, y_min, x_max, y_max] ++ + """ + if isinstance(bbox_data, tuple) and len(bbox_data) == 4: + # Handle Tesseract format (x, y, width, height) + x, y, w, h = bbox_data + return [int(x), int(y), int(x + w), int(y + h)] +- else: +- # Handle original format (list of coordinate tuples) +- xs, ys = zip(*bbox_data) +- return [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))] ++ # Handle original format (list of coordinate tuples) ++ xs, ys = zip(*bbox_data) ++ return [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))] + + def _process_single(self, image: NDArray[np.uint8]) -> list[OCRResult]: + """Process a single image with Tesseract.""" + try: + results = pytesseract.image_to_data( +- image, output_type=pytesseract.Output.DICT, config=self.custom_config ++ image, ++ output_type=pytesseract.Output.DICT, ++ config=self.custom_config, + ) + + ocr_results = [] + n_boxes = len(results["text"]) + + for i in range(n_boxes): +- if int(results["conf"][i]) < 0 or not results["text"][i].strip(): ++ if ( ++ int(results["conf"][i]) < 0 ++ or not results["text"][i].strip() ++ ): + continue + + # Create bbox_data tuple for compatibility +@@ -110,21 +137,26 @@ class TesseractOCR: + results["top"][i], + results["width"][i], + results["height"][i], +- ) ++ ), + ) + + ocr_results.append( +- OCRResult(bounding_box=bbox, word=results["text"][i].strip()) ++ OCRResult( ++ bounding_box=bbox, ++ word=results["text"][i].strip(), ++ ), + ) + +- return ocr_results +- + except Exception as e: +- logging.error("Error processing image: %s", str(e)) ++ logging.exception("Error processing image: %s", str(e)) + return [] + ++ else: ++ return ocr_results ++ + def process_batch( +- self, images: list[Image.Image] ++ self, ++ images: list[Image.Image], + ) -> tuple[OCRResponse, list[Image.Image]]: + """Process multiple images in optimized batch.""" + # Preprocess all images +diff --git a/src/payload/model_models.py b/src/payload/model_models.py +deleted file mode 100644 +index eab2f64..0000000 +--- a/src/payload/model_models.py ++++ /dev/null +@@ -1,39 +0,0 @@ +-from dataclasses import dataclass +- +-import torch +-from pydantic import BaseModel, ConfigDict +- +- +-@dataclass +-class PagePrediction: +- """Stores prediction results for a single page.""" +- +- page_number: int +- logits: torch.Tensor +- confidence: float +- predicted_class: str +- text_length: int +- +- +-class ProcessorResult(BaseModel): +- """Result data for document processing.""" +- +- input_ids: list +- attention_mask: list +- bbox: list +- pixel_values: list +- file_name: str +- text: str +- +- model_config = ConfigDict( +- arbitrary_types_allowed=True, +- json_schema_extra={ +- "example": { +- "input_ids": [[1, 2, 3, 4, 5]], +- "attention_mask": [[1, 1, 1, 1, 1]], +- "bbox": [[0, 0, 100, 50]], +- "pixel_values": [[0, 0, 0, 255, 255, 255]], +- "file_name": "example.pdf", +- } +- }, +- ) +diff --git a/src/payload/ocr_models.py b/src/payload/ocr_models.py +index a127e8d..59ca23c 100644 +--- a/src/payload/ocr_models.py ++++ b/src/payload/ocr_models.py +@@ -1,33 +1,14 @@ + from pydantic import BaseModel, ConfigDict, Field + +- +-class OCRResult(BaseModel): +- """Structured OCR result using Pydantic BaseModel.""" +- +- bounding_box: list[int] = Field( +- ..., +- description="Coordinates of bounding box [x_min, y_min, x_max, y_max]", +- min_items=4, +- max_items=4, +- ) +- word: str = Field(..., description="Recognized text") +- +- model_config = ConfigDict( +- frozen=True, +- json_schema_extra={ +- "example": { +- "bounding_box": [100, 100, 200, 150], +- "word": "Example", +- } +- }, +- ) ++from .shared_models import OCRResult + + + class OCRResponse(BaseModel): + """Response model for OCR processing.""" + + results: list[list[OCRResult]] = Field( +- ..., description="list of OCR results from the document" ++ ..., ++ description="list of OCR results from the document", + ) + + page_count: int = Field(1, description="Number of pages processed", ge=1) +diff --git a/src/payload/predictor_models.py b/src/payload/predictor_models.py +new file mode 100644 +index 0000000..022c6c7 +--- /dev/null ++++ b/src/payload/predictor_models.py +@@ -0,0 +1,14 @@ ++from dataclasses import dataclass ++ ++import torch ++ ++ ++@dataclass ++class PagePrediction: ++ """Stores prediction results for a single page.""" ++ ++ page_number: int ++ logits: torch.Tensor ++ confidence: float ++ predicted_class: str ++ text_length: int +diff --git a/src/payload/processor_models.py b/src/payload/processor_models.py +index c0e8b3e..7751e02 100644 +--- a/src/payload/processor_models.py ++++ b/src/payload/processor_models.py +@@ -1,38 +1,6 @@ +-import torch + from pydantic import BaseModel, ConfigDict, Field + +- +-class BoundingBox(BaseModel): +- """Represents a bounding box for OCR results.""" +- +- coordinates: list[int] = Field( +- ..., +- min_items=4, +- max_items=4, +- description="Coordinates in format [x_min, y_min, x_max, y_max]", +- ) +- +- +-class OCRResult(BaseModel): +- """Structured OCR result using Pydantic BaseModel.""" +- +- bounding_box: list[int] = Field( +- ..., +- description="Coordinates of bounding box [x_min, y_min, x_max, y_max]", +- min_items=4, +- max_items=4, +- ) +- word: str = Field(..., description="Recognized text") +- +- model_config = ConfigDict( +- frozen=True, +- json_schema_extra={ +- "example": { +- "bounding_box": [100, 100, 200, 150], +- "word": "Example", +- } +- }, +- ) ++from .shared_models import OCRResult + + + class ProcessorInput(BaseModel): +@@ -45,29 +13,30 @@ class ProcessorInput(BaseModel): + model_config = ConfigDict( + json_schema_extra={ + "example": { +- "ocr_result": [{"word": "Example", "bounding_box": [0, 0, 100, 50]}], ++ "ocr_result": [ ++ {"word": "Example", "bounding_box": [0, 0, 100, 50]}, ++ ], + "images": ["base64_encoded_image_string"], +- } +- } ++ }, ++ }, + ) + + +-class ProcessorResult(BaseModel): ++class ProcessorOutput(BaseModel): + """Result data for document processing.""" + +- input_ids: torch.Tensor +- attention_mask: torch.Tensor +- bbox: torch.Tensor +- pixel_values: torch.Tensor ++ input_ids: list ++ attention_mask: list ++ bbox: list ++ pixel_values: list + + model_config = ConfigDict( +- arbitrary_types_allowed=True, + json_schema_extra={ + "example": { + "input_ids": [[1, 2, 3, 4, 5]], + "attention_mask": [[1, 1, 1, 1, 1]], + "bbox": [[0, 0, 100, 50]], + "pixel_values": [[0, 0, 0, 255, 255, 255]], +- } ++ }, + }, + ) +diff --git a/src/payload/shared_models.py b/src/payload/shared_models.py +new file mode 100644 +index 0000000..0703db3 +--- /dev/null ++++ b/src/payload/shared_models.py +@@ -0,0 +1,51 @@ ++from __future__ import annotations ++ ++from pydantic import BaseModel, ConfigDict, Field ++ ++ ++class OCRResult(BaseModel): ++ """Structured OCR result using Pydantic BaseModel.""" ++ ++ bounding_box: list[int] = Field( ++ default=..., ++ min_length=4, ++ max_length=4, ++ description="Coordinates in format [x_min, y_min, x_max, y_max]", ++ ) ++ word: str = Field(..., description="Recognized text") ++ ++ model_config = ConfigDict( ++ frozen=True, ++ json_schema_extra={ ++ "example": { ++ "bounding_box": [100, 100, 200, 150], ++ "word": "Example", ++ }, ++ }, ++ ) ++ ++ ++class ProcessorResult(BaseModel): ++ """Result data for document processing.""" ++ ++ input_ids: list | None ++ attention_mask: list | None ++ bbox: list | None ++ pixel_values: list | None ++ file_name: str = Field(..., description="Name of the processed file") ++ text: str = Field(..., description="Text extracted from OCR") ++ language: str = Field(..., description="Detected language") ++ ++ model_config = ConfigDict( ++ json_schema_extra={ ++ "example": { ++ "input_ids": [[1, 2, 3, 4, 5]], ++ "attention_mask": [[1, 1, 1, 1, 1]], ++ "bbox": [[0, 0, 100, 50]], ++ "pixel_values": [[0, 0, 0, 255, 255, 255]], ++ "file_name": "example.pdf", ++ "text": "Example text", ++ "language": "en", ++ }, ++ }, ++ ) +diff --git a/src/payload/summarizer_models.py b/src/payload/summarizer_models.py +index b28419a..44f64d5 100644 +--- a/src/payload/summarizer_models.py ++++ b/src/payload/summarizer_models.py +@@ -1,5 +1,3 @@ +-# src/summarization/summarizer.py +- + from pydantic import BaseModel, Field + + +@@ -8,4 +6,13 @@ class SummarizationRequest(BaseModel): + + file_name: str = Field(..., description="Name of the file to summarize") + text: str = Field(..., description="Text content to summarize") +- classification: str = Field(..., description="Predicted classes for the text") ++ classification: str = Field( ++ ..., description="Predicted classes for the text" ++ ) ++ ++ ++class SummaryResponse(BaseModel): ++ """Structured response from the summarization model.""" ++ ++ summary: str = Field(..., description="Generated summary text") ++ word_count: int = Field(..., description="Number of words in summary") +diff --git a/src/predictor/layoutlm_wrapper.py b/src/predictor/layoutlm_wrapper.py +new file mode 100644 +index 0000000..58512f8 +--- /dev/null ++++ b/src/predictor/layoutlm_wrapper.py +@@ -0,0 +1,139 @@ ++import lightning.pytorch as pl ++import torch ++from torchmetrics import Accuracy ++from transformers import LayoutLMv3ForSequenceClassification ++ ++from configs.model_config import ModelConfig ++ ++ ++class LayoutLMV3Wrapper(pl.LightningModule): ++ """PyTorch Lightning module for document classification using LayoutLMv3.""" ++ ++ def __init__(self, config: ModelConfig) -> None: ++ """Initialize the model. ++ ++ Args: ++ n_classes: Number of document classes to predict ++ ++ """ ++ super().__init__() ++ self.n_classes = len(config.DOCUMENT_CLASSES) ++ self.model = LayoutLMv3ForSequenceClassification.from_pretrained( ++ "/app/data/models/layoutlmv3-base-finetuned-rvlcdip", ++ num_labels=self.n_classes, ++ use_safetensors=True, ++ ) ++ self.config = config ++ self.model.config.id2label = dict(enumerate(config.DOCUMENT_CLASSES)) ++ self.model.config.label2id = { ++ v: k for k, v in enumerate(config.DOCUMENT_CLASSES) ++ } ++ self.train_accuracy = Accuracy( ++ task="multiclass", ++ num_classes=self.n_classes, ++ ) ++ self.val_accuracy = Accuracy( ++ task="multiclass", ++ num_classes=self.n_classes, ++ ) ++ ++ def forward( ++ self, ++ input_ids: torch.Tensor, ++ attention_mask: torch.Tensor, ++ bbox: torch.Tensor, ++ pixel_values: torch.Tensor, ++ ) -> object: ++ """Forward pass through the model. ++ ++ Args: ++ input_ids: Input token IDs ++ attention_mask: Attention mask ++ bbox: Bounding box coordinates ++ pixel_values: Image pixel values ++ ++ Returns: ++ Model output containing logits and loss ++ ++ """ ++ return self.model( ++ input_ids, ++ attention_mask=attention_mask, ++ bbox=bbox, ++ pixel_values=pixel_values, ++ ) ++ ++ def training_step( ++ self, ++ batch: dict[str, torch.Tensor], ++ batch_idx: int, # noqa: ARG002 ++ ) -> torch.Tensor: ++ """Training step for one batch. ++ ++ Args: ++ batch: Dictionary containing batch data ++ batch_idx: Index of current batch (unused) ++ ++ Returns: ++ Training loss ++ ++ """ ++ input_ids = batch["input_ids"] ++ attention_mask = batch["attention_mask"] ++ bbox = batch["bbox"] ++ pixel_values = batch["pixel_values"] ++ labels = batch["labels"] ++ ++ output = self(input_ids, attention_mask, bbox, pixel_values, labels) ++ ++ self.log("train_loss", output.loss) ++ self.log( ++ "train_acc", ++ self.train_accuracy(output.logits, labels), ++ on_step=True, ++ on_epoch=True, ++ ) ++ ++ return output.loss ++ ++ def validation_step( ++ self, ++ batch: dict[str, torch.Tensor], ++ batch_idx: int, # noqa: ARG002 ++ ) -> torch.Tensor: ++ """Execute validation step for one batch. ++ ++ Args: ++ batch: Dictionary containing batch data ++ batch_idx: Index of current batch (unused) ++ ++ Returns: ++ Validation loss ++ ++ """ ++ input_ids = batch["input_ids"] ++ attention_mask = batch["attention_mask"] ++ bbox = batch["bbox"] ++ pixel_values = batch["pixel_values"] ++ labels = batch["labels"] ++ ++ output = self(input_ids, attention_mask, bbox, pixel_values, labels) ++ ++ self.log("val_loss", output.loss) ++ self.log( ++ "val_acc", ++ self.val_accuracy(output.logits, labels), ++ on_step=False, ++ on_epoch=True, ++ ) ++ ++ return output.loss ++ ++ def configure_optimizers(self) -> torch.optim.Optimizer: ++ """Configure optimizers for training. ++ ++ Returns: ++ Adam optimizer instance ++ ++ """ ++ return torch.optim.Adam(self.model.parameters(), lr=1e-5) +diff --git a/src/predictor/llm_model.py b/src/predictor/llm_model.py +new file mode 100644 +index 0000000..5a87484 +--- /dev/null ++++ b/src/predictor/llm_model.py +@@ -0,0 +1,352 @@ ++from __future__ import annotations ++ ++import json ++import logging ++import re ++from datetime import datetime ++from typing import Any, NotRequired, TypedDict ++ ++import aiohttp ++from fastapi import FastAPI, HTTPException ++from pydantic import BaseModel, Field ++ ++from configs.model_config import ModelConfig ++ ++config = ModelConfig() ++config.LOG_DIR.mkdir(parents=True, exist_ok=True) ++ ++logging.basicConfig( ++ level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, ++ format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", ++ datefmt="%Y-%m-%d %H:%M:%S", ++ handlers=[ ++ logging.FileHandler( ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", ++ ), ++ logging.StreamHandler(), ++ ], ++) ++ ++logger = logging.getLogger(__name__) ++app = FastAPI() ++ ++ ++class ClassificationResponse(BaseModel): ++ """Structured response from the classification model.""" ++ ++ class_label: str = Field(..., description="Predicted document class") ++ confidence: float = Field(..., description="Prediction confidence score") ++ ++ ++class OllamaOptions(TypedDict): ++ """Type definition for Ollama API options.""" ++ ++ temperature: float ++ top_p: float ++ frequency_penalty: float ++ presence_penalty: float ++ num_ctx: int ++ num_gpu: int ++ num_thread: int ++ ++ ++class OllamaRequest(TypedDict, total=False): ++ """Type definition for Ollama API request.""" ++ ++ model: str # required ++ prompt: str # required ++ format: NotRequired[str] ++ options: NotRequired[OllamaOptions] ++ system: NotRequired[str] ++ stream: NotRequired[bool] ++ raw: NotRequired[bool] ++ keep_alive: NotRequired[str | int] ++ ++ ++class LLMModelWrapper: ++ """Document classification using direct Ollama integration.""" ++ ++ CLASSIFICATION_SYSTEM_PROMPT = """You are a document classification expert tasked with precise analysis. ++ Core Requirements: ++ 1. Analyze text provided in {language} ++ 2. Classify into categories: {categories} ++ 3. Output JSON format: {{"class_label": "category", "confidence": number}} ++ ++ Guidelines: ++ - Evaluate based on content, style, terminology and format ++ - Look for distinctive markers and key phrases ++ - Consider document structure and formatting patterns ++ - Maintain consistent standards across documents ++ - Use confidence scores that realistically reflect certainty ++ - Confidence range: 0-100 ++ - Return clean JSON only, no other text""" ++ ++ CLASSIFICATION_PROMPT = """Task Analysis: ++ You are examining a document in {language} to determine its category from: {categories} ++ ++ Document Classification Guidelines: ++ 1. Analyze these key aspects: ++ - Subject matter and main themes ++ - Technical terminology usage ++ - Writing style and tone ++ - Document structure and sections ++ - Target audience indicators ++ - Domain-specific formatting ++ ++ 2. Evidence Collection: ++ - Identify definitive category markers ++ - Note absence of expected features ++ - Compare against typical examples ++ - Check for mixed/ambiguous signals ++ - Evaluate consistency throughout ++ ++ 3. Confidence Scoring: ++ - 90-100: Unambiguous match with strong indicators ++ - 70-89: Clear match with some uncertainty ++ - 50-69: Probable match with mixed signals ++ - Below 50: Significant uncertainty ++ ++ Input Document: ++ {text} ++ ++ Required Response Format: ++ - Pure JSON object ++ - Must include class_label and confidence ++ - Example: {{"class_label": "example_category", "confidence": 85}} ++ - No explanatory text outside JSON ++ ++ Respond with classification:""" ++ ++ def __init__(self, config: ModelConfig) -> None: ++ """Initialize classifier with configuration.""" ++ self.config = config ++ self.base_url = f"{config.OLLAMA_BASE_URL}/api/generate" ++ ++ def _prepare_request( ++ self, ++ text: str, ++ language: str, ++ ) -> OllamaRequest: ++ """Prepare the request payload for Ollama API.""" ++ system_prompt = self.CLASSIFICATION_SYSTEM_PROMPT.format( ++ language=language, ++ categories=self.config.DOCUMENT_CLASSES, ++ ) ++ ++ user_prompt = self.CLASSIFICATION_PROMPT.format( ++ text=text, ++ language=language, ++ categories=self.config.DOCUMENT_CLASSES, ++ ) ++ ++ return { ++ "model": self.config.MODEL_NAME, ++ "prompt": user_prompt, ++ "system": system_prompt, ++ "format": "json", ++ "stream": False, ++ "options": { ++ "temperature": self.config.TEMPERATURE, ++ "top_p": self.config.TOP_P, ++ "frequency_penalty": self.config.FREQUENCY_PENALTY, ++ "presence_penalty": self.config.PRESENCE_PENALTY, ++ "num_ctx": self.config.NUM_CTX, ++ "num_gpu": self.config.NUM_GPU, ++ "num_thread": self.config.NUM_THREAD, ++ }, ++ "keep_alive": "15m", ++ } ++ ++ def _process_raw_response(self, content: str) -> ClassificationResponse: ++ """Process raw response when JSON parsing fails. ++ ++ Args: ++ content: Raw response content from the model ++ ++ Returns: ++ Structured classification response ++ ++ Raises: ++ ValueError: If unable to extract valid classification ++ ++ """ ++ # Remove any potential markdown code blocks ++ content = re.sub(r"```json\s*|\s*```", "", content) ++ ++ # Try to find class and confidence using regex ++ class_match = re.search( ++ r"class_label[\"']?\s*:\s*[\"']([^\"']+)[\"']", ++ content, ++ ) ++ conf_match = re.search( ++ r"confidence[\"']?\s*:\s*(0?\.\d+|1\.0?|1|0)", ++ content, ++ ) ++ ++ if not (class_match and conf_match): ++ raise ValueError( ++ "Unable to extract valid classification from response", ++ ) ++ ++ class_label = class_match.group(1) ++ confidence = float(conf_match.group(1)) ++ ++ if class_label not in self.config.DOCUMENT_CLASSES: ++ raise ValueError(f"Invalid class label: {class_label}") ++ ++ if not 0 <= confidence <= 100: ++ logger.warning( ++ "Invalid confidence score: %s, calculating...", ++ confidence, ++ ) ++ confidence = min(100, confidence) ++ ++ return ClassificationResponse( ++ class_label=class_label, ++ confidence=confidence, ++ ) ++ ++ def _validate_classification_response( ++ self, ++ response_data: dict[str, Any], ++ ) -> ClassificationResponse: ++ """Validate and process the classification response. ++ ++ Args: ++ response_data: Parsed JSON response ++ ++ Returns: ++ Validated classification response ++ ++ Raises: ++ ValueError: If response doesn't meet requirements ++ ++ """ ++ if not isinstance(response_data, dict): ++ raise ValueError("Response must be a JSON object") ++ ++ if ( ++ "class_label" not in response_data ++ or "confidence" not in response_data ++ ): ++ raise ValueError( ++ 'Response must contain "class_label" and "confidence" fields', ++ ) ++ ++ class_label = response_data["class_label"] ++ confidence = response_data["confidence"] ++ ++ if not isinstance(class_label, str) or not isinstance( ++ confidence, ++ (int, float), ++ ): ++ raise ValueError("Invalid field types in response") ++ ++ if class_label not in self.config.DOCUMENT_CLASSES: ++ raise ValueError(f"Invalid class label: {class_label}") ++ ++ if not 0 <= confidence <= 100: ++ logger.warning( ++ "Invalid confidence score: %s, calculating...", ++ confidence, ++ ) ++ confidence = min(100, confidence) ++ ++ return ClassificationResponse( ++ class_label=class_label, ++ confidence=float(confidence), ++ ) ++ ++ async def predict_class( ++ self, ++ text: str, ++ language: str, ++ ) -> str: ++ """Predict document class using the LLM model. ++ ++ Args: ++ text: Document text to classify ++ language: Language of the document ++ ++ Returns: ++ Predicted document class in format "class_label|confidence" ++ ++ Raises: ++ HTTPException: If classification fails ++ ++ """ ++ ++ def _raise_invalid_response(): ++ msg = "Invalid response format from Ollama" ++ raise ValueError(msg) ++ ++ def _raise_empty_response(): ++ msg = "Empty response from Ollama" ++ raise ValueError(msg) ++ ++ try: ++ request_data = self._prepare_request(text, language) ++ ++ timeout = aiohttp.ClientTimeout(total=300) ++ async with ( ++ aiohttp.ClientSession(timeout=timeout) as session, ++ session.post( ++ self.base_url, ++ json=request_data, ++ ) as response, ++ ): ++ response.raise_for_status() ++ result = await response.json() ++ ++ if not isinstance(result, dict) or "response" not in result: ++ _raise_invalid_response() ++ ++ content = result["response"].strip() ++ if not content: ++ _raise_empty_response() ++ ++ try: ++ # Try to parse as JSON first ++ response_data = json.loads(content) ++ classification = self._validate_classification_response( ++ response_data, ++ ) ++ except (json.JSONDecodeError, ValueError) as e: ++ logger.warning( ++ "Failed to parse JSON response, falling back to raw " ++ "processing: %s", ++ str(e), ++ ) ++ # Fall back to raw response processing ++ classification = self._process_raw_response(content) ++ ++ # Return in the expected format "class_label|confidence" ++ return ( ++ f"{classification.class_label}|{classification.confidence}" ++ ) ++ ++ except aiohttp.ClientError as e: ++ logger.exception("Ollama API communication error") ++ raise HTTPException( ++ status_code=500, ++ detail=f"Failed to communicate with Ollama: {e!s}", ++ ) from e ++ ++ except ValueError as e: ++ logger.exception("Invalid response format from Ollama") ++ raise HTTPException( ++ status_code=500, ++ detail=str(e), ++ ) from e ++ ++ except Exception as e: ++ logger.exception("Classification failed") ++ raise HTTPException( ++ status_code=500, ++ detail=f"Classification failed: {e!s}", ++ ) from e ++ ++ ++# Create model instance ++llm_model = LLMModelWrapper(config) +diff --git a/src/predictor/model.py b/src/predictor/model.py +deleted file mode 100644 +index 20c69a3..0000000 +--- a/src/predictor/model.py ++++ /dev/null +@@ -1,264 +0,0 @@ +-import logging +-from datetime import datetime +-from typing import Any, AsyncGenerator +- +-import lightning.pytorch as pl +-import requests +-import torch +-import torch.nn.functional as F +-from fastapi import Depends, FastAPI, HTTPException +-from torchmetrics import Accuracy +-from transformers import LayoutLMv3ForSequenceClassification, PreTrainedModel +- +-from configs.model_config import ModelConfig +-from database import DocumentError, DocumentRepository, get_repository +-from payload.model_models import PagePrediction, ProcessorResult +- +-config = ModelConfig() +-config.LOG_DIR.mkdir(parents=True, exist_ok=True) +- +-logging.basicConfig( +- level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, +- format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", +- datefmt="%Y-%m-%d %H:%M:%S", +- handlers=[ +- logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" +- ), +- logging.StreamHandler(), +- ], +-) +- +-logger = logging.getLogger(__name__) +- +-app = FastAPI() +- +- +-class ModelModule(pl.LightningModule): +- def __init__(self, n_classes: int = 15): +- super().__init__() +- self.model = LayoutLMv3ForSequenceClassification.from_pretrained( +- "/app/data/models/layoutlmv3-base-finetuned-rvlcdip", +- num_labels=n_classes, +- use_safetensors=True, +- ) +- self.model.config.id2label = { +- k: v for k, v in enumerate(config.DOCUMENT_CLASSES) +- } +- self.model.config.label2id = { +- v: k for k, v in enumerate(config.DOCUMENT_CLASSES) +- } +- self.train_accuracy = Accuracy(task="multiclass", num_classes=n_classes) +- self.val_accuracy = Accuracy(task="multiclass", num_classes=n_classes) +- +- def forward(self, input_ids, attention_mask, bbox, pixel_values): +- return self.model( +- input_ids, +- attention_mask=attention_mask, +- bbox=bbox, +- pixel_values=pixel_values, +- ) +- +- def training_step(self, batch, batch_idx): +- input_ids = batch["input_ids"] +- attention_mask = batch["attention_mask"] +- bbox = batch["bbox"] +- pixel_values = batch["pixel_values"] +- labels = batch["labels"] +- +- output = self(input_ids, attention_mask, bbox, pixel_values, labels) +- +- self.log("train_loss", output.loss) +- self.log( +- "train_acc", +- self.train_accuracy(output.logits, labels), +- on_step=True, +- on_epoch=True, +- ) +- +- return output.loss +- +- def validation_step(self, batch, batch_idx): +- input_ids = batch["input_ids"] +- attention_mask = batch["attention_mask"] +- bbox = batch["bbox"] +- pixel_values = batch["pixel_values"] +- labels = batch["labels"] +- +- output = self(input_ids, attention_mask, bbox, pixel_values, labels) +- +- self.log("val_loss", output.loss) +- self.log( +- "val_acc", +- self.val_accuracy(output.logits, labels), +- on_step=False, +- on_epoch=True, +- ) +- +- return output.loss +- +- def configure_optimizers(self): +- optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-5) +- return optimizer +- +- +-model = ModelModule(n_classes=len(config.DOCUMENT_CLASSES)) +-model.eval() +- +- +-def _calculate_page_weights(page_predictions: list[PagePrediction]) -> torch.Tensor: +- """Calculate weights for each page based on multiple factors. +- +- Args: +- page_predictions: List of predictions for each page +- +- Returns: +- Tensor of normalized weights for each page +- """ +- text_lengths = torch.tensor([pred.text_length for pred in page_predictions]) +- confidences = torch.tensor([pred.confidence for pred in page_predictions]) +- +- if text_lengths.max() > 0: +- normalized_lengths = text_lengths / text_lengths.max() +- else: +- normalized_lengths = torch.ones_like(text_lengths) +- +- weights = (normalized_lengths * confidences) + 1e-6 +- +- for i, (raw_weight, length, conf) in enumerate( +- zip(weights, text_lengths, confidences) +- ): +- logger.debug( +- f"Page {i+1} pre-normalization: " +- f"weight={raw_weight:.4f}, " +- f"text_length={length}, " +- f"confidence={conf:.4f}" +- ) +- +- temperature = 1.0 +- normalized_weights = F.softmax(weights / temperature, dim=0) +- +- for i, weight in enumerate(normalized_weights): +- logger.debug(f"Page {i+1} final weight: {weight:.4f}") +- +- return normalized_weights +- +- +-def aggregate_predictions( +- model: PreTrainedModel, page_predictions: list[PagePrediction] +-) -> dict[str, Any]: +- """Aggregate predictions from multiple pages using weighted voting. +- +- Args: +- page_predictions: List of predictions for each page +- +- Returns: +- Dictionary containing final classification results +- """ +- if not page_predictions: +- raise ValueError("No valid predictions to aggregate") +- +- weights = _calculate_page_weights(page_predictions) +- +- stacked_logits = torch.stack([pred.logits for pred in page_predictions]) +- weighted_logits = (stacked_logits * weights.unsqueeze(-1)).sum(dim=0) +- +- probabilities = F.softmax(weighted_logits, dim=-1) +- confidence, predicted_class = torch.max(probabilities, dim=-1) +- +- return { +- "predicted_class": model.config.id2label[predicted_class.item()], +- "confidence": confidence.item(), +- "page_predictions": [ +- { +- "page": pred.page_number, +- "class": pred.predicted_class, +- "confidence": pred.confidence, +- "weight": weight.item(), +- } +- for pred, weight in zip(page_predictions, weights) +- ], +- "probability_distribution": { +- model.config.id2label[i]: prob.item() +- for i, prob in enumerate(probabilities) +- }, +- } +- +- +-@app.post("/predict-class") +-async def predict( +- data: ProcessorResult, +- repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), +-) -> dict[str, str]: +- """ +- Predict document class from processed data. +- +- Args: +- data: Processed data from document processor +- repository: Document repository instance +- """ +- +- try: +- logger.info("Received data for prediction") +- input_ids = torch.tensor(data.input_ids) +- attention_mask = torch.tensor(data.attention_mask) +- bbox = torch.tensor(data.bbox) +- pixel_values = torch.tensor(data.pixel_values) +- +- with torch.inference_mode(): +- output = model(input_ids, attention_mask, bbox, pixel_values) +- +- probabilities = F.softmax(output.logits, dim=-1) +- confidence, predicted_class = torch.max(probabilities, dim=-1) +- +- predictions = [] +- for i in range(output.logits.size(0)): +- pred_class = predicted_class[i].item() +- conf = confidence[i].item() +- text_length = torch.sum(attention_mask[i]).item() +- +- predictions.append( +- PagePrediction( +- page_number=i, +- logits=output.logits[i], +- confidence=conf, +- predicted_class=model.model.config.id2label[pred_class], +- text_length=text_length, +- ) +- ) +- +- detailed_results = aggregate_predictions(model.model, predictions) +- +- logger.debug("Prediction results: %s", detailed_results) +- logger.info("Predicted class: %s", detailed_results["predicted_class"]) +- +- try: +- await repository.update_classification( +- data.file_name, +- detailed_results["predicted_class"], +- ) +- except DocumentError as e: +- logger.error("Failed to update classification: %s", str(e)) +- raise HTTPException( +- status_code=500, +- detail="Failed to update classification", +- ) from e +- +- response = requests.post( +- config.SUMMARIZER_URL, +- json={ +- "file_name": data.file_name, +- "text": data.text, +- "classification": detailed_results["predicted_class"], +- }, +- timeout=300, +- ) +- +- return response.json() +- +- except Exception as e: +- logger.exception("Prediction failed") +- raise HTTPException( +- status_code=500, +- detail=str(e), +- ) from e +diff --git a/src/predictor/predictor.py b/src/predictor/predictor.py +new file mode 100644 +index 0000000..4612836 +--- /dev/null ++++ b/src/predictor/predictor.py +@@ -0,0 +1,271 @@ ++import logging ++from collections.abc import AsyncGenerator ++from datetime import datetime ++from typing import Any ++ ++import aiohttp ++import torch ++import torch.nn.functional as f ++from fastapi import Depends, FastAPI, HTTPException ++from layoutlm_wrapper import LayoutLMV3Wrapper ++from lingua import Language ++from llm_model import LLMModelWrapper ++from transformers import PreTrainedModel ++ ++from configs.model_config import ModelConfig ++from database import DocumentError, DocumentRepository, get_repository ++from payload.predictor_models import PagePrediction ++from payload.shared_models import ProcessorResult ++ ++config = ModelConfig() ++config.LOG_DIR.mkdir(parents=True, exist_ok=True) ++ ++logging.basicConfig( ++ level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, ++ format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", ++ datefmt="%Y-%m-%d %H:%M:%S", ++ handlers=[ ++ logging.FileHandler( ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", ++ ), ++ logging.StreamHandler(), ++ ], ++) ++ ++ ++logger = logging.getLogger(__name__) ++ ++app = FastAPI() ++ ++ ++layoutlm_model = LayoutLMV3Wrapper(config) ++layoutlm_model.eval() ++ ++llm_model = LLMModelWrapper(config) ++ ++ ++def _calculate_page_weights( ++ page_predictions: list[PagePrediction], ++) -> torch.Tensor: ++ """Calculate weights for each page based on multiple factors. ++ ++ Args: ++ page_predictions: List of predictions for each page ++ ++ Returns: ++ Tensor of normalized weights for each page ++ ++ """ ++ text_lengths = torch.tensor([pred.text_length for pred in page_predictions]) ++ confidences = torch.tensor([pred.confidence for pred in page_predictions]) ++ ++ if text_lengths.max() > 0: ++ normalized_lengths = text_lengths / text_lengths.max() ++ else: ++ normalized_lengths = torch.ones_like(text_lengths) ++ ++ weights = (normalized_lengths * confidences) + 1e-6 ++ ++ for i, (raw_weight, length, conf) in enumerate( ++ zip(weights, text_lengths, confidences), ++ ): ++ logger.debug( ++ "Page %(page)d pre-normalization: weight=%(weight).4f, text_length=%(length)d, confidence=%(conf).4f", ++ { ++ "page": i + 1, ++ "weight": raw_weight, ++ "length": length, ++ "conf": conf, ++ }, ++ ) ++ ++ temperature = 1.0 ++ normalized_weights = f.softmax(weights / temperature, dim=0) ++ ++ for i, weight in enumerate(normalized_weights): ++ logger.debug( ++ "Page %(page)d final weight: %(weight).4f", ++ {"page": i + 1, "weight": weight}, ++ ) ++ ++ return normalized_weights ++ ++ ++def aggregate_predictions( ++ model: PreTrainedModel, ++ page_predictions: list[PagePrediction], ++) -> dict[str, Any]: ++ """Aggregate predictions from multiple pages using weighted voting. ++ ++ Args: ++ model: Pre-trained model containing label mapping configuration ++ page_predictions: List of predictions for each page ++ ++ Returns: ++ Dictionary containing final classification results ++ ++ """ ++ if not page_predictions: ++ msg = "No valid predictions to aggregate" ++ raise ValueError(msg) ++ ++ weights = _calculate_page_weights(page_predictions) ++ ++ stacked_logits = torch.stack([pred.logits for pred in page_predictions]) ++ weighted_logits = (stacked_logits * weights.unsqueeze(-1)).sum(dim=0) ++ ++ probabilities = f.softmax(weighted_logits, dim=-1) ++ confidence, predicted_class = torch.max(probabilities, dim=-1) ++ ++ return { ++ "predicted_class": model.config.id2label[int(predicted_class.item())], ++ "confidence": confidence.item(), ++ "page_predictions": [ ++ { ++ "page": pred.page_number, ++ "class": pred.predicted_class, ++ "confidence": pred.confidence, ++ "weight": weight.item(), ++ } ++ for pred, weight in zip(page_predictions, weights) ++ ], ++ "probability_distribution": { ++ model.config.id2label[i]: prob.item() ++ for i, prob in enumerate(probabilities) ++ }, ++ } ++ ++ ++@app.post("/predict-class") ++async def predict( ++ data: ProcessorResult, ++ repository: AsyncGenerator[DocumentRepository, None] = Depends( ++ get_repository, ++ ), ++) -> dict[str, str]: ++ """Predict document class from processed data. ++ ++ Args: ++ data: Processed data from document processor ++ repository: Document repository instance ++ ++ Returns: ++ Dictionary containing prediction results and summary ++ ++ """ ++ try: ++ logger.info("Received data for prediction") ++ ++ # Initialize variables for prediction results ++ detailed_results = None ++ ++ # Choose prediction method based on language ++ if getattr(Language, data.language) != Language.ENGLISH: ++ # Use LLM for non-English documents ++ logger.info("Using LLM model for non-English document") ++ prediction_result = await llm_model.predict_class( ++ data.text, ++ data.language, ++ ) ++ logger.debug("LLM prediction result: %s", prediction_result) ++ # Parse the LLM output (format: "class_label|confidence_score") ++ predicted_class, confidence = prediction_result.split("|") ++ confidence = float(confidence) / 100 ++ ++ detailed_results = { ++ "predicted_class": predicted_class, ++ "confidence": confidence, ++ "page_predictions": [ ++ { ++ "page": 0, ++ "class": predicted_class, ++ "confidence": confidence, ++ "weight": 1.0, ++ }, ++ ], ++ "probability_distribution": { ++ predicted_class: confidence, ++ }, ++ } ++ else: ++ # Use LayoutLM for English documents ++ logger.info("Using LayoutLM model for English document") ++ input_ids = torch.tensor(data.input_ids) ++ attention_mask = torch.tensor(data.attention_mask) ++ bbox = torch.tensor(data.bbox) ++ pixel_values = torch.tensor(data.pixel_values) ++ ++ with torch.inference_mode(): ++ output = layoutlm_model( ++ input_ids, ++ attention_mask, ++ bbox, ++ pixel_values, ++ ) ++ ++ probabilities = f.softmax(output.logits, dim=-1) ++ confidence, predicted_class = torch.max(probabilities, dim=-1) ++ ++ predictions = [] ++ for i in range(output.logits.size(0)): ++ pred_class = int(predicted_class[i].item()) ++ conf = confidence[i].item() ++ text_length = int(torch.sum(attention_mask[i]).item()) ++ ++ predictions.append( ++ PagePrediction( ++ page_number=i, ++ logits=output.logits[i], ++ confidence=conf, ++ predicted_class=layoutlm_model.model.config.id2label[ ++ pred_class ++ ], ++ text_length=text_length, ++ ), ++ ) ++ ++ detailed_results = aggregate_predictions( ++ layoutlm_model.model, ++ predictions, ++ ) ++ ++ logger.debug("Prediction results: %s", detailed_results) ++ logger.info("Predicted class: %s", detailed_results["predicted_class"]) ++ ++ # Update classification in repository ++ try: ++ await repository.update_classification( ++ data.file_name, ++ detailed_results["predicted_class"], ++ ) ++ except DocumentError as e: ++ logger.exception("Failed to update classification") ++ raise HTTPException( ++ status_code=500, ++ detail="Failed to update classification", ++ ) from e ++ ++ # Send to summarizer ++ timeout = aiohttp.ClientTimeout(total=480) ++ async with ( ++ aiohttp.ClientSession() as session, ++ session.post( ++ config.SUMMARIZER_URL, ++ json={ ++ "file_name": data.file_name, ++ "text": data.text, ++ "classification": detailed_results["predicted_class"], ++ }, ++ timeout=timeout, ++ ) as response, ++ ): ++ response.raise_for_status() ++ return await response.json() ++ ++ except Exception as e: ++ logger.exception("Prediction failed") ++ raise HTTPException( ++ status_code=500, ++ detail=str(e), ++ ) from e +diff --git a/src/processor/dataset.py b/src/processor/dataset.py +index 423599a..41ec4ac 100644 +--- a/src/processor/dataset.py ++++ b/src/processor/dataset.py +@@ -1,16 +1,22 @@ ++from __future__ import annotations ++ + import base64 + import io + import logging + from datetime import datetime +-from typing import Optional ++from typing import TYPE_CHECKING + + import torch + from PIL import Image + from torch.utils.data import Dataset +-from transformers import ProcessorMixin + + from configs.processor_config import ProcessorConfig +-from payload.processor_models import OCRResult, ProcessorInput ++ ++if TYPE_CHECKING: ++ from transformers import ProcessorMixin ++ ++ from payload.processor_models import ProcessorInput ++ from payload.shared_models import OCRResult + + config = ProcessorConfig() + config.LOG_DIR.mkdir(parents=True, exist_ok=True) +@@ -21,7 +27,8 @@ logging.basicConfig( + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", + ), + logging.StreamHandler(), + ], +@@ -38,24 +45,27 @@ class DocumentClassificationDataset(Dataset): + processor: ProcessorMixin, + data: ProcessorInput, + config: ProcessorConfig, +- labels: Optional[list[int]] = None, ++ labels: list[int] | None = None, + *, +- encodings: Optional[dict[str, torch.Tensor]] = None, ++ encodings: dict[str, torch.Tensor] | None = None, + ) -> None: +- """ +- Initialize document classification dataset. ++ """Initialize document classification dataset. + + Args: + processor: LayoutLMv3 processor instance + data: Validated input data + config: Processing configuration + labels: Optional classification labels ++ encodings: Pre-computed encodings (optional) ++ + """ + self.processor = processor + self.config = config + self.labels = labels + self.encodings = ( +- encodings if encodings is not None else self._prepare_encodings(data) ++ encodings ++ if encodings is not None ++ else self._prepare_encodings(data) + ) + + @classmethod +@@ -65,8 +75,7 @@ class DocumentClassificationDataset(Dataset): + data: ProcessorInput, + config: ProcessorConfig, + ) -> dict[str, torch.Tensor]: +- """ +- Get document encodings without instantiating the full dataset. ++ """Get document encodings without instantiating the full dataset. + + This method processes the input data and returns only the encodings, + which is useful when you don't need the full dataset functionality. +@@ -81,6 +90,7 @@ class DocumentClassificationDataset(Dataset): + + Raises: + ValueError: If encoding preparation fails ++ + """ + temp_instance = cls( + processor=processor, +@@ -89,23 +99,36 @@ class DocumentClassificationDataset(Dataset): + encodings={}, + ) + +- return temp_instance._prepare_encodings(data) ++ return temp_instance.prepare_encodings(data) ++ ++ def _check_images(self, images: list[Image.Image]) -> None: ++ """Check if images are valid.""" ++ if not images: ++ error_msg = "No valid images found in input data" ++ raise ValueError(error_msg) + +- def _prepare_encodings(self, data: ProcessorInput) -> dict[str, torch.Tensor]: ++ def prepare_encodings( ++ self, ++ data: ProcessorInput, ++ ) -> dict[str, torch.Tensor]: + """Prepare encodings from input data for multiple pages.""" + try: + images = self._decode_images(data.images) +- if not images: +- raise ValueError("No valid images found in input data") ++ self._check_images(images) + + scales = self._calculate_scales(images[0].size) + words_per_page, boxes_per_page = self._prepare_ocr_data( +- data.ocr_result, scales ++ data.ocr_result, ++ scales, + ) + + # Process each page separately + page_encodings = [] +- for img, words, boxes in zip(images, words_per_page, boxes_per_page): ++ for img, words, boxes in zip( ++ images, ++ words_per_page, ++ boxes_per_page, ++ ): + encoding = self.processor( + [img], # Processor expects a list of images + words, +@@ -120,14 +143,20 @@ class DocumentClassificationDataset(Dataset): + # Combine encodings from all pages + combined_encodings = { + "input_ids": torch.cat( +- [enc["input_ids"] for enc in page_encodings], dim=0 ++ [enc["input_ids"] for enc in page_encodings], ++ dim=0, + ), + "attention_mask": torch.cat( +- [enc["attention_mask"] for enc in page_encodings], dim=0 ++ [enc["attention_mask"] for enc in page_encodings], ++ dim=0, ++ ), ++ "bbox": torch.cat( ++ [enc["bbox"] for enc in page_encodings], ++ dim=0, + ), +- "bbox": torch.cat([enc["bbox"] for enc in page_encodings], dim=0), + "pixel_values": torch.cat( +- [enc["pixel_values"] for enc in page_encodings], dim=0 ++ [enc["pixel_values"] for enc in page_encodings], ++ dim=0, + ), + } + +@@ -136,11 +165,12 @@ class DocumentClassificationDataset(Dataset): + {k: v.shape for k, v in combined_encodings.items()}, + ) + +- return combined_encodings +- + except Exception as e: ++ error_msg = f"Encoding preparation failed: {e!s}" + logger.exception("Error preparing encodings") +- raise ValueError(f"Encoding preparation failed: {str(e)}") from e ++ raise ValueError(error_msg) from e ++ else: ++ return combined_encodings + + @staticmethod + def _decode_images(encoded_images: list[str]) -> list[Image.Image]: +@@ -150,7 +180,10 @@ class DocumentClassificationDataset(Dataset): + for img in encoded_images + ] + +- def _calculate_scales(self, image_size: tuple[int, int]) -> tuple[float, float]: ++ def _calculate_scales( ++ self, ++ image_size: tuple[int, int], ++ ) -> tuple[float, float]: + """Calculate scaling factors for image resizing.""" + width, height = image_size + logger.debug("Image size: %s", image_size) +@@ -162,7 +195,8 @@ class DocumentClassificationDataset(Dataset): + + @staticmethod + def _prepare_ocr_data( +- ocr_results: list[list[OCRResult]], scales: tuple[float, float] ++ ocr_results: list[list[OCRResult]], ++ scales: tuple[float, float], + ) -> tuple[list[str], list[list[int]]]: + """Prepare OCR data with scaling.""" + if not ocr_results: +@@ -179,7 +213,8 @@ class DocumentClassificationDataset(Dataset): + scaled_box = [ + int(coord * scale) + for coord, scale in zip( +- result.bounding_box, [width_scale, height_scale] * 2 ++ result.bounding_box, ++ [width_scale, height_scale] * 2, + ) + ] + tmp_box.append(scaled_box) +diff --git a/src/processor/processor.py b/src/processor/processor.py +index 184974a..d2c4d57 100644 +--- a/src/processor/processor.py ++++ b/src/processor/processor.py +@@ -2,9 +2,10 @@ import logging + from datetime import datetime + from pathlib import Path + +-import requests ++import aiohttp + from dataset import DocumentClassificationDataset + from fastapi import FastAPI, HTTPException ++from lingua import Language, LanguageDetectorBuilder + from transformers import ( + LayoutLMv3ImageProcessor, + LayoutLMv3Processor, +@@ -12,7 +13,7 @@ from transformers import ( + ) + + from configs.processor_config import ProcessorConfig +-from payload.processor_models import ProcessorInput, ProcessorResult ++from payload.processor_models import ProcessorInput, ProcessorOutput + + config = ProcessorConfig() + # TMP solution to avoid error during testing +@@ -28,7 +29,8 @@ logging.basicConfig( + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", + ), + logging.StreamHandler(), + ], +@@ -37,6 +39,11 @@ logging.basicConfig( + logger = logging.getLogger(__name__) + + app = FastAPI() ++detector = ( ++ LanguageDetectorBuilder.from_all_languages() ++ .with_preloaded_language_models() ++ .build() ++) + + + class DocumentProcessor: +@@ -46,33 +53,39 @@ class DocumentProcessor: + """Initialize document processor.""" + self.processor = LayoutLMv3Processor( + LayoutLMv3ImageProcessor(apply_ocr=False), +- LayoutLMv3TokenizerFast.from_pretrained("/app/data/models/layoutlmv3-base"), ++ LayoutLMv3TokenizerFast.from_pretrained( ++ "/app/data/models/layoutlmv3-base", ++ ), + ) + +- def process_document(self, input_data: ProcessorInput) -> ProcessorResult: +- """ +- Process document with LayoutLMv3. ++ def process_document(self, input_data: ProcessorInput) -> ProcessorOutput: ++ """Process document with LayoutLMv3. + + Args: + input_data: Validated input data containing OCR results and images ++ + """ + try: +- encodings: list[dict] = DocumentClassificationDataset.get_encodings( +- self.processor, input_data, config ++ encodings: dict = DocumentClassificationDataset.get_encodings( ++ self.processor, ++ input_data, ++ config, + ) + +- result = ProcessorResult( +- input_ids=encodings["input_ids"], +- attention_mask=encodings["attention_mask"], +- bbox=encodings["bbox"], +- pixel_values=encodings["pixel_values"], ++ result = ProcessorOutput( ++ input_ids=encodings["input_ids"].tolist(), ++ attention_mask=encodings["attention_mask"].tolist(), ++ bbox=encodings["bbox"].tolist(), ++ pixel_values=encodings["pixel_values"].tolist(), + ) + +- return result +- + except Exception as e: + logger.exception("Document processing failed") +- raise HTTPException(status_code=500, detail=f"Processing failed: {str(e)}") ++ detail = f"Processing failed: {e!s}" ++ raise HTTPException(status_code=500, detail=detail) from e ++ ++ else: ++ return result + + + # Create processor instance +@@ -81,35 +94,79 @@ document_processor = DocumentProcessor() + + @app.post("/text-preprocess") + async def process_text(data: ProcessorInput) -> dict[str, str]: +- """ +- Process document text and layout. ++ """Process document text and layout. + + Args: + data: Validated input data containing OCR results and images ++ + """ + try: ++ text = " ".join( ++ result.word ++ for ocr_result in data.ocr_result ++ for result in ocr_result ++ ) ++ ++ detected_language = detector.detect_language_of(text) ++ ++ if detected_language is None: ++ # Default to English if language detection fails ++ detected_language = Language.ENGLISH ++ ++ if detected_language != Language.ENGLISH: ++ timeout = aiohttp.ClientTimeout(total=480) ++ async with ( ++ aiohttp.ClientSession() as session, ++ session.post( ++ config.PREDICT_URL, ++ json={ ++ "input_ids": None, ++ "attention_mask": None, ++ "bbox": None, ++ "pixel_values": None, ++ "file_name": data.file_name, ++ "text": text, ++ "language": detected_language.name, ++ }, ++ timeout=timeout, ++ ) as response, ++ ): ++ response.raise_for_status() ++ return await response.json() ++ + encodings = document_processor.process_document(data) + +- encodings = {k: v.tolist() for k, v in encodings.model_dump().items()} +- +- # logger.info( +- # "Text from OCR: %s", " ".join(result.word for result in data.ocr_result[0]) +- # ) +- +- response = requests.post( +- config.PREDICT_URL, +- json={ +- "input_ids": encodings["input_ids"], +- "attention_mask": encodings["attention_mask"], +- "bbox": encodings["bbox"], +- "pixel_values": encodings["pixel_values"], +- "file_name": data.file_name, +- "text": " ".join(result.word for result in data.ocr_result[0]), +- }, +- timeout=300, ++ encodings = encodings.model_dump() ++ ++ logger.debug( ++ "Text from OCR: %s", ++ " ".join( ++ result.word ++ for ocr_result in data.ocr_result ++ for result in ocr_result ++ ), + ) +- return response.json() ++ ++ timeout = aiohttp.ClientTimeout(total=480) ++ async with ( ++ aiohttp.ClientSession() as session, ++ session.post( ++ config.PREDICT_URL, ++ json={ ++ "input_ids": encodings["input_ids"], ++ "attention_mask": encodings["attention_mask"], ++ "bbox": encodings["bbox"], ++ "pixel_values": encodings["pixel_values"], ++ "file_name": data.file_name, ++ "text": text, ++ "language": detected_language.name, ++ }, ++ timeout=timeout, ++ ) as response, ++ ): ++ response.raise_for_status() ++ return await response.json() + + except Exception as e: + logger.exception("Endpoint processing failed") +- raise HTTPException(status_code=500, detail=str(e)) ++ raise HTTPException(status_code=500, detail=str(e)) from e +diff --git a/src/summarization/summarizer.py b/src/summarization/summarizer.py +index f002f03..1a7849b 100644 +--- a/src/summarization/summarizer.py ++++ b/src/summarization/summarizer.py +@@ -1,18 +1,17 @@ ++from __future__ import annotations ++ ++import json + import logging ++import re + from datetime import datetime +-from typing import AsyncGenerator ++from typing import Any, NotRequired, TypedDict, cast + ++import aiohttp + from fastapi import Depends, FastAPI, HTTPException +-from langchain.prompts import ( +- ChatPromptTemplate, +- HumanMessagePromptTemplate, +- SystemMessagePromptTemplate, +-) +-from langchain_ollama.chat_models import ChatOllama + + from configs.summarization_config import SummarizationConfig + from database import DocumentError, DocumentRepository, get_repository +-from payload.summarizer_models import SummarizationRequest ++from payload.summarizer_models import SummarizationRequest, SummaryResponse + + config = SummarizationConfig() + config.LOG_DIR.mkdir(parents=True, exist_ok=True) +@@ -23,70 +22,228 @@ logging.basicConfig( + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( +- config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" ++ config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", ++ mode="a", + ), + logging.StreamHandler(), + ], + ) + + logger = logging.getLogger(__name__) +- + app = FastAPI() + + ++class OllamaOptions(TypedDict): ++ """Type definition for Ollama API options.""" ++ ++ temperature: float ++ top_p: float ++ frequency_penalty: float ++ presence_penalty: float ++ num_ctx: int ++ num_gpu: int ++ num_thread: int ++ ++ ++class OllamaRequest(TypedDict, total=False): ++ """Type definition for Ollama API request.""" ++ ++ model: str # required ++ prompt: str # required ++ format: NotRequired[str] ++ options: NotRequired[OllamaOptions] ++ system: NotRequired[str] ++ stream: NotRequired[bool] ++ raw: NotRequired[bool] ++ keep_alive: NotRequired[str | int] ++ ++ + class Summarizer: +- """Text summarization using Ollama and LangChain.""" +- +- SUMMARY_SYSTEM_PROMPT = """You are a precise summarization assistant that creates database-friendly summaries. Follow these rules exactly: +- 1. Output only the summary text, no introductions or extra words +- 2. Write complete sentences without periods at the end (use spaces between sentences) +- 3. Stay strictly between {min_length} and {max_length} words +- 4. Write in a formal tone appropriate for {classification} documents +- 5. Use clear connecting words between sentences for flow""" +- +- SUMMARY_PROMPT = """ +- Write a summary of the {classification} text below +- The summary must be between {min_length} and {max_length} words +- Do not use periods at the end of sentences, only between sentences +- Focus on key information relevant to {classification} type +- Only output the summary text, nothing else +- +- +- ++ """Text summarization using direct Ollama integration.""" ++ ++ SUMMARY_SYSTEM_PROMPT = """You are an expert summarization analyst specializing in precise content distillation. ++ ++ Core Requirements: ++ 1. Process text in target format: {classification} ++ 2. Generate summaries between {min_length}-{max_length} words ++ 3. Output JSON format: {{"summary": "extracted key points", "word_count": number}} ++ ++ Technical Guidelines: ++ - Create self-contained, complete thought units ++ - Use professional language suited to {classification} context ++ - Employ clear transition phrases between ideas ++ - Maintain consistent technical depth throughout ++ - Structure content with logical progression ++ - Focus on essential information density ++ - Return only valid JSON output""" ++ ++ SUMMARY_PROMPT = """Document Analysis Parameters: ++ - Document Type: {classification} ++ - Length Constraints: {min_length} to {max_length} words ++ - Output Format: {{"summary": "content", "word_count": number}} ++ ++ Summarization Guidelines: ++ 1. Content Analysis: ++ - Identify core themes and key arguments ++ - Extract essential supporting evidence ++ - Preserve critical technical details ++ - Maintain original document tone ++ - Focus on {classification}-specific elements ++ ++ 2. Summary Construction: ++ - Begin with main thesis/findings ++ - Include critical methodology details ++ - Preserve key statistical data ++ - Connect ideas with clear transitions ++ - End with significant conclusions ++ ++ 3. Technical Requirements: ++ - Write complete semantic units ++ - Use precise technical terminology ++ - Maintain formal language register ++ - Apply consistent formatting ++ - Generate database-compatible output ++ ++ Source Document: + {text} +- +- +- +- - Only output the summary +- - No introduction or meta text +- - No periods at end of sentences +- - Must be {min_length}-{max_length} words +- +- +- Summary:""" +- +- def __init__(self): +- """Initialize summarizer with Ollama model.""" +- self.llm = ChatOllama( +- model=config.MODEL_NAME, +- temperature=config.TEMPERATURE, +- top_p=config.TOP_P, +- base_url=config.OLLAMA_BASE_URL, +- frequency_penalty=config.FREQUENCY_PENALTY, +- presence_penalty=config.PRESENCE_PENALTY, +- num_ctx=config.NUM_CTX, +- num_gpu=config.NUM_GPU, +- num_thread=config.NUM_THREAD, ++ ++ Response Specifications: ++ - Pure JSON structure ++ - Contains summary and word_count ++ - Meets length requirements ++ - No explanatory text ++ - No terminal periods except between thoughts ++ - Do not use points or bullet lists ++ ++ Generate summary:""" ++ ++ def __init__(self, config: SummarizationConfig) -> None: ++ """Initialize summarizer with configuration.""" ++ self.config = config ++ self.base_url = f"{config.OLLAMA_BASE_URL}/api/generate" ++ ++ def _prepare_request( ++ self, ++ text: str, ++ min_length: int, ++ max_length: int, ++ classification: str, ++ ) -> OllamaRequest: ++ """Prepare the request payload for Ollama API.""" ++ system_prompt = self.SUMMARY_SYSTEM_PROMPT.format( ++ min_length=min_length, ++ max_length=max_length, ++ classification=classification, ++ ) ++ ++ user_prompt = self.SUMMARY_PROMPT.format( ++ text=text, ++ min_length=min_length, ++ max_length=max_length, ++ classification=classification, + ) + +- self.prompt = ChatPromptTemplate.from_messages( +- [ +- SystemMessagePromptTemplate.from_template(self.SUMMARY_SYSTEM_PROMPT), +- HumanMessagePromptTemplate.from_template(self.SUMMARY_PROMPT), +- ] ++ return { ++ "model": self.config.MODEL_NAME, ++ "prompt": user_prompt, ++ "system": system_prompt, ++ "format": "json", ++ "stream": False, ++ "options": { ++ "temperature": self.config.TEMPERATURE, ++ "top_p": self.config.TOP_P, ++ "frequency_penalty": self.config.FREQUENCY_PENALTY, ++ "presence_penalty": self.config.PRESENCE_PENALTY, ++ "num_ctx": self.config.NUM_CTX, ++ "num_gpu": self.config.NUM_GPU, ++ "num_thread": self.config.NUM_THREAD, ++ }, ++ "keep_alive": "15m", ++ } ++ ++ def _extract_json_from_text(self, text: str) -> dict[str, Any]: ++ """Extract JSON from text that might contain additional content. ++ ++ Args: ++ text: Text that might contain JSON ++ ++ Returns: ++ Extracted JSON as dict ++ ++ Raises: ++ ValueError: If no valid JSON found ++ ++ """ ++ # Remove any markdown code blocks ++ text = re.sub(r"```json\s*|\s*```", "", text) ++ ++ # Try to find JSON pattern ++ json_match = re.search(r"\{.*\}", text, re.DOTALL) ++ if not json_match: ++ raise ValueError("No JSON object found in response") ++ ++ try: ++ return cast(dict[str, Any], json.loads(json_match.group())) ++ except json.JSONDecodeError as e: ++ raise ValueError(f"Failed to parse JSON: {e!s}") from e ++ ++ def _process_raw_response(self, content: str) -> SummaryResponse: ++ """Process raw response when JSON parsing fails.""" ++ # Remove any potential markdown code blocks ++ content = re.sub(r"```json\s*|\s*```", "", content) ++ ++ # Try to find content that looks like a summary ++ text = re.sub(r"\s+", " ", content).strip() ++ ++ # Count words in the extracted text ++ word_count = len(text.split()) ++ ++ if not text: ++ raise ValueError("Unable to extract valid summary from response") ++ ++ return SummaryResponse( ++ summary=text, ++ word_count=word_count, + ) + +- self.chain = self.prompt | self.llm ++ def _validate_summary_response( ++ self, ++ response_data: dict[str, Any], ++ min_length: int, ++ max_length: int, ++ ) -> SummaryResponse: ++ """Validate and process the summary response.""" ++ if not isinstance(response_data, dict): ++ raise ValueError("Response must be a JSON object") ++ ++ if "summary" not in response_data or "word_count" not in response_data: ++ raise ValueError( ++ 'Response must contain "summary" and "word_count" fields', ++ ) ++ ++ summary = response_data["summary"] ++ word_count = response_data["word_count"] ++ ++ if not isinstance(summary, str) or not isinstance( ++ word_count, ++ (int, float), ++ ): ++ raise ValueError("Invalid field types in response") ++ ++ # Convert word_count to int if it's a float ++ word_count = int(word_count) ++ ++ actual_word_count = len(summary.split()) ++ if actual_word_count < min_length or actual_word_count > max_length: ++ logger.warning( ++ "Summary length (%d words) outside allowed range", ++ actual_word_count, ++ ) ++ ++ return SummaryResponse( ++ summary=summary, ++ word_count=actual_word_count, ++ ) + + async def generate_summary( + self, +@@ -95,53 +252,95 @@ class Summarizer: + max_length: int = 300, + classification: str = "unclassified", + ) -> str: +- """ +- Generate a summary of the input text. ++ """Generate a summary of the input text.""" + +- Args: +- text: Input text to summarize +- min_length: Minimum summary length in words +- max_length: Maximum summary length in words ++ def _validate_ollama_response(result: object) -> None: ++ """Validate Ollama API response format.""" ++ error_msg = "Invalid response format from Ollama" ++ if not isinstance(result, dict) or "response" not in result: ++ raise ValueError(error_msg) ++ ++ def _validate_content(content: str) -> None: ++ """Validate response content is not empty.""" ++ error_msg = "Empty response from Ollama" ++ if not content: ++ raise ValueError(error_msg) + +- Returns: +- Generated summary text +- """ + try: +- response = await self.chain.ainvoke( +- { +- "text": text, +- "min_length": min_length, +- "max_length": max_length, +- "classification": classification, +- } ++ request_data = self._prepare_request( ++ text, ++ min_length, ++ max_length, ++ classification, + ) +- return response.content.strip().replace(" \n", ". ") ++ ++ timeout = aiohttp.ClientTimeout(total=300) ++ async with ( ++ aiohttp.ClientSession(timeout=timeout) as session, ++ session.post(self.base_url, json=request_data) as response, ++ ): ++ response.raise_for_status() ++ result = await response.json() ++ ++ _validate_ollama_response(result) ++ ++ content = result["response"].strip() ++ _validate_content(content) ++ ++ logger.debug("Raw response from Ollama: %s", content) ++ ++ try: ++ # Try to extract and parse JSON from response ++ response_data = self._extract_json_from_text(content) ++ summary_response = self._validate_summary_response( ++ response_data, ++ min_length, ++ max_length, ++ ) ++ # Return only the summary text ++ return summary_response.summary.replace(" \n", ".") ++ ++ except (json.JSONDecodeError, ValueError) as e: ++ logger.warning( ++ "Failed to parse JSON response, falling back to raw " ++ "processing: %s", ++ str(e), ++ ) ++ # Fall back to raw response processing ++ summary_response = self._process_raw_response(content) ++ return summary_response.summary.replace(" \n", ".") ++ ++ except aiohttp.ClientError as e: ++ logger.exception("Ollama API communication error") ++ raise HTTPException( ++ status_code=500, ++ detail=f"Failed to communicate with Ollama: {e!s}", ++ ) from e ++ ++ except ValueError as e: ++ logger.exception("Invalid response format from Ollama") ++ raise HTTPException( ++ status_code=500, ++ detail=str(e), ++ ) from e ++ + except Exception as e: +- logger.error("Summarization failed: %s", str(e)) ++ logger.exception("Summarization failed") + raise HTTPException( + status_code=500, +- detail="Summarization failed", +- ) ++ detail=f"Summarization failed: {e!s}", ++ ) from e + + +-summarizer = Summarizer() ++summarizer = Summarizer(config) + + + @app.post("/summarize") + async def summarize_document( + request: SummarizationRequest, +- repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), ++ repository: DocumentRepository = Depends(get_repository), + ) -> dict[str, str]: +- """ +- Generate a summary for the given document. +- +- Args: +- request: Summarization request containing text and parameters +- repository: Document repository instance +- +- Returns: +- Dictionary containing the generated summary +- """ ++ """Generate a summary for the given document.""" + try: + summary = await summarizer.generate_summary( + text=request.text, +@@ -150,21 +349,25 @@ async def summarize_document( + classification=request.classification, + ) + +- # Update document in database with summary + try: + await repository.update_summary(request.file_name, summary) + except DocumentError as e: +- logger.error("Failed to update summary: %s", str(e)) ++ logger.exception("Failed to update summary") + raise HTTPException( + status_code=500, + detail="Failed to save summary", +- ) +- +- return {"summary": summary, "classification": request.classification} ++ ) from e + + except Exception as e: + logger.exception("Summarization endpoint failed") + raise HTTPException( + status_code=500, + detail=str(e), +- ) ++ ) from e ++ ++ else: ++ return { ++ "file_name": request.file_name, ++ "summary": summary, ++ "classification": request.classification, ++ } +diff --git a/src/utils/utils.py b/src/utils/utils.py +index 730a290..006f69d 100644 +--- a/src/utils/utils.py ++++ b/src/utils/utils.py +@@ -1,13 +1,16 @@ +-import os + import re +-from typing import AsyncGenerator ++from collections.abc import AsyncGenerator ++from pathlib import Path ++from typing import NoReturn + + from database.repository import DocumentRepository + + +-def make_unique_filename(original_filename: str, existing_filenames: set[str]) -> str: +- """ +- Generate a unique filename by appending a number if the filename already exists. ++def make_unique_filename( ++ original_filename: str, ++ existing_filenames: set[str], ++) -> str: ++ """Generate a unique filename by appending a number if the filename already exists. + + Args: + original_filename: The original filename to make unique +@@ -23,12 +26,14 @@ def make_unique_filename(original_filename: str, existing_filenames: set[str]) - + 'test (2).pdf' + >>> make_unique_filename("my file.pdf", {"my file.pdf"}) + 'my file (1).pdf' ++ + """ + if original_filename not in existing_filenames: + return original_filename + +- # Split the filename into name and extension +- name, ext = os.path.splitext(original_filename) ++ path = Path(original_filename) ++ name = path.stem ++ ext = path.suffix + + # Check if filename already ends with a number in parentheses + pattern = r"(.*?)\s*(?:\((\d+)\))?$" +@@ -52,8 +57,7 @@ async def get_unique_filename( + repository: AsyncGenerator[DocumentRepository, None], + max_attempts: int = 100, + ) -> str: +- """ +- Generate a unique filename that doesn't exist in the database. ++ """Generate a unique filename that doesn't exist in the database. + + Args: + filename: Original filename to make unique +@@ -65,7 +69,13 @@ async def get_unique_filename( + + Raises: + ValueError: If unable to generate unique filename within max_attempts ++ + """ ++ # Create error message once ++ error_message = ( ++ "Unable to generate unique filename for {} within {} attempts" ++ ) ++ + try: + # Get all existing filenames from database + documents = await repository.get_all() +@@ -77,12 +87,16 @@ async def get_unique_filename( + # Verify we didn't exceed max attempts (check the number in parentheses) + match = re.search(r"\((\d+)\)", unique_name) + if match and int(match.group(1)) > max_attempts: +- raise ValueError( +- f"Unable to generate unique filename for {filename} " +- f"within {max_attempts} attempts" +- ) ++ # Abstract raise to inner function ++ def raise_max_attempts() -> NoReturn: ++ raise ValueError(error_message.format(filename, max_attempts)) ++ ++ raise_max_attempts() + +- return unique_name ++ else: ++ return unique_name + +- except Exception as e: +- raise ValueError(f"Error generating unique filename: {str(e)}") ++ except (StopAsyncIteration, AttributeError) as e: ++ # Distinguish exception source ++ error_msg = "Error generating unique filename: {}" ++ raise ValueError(error_msg.format(str(e))) from e diff --git a/.gitignore b/.gitignore index b83fb7b..964f931 100644 --- a/.gitignore +++ b/.gitignore @@ -167,4 +167,7 @@ cython_debug/ logs/ __*.py !__init__.py -models/ \ No newline at end of file +models/ + +.python-version +__*.toml \ No newline at end of file diff --git a/Dockerfile.ocr b/Dockerfile.ocr index 7efe618..a4130c0 100644 --- a/Dockerfile.ocr +++ b/Dockerfile.ocr @@ -1,39 +1,43 @@ -FROM ghcr.io/astral-sh/uv:latest AS builder -FROM python:3.12-slim-bullseye AS final - -LABEL authors="codeplayer" - -ENV VIRTUAL_ENV=/opt/venv -ENV PYTHONUNBUFFERED=1 -ENV PYTHONDONTWRITEBYTECODE=1 +FROM python:3.12-slim-bullseye + +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +ENV UV_PYTHON_DOWNLOADS=never +# Location of the virtual environment +ENV UV_PROJECT_ENVIRONMENT="/venv" +# Location of the python installation via uv +ENV UV_PYTHON_INSTALL_DIR="/python" +# Byte compile the python files on installation +ENV UV_COMPILE_BYTECODE=1 +# Python verision to use +ENV UV_PYTHON=python3.12 +# Tweaking the PATH variable for easier use +ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" WORKDIR /app # Install only required runtime dependencies RUN apt-get update && \ - apt-get install -y --no-install-recommends \ - poppler-utils tesseract-ocr libtesseract-dev \ - && rm -rf /var/lib/apt/lists/* - -# Create and activate virtual environment -RUN python -m venv $VIRTUAL_ENV -ENV PATH="$VIRTUAL_ENV/bin:$PATH" + apt-get install -y --no-install-recommends \ + poppler-utils tesseract-ocr libtesseract-dev \ + && rm -rf /var/lib/apt/lists/* # Install dependencies using uv -COPY --from=builder /uv /uv -COPY requirements.txt . RUN --mount=type=cache,target=/root/.cache/uv \ - /uv pip install --no-cache-dir -r requirements.txt + --mount=type=bind,source=uv.lock,target=uv.lock \ + --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ + uv sync --frozen --no-install-project --no-editable # Copy only necessary files COPY src/ocr/ /app/code/ COPY src/configs/ocr_config.py /app/code/configs/ COPY src/configs/database_config.py /app/code/configs/ COPY src/payload/ocr_models.py /app/code/payload/ +COPY src/payload/shared_models.py /app/code/payload/ COPY src/database/ /app/code/database/ COPY src/utils/ /app/code/utils/ COPY .env /app/code/ WORKDIR /app/code/ -CMD ["python", "-m", "uvicorn", "ocr:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file +CMD ["uv", "run", "uvicorn", "ocr:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/Dockerfile.predictor b/Dockerfile.predictor index 3dd20d5..efcbb6c 100644 --- a/Dockerfile.predictor +++ b/Dockerfile.predictor @@ -1,36 +1,42 @@ -FROM ghcr.io/astral-sh/uv:latest AS builder -FROM python:3.12-slim-bullseye AS final - -ENV VIRTUAL_ENV=/opt/venv -ENV PYTHONUNBUFFERED=1 -ENV PYTHONDONTWRITEBYTECODE=1 +FROM python:3.12-slim-bullseye + +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +ENV UV_PYTHON_DOWNLOADS=never +# Location of the virtual environment +ENV UV_PROJECT_ENVIRONMENT="/venv" +# Location of the python installation via uv +ENV UV_PYTHON_INSTALL_DIR="/python" +# Byte compile the python files on installation +ENV UV_COMPILE_BYTECODE=1 +# Python verision to use +ENV UV_PYTHON=python3.12 +# Tweaking the PATH variable for easier use +ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" WORKDIR /app # Install minimal required dependencies RUN apt-get update && \ - apt-get install -y --no-install-recommends \ - git \ - && rm -rf /var/lib/apt/lists/* - -# Create and activate virtual environment -RUN python -m venv $VIRTUAL_ENV -ENV PATH="$VIRTUAL_ENV/bin:$PATH" + apt-get install -y --no-install-recommends \ + git \ + && rm -rf /var/lib/apt/lists/* # Install dependencies using uv -COPY --from=builder /uv /uv -COPY requirements.txt . RUN --mount=type=cache,target=/root/.cache/uv \ - /uv pip install --no-cache-dir -r requirements.txt + --mount=type=bind,source=uv.lock,target=uv.lock \ + --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ + uv sync --frozen --no-install-project --no-editable # Copy only necessary files COPY src/predictor/ /app/code/ COPY src/configs/model_config.py /app/code/configs/ COPY src/configs/database_config.py /app/code/configs/ -COPY src/payload/model_models.py /app/code/payload/ +COPY src/payload/predictor_models.py /app/code/payload/ +COPY src/payload/shared_models.py /app/code/payload/ COPY src/database/ /app/code/database/ COPY .env /app/code/ WORKDIR /app/code/ -CMD ["python", "-m", "uvicorn", "model:app", "--host", "0.0.0.0", "--port", "7070"] \ No newline at end of file +CMD ["uv", "run", "uvicorn", "predictor:app", "--host", "0.0.0.0", "--port", "7070"] diff --git a/Dockerfile.processor b/Dockerfile.processor index 2e0d56c..db257bc 100644 --- a/Dockerfile.processor +++ b/Dockerfile.processor @@ -1,33 +1,39 @@ -FROM ghcr.io/astral-sh/uv:latest AS builder FROM python:3.12-slim-bullseye AS final -ENV VIRTUAL_ENV=/opt/venv -ENV PYTHONUNBUFFERED=1 -ENV PYTHONDONTWRITEBYTECODE=1 +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv + +ENV UV_PYTHON_DOWNLOADS=never +# Location of the virtual environment +ENV UV_PROJECT_ENVIRONMENT="/venv" +# Location of the python installation via uv +ENV UV_PYTHON_INSTALL_DIR="/python" +# Byte compile the python files on installation +ENV UV_COMPILE_BYTECODE=1 +# Python verision to use +ENV UV_PYTHON=python3.12 +# Tweaking the PATH variable for easier use +ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" WORKDIR /app # Install minimal required dependencies RUN apt-get update && \ - apt-get install -y --no-install-recommends \ - git \ - && rm -rf /var/lib/apt/lists/* - -# Create and activate virtual environment -RUN python -m venv $VIRTUAL_ENV -ENV PATH="$VIRTUAL_ENV/bin:$PATH" + apt-get install -y --no-install-recommends \ + git \ + && rm -rf /var/lib/apt/lists/* # Install dependencies using uv -COPY --from=builder /uv /uv -COPY requirements.txt . RUN --mount=type=cache,target=/root/.cache/uv \ - /uv pip install --no-cache-dir -r requirements.txt + --mount=type=bind,source=uv.lock,target=uv.lock \ + --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ + uv sync --frozen --no-install-project --no-editable # Copy only necessary files COPY src/processor/ /app/code/ COPY src/configs/processor_config.py /app/code/configs/ COPY src/payload/processor_models.py /app/code/payload/ +COPY src/payload/shared_models.py /app/code/payload/ WORKDIR /app/code/ -CMD ["python", "-m", "uvicorn", "processor:app", "--host", "0.0.0.0", "--port", "9090"] \ No newline at end of file +CMD ["uv", "run", "uvicorn", "processor:app", "--host", "0.0.0.0", "--port", "9090"] diff --git a/Dockerfile.summarizer b/Dockerfile.summarizer index 9737cb1..310227f 100644 --- a/Dockerfile.summarizer +++ b/Dockerfile.summarizer @@ -1,30 +1,42 @@ -FROM ghcr.io/astral-sh/uv:latest AS builder -FROM python:3.12-slim-bullseye AS final +FROM python:3.12-slim-bullseye -ENV VIRTUAL_ENV=/opt/venv -ENV PYTHONUNBUFFERED=1 -ENV PYTHONDONTWRITEBYTECODE=1 +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +ENV UV_PYTHON_DOWNLOADS=never +# Location of the virtual environment +ENV UV_PROJECT_ENVIRONMENT="/venv" +# Location of the python installation via uv +ENV UV_PYTHON_INSTALL_DIR="/python" +# Byte compile the python files on installation +ENV UV_COMPILE_BYTECODE=1 +# Python verision to use +ENV UV_PYTHON=python3.12 +# Tweaking the PATH variable for easier use +ENV PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH" WORKDIR /app -# Create and activate virtual environment -RUN python -m venv $VIRTUAL_ENV -ENV PATH="$VIRTUAL_ENV/bin:$PATH" +# Install minimal required dependencies +RUN apt-get update && \ + apt-get install -y --no-install-recommends \ + git \ + && rm -rf /var/lib/apt/lists/* # Install dependencies using uv -COPY --from=builder /uv /uv -COPY requirements.txt . RUN --mount=type=cache,target=/root/.cache/uv \ - /uv pip install --no-cache-dir -r requirements.txt + --mount=type=bind,source=uv.lock,target=uv.lock \ + --mount=type=bind,source=pyproject.toml,target=pyproject.toml \ + uv sync --frozen --no-install-project --no-editable # Copy only necessary files COPY src/summarization/ /app/code/ COPY src/configs/summarization_config.py /app/code/configs/ COPY src/configs/database_config.py /app/code/configs/ COPY src/payload/summarizer_models.py /app/code/payload/ +COPY src/payload/shared_models.py /app/code/payload/ COPY src/database/ /app/code/database/ COPY .env /app/code/ WORKDIR /app/code/ -CMD ["python", "-m", "uvicorn", "summarizer:app", "--host", "0.0.0.0", "--port", "6060"] \ No newline at end of file +CMD ["uv", "run", "uvicorn", "summarizer:app", "--host", "0.0.0.0", "--port", "6060"] diff --git a/docker-compose.yml b/docker-compose.yml index 5bfd449..62ce144 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -4,13 +4,13 @@ services: image: postgres:latest restart: unless-stopped healthcheck: - test: [ "CMD-SHELL", "pg_isready -U postgres" ] - interval: 5s + test: ["CMD-SHELL", "pg_isready -U postgres"] + interval: 120s timeout: 5s retries: 5 environment: POSTGRES_USER: postgres - POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD environment variable is required} + POSTGRES_PASSWORD: postgres POSTGRES_DB: document_classification TZ: Europe/Warsaw ports: @@ -85,6 +85,7 @@ services: depends_on: - processor - database + - ollama volumes: - type: bind source: logs @@ -111,13 +112,14 @@ services: source: init-ollama.sh target: /app/init-ollama.sh healthcheck: - test: ollama ps || exit 1 - interval: 5s - timeout: 5s + test: "ollama --version && ollama ps || exit 1" + interval: 120s + timeout: 10s retries: 5 + start_period: 30s networks: - document-classification - entrypoint: [ "/usr/bin/bash", "/app/init-ollama.sh" ] + entrypoint: ["/usr/bin/bash", "/app/init-ollama.sh"] summarizer: container_name: summarizer_service diff --git a/init-ollama.sh b/init-ollama.sh index 83a0451..e6aa7fa 100755 --- a/init-ollama.sh +++ b/init-ollama.sh @@ -1,16 +1,27 @@ #!/bin/bash +# Selected model. +MODEL=llama3.2:3b +# MODEL=gemma2:2b + # Start Ollama in the background. -/bin/ollama serve & -# Record Process ID. -pid=$! +echo "Starting Ollama server..." +ollama serve & +SERVE_PID=$! + +echo "Waiting for Ollama server to be active..." +while ! ollama list | grep -q 'NAME'; do + sleep 1 +done -# Pause for Ollama to start. -sleep 5 +echo "🔴 Retrieve ${MODEL} model..." +ollama pull ${MODEL} +echo "🟢 Done!" -echo "🔴 Retrieve LLAMA3.2 3B model..." -ollama pull llama3.2:3b +# Preload the model. +echo "🔴 Preload ${MODEL} model..." +ollama run ${MODEL} "" echo "🟢 Done!" # Wait for Ollama process to finish. -wait $pid \ No newline at end of file +wait $SERVE_PID diff --git a/pdm.lock b/pdm.lock deleted file mode 100644 index 3822229..0000000 --- a/pdm.lock +++ /dev/null @@ -1,1848 +0,0 @@ -# This file is @generated by PDM. -# It is not intended for manual editing. - -[metadata] -groups = ["default"] -strategy = [] -lock_version = "4.5.0" -content_hash = "sha256:6394943eaa538604cbf53c4231ed9c26d5f7ab832a3c219988dafc18c454c89c" - -[[metadata.targets]] -requires_python = ">=3.12,<3.13" - -[[package]] -name = "aiofiles" -version = "24.1.0" -summary = "" -files = [ - {file = "aiofiles-24.1.0-py3-none-any.whl", hash = "sha256:b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5"}, - {file = "aiofiles-24.1.0.tar.gz", hash = "sha256:22a075c9e5a3810f0c2e48f3008c94d68c65d763b9b03857924c99e57355166c"}, -] - -[[package]] -name = "aiohappyeyeballs" -version = "2.4.3" -summary = "" -files = [ - {file = "aiohappyeyeballs-2.4.3-py3-none-any.whl", hash = "sha256:8a7a83727b2756f394ab2895ea0765a0a8c475e3c71e98d43d76f22b4b435572"}, - {file = "aiohappyeyeballs-2.4.3.tar.gz", hash = "sha256:75cf88a15106a5002a8eb1dab212525c00d1f4c0fa96e551c9fbe6f09a621586"}, -] - -[[package]] -name = "aiohttp" -version = "3.11.2" -summary = "" -dependencies = [ - "aiohappyeyeballs", - "aiosignal", - "attrs", - "frozenlist", - "multidict", - "propcache", - "yarl", -] -files = [ - {file = "aiohttp-3.11.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f833a80d9de9307d736b6af58c235b17ef7f90ebea7b9c49cd274dec7a66a2f1"}, - {file = "aiohttp-3.11.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:382f853516664d2ebfc75dc01da4a10fdef5edcb335fe7b45cf471ce758ecb18"}, - {file = "aiohttp-3.11.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3a2bcf6c81639a165da93469e1e0aff67c956721f3fa9c0560f07dd1e505116"}, - {file = "aiohttp-3.11.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de3b4d5fb5d69749104b880a157f38baeea7765c93d9cd3837cedd5b84729e10"}, - {file = "aiohttp-3.11.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0a90a0dc4b054b5af299a900bf950fe8f9e3e54322bc405005f30aa5cacc5c98"}, - {file = "aiohttp-3.11.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32334f35824811dd20a12cc90825d000e6b50faaeaa71408d42269151a66140d"}, - {file = "aiohttp-3.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cba0b8d25aa2d450762f3dd6df85498f5e7c3ad0ddeb516ef2b03510f0eea32"}, - {file = "aiohttp-3.11.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bbb2dbc2701ab7e9307ca3a8fa4999c5b28246968e0a0202a5afabf48a42e22"}, - {file = "aiohttp-3.11.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97fba98fc5d9ccd3d33909e898d00f2494d6a9eec7cbda3d030632e2c8bb4d00"}, - {file = "aiohttp-3.11.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0ebdf5087e2ce903d8220cc45dcece90c2199ae4395fd83ca616fcc81010db2c"}, - {file = "aiohttp-3.11.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:122768e3ae9ce74f981b46edefea9c6e5a40aea38aba3ac50168e6370459bf20"}, - {file = "aiohttp-3.11.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5587da333b7d280a312715b843d43e734652aa382cba824a84a67c81f75b338b"}, - {file = "aiohttp-3.11.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:85de9904bc360fd29a98885d2bfcbd4e02ab33c53353cb70607f2bea2cb92468"}, - {file = "aiohttp-3.11.2-cp312-cp312-win32.whl", hash = "sha256:b470de64d17156c37e91effc109d3b032b39867000e2c126732fe01d034441f9"}, - {file = "aiohttp-3.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:3f617a48b70f4843d54f52440ea1e58da6bdab07b391a3a6aed8d3b311a4cc04"}, - {file = "aiohttp-3.11.2.tar.gz", hash = "sha256:68d1f46f9387db3785508f5225d3acbc5825ca13d9c29f2b5cce203d5863eb79"}, -] - -[[package]] -name = "aiosignal" -version = "1.3.1" -summary = "" -dependencies = [ - "frozenlist", -] -files = [ - {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, - {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, -] - -[[package]] -name = "annotated-types" -version = "0.7.0" -summary = "" -files = [ - {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, - {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, -] - -[[package]] -name = "anyio" -version = "4.6.2.post1" -summary = "" -dependencies = [ - "idna", - "sniffio", -] -files = [ - {file = "anyio-4.6.2.post1-py3-none-any.whl", hash = "sha256:6d170c36fba3bdd840c73d3868c1e777e33676a69c3a72cf0a0d5d6d8009b61d"}, - {file = "anyio-4.6.2.post1.tar.gz", hash = "sha256:4c8bc31ccdb51c7f7bd251f51c609e038d63e34219b44aa86e47576389880b4c"}, -] - -[[package]] -name = "asyncpg" -version = "0.30.0" -summary = "" -files = [ - {file = "asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e"}, - {file = "asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a"}, - {file = "asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3"}, - {file = "asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737"}, - {file = "asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a"}, - {file = "asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af"}, - {file = "asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e"}, - {file = "asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305"}, - {file = "asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851"}, -] - -[[package]] -name = "attrs" -version = "24.2.0" -summary = "" -files = [ - {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, - {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, -] - -[[package]] -name = "certifi" -version = "2024.8.30" -summary = "" -files = [ - {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, - {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.0" -summary = "" -files = [ - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9"}, - {file = "charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079"}, - {file = "charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e"}, -] - -[[package]] -name = "click" -version = "8.1.7" -summary = "" -dependencies = [ - "colorama; platform_system == \"Windows\"", -] -files = [ - {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, - {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, -] - -[[package]] -name = "colorama" -version = "0.4.6" -summary = "" -files = [ - {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, - {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, -] - -[[package]] -name = "datasets" -version = "3.1.0" -summary = "" -dependencies = [ - "aiohttp", - "dill", - "filelock", - "fsspec", - "huggingface-hub", - "multiprocess", - "numpy", - "packaging", - "pandas", - "pyarrow", - "pyyaml", - "requests", - "tqdm", - "xxhash", -] -files = [ - {file = "datasets-3.1.0-py3-none-any.whl", hash = "sha256:dc8808a6d17838fe05e13b39aa7ac3ea0fd0806ed7004eaf4d4eb2c2a356bc61"}, - {file = "datasets-3.1.0.tar.gz", hash = "sha256:c92cac049e0f9f85b0dd63739c68e564c657b1624bc2b66b1e13489062832e27"}, -] - -[[package]] -name = "dill" -version = "0.3.8" -summary = "" -files = [ - {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, - {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, -] - -[[package]] -name = "dnspython" -version = "2.7.0" -summary = "" -files = [ - {file = "dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86"}, - {file = "dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1"}, -] - -[[package]] -name = "easyocr" -version = "1.7.2" -summary = "" -dependencies = [ - "ninja", - "numpy", - "opencv-python-headless", - "pillow", - "pyclipper", - "python-bidi", - "pyyaml", - "scikit-image", - "scipy", - "shapely", - "torch", - "torchvision", -] -files = [ - {file = "easyocr-1.7.2-py3-none-any.whl", hash = "sha256:5be12f9b0e595d443c9c3d10b0542074b50f0ec2d98b141a109cd961fd1c177c"}, -] - -[[package]] -name = "email-validator" -version = "2.2.0" -summary = "" -dependencies = [ - "dnspython", - "idna", -] -files = [ - {file = "email_validator-2.2.0-py3-none-any.whl", hash = "sha256:561977c2d73ce3611850a06fa56b414621e0c8faa9d66f2611407d87465da631"}, - {file = "email_validator-2.2.0.tar.gz", hash = "sha256:cb690f344c617a714f22e66ae771445a1ceb46821152df8e165c5f9a364582b7"}, -] - -[[package]] -name = "fastapi" -version = "0.115.5" -summary = "" -dependencies = [ - "pydantic", - "starlette", - "typing-extensions", -] -files = [ - {file = "fastapi-0.115.5-py3-none-any.whl", hash = "sha256:596b95adbe1474da47049e802f9a65ab2ffa9c2b07e7efee70eb8a66c9f2f796"}, - {file = "fastapi-0.115.5.tar.gz", hash = "sha256:0e7a4d0dc0d01c68df21887cce0945e72d3c48b9f4f79dfe7a7d53aa08fbb289"}, -] - -[[package]] -name = "fastapi-cli" -version = "0.0.5" -summary = "" -dependencies = [ - "typer", - "uvicorn", -] -files = [ - {file = "fastapi_cli-0.0.5-py3-none-any.whl", hash = "sha256:e94d847524648c748a5350673546bbf9bcaeb086b33c24f2e82e021436866a46"}, - {file = "fastapi_cli-0.0.5.tar.gz", hash = "sha256:d30e1239c6f46fcb95e606f02cdda59a1e2fa778a54b64686b3ff27f6211ff9f"}, -] - -[[package]] -name = "fastapi-cli" -version = "0.0.5" -extras = ["standard"] -summary = "" -dependencies = [ - "fastapi-cli==0.0.5", - "uvicorn", -] -files = [ - {file = "fastapi_cli-0.0.5-py3-none-any.whl", hash = "sha256:e94d847524648c748a5350673546bbf9bcaeb086b33c24f2e82e021436866a46"}, - {file = "fastapi_cli-0.0.5.tar.gz", hash = "sha256:d30e1239c6f46fcb95e606f02cdda59a1e2fa778a54b64686b3ff27f6211ff9f"}, -] - -[[package]] -name = "fastapi" -version = "0.115.5" -extras = ["standard"] -summary = "" -dependencies = [ - "email-validator", - "fastapi-cli", - "fastapi==0.115.5", - "httpx", - "jinja2", - "python-multipart", - "uvicorn", -] -files = [ - {file = "fastapi-0.115.5-py3-none-any.whl", hash = "sha256:596b95adbe1474da47049e802f9a65ab2ffa9c2b07e7efee70eb8a66c9f2f796"}, - {file = "fastapi-0.115.5.tar.gz", hash = "sha256:0e7a4d0dc0d01c68df21887cce0945e72d3c48b9f4f79dfe7a7d53aa08fbb289"}, -] - -[[package]] -name = "filelock" -version = "3.16.1" -summary = "" -files = [ - {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, - {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, -] - -[[package]] -name = "frozenlist" -version = "1.5.0" -summary = "" -files = [ - {file = "frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21"}, - {file = "frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d"}, - {file = "frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f"}, - {file = "frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8"}, - {file = "frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f"}, - {file = "frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3"}, - {file = "frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817"}, -] - -[[package]] -name = "fsspec" -version = "2024.9.0" -summary = "" -files = [ - {file = "fsspec-2024.9.0-py3-none-any.whl", hash = "sha256:a0947d552d8a6efa72cc2c730b12c41d043509156966cca4fb157b0f2a0c574b"}, - {file = "fsspec-2024.9.0.tar.gz", hash = "sha256:4b0afb90c2f21832df142f292649035d80b421f60a9e1c027802e5a0da2b04e8"}, -] - -[[package]] -name = "fsspec" -version = "2024.9.0" -extras = ["http"] -summary = "" -dependencies = [ - "aiohttp", - "fsspec==2024.9.0", -] -files = [ - {file = "fsspec-2024.9.0-py3-none-any.whl", hash = "sha256:a0947d552d8a6efa72cc2c730b12c41d043509156966cca4fb157b0f2a0c574b"}, - {file = "fsspec-2024.9.0.tar.gz", hash = "sha256:4b0afb90c2f21832df142f292649035d80b421f60a9e1c027802e5a0da2b04e8"}, -] - -[[package]] -name = "greenlet" -version = "3.1.1" -summary = "" -files = [ - {file = "greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9"}, - {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0"}, - {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942"}, - {file = "greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01"}, - {file = "greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467"}, -] - -[[package]] -name = "h11" -version = "0.14.0" -summary = "" -files = [ - {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, - {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, -] - -[[package]] -name = "httpcore" -version = "1.0.6" -summary = "" -dependencies = [ - "certifi", - "h11", -] -files = [ - {file = "httpcore-1.0.6-py3-none-any.whl", hash = "sha256:27b59625743b85577a8c0e10e55b50b5368a4f2cfe8cc7bcfa9cf00829c2682f"}, - {file = "httpcore-1.0.6.tar.gz", hash = "sha256:73f6dbd6eb8c21bbf7ef8efad555481853f5f6acdeaff1edb0694289269ee17f"}, -] - -[[package]] -name = "httptools" -version = "0.6.4" -summary = "" -files = [ - {file = "httptools-0.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df017d6c780287d5c80601dafa31f17bddb170232d85c066604d8558683711a2"}, - {file = "httptools-0.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:85071a1e8c2d051b507161f6c3e26155b5c790e4e28d7f236422dbacc2a9cc44"}, - {file = "httptools-0.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69422b7f458c5af875922cdb5bd586cc1f1033295aa9ff63ee196a87519ac8e1"}, - {file = "httptools-0.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16e603a3bff50db08cd578d54f07032ca1631450ceb972c2f834c2b860c28ea2"}, - {file = "httptools-0.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec4f178901fa1834d4a060320d2f3abc5c9e39766953d038f1458cb885f47e81"}, - {file = "httptools-0.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb89ecf8b290f2e293325c646a211ff1c2493222798bb80a530c5e7502494f"}, - {file = "httptools-0.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:db78cb9ca56b59b016e64b6031eda5653be0589dba2b1b43453f6e8b405a0970"}, - {file = "httptools-0.6.4.tar.gz", hash = "sha256:4e93eee4add6493b59a5c514da98c939b244fce4a0d8879cd3f466562f4b7d5c"}, -] - -[[package]] -name = "httpx" -version = "0.27.2" -summary = "" -dependencies = [ - "anyio", - "certifi", - "httpcore", - "idna", - "sniffio", -] -files = [ - {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, - {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, -] - -[[package]] -name = "huggingface-hub" -version = "0.26.1" -summary = "" -dependencies = [ - "filelock", - "fsspec", - "packaging", - "pyyaml", - "requests", - "tqdm", - "typing-extensions", -] -files = [ - {file = "huggingface_hub-0.26.1-py3-none-any.whl", hash = "sha256:5927a8fc64ae68859cd954b7cc29d1c8390a5e15caba6d3d349c973be8fdacf3"}, - {file = "huggingface_hub-0.26.1.tar.gz", hash = "sha256:414c0d9b769eecc86c70f9d939d0f48bb28e8461dd1130021542eff0212db890"}, -] - -[[package]] -name = "idna" -version = "3.10" -summary = "" -files = [ - {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, - {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, -] - -[[package]] -name = "imageio" -version = "2.36.0" -summary = "" -dependencies = [ - "numpy", - "pillow", -] -files = [ - {file = "imageio-2.36.0-py3-none-any.whl", hash = "sha256:471f1eda55618ee44a3c9960911c35e647d9284c68f077e868df633398f137f0"}, - {file = "imageio-2.36.0.tar.gz", hash = "sha256:1c8f294db862c256e9562354d65aa54725b8dafed7f10f02bb3ec20ec1678850"}, -] - -[[package]] -name = "jinja2" -version = "3.1.4" -summary = "" -dependencies = [ - "markupsafe", -] -files = [ - {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"}, - {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"}, -] - -[[package]] -name = "jsonpatch" -version = "1.33" -summary = "" -dependencies = [ - "jsonpointer", -] -files = [ - {file = "jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade"}, - {file = "jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c"}, -] - -[[package]] -name = "jsonpointer" -version = "3.0.0" -summary = "" -files = [ - {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, - {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, -] - -[[package]] -name = "langchain" -version = "0.3.9" -summary = "" -dependencies = [ - "aiohttp", - "langchain-core", - "langchain-text-splitters", - "langsmith", - "numpy", - "pydantic", - "pyyaml", - "requests", - "sqlalchemy", - "tenacity", -] -files = [ - {file = "langchain-0.3.9-py3-none-any.whl", hash = "sha256:ade5a1fee2f94f2e976a6c387f97d62cc7f0b9f26cfe0132a41d2bda761e1045"}, - {file = "langchain-0.3.9.tar.gz", hash = "sha256:4950c4ad627d0aa95ce6bda7de453e22059b7e7836b562a8f781fb0b05d7294c"}, -] - -[[package]] -name = "langchain-core" -version = "0.3.21" -summary = "" -dependencies = [ - "jsonpatch", - "langsmith", - "packaging", - "pydantic", - "pyyaml", - "tenacity", - "typing-extensions", -] -files = [ - {file = "langchain_core-0.3.21-py3-none-any.whl", hash = "sha256:7e723dff80946a1198976c6876fea8326dc82566ef9bcb5f8d9188f738733665"}, - {file = "langchain_core-0.3.21.tar.gz", hash = "sha256:561b52b258ffa50a9fb11d7a1940ebfd915654d1ec95b35e81dfd5ee84143411"}, -] - -[[package]] -name = "langchain-ollama" -version = "0.2.0" -summary = "" -dependencies = [ - "langchain-core", - "ollama", -] -files = [ - {file = "langchain_ollama-0.2.0-py3-none-any.whl", hash = "sha256:aa5b794599652494a07fd27b22784854480cd4c793f0db5e81ebeccc2affd135"}, - {file = "langchain_ollama-0.2.0.tar.gz", hash = "sha256:250ad9f3edce1a0ca16e4fad19f783ac728d7d76888ba952c462cd9f680353f7"}, -] - -[[package]] -name = "langchain-text-splitters" -version = "0.3.2" -summary = "" -dependencies = [ - "langchain-core", -] -files = [ - {file = "langchain_text_splitters-0.3.2-py3-none-any.whl", hash = "sha256:0db28c53f41d1bc024cdb3b1646741f6d46d5371e90f31e7e7c9fbe75d01c726"}, - {file = "langchain_text_splitters-0.3.2.tar.gz", hash = "sha256:81e6515d9901d6dd8e35fb31ccd4f30f76d44b771890c789dc835ef9f16204df"}, -] - -[[package]] -name = "langsmith" -version = "0.1.147" -summary = "" -dependencies = [ - "httpx", - "orjson; platform_python_implementation != \"PyPy\"", - "pydantic", - "requests", - "requests-toolbelt", -] -files = [ - {file = "langsmith-0.1.147-py3-none-any.whl", hash = "sha256:7166fc23b965ccf839d64945a78e9f1157757add228b086141eb03a60d699a15"}, - {file = "langsmith-0.1.147.tar.gz", hash = "sha256:2e933220318a4e73034657103b3b1a3a6109cc5db3566a7e8e03be8d6d7def7a"}, -] - -[[package]] -name = "lazy-loader" -version = "0.4" -summary = "" -dependencies = [ - "packaging", -] -files = [ - {file = "lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc"}, - {file = "lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1"}, -] - -[[package]] -name = "lightning" -version = "2.4.0" -summary = "" -dependencies = [ - "fsspec", - "lightning-utilities", - "packaging", - "pytorch-lightning", - "pyyaml", - "torch", - "torchmetrics", - "tqdm", - "typing-extensions", -] -files = [ - {file = "lightning-2.4.0-py3-none-any.whl", hash = "sha256:560163af9711cf59055c448232c473150a299089efce0d2be3cc3288082d8768"}, - {file = "lightning-2.4.0.tar.gz", hash = "sha256:9156604cc56e4b2b603f34fa7f0fe5107375c8e6d85e74544b319a15faa9ed0e"}, -] - -[[package]] -name = "lightning-utilities" -version = "0.11.8" -summary = "" -dependencies = [ - "packaging", - "setuptools", - "typing-extensions", -] -files = [ - {file = "lightning_utilities-0.11.8-py3-none-any.whl", hash = "sha256:a57edb34a44258f0c61eed8b8b88926766e9052f5e60bbe69e4871a2b2bfd970"}, - {file = "lightning_utilities-0.11.8.tar.gz", hash = "sha256:8dfbdc6c52f9847efc948dc462ab8bebb4f4e9a43bd69c82c1b1da484dac20e6"}, -] - -[[package]] -name = "markdown-it-py" -version = "3.0.0" -summary = "" -dependencies = [ - "mdurl", -] -files = [ - {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, - {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, -] - -[[package]] -name = "markupsafe" -version = "3.0.2" -summary = "" -files = [ - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87"}, - {file = "markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0"}, -] - -[[package]] -name = "mdurl" -version = "0.1.2" -summary = "" -files = [ - {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, - {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, -] - -[[package]] -name = "mpmath" -version = "1.3.0" -summary = "" -files = [ - {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, - {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, -] - -[[package]] -name = "multidict" -version = "6.1.0" -summary = "" -files = [ - {file = "multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa"}, - {file = "multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436"}, - {file = "multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761"}, - {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e"}, - {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef"}, - {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95"}, - {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925"}, - {file = "multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966"}, - {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305"}, - {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2"}, - {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2"}, - {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6"}, - {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3"}, - {file = "multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133"}, - {file = "multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1"}, - {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, - {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, -] - -[[package]] -name = "multiprocess" -version = "0.70.16" -summary = "" -dependencies = [ - "dill", -] -files = [ - {file = "multiprocess-0.70.16-py310-none-any.whl", hash = "sha256:c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02"}, - {file = "multiprocess-0.70.16-py311-none-any.whl", hash = "sha256:af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a"}, - {file = "multiprocess-0.70.16-py312-none-any.whl", hash = "sha256:fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e"}, - {file = "multiprocess-0.70.16-py38-none-any.whl", hash = "sha256:a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435"}, - {file = "multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3"}, - {file = "multiprocess-0.70.16.tar.gz", hash = "sha256:161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1"}, -] - -[[package]] -name = "networkx" -version = "3.4.2" -summary = "" -files = [ - {file = "networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f"}, - {file = "networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1"}, -] - -[[package]] -name = "ninja" -version = "1.11.1.1" -summary = "" -files = [ - {file = "ninja-1.11.1.1-py2.py3-none-macosx_10_9_universal2.macosx_10_9_x86_64.macosx_11_0_arm64.macosx_11_0_universal2.whl", hash = "sha256:376889c76d87b95b5719fdd61dd7db193aa7fd4432e5d52d2e44e4c497bdbbee"}, - {file = "ninja-1.11.1.1-py2.py3-none-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:ecf80cf5afd09f14dcceff28cb3f11dc90fb97c999c89307aea435889cb66877"}, - {file = "ninja-1.11.1.1-py2.py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:84502ec98f02a037a169c4b0d5d86075eaf6afc55e1879003d6cab51ced2ea4b"}, - {file = "ninja-1.11.1.1-py2.py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:73b93c14046447c7c5cc892433d4fae65d6364bec6685411cb97a8bcf815f93a"}, - {file = "ninja-1.11.1.1-py2.py3-none-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:18302d96a5467ea98b68e1cae1ae4b4fb2b2a56a82b955193c637557c7273dbd"}, - {file = "ninja-1.11.1.1-py2.py3-none-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aad34a70ef15b12519946c5633344bc775a7656d789d9ed5fdb0d456383716ef"}, - {file = "ninja-1.11.1.1-py2.py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:d491fc8d89cdcb416107c349ad1e3a735d4c4af5e1cb8f5f727baca6350fdaea"}, - {file = "ninja-1.11.1.1-py2.py3-none-musllinux_1_1_i686.whl", hash = "sha256:7563ce1d9fe6ed5af0b8dd9ab4a214bf4ff1f2f6fd6dc29f480981f0f8b8b249"}, - {file = "ninja-1.11.1.1-py2.py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:9df724344202b83018abb45cb1efc22efd337a1496514e7e6b3b59655be85205"}, - {file = "ninja-1.11.1.1-py2.py3-none-musllinux_1_1_s390x.whl", hash = "sha256:3e0f9be5bb20d74d58c66cc1c414c3e6aeb45c35b0d0e41e8d739c2c0d57784f"}, - {file = "ninja-1.11.1.1-py2.py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:76482ba746a2618eecf89d5253c0d1e4f1da1270d41e9f54dfbd91831b0f6885"}, - {file = "ninja-1.11.1.1-py2.py3-none-win32.whl", hash = "sha256:fa2ba9d74acfdfbfbcf06fad1b8282de8a7a8c481d9dee45c859a8c93fcc1082"}, - {file = "ninja-1.11.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:95da904130bfa02ea74ff9c0116b4ad266174fafb1c707aa50212bc7859aebf1"}, - {file = "ninja-1.11.1.1-py2.py3-none-win_arm64.whl", hash = "sha256:185e0641bde601e53841525c4196278e9aaf4463758da6dd1e752c0a0f54136a"}, - {file = "ninja-1.11.1.1.tar.gz", hash = "sha256:9d793b08dd857e38d0b6ffe9e6b7145d7c485a42dcfea04905ca0cdb6017cc3c"}, -] - -[[package]] -name = "numpy" -version = "2.1.3" -summary = "" -files = [ - {file = "numpy-2.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f55ba01150f52b1027829b50d70ef1dafd9821ea82905b63936668403c3b471e"}, - {file = "numpy-2.1.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13138eadd4f4da03074851a698ffa7e405f41a0845a6b1ad135b81596e4e9958"}, - {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a6b46587b14b888e95e4a24d7b13ae91fa22386c199ee7b418f449032b2fa3b8"}, - {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:0fa14563cc46422e99daef53d725d0c326e99e468a9320a240affffe87852564"}, - {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8637dcd2caa676e475503d1f8fdb327bc495554e10838019651b76d17b98e512"}, - {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2312b2aa89e1f43ecea6da6ea9a810d06aae08321609d8dc0d0eda6d946a541b"}, - {file = "numpy-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a38c19106902bb19351b83802531fea19dee18e5b37b36454f27f11ff956f7fc"}, - {file = "numpy-2.1.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02135ade8b8a84011cbb67dc44e07c58f28575cf9ecf8ab304e51c05528c19f0"}, - {file = "numpy-2.1.3-cp312-cp312-win32.whl", hash = "sha256:e6988e90fcf617da2b5c78902fe8e668361b43b4fe26dbf2d7b0f8034d4cafb9"}, - {file = "numpy-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:0d30c543f02e84e92c4b1f415b7c6b5326cbe45ee7882b6b77db7195fb971e3a"}, - {file = "numpy-2.1.3.tar.gz", hash = "sha256:aa08e04e08aaf974d4458def539dece0d28146d866a39da5639596f4921fd761"}, -] - -[[package]] -name = "nvidia-cublas-cu12" -version = "12.4.5.8" -summary = "" -files = [ - {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0f8aa1706812e00b9f19dfe0cdb3999b092ccb8ca168c0db5b8ea712456fd9b3"}, - {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b"}, -] - -[[package]] -name = "nvidia-cuda-cupti-cu12" -version = "12.4.127" -summary = "" -files = [ - {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:79279b35cf6f91da114182a5ce1864997fd52294a87a16179ce275773799458a"}, - {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb"}, -] - -[[package]] -name = "nvidia-cuda-nvrtc-cu12" -version = "12.4.127" -summary = "" -files = [ - {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0eedf14185e04b76aa05b1fea04133e59f465b6f960c0cbf4e37c3cb6b0ea198"}, - {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338"}, -] - -[[package]] -name = "nvidia-cuda-runtime-cu12" -version = "12.4.127" -summary = "" -files = [ - {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:961fe0e2e716a2a1d967aab7caee97512f71767f852f67432d572e36cb3a11f3"}, - {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5"}, -] - -[[package]] -name = "nvidia-cudnn-cu12" -version = "9.1.0.70" -summary = "" -dependencies = [ - "nvidia-cublas-cu12", -] -files = [ - {file = "nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f"}, -] - -[[package]] -name = "nvidia-cufft-cu12" -version = "11.2.1.3" -summary = "" -dependencies = [ - "nvidia-nvjitlink-cu12", -] -files = [ - {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5dad8008fc7f92f5ddfa2101430917ce2ffacd86824914c82e28990ad7f00399"}, - {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9"}, -] - -[[package]] -name = "nvidia-curand-cu12" -version = "10.3.5.147" -summary = "" -files = [ - {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1f173f09e3e3c76ab084aba0de819c49e56614feae5c12f69883f4ae9bb5fad9"}, - {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b"}, -] - -[[package]] -name = "nvidia-cusolver-cu12" -version = "11.6.1.9" -summary = "" -dependencies = [ - "nvidia-cublas-cu12", - "nvidia-cusparse-cu12", - "nvidia-nvjitlink-cu12", -] -files = [ - {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d338f155f174f90724bbde3758b7ac375a70ce8e706d70b018dd3375545fc84e"}, - {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl", hash = "sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260"}, -] - -[[package]] -name = "nvidia-cusparse-cu12" -version = "12.3.1.170" -summary = "" -dependencies = [ - "nvidia-nvjitlink-cu12", -] -files = [ - {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_aarch64.whl", hash = "sha256:9d32f62896231ebe0480efd8a7f702e143c98cfaa0e8a76df3386c1ba2b54df3"}, - {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1"}, -] - -[[package]] -name = "nvidia-nccl-cu12" -version = "2.21.5" -summary = "" -files = [ - {file = "nvidia_nccl_cu12-2.21.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0"}, -] - -[[package]] -name = "nvidia-nvjitlink-cu12" -version = "12.4.127" -summary = "" -files = [ - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83"}, - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57"}, -] - -[[package]] -name = "nvidia-nvtx-cu12" -version = "12.4.127" -summary = "" -files = [ - {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7959ad635db13edf4fc65c06a6e9f9e55fc2f92596db928d169c0bb031e88ef3"}, - {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a"}, -] - -[[package]] -name = "ollama" -version = "0.4.2" -summary = "" -dependencies = [ - "httpx", - "pydantic", -] -files = [ - {file = "ollama-0.4.2-py3-none-any.whl", hash = "sha256:3059fe1fe34e24c782e9e8eebf69bcd2d7037007cb4b3cfda4b32bfee36ae2ef"}, - {file = "ollama-0.4.2.tar.gz", hash = "sha256:5dffc826737a1d121c9ae371439cace20ab02ec4b0840fd55c56efa9a3fb3646"}, -] - -[[package]] -name = "opencv-python-headless" -version = "4.10.0.84" -summary = "" -dependencies = [ - "numpy", -] -files = [ - {file = "opencv-python-headless-4.10.0.84.tar.gz", hash = "sha256:f2017c6101d7c2ef8d7bc3b414c37ff7f54d64413a1847d89970b6b7069b4e1a"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a4f4bcb07d8f8a7704d9c8564c224c8b064c63f430e95b61ac0bffaa374d330e"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:5ae454ebac0eb0a0b932e3406370aaf4212e6a3fdb5038cc86c7aea15a6851da"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46071015ff9ab40fccd8a163da0ee14ce9846349f06c6c8c0f2870856ffa45db"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:377d08a7e48a1405b5e84afcbe4798464ce7ee17081c1c23619c8b398ff18295"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:9092404b65458ed87ce932f613ffbb1106ed2c843577501e5768912360fc50ec"}, - {file = "opencv_python_headless-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:afcf28bd1209dd58810d33defb622b325d3cbe49dcd7a43a902982c33e5fad05"}, -] - -[[package]] -name = "orjson" -version = "3.10.12" -summary = "" -files = [ - {file = "orjson-3.10.12-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:53206d72eb656ca5ac7d3a7141e83c5bbd3ac30d5eccfe019409177a57634b0d"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac8010afc2150d417ebda810e8df08dd3f544e0dd2acab5370cfa6bcc0662f8f"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed459b46012ae950dd2e17150e838ab08215421487371fa79d0eced8d1461d70"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8dcb9673f108a93c1b52bfc51b0af422c2d08d4fc710ce9c839faad25020bb69"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22a51ae77680c5c4652ebc63a83d5255ac7d65582891d9424b566fb3b5375ee9"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:910fdf2ac0637b9a77d1aad65f803bac414f0b06f720073438a7bd8906298192"}, - {file = "orjson-3.10.12-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:24ce85f7100160936bc2116c09d1a8492639418633119a2224114f67f63a4559"}, - {file = "orjson-3.10.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a76ba5fc8dd9c913640292df27bff80a685bed3a3c990d59aa6ce24c352f8fc"}, - {file = "orjson-3.10.12-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ff70ef093895fd53f4055ca75f93f047e088d1430888ca1229393a7c0521100f"}, - {file = "orjson-3.10.12-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f4244b7018b5753ecd10a6d324ec1f347da130c953a9c88432c7fbc8875d13be"}, - {file = "orjson-3.10.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:16135ccca03445f37921fa4b585cff9a58aa8d81ebcb27622e69bfadd220b32c"}, - {file = "orjson-3.10.12-cp312-none-win32.whl", hash = "sha256:2d879c81172d583e34153d524fcba5d4adafbab8349a7b9f16ae511c2cee8708"}, - {file = "orjson-3.10.12-cp312-none-win_amd64.whl", hash = "sha256:fc23f691fa0f5c140576b8c365bc942d577d861a9ee1142e4db468e4e17094fb"}, - {file = "orjson-3.10.12.tar.gz", hash = "sha256:0a78bbda3aea0f9f079057ee1ee8a1ecf790d4f1af88dd67493c6b8ee52506ff"}, -] - -[[package]] -name = "packaging" -version = "24.1" -summary = "" -files = [ - {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, - {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, -] - -[[package]] -name = "pandas" -version = "2.2.3" -summary = "" -dependencies = [ - "numpy", - "python-dateutil", - "pytz", - "tzdata", -] -files = [ - {file = "pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9"}, - {file = "pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4"}, - {file = "pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3"}, - {file = "pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319"}, - {file = "pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8"}, - {file = "pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a"}, - {file = "pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13"}, - {file = "pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667"}, -] - -[[package]] -name = "pdf2image" -version = "1.17.0" -summary = "" -dependencies = [ - "pillow", -] -files = [ - {file = "pdf2image-1.17.0-py3-none-any.whl", hash = "sha256:ecdd58d7afb810dffe21ef2b1bbc057ef434dabbac6c33778a38a3f7744a27e2"}, - {file = "pdf2image-1.17.0.tar.gz", hash = "sha256:eaa959bc116b420dd7ec415fcae49b98100dda3dd18cd2fdfa86d09f112f6d57"}, -] - -[[package]] -name = "pillow" -version = "11.0.0" -summary = "" -files = [ - {file = "pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923"}, - {file = "pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903"}, - {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4"}, - {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f"}, - {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9"}, - {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7"}, - {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6"}, - {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc"}, - {file = "pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6"}, - {file = "pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47"}, - {file = "pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25"}, - {file = "pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739"}, -] - -[[package]] -name = "propcache" -version = "0.2.0" -summary = "" -files = [ - {file = "propcache-0.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ee7606193fb267be4b2e3b32714f2d58cad27217638db98a60f9efb5efeccc2"}, - {file = "propcache-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:91ee8fc02ca52e24bcb77b234f22afc03288e1dafbb1f88fe24db308910c4ac7"}, - {file = "propcache-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e900bad2a8456d00a113cad8c13343f3b1f327534e3589acc2219729237a2e8"}, - {file = "propcache-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f52a68c21363c45297aca15561812d542f8fc683c85201df0bebe209e349f793"}, - {file = "propcache-0.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e41d67757ff4fbc8ef2af99b338bfb955010444b92929e9e55a6d4dcc3c4f09"}, - {file = "propcache-0.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a64e32f8bd94c105cc27f42d3b658902b5bcc947ece3c8fe7bc1b05982f60e89"}, - {file = "propcache-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55346705687dbd7ef0d77883ab4f6fabc48232f587925bdaf95219bae072491e"}, - {file = "propcache-0.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00181262b17e517df2cd85656fcd6b4e70946fe62cd625b9d74ac9977b64d8d9"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6994984550eaf25dd7fc7bd1b700ff45c894149341725bb4edc67f0ffa94efa4"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:56295eb1e5f3aecd516d91b00cfd8bf3a13991de5a479df9e27dd569ea23959c"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:439e76255daa0f8151d3cb325f6dd4a3e93043e6403e6491813bcaaaa8733887"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f6475a1b2ecb310c98c28d271a30df74f9dd436ee46d09236a6b750a7599ce57"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3444cdba6628accf384e349014084b1cacd866fbb88433cd9d279d90a54e0b23"}, - {file = "propcache-0.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a9d9b4d0a9b38d1c391bb4ad24aa65f306c6f01b512e10a8a34a2dc5675d348"}, - {file = "propcache-0.2.0-cp312-cp312-win32.whl", hash = "sha256:69d3a98eebae99a420d4b28756c8ce6ea5a29291baf2dc9ff9414b42676f61d5"}, - {file = "propcache-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:ad9c9b99b05f163109466638bd30ada1722abb01bbb85c739c50b6dc11f92dc3"}, - {file = "propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036"}, - {file = "propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70"}, -] - -[[package]] -name = "psutil" -version = "6.1.0" -summary = "" -files = [ - {file = "psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688"}, - {file = "psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e"}, - {file = "psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38"}, - {file = "psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b"}, - {file = "psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a"}, - {file = "psutil-6.1.0-cp37-abi3-win32.whl", hash = "sha256:1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e"}, - {file = "psutil-6.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be"}, - {file = "psutil-6.1.0.tar.gz", hash = "sha256:353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a"}, -] - -[[package]] -name = "psycopg2-binary" -version = "2.9.10" -summary = "" -files = [ - {file = "psycopg2-binary-2.9.10.tar.gz", hash = "sha256:4b3df0e6990aa98acda57d983942eff13d824135fe2250e6522edaa782a06de2"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:880845dfe1f85d9d5f7c412efea7a08946a46894537e4e5d091732eb1d34d9a0"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9440fa522a79356aaa482aa4ba500b65f28e5d0e63b801abf6aa152a29bd842a"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3923c1d9870c49a2d44f795df0c889a22380d36ef92440ff618ec315757e539"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7b2c956c028ea5de47ff3a8d6b3cc3330ab45cf0b7c3da35a2d6ff8420896526"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f758ed67cab30b9a8d2833609513ce4d3bd027641673d4ebc9c067e4d208eec1"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cd9b4f2cfab88ed4a9106192de509464b75a906462fb846b936eabe45c2063e"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dc08420625b5a20b53551c50deae6e231e6371194fa0651dbe0fb206452ae1f"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7cd730dfa7c36dbe8724426bf5612798734bff2d3c3857f36f2733f5bfc7c00"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:155e69561d54d02b3c3209545fb08938e27889ff5a10c19de8d23eb5a41be8a5"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3cc28a6fd5a4a26224007712e79b81dbaee2ffb90ff406256158ec4d7b52b47"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-win32.whl", hash = "sha256:ec8a77f521a17506a24a5f626cb2aee7850f9b69a0afe704586f63a464f3cd64"}, - {file = "psycopg2_binary-2.9.10-cp312-cp312-win_amd64.whl", hash = "sha256:18c5ee682b9c6dd3696dad6e54cc7ff3a1a9020df6a5c0f861ef8bfd338c3ca0"}, -] - -[[package]] -name = "pyarrow" -version = "18.0.0" -summary = "" -files = [ - {file = "pyarrow-18.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:e7ab04f272f98ebffd2a0661e4e126036f6936391ba2889ed2d44c5006237802"}, - {file = "pyarrow-18.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:03f40b65a43be159d2f97fd64dc998f769d0995a50c00f07aab58b0b3da87e1f"}, - {file = "pyarrow-18.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be08af84808dff63a76860847c48ec0416928a7b3a17c2f49a072cac7c45efbd"}, - {file = "pyarrow-18.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c70c1965cde991b711a98448ccda3486f2a336457cf4ec4dca257a926e149c9"}, - {file = "pyarrow-18.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:00178509f379415a3fcf855af020e3340254f990a8534294ec3cf674d6e255fd"}, - {file = "pyarrow-18.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a71ab0589a63a3e987beb2bc172e05f000a5c5be2636b4b263c44034e215b5d7"}, - {file = "pyarrow-18.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:fe92efcdbfa0bcf2fa602e466d7f2905500f33f09eb90bf0bcf2e6ca41b574c8"}, - {file = "pyarrow-18.0.0.tar.gz", hash = "sha256:a6aa027b1a9d2970cf328ccd6dbe4a996bc13c39fd427f502782f5bdb9ca20f5"}, -] - -[[package]] -name = "pyclipper" -version = "1.3.0.post6" -summary = "" -files = [ - {file = "pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:6363b9d79ba1b5d8f32d1623e797c1e9f994600943402e68d5266067bdde173e"}, - {file = "pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:32cd7fb9c1c893eb87f82a072dbb5e26224ea7cebbad9dc306d67e1ac62dd229"}, - {file = "pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3aab10e3c10ed8fa60c608fb87c040089b83325c937f98f06450cf9fcfdaf1d"}, - {file = "pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58eae2ff92a8cae1331568df076c4c5775bf946afab0068b217f0cf8e188eb3c"}, - {file = "pyclipper-1.3.0.post6-cp312-cp312-win32.whl", hash = "sha256:793b0aa54b914257aa7dc76b793dd4dcfb3c84011d48df7e41ba02b571616eaf"}, - {file = "pyclipper-1.3.0.post6-cp312-cp312-win_amd64.whl", hash = "sha256:d3f9da96f83b8892504923beb21a481cd4516c19be1d39eb57a92ef1c9a29548"}, - {file = "pyclipper-1.3.0.post6.tar.gz", hash = "sha256:42bff0102fa7a7f2abdd795a2594654d62b786d0c6cd67b72d469114fdeb608c"}, -] - -[[package]] -name = "pydantic" -version = "2.9.2" -summary = "" -dependencies = [ - "annotated-types", - "pydantic-core", - "typing-extensions", -] -files = [ - {file = "pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12"}, - {file = "pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f"}, -] - -[[package]] -name = "pydantic-core" -version = "2.23.4" -summary = "" -dependencies = [ - "typing-extensions", -] -files = [ - {file = "pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231"}, - {file = "pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36"}, - {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126"}, - {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e"}, - {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24"}, - {file = "pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84"}, - {file = "pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9"}, - {file = "pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863"}, -] - -[[package]] -name = "pygments" -version = "2.18.0" -summary = "" -files = [ - {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, - {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, -] - -[[package]] -name = "pytesseract" -version = "0.3.13" -summary = "" -dependencies = [ - "packaging", - "pillow", -] -files = [ - {file = "pytesseract-0.3.13-py3-none-any.whl", hash = "sha256:7a99c6c2ac598360693d83a416e36e0b33a67638bb9d77fdcac094a3589d4b34"}, - {file = "pytesseract-0.3.13.tar.gz", hash = "sha256:4bf5f880c99406f52a3cfc2633e42d9dc67615e69d8a509d74867d3baddb5db9"}, -] - -[[package]] -name = "python-bidi" -version = "0.6.3" -summary = "" -files = [ - {file = "python_bidi-0.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4bdc9dc1143c558ca6931d6712339a30470959f2b7eecb3d0687db7075c20a87"}, - {file = "python_bidi-0.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0775499b8037103278f05b2bf92d25bf04f40a9f77884ec3d42b01a1e52a40fe"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb3091aa5efbfc4da6fd52a2fccbf7853c6dc253ddaf9a189bcf3c4345865aa9"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c75a9b68b3f5a8da9a33fe37607d9b267a8a3c5806d283a4a47365256773dd1e"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:208e09819ee0485c2ed4dc1932c39fc073dac3f2cb70b6d2ae0b7296e86831e6"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e17b67d86cd38f2bebc4a46090f83cabb0d1da3a3c920c68efe8093ae1a8d0d1"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:933a17938f767fa64a8365732eba787a81c26214d89e1b3abe87912325ba26a9"}, - {file = "python_bidi-0.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:772efb3e0ef17396bfd9d47da4805c74ed6c04f27cac08d7757f76602837fb9d"}, - {file = "python_bidi-0.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9a99114f33f8c0273a61b4afe7d4d715e098318ee4e5ce8f6bb5da8dcd3f95c7"}, - {file = "python_bidi-0.6.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b30e620d39e85a30bb42f460fd8b5274caf261517edeb853b975d9ea1939b6bd"}, - {file = "python_bidi-0.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bee94e3152a6c9ba731e086c9cc6203904290506ba52c505a2e59abab481eb13"}, - {file = "python_bidi-0.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:926164ec594e9ea9a64faf54273c711d5e3233bcc6ef8966c6eeaddfb3b3075f"}, - {file = "python_bidi-0.6.3-cp312-none-win32.whl", hash = "sha256:cea395a7daee14c7d50a7e20890d12b9ff1938d81b23eb564f1707a175c37202"}, - {file = "python_bidi-0.6.3-cp312-none-win_amd64.whl", hash = "sha256:350e6c76f942465871f2b473a2076f5002f1df06e4c7abee3029ccca5f006786"}, - {file = "python_bidi-0.6.3.tar.gz", hash = "sha256:e12114969001a328aea859f79efc30ab9c15241befb86e07029d8961d97fae36"}, -] - -[[package]] -name = "python-dateutil" -version = "2.9.0.post0" -summary = "" -dependencies = [ - "six", -] -files = [ - {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, - {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, -] - -[[package]] -name = "python-dotenv" -version = "1.0.1" -summary = "" -files = [ - {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"}, - {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"}, -] - -[[package]] -name = "python-multipart" -version = "0.0.18" -summary = "" -files = [ - {file = "python_multipart-0.0.18-py3-none-any.whl", hash = "sha256:efe91480f485f6a361427a541db4796f9e1591afc0fb8e7a4ba06bfbc6708996"}, - {file = "python_multipart-0.0.18.tar.gz", hash = "sha256:7a68db60c8bfb82e460637fa4750727b45af1d5e2ed215593f917f64694d34fe"}, -] - -[[package]] -name = "pytorch-lightning" -version = "2.4.0" -summary = "" -dependencies = [ - "fsspec", - "lightning-utilities", - "packaging", - "pyyaml", - "torch", - "torchmetrics", - "tqdm", - "typing-extensions", -] -files = [ - {file = "pytorch-lightning-2.4.0.tar.gz", hash = "sha256:6aa897fd9d6dfa7b7b49f37c2f04e13592861831d08deae584dfda423fdb71c8"}, - {file = "pytorch_lightning-2.4.0-py3-none-any.whl", hash = "sha256:9ac7935229ac022ef06994c928217ed37f525ac6700f7d4fc57009624570e655"}, -] - -[[package]] -name = "pytz" -version = "2024.2" -summary = "" -files = [ - {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, - {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, -] - -[[package]] -name = "pyyaml" -version = "6.0.2" -summary = "" -files = [ - {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"}, - {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"}, - {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"}, - {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, - {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, -] - -[[package]] -name = "regex" -version = "2024.9.11" -summary = "" -files = [ - {file = "regex-2024.9.11-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b0d0a6c64fcc4ef9c69bd5b3b3626cc3776520a1637d8abaa62b9edc147a58f7"}, - {file = "regex-2024.9.11-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:49b0e06786ea663f933f3710a51e9385ce0cba0ea56b67107fd841a55d56a231"}, - {file = "regex-2024.9.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5b513b6997a0b2f10e4fd3a1313568e373926e8c252bd76c960f96fd039cd28d"}, - {file = "regex-2024.9.11-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee439691d8c23e76f9802c42a95cfeebf9d47cf4ffd06f18489122dbb0a7ad64"}, - {file = "regex-2024.9.11-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8f877c89719d759e52783f7fe6e1c67121076b87b40542966c02de5503ace42"}, - {file = "regex-2024.9.11-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23b30c62d0f16827f2ae9f2bb87619bc4fba2044911e2e6c2eb1af0161cdb766"}, - {file = "regex-2024.9.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85ab7824093d8f10d44330fe1e6493f756f252d145323dd17ab6b48733ff6c0a"}, - {file = "regex-2024.9.11-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8dee5b4810a89447151999428fe096977346cf2f29f4d5e29609d2e19e0199c9"}, - {file = "regex-2024.9.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98eeee2f2e63edae2181c886d7911ce502e1292794f4c5ee71e60e23e8d26b5d"}, - {file = "regex-2024.9.11-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:57fdd2e0b2694ce6fc2e5ccf189789c3e2962916fb38779d3e3521ff8fe7a822"}, - {file = "regex-2024.9.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d552c78411f60b1fdaafd117a1fca2f02e562e309223b9d44b7de8be451ec5e0"}, - {file = "regex-2024.9.11-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a0b2b80321c2ed3fcf0385ec9e51a12253c50f146fddb2abbb10f033fe3d049a"}, - {file = "regex-2024.9.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:18406efb2f5a0e57e3a5881cd9354c1512d3bb4f5c45d96d110a66114d84d23a"}, - {file = "regex-2024.9.11-cp312-cp312-win32.whl", hash = "sha256:e464b467f1588e2c42d26814231edecbcfe77f5ac414d92cbf4e7b55b2c2a776"}, - {file = "regex-2024.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:9e8719792ca63c6b8340380352c24dcb8cd7ec49dae36e963742a275dfae6009"}, - {file = "regex-2024.9.11.tar.gz", hash = "sha256:6c188c307e8433bcb63dc1915022deb553b4203a70722fc542c363bf120a01fd"}, -] - -[[package]] -name = "requests" -version = "2.32.3" -summary = "" -dependencies = [ - "certifi", - "charset-normalizer", - "idna", - "urllib3", -] -files = [ - {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, - {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, -] - -[[package]] -name = "requests-toolbelt" -version = "1.0.0" -summary = "" -dependencies = [ - "requests", -] -files = [ - {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"}, - {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"}, -] - -[[package]] -name = "rich" -version = "13.9.4" -summary = "" -dependencies = [ - "markdown-it-py", - "pygments", -] -files = [ - {file = "rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90"}, - {file = "rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098"}, -] - -[[package]] -name = "safetensors" -version = "0.4.5" -summary = "" -files = [ - {file = "safetensors-0.4.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:473300314e026bd1043cef391bb16a8689453363381561b8a3e443870937cc1e"}, - {file = "safetensors-0.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:801183a0f76dc647f51a2d9141ad341f9665602a7899a693207a82fb102cc53e"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1524b54246e422ad6fb6aea1ac71edeeb77666efa67230e1faf6999df9b2e27f"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b3139098e3e8b2ad7afbca96d30ad29157b50c90861084e69fcb80dec7430461"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65573dc35be9059770808e276b017256fa30058802c29e1038eb1c00028502ea"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd33da8e9407559f8779c82a0448e2133737f922d71f884da27184549416bfed"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3685ce7ed036f916316b567152482b7e959dc754fcc4a8342333d222e05f407c"}, - {file = "safetensors-0.4.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dde2bf390d25f67908278d6f5d59e46211ef98e44108727084d4637ee70ab4f1"}, - {file = "safetensors-0.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7469d70d3de970b1698d47c11ebbf296a308702cbaae7fcb993944751cf985f4"}, - {file = "safetensors-0.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3a6ba28118636a130ccbb968bc33d4684c48678695dba2590169d5ab03a45646"}, - {file = "safetensors-0.4.5-cp312-none-win32.whl", hash = "sha256:c859c7ed90b0047f58ee27751c8e56951452ed36a67afee1b0a87847d065eec6"}, - {file = "safetensors-0.4.5-cp312-none-win_amd64.whl", hash = "sha256:b5a8810ad6a6f933fff6c276eae92c1da217b39b4d8b1bc1c0b8af2d270dc532"}, - {file = "safetensors-0.4.5.tar.gz", hash = "sha256:d73de19682deabb02524b3d5d1f8b3aaba94c72f1bbfc7911b9b9d5d391c0310"}, -] - -[[package]] -name = "scikit-image" -version = "0.24.0" -summary = "" -dependencies = [ - "imageio", - "lazy-loader", - "networkx", - "numpy", - "packaging", - "pillow", - "scipy", - "tifffile", -] -files = [ - {file = "scikit_image-0.24.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6fccceb54c9574590abcddc8caf6cefa57c13b5b8b4260ab3ff88ad8f3c252b3"}, - {file = "scikit_image-0.24.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ccc01e4760d655aab7601c1ba7aa4ddd8b46f494ac46ec9c268df6f33ccddf4c"}, - {file = "scikit_image-0.24.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18836a18d3a7b6aca5376a2d805f0045826bc6c9fc85331659c33b4813e0b563"}, - {file = "scikit_image-0.24.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8579bda9c3f78cb3b3ed8b9425213c53a25fa7e994b7ac01f2440b395babf660"}, - {file = "scikit_image-0.24.0-cp312-cp312-win_amd64.whl", hash = "sha256:82ab903afa60b2da1da2e6f0c8c65e7c8868c60a869464c41971da929b3e82bc"}, - {file = "scikit_image-0.24.0.tar.gz", hash = "sha256:5d16efe95da8edbeb363e0c4157b99becbd650a60b77f6e3af5768b66cf007ab"}, -] - -[[package]] -name = "scipy" -version = "1.14.1" -summary = "" -dependencies = [ - "numpy", -] -files = [ - {file = "scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d"}, - {file = "scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07"}, - {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5"}, - {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc"}, - {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310"}, - {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066"}, - {file = "scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1"}, - {file = "scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f"}, - {file = "scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417"}, -] - -[[package]] -name = "setuptools" -version = "75.2.0" -summary = "" -files = [ - {file = "setuptools-75.2.0-py3-none-any.whl", hash = "sha256:a7fcb66f68b4d9e8e66b42f9876150a3371558f98fa32222ffaa5bced76406f8"}, - {file = "setuptools-75.2.0.tar.gz", hash = "sha256:753bb6ebf1f465a1912e19ed1d41f403a79173a9acf66a42e7e6aec45c3c16ec"}, -] - -[[package]] -name = "shapely" -version = "2.0.6" -summary = "" -dependencies = [ - "numpy", -] -files = [ - {file = "shapely-2.0.6-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cec9193519940e9d1b86a3b4f5af9eb6910197d24af02f247afbfb47bcb3fab0"}, - {file = "shapely-2.0.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83b94a44ab04a90e88be69e7ddcc6f332da7c0a0ebb1156e1c4f568bbec983c3"}, - {file = "shapely-2.0.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:537c4b2716d22c92036d00b34aac9d3775e3691f80c7aa517c2c290351f42cd8"}, - {file = "shapely-2.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fea108334be345c283ce74bf064fa00cfdd718048a8af7343c59eb40f59726"}, - {file = "shapely-2.0.6-cp312-cp312-win32.whl", hash = "sha256:42fd4cd4834747e4990227e4cbafb02242c0cffe9ce7ef9971f53ac52d80d55f"}, - {file = "shapely-2.0.6-cp312-cp312-win_amd64.whl", hash = "sha256:665990c84aece05efb68a21b3523a6b2057e84a1afbef426ad287f0796ef8a48"}, - {file = "shapely-2.0.6.tar.gz", hash = "sha256:997f6159b1484059ec239cacaa53467fd8b5564dabe186cd84ac2944663b0bf6"}, -] - -[[package]] -name = "shellingham" -version = "1.5.4" -summary = "" -files = [ - {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"}, - {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"}, -] - -[[package]] -name = "six" -version = "1.16.0" -summary = "" -files = [ - {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, - {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, -] - -[[package]] -name = "sniffio" -version = "1.3.1" -summary = "" -files = [ - {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, - {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, -] - -[[package]] -name = "sqlalchemy" -version = "2.0.36" -summary = "" -dependencies = [ - "greenlet; platform_machine == \"AMD64\" or platform_machine == \"WIN32\" or platform_machine == \"aarch64\" or platform_machine == \"amd64\" or platform_machine == \"ppc64le\" or platform_machine == \"win32\" or platform_machine == \"x86_64\"", - "typing-extensions", -] -files = [ - {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7b64e6ec3f02c35647be6b4851008b26cff592a95ecb13b6788a54ef80bbdd4"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46331b00096a6db1fdc052d55b101dbbfc99155a548e20a0e4a8e5e4d1362855"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdf3386a801ea5aba17c6410dd1dc8d39cf454ca2565541b5ac42a84e1e28f53"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9dfa18ff2a67b09b372d5db8743c27966abf0e5344c555d86cc7199f7ad83a"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:90812a8933df713fdf748b355527e3af257a11e415b613dd794512461eb8a686"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1bc330d9d29c7f06f003ab10e1eaced295e87940405afe1b110f2eb93a233588"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-win32.whl", hash = "sha256:79d2e78abc26d871875b419e1fd3c0bca31a1cb0043277d0d850014599626c2e"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-win_amd64.whl", hash = "sha256:b544ad1935a8541d177cb402948b94e871067656b3a0b9e91dbec136b06a2ff5"}, - {file = "SQLAlchemy-2.0.36-py3-none-any.whl", hash = "sha256:fddbe92b4760c6f5d48162aef14824add991aeda8ddadb3c31d56eb15ca69f8e"}, - {file = "sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5"}, -] - -[[package]] -name = "sqlalchemy" -version = "2.0.36" -extras = ["asyncio"] -summary = "" -dependencies = [ - "greenlet", - "sqlalchemy==2.0.36", -] -files = [ - {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7b64e6ec3f02c35647be6b4851008b26cff592a95ecb13b6788a54ef80bbdd4"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46331b00096a6db1fdc052d55b101dbbfc99155a548e20a0e4a8e5e4d1362855"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdf3386a801ea5aba17c6410dd1dc8d39cf454ca2565541b5ac42a84e1e28f53"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9dfa18ff2a67b09b372d5db8743c27966abf0e5344c555d86cc7199f7ad83a"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:90812a8933df713fdf748b355527e3af257a11e415b613dd794512461eb8a686"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1bc330d9d29c7f06f003ab10e1eaced295e87940405afe1b110f2eb93a233588"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-win32.whl", hash = "sha256:79d2e78abc26d871875b419e1fd3c0bca31a1cb0043277d0d850014599626c2e"}, - {file = "SQLAlchemy-2.0.36-cp312-cp312-win_amd64.whl", hash = "sha256:b544ad1935a8541d177cb402948b94e871067656b3a0b9e91dbec136b06a2ff5"}, - {file = "SQLAlchemy-2.0.36-py3-none-any.whl", hash = "sha256:fddbe92b4760c6f5d48162aef14824add991aeda8ddadb3c31d56eb15ca69f8e"}, - {file = "sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5"}, -] - -[[package]] -name = "starlette" -version = "0.41.2" -summary = "" -dependencies = [ - "anyio", -] -files = [ - {file = "starlette-0.41.2-py3-none-any.whl", hash = "sha256:fbc189474b4731cf30fcef52f18a8d070e3f3b46c6a04c97579e85e6ffca942d"}, - {file = "starlette-0.41.2.tar.gz", hash = "sha256:9834fd799d1a87fd346deb76158668cfa0b0d56f85caefe8268e2d97c3468b62"}, -] - -[[package]] -name = "sympy" -version = "1.13.1" -summary = "" -dependencies = [ - "mpmath", -] -files = [ - {file = "sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8"}, - {file = "sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f"}, -] - -[[package]] -name = "tenacity" -version = "9.0.0" -summary = "" -files = [ - {file = "tenacity-9.0.0-py3-none-any.whl", hash = "sha256:93de0c98785b27fcf659856aa9f54bfbd399e29969b0621bc7f762bd441b4539"}, - {file = "tenacity-9.0.0.tar.gz", hash = "sha256:807f37ca97d62aa361264d497b0e31e92b8027044942bfa756160d908320d73b"}, -] - -[[package]] -name = "tifffile" -version = "2024.9.20" -summary = "" -dependencies = [ - "numpy", -] -files = [ - {file = "tifffile-2024.9.20-py3-none-any.whl", hash = "sha256:c54dc85bc1065d972cb8a6ffb3181389d597876aa80177933459733e4ed243dd"}, - {file = "tifffile-2024.9.20.tar.gz", hash = "sha256:3fbf3be2f995a7051a8ae05a4be70c96fc0789f22ed6f1c4104c973cf68a640b"}, -] - -[[package]] -name = "tokenizers" -version = "0.20.1" -summary = "" -dependencies = [ - "huggingface-hub", -] -files = [ - {file = "tokenizers-0.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:407ab666b38e02228fa785e81f7cf79ef929f104bcccf68a64525a54a93ceac9"}, - {file = "tokenizers-0.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f13a2d16032ebc8bd812eb8099b035ac65887d8f0c207261472803b9633cf3e"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e98eee4dca22849fbb56a80acaa899eec5b72055d79637dd6aa15d5e4b8628c9"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47c1bcdd61e61136087459cb9e0b069ff23b5568b008265e5cbc927eae3387ce"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:128c1110e950534426e2274837fc06b118ab5f2fa61c3436e60e0aada0ccfd67"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2e2d47a819d2954f2c1cd0ad51bb58ffac6f53a872d5d82d65d79bf76b9896d"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bdd67a0e3503a9a7cf8bc5a4a49cdde5fa5bada09a51e4c7e1c73900297539bd"}, - {file = "tokenizers-0.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:689b93d2e26d04da337ac407acec8b5d081d8d135e3e5066a88edd5bdb5aff89"}, - {file = "tokenizers-0.20.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0c6a796ddcd9a19ad13cf146997cd5895a421fe6aec8fd970d69f9117bddb45c"}, - {file = "tokenizers-0.20.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3ea919687aa7001a8ff1ba36ac64f165c4e89035f57998fa6cedcfd877be619d"}, - {file = "tokenizers-0.20.1-cp312-none-win32.whl", hash = "sha256:6d3ac5c1f48358ffe20086bf065e843c0d0a9fce0d7f0f45d5f2f9fba3609ca5"}, - {file = "tokenizers-0.20.1-cp312-none-win_amd64.whl", hash = "sha256:b0874481aea54a178f2bccc45aa2d0c99cd3f79143a0948af6a9a21dcc49173b"}, - {file = "tokenizers-0.20.1.tar.gz", hash = "sha256:84edcc7cdeeee45ceedb65d518fffb77aec69311c9c8e30f77ad84da3025f002"}, -] - -[[package]] -name = "torch" -version = "2.5.1" -summary = "" -dependencies = [ - "filelock", - "fsspec", - "jinja2", - "networkx", - "nvidia-cublas-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cuda-cupti-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cuda-nvrtc-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cuda-runtime-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cudnn-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cufft-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-curand-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cusolver-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-cusparse-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-nccl-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-nvjitlink-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "nvidia-nvtx-cu12; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "setuptools", - "sympy", - "triton; platform_machine == \"x86_64\" and platform_system == \"Linux\"", - "typing-extensions", -] -files = [ - {file = "torch-2.5.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:ed231a4b3a5952177fafb661213d690a72caaad97d5824dd4fc17ab9e15cec03"}, - {file = "torch-2.5.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:3f4b7f10a247e0dcd7ea97dc2d3bfbfc90302ed36d7f3952b0008d0df264e697"}, - {file = "torch-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:73e58e78f7d220917c5dbfad1a40e09df9929d3b95d25e57d9f8558f84c9a11c"}, - {file = "torch-2.5.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:8c712df61101964eb11910a846514011f0b6f5920c55dbf567bff8a34163d5b1"}, -] - -[[package]] -name = "torchaudio" -version = "2.5.1" -summary = "" -dependencies = [ - "torch", -] -files = [ - {file = "torchaudio-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f1cbfdfd1bbdfbe7289d47a74f36ff6c5d87c3205606202fef5a7fb693f61cf0"}, - {file = "torchaudio-2.5.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:9c8fb06fbd8d2016e7b7caf15a3231867c792a2e3b0f2f8f9013633e9c2ce412"}, - {file = "torchaudio-2.5.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:6bb65416405f40e00b20701257c16e7493bfdd7188e02e87cc5b389c31c10c2c"}, - {file = "torchaudio-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:ec8f12d6be12aed248a0d65a76c7bb341ee5eef969fe2e9dc3154c7cfba1bdf4"}, -] - -[[package]] -name = "torchmetrics" -version = "1.6.0" -summary = "" -dependencies = [ - "lightning-utilities", - "numpy", - "packaging", - "torch", -] -files = [ - {file = "torchmetrics-1.6.0-py3-none-any.whl", hash = "sha256:a508cdd87766cedaaf55a419812bf9f493aff8fffc02cc19df5a8e2e7ccb942a"}, - {file = "torchmetrics-1.6.0.tar.gz", hash = "sha256:aebba248708fb90def20cccba6f55bddd134a58de43fb22b0c5ca0f3a89fa984"}, -] - -[[package]] -name = "torchvision" -version = "0.20.1" -summary = "" -dependencies = [ - "numpy", - "pillow", - "torch", -] -files = [ - {file = "torchvision-0.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a31256ff945d64f006bb306813a7c95a531fe16bfb2535c837dd4c104533d7a"}, - {file = "torchvision-0.20.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:17cd78adddf81dac57d7dccc9277a4d686425b1c55715f308769770cb26cad5c"}, - {file = "torchvision-0.20.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:9f853ba4497ac4691815ad41b523ee23cf5ba4f87b1ce869d704052e233ca8b7"}, - {file = "torchvision-0.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:4a330422c36dbfc946d3a6c1caec3489db07ecdf3675d83369adb2e5a0ca17c4"}, -] - -[[package]] -name = "tqdm" -version = "4.66.5" -summary = "" -dependencies = [ - "colorama; platform_system == \"Windows\"", -] -files = [ - {file = "tqdm-4.66.5-py3-none-any.whl", hash = "sha256:90279a3770753eafc9194a0364852159802111925aa30eb3f9d85b0e805ac7cd"}, - {file = "tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad"}, -] - -[[package]] -name = "transformers" -version = "4.46.3" -summary = "" -dependencies = [ - "filelock", - "huggingface-hub", - "numpy", - "packaging", - "pyyaml", - "regex", - "requests", - "safetensors", - "tokenizers", - "tqdm", -] -files = [ - {file = "transformers-4.46.3-py3-none-any.whl", hash = "sha256:a12ef6f52841fd190a3e5602145b542d03507222f2c64ebb7ee92e8788093aef"}, - {file = "transformers-4.46.3.tar.gz", hash = "sha256:8ee4b3ae943fe33e82afff8e837f4b052058b07ca9be3cb5b729ed31295f72cc"}, -] - -[[package]] -name = "triton" -version = "3.1.0" -summary = "" -dependencies = [ - "filelock", -] -files = [ - {file = "triton-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8182f42fd8080a7d39d666814fa36c5e30cc00ea7eeeb1a2983dbb4c99a0fdc"}, -] - -[[package]] -name = "typer" -version = "0.12.5" -summary = "" -dependencies = [ - "click", - "rich", - "shellingham", - "typing-extensions", -] -files = [ - {file = "typer-0.12.5-py3-none-any.whl", hash = "sha256:62fe4e471711b147e3365034133904df3e235698399bc4de2b36c8579298d52b"}, - {file = "typer-0.12.5.tar.gz", hash = "sha256:f592f089bedcc8ec1b974125d64851029c3b1af145f04aca64d69410f0c9b722"}, -] - -[[package]] -name = "typing-extensions" -version = "4.12.2" -summary = "" -files = [ - {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, - {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, -] - -[[package]] -name = "tzdata" -version = "2024.2" -summary = "" -files = [ - {file = "tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd"}, - {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, -] - -[[package]] -name = "urllib3" -version = "2.2.3" -summary = "" -files = [ - {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"}, - {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"}, -] - -[[package]] -name = "uvicorn" -version = "0.32.0" -summary = "" -dependencies = [ - "click", - "h11", -] -files = [ - {file = "uvicorn-0.32.0-py3-none-any.whl", hash = "sha256:60b8f3a5ac027dcd31448f411ced12b5ef452c646f76f02f8cc3f25d8d26fd82"}, - {file = "uvicorn-0.32.0.tar.gz", hash = "sha256:f78b36b143c16f54ccdb8190d0a26b5f1901fe5a3c777e1ab29f26391af8551e"}, -] - -[[package]] -name = "uvicorn" -version = "0.32.0" -extras = ["standard"] -summary = "" -dependencies = [ - "colorama; sys_platform == \"win32\"", - "httptools", - "python-dotenv", - "pyyaml", - "uvicorn==0.32.0", - "uvloop; platform_python_implementation != \"PyPy\" and (sys_platform != \"cygwin\" and sys_platform != \"win32\")", - "watchfiles", - "websockets", -] -files = [ - {file = "uvicorn-0.32.0-py3-none-any.whl", hash = "sha256:60b8f3a5ac027dcd31448f411ced12b5ef452c646f76f02f8cc3f25d8d26fd82"}, - {file = "uvicorn-0.32.0.tar.gz", hash = "sha256:f78b36b143c16f54ccdb8190d0a26b5f1901fe5a3c777e1ab29f26391af8551e"}, -] - -[[package]] -name = "uvloop" -version = "0.21.0" -summary = "" -files = [ - {file = "uvloop-0.21.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:359ec2c888397b9e592a889c4d72ba3d6befba8b2bb01743f72fffbde663b59c"}, - {file = "uvloop-0.21.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7089d2dc73179ce5ac255bdf37c236a9f914b264825fdaacaded6990a7fb4c2"}, - {file = "uvloop-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4dcdbd9ae0a372f2167a207cd98c9f9a1ea1188a8a526431eef2f8116cc8d"}, - {file = "uvloop-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86975dca1c773a2c9864f4c52c5a55631038e387b47eaf56210f873887b6c8dc"}, - {file = "uvloop-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:461d9ae6660fbbafedd07559c6a2e57cd553b34b0065b6550685f6653a98c1cb"}, - {file = "uvloop-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:183aef7c8730e54c9a3ee3227464daed66e37ba13040bb3f350bc2ddc040f22f"}, - {file = "uvloop-0.21.0.tar.gz", hash = "sha256:3bf12b0fda68447806a7ad847bfa591613177275d35b6724b1ee573faa3704e3"}, -] - -[[package]] -name = "watchfiles" -version = "0.24.0" -summary = "" -dependencies = [ - "anyio", -] -files = [ - {file = "watchfiles-0.24.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:7211b463695d1e995ca3feb38b69227e46dbd03947172585ecb0588f19b0d87a"}, - {file = "watchfiles-0.24.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b8693502d1967b00f2fb82fc1e744df128ba22f530e15b763c8d82baee15370"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdab9555053399318b953a1fe1f586e945bc8d635ce9d05e617fd9fe3a4687d6"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:34e19e56d68b0dad5cff62273107cf5d9fbaf9d75c46277aa5d803b3ef8a9e9b"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:41face41f036fee09eba33a5b53a73e9a43d5cb2c53dad8e61fa6c9f91b5a51e"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5148c2f1ea043db13ce9b0c28456e18ecc8f14f41325aa624314095b6aa2e9ea"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7e4bd963a935aaf40b625c2499f3f4f6bbd0c3776f6d3bc7c853d04824ff1c9f"}, - {file = "watchfiles-0.24.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c79d7719d027b7a42817c5d96461a99b6a49979c143839fc37aa5748c322f234"}, - {file = "watchfiles-0.24.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:32aa53a9a63b7f01ed32e316e354e81e9da0e6267435c7243bf8ae0f10b428ef"}, - {file = "watchfiles-0.24.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ce72dba6a20e39a0c628258b5c308779b8697f7676c254a845715e2a1039b968"}, - {file = "watchfiles-0.24.0-cp312-none-win32.whl", hash = "sha256:d9018153cf57fc302a2a34cb7564870b859ed9a732d16b41a9b5cb2ebed2d444"}, - {file = "watchfiles-0.24.0-cp312-none-win_amd64.whl", hash = "sha256:551ec3ee2a3ac9cbcf48a4ec76e42c2ef938a7e905a35b42a1267fa4b1645896"}, - {file = "watchfiles-0.24.0-cp312-none-win_arm64.whl", hash = "sha256:b52a65e4ea43c6d149c5f8ddb0bef8d4a1e779b77591a458a893eb416624a418"}, - {file = "watchfiles-0.24.0.tar.gz", hash = "sha256:afb72325b74fa7a428c009c1b8be4b4d7c2afedafb2982827ef2156646df2fe1"}, -] - -[[package]] -name = "websockets" -version = "13.1" -summary = "" -files = [ - {file = "websockets-13.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9d75baf00138f80b48f1eac72ad1535aac0b6461265a0bcad391fc5aba875cfc"}, - {file = "websockets-13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9b6f347deb3dcfbfde1c20baa21c2ac0751afaa73e64e5b693bb2b848efeaa49"}, - {file = "websockets-13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de58647e3f9c42f13f90ac7e5f58900c80a39019848c5547bc691693098ae1bd"}, - {file = "websockets-13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1b54689e38d1279a51d11e3467dd2f3a50f5f2e879012ce8f2d6943f00e83f0"}, - {file = "websockets-13.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf1781ef73c073e6b0f90af841aaf98501f975d306bbf6221683dd594ccc52b6"}, - {file = "websockets-13.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d23b88b9388ed85c6faf0e74d8dec4f4d3baf3ecf20a65a47b836d56260d4b9"}, - {file = "websockets-13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3c78383585f47ccb0fcf186dcb8a43f5438bd7d8f47d69e0b56f71bf431a0a68"}, - {file = "websockets-13.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d6d300f8ec35c24025ceb9b9019ae9040c1ab2f01cddc2bcc0b518af31c75c14"}, - {file = "websockets-13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a9dcaf8b0cc72a392760bb8755922c03e17a5a54e08cca58e8b74f6902b433cf"}, - {file = "websockets-13.1-cp312-cp312-win32.whl", hash = "sha256:2f85cf4f2a1ba8f602298a853cec8526c2ca42a9a4b947ec236eaedb8f2dc80c"}, - {file = "websockets-13.1-cp312-cp312-win_amd64.whl", hash = "sha256:38377f8b0cdeee97c552d20cf1865695fcd56aba155ad1b4ca8779a5b6ef4ac3"}, - {file = "websockets-13.1-py3-none-any.whl", hash = "sha256:a9a396a6ad26130cdae92ae10c36af09d9bfe6cafe69670fd3b6da9b07b4044f"}, - {file = "websockets-13.1.tar.gz", hash = "sha256:a3b3366087c1bc0a2795111edcadddb8b3b59509d5db5d7ea3fdd69f954a8878"}, -] - -[[package]] -name = "xxhash" -version = "3.5.0" -summary = "" -files = [ - {file = "xxhash-3.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:14470ace8bd3b5d51318782cd94e6f94431974f16cb3b8dc15d52f3b69df8e00"}, - {file = "xxhash-3.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:59aa1203de1cb96dbeab595ded0ad0c0056bb2245ae11fac11c0ceea861382b9"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08424f6648526076e28fae6ea2806c0a7d504b9ef05ae61d196d571e5c879c84"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:61a1ff00674879725b194695e17f23d3248998b843eb5e933007ca743310f793"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2f2c61bee5844d41c3eb015ac652a0229e901074951ae48581d58bfb2ba01be"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d32a592cac88d18cc09a89172e1c32d7f2a6e516c3dfde1b9adb90ab5df54a6"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70dabf941dede727cca579e8c205e61121afc9b28516752fd65724be1355cc90"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e5d0ddaca65ecca9c10dcf01730165fd858533d0be84c75c327487c37a906a27"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e5b5e16c5a480fe5f59f56c30abdeba09ffd75da8d13f6b9b6fd224d0b4d0a2"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149b7914451eb154b3dfaa721315117ea1dac2cc55a01bfbd4df7c68c5dd683d"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:eade977f5c96c677035ff39c56ac74d851b1cca7d607ab3d8f23c6b859379cab"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fa9f547bd98f5553d03160967866a71056a60960be00356a15ecc44efb40ba8e"}, - {file = "xxhash-3.5.0-cp312-cp312-win32.whl", hash = "sha256:f7b58d1fd3551b8c80a971199543379be1cee3d0d409e1f6d8b01c1a2eebf1f8"}, - {file = "xxhash-3.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:fa0cafd3a2af231b4e113fba24a65d7922af91aeb23774a8b78228e6cd785e3e"}, - {file = "xxhash-3.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:586886c7e89cb9828bcd8a5686b12e161368e0064d040e225e72607b43858ba2"}, - {file = "xxhash-3.5.0.tar.gz", hash = "sha256:84f2caddf951c9cbf8dc2e22a89d4ccf5d86391ac6418fe81e3c67d0cf60b45f"}, -] - -[[package]] -name = "yarl" -version = "1.17.1" -summary = "" -dependencies = [ - "idna", - "multidict", - "propcache", -] -files = [ - {file = "yarl-1.17.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:327828786da2006085a4d1feb2594de6f6d26f8af48b81eb1ae950c788d97f61"}, - {file = "yarl-1.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cc353841428d56b683a123a813e6a686e07026d6b1c5757970a877195f880c2d"}, - {file = "yarl-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c73df5b6e8fabe2ddb74876fb82d9dd44cbace0ca12e8861ce9155ad3c886139"}, - {file = "yarl-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bdff5e0995522706c53078f531fb586f56de9c4c81c243865dd5c66c132c3b5"}, - {file = "yarl-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:06157fb3c58f2736a5e47c8fcbe1afc8b5de6fb28b14d25574af9e62150fcaac"}, - {file = "yarl-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1654ec814b18be1af2c857aa9000de7a601400bd4c9ca24629b18486c2e35463"}, - {file = "yarl-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f6595c852ca544aaeeb32d357e62c9c780eac69dcd34e40cae7b55bc4fb1147"}, - {file = "yarl-1.17.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:459e81c2fb920b5f5df744262d1498ec2c8081acdcfe18181da44c50f51312f7"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e48cdb8226644e2fbd0bdb0a0f87906a3db07087f4de77a1b1b1ccfd9e93685"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d9b6b28a57feb51605d6ae5e61a9044a31742db557a3b851a74c13bc61de5172"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e594b22688d5747b06e957f1ef822060cb5cb35b493066e33ceac0cf882188b7"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5f236cb5999ccd23a0ab1bd219cfe0ee3e1c1b65aaf6dd3320e972f7ec3a39da"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a2a64e62c7a0edd07c1c917b0586655f3362d2c2d37d474db1a509efb96fea1c"}, - {file = "yarl-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d0eea830b591dbc68e030c86a9569826145df485b2b4554874b07fea1275a199"}, - {file = "yarl-1.17.1-cp312-cp312-win32.whl", hash = "sha256:46ddf6e0b975cd680eb83318aa1d321cb2bf8d288d50f1754526230fcf59ba96"}, - {file = "yarl-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:117ed8b3732528a1e41af3aa6d4e08483c2f0f2e3d3d7dca7cf538b3516d93df"}, - {file = "yarl-1.17.1-py3-none-any.whl", hash = "sha256:f1790a4b1e8e8e028c391175433b9c8122c39b46e1663228158e61e6f915bf06"}, - {file = "yarl-1.17.1.tar.gz", hash = "sha256:067a63fcfda82da6b198fa73079b1ca40b7c9b7994995b6ee38acda728b64d47"}, -] diff --git a/pyproject.toml b/pyproject.toml index 01dd4b2..f24f248 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,38 +1,29 @@ [project] -name = "DocumentClassification" +name = "documentclassification" version = "0.1.0" -description = "Default template for PDM package" -authors = [ - { name = "Jakub Zenon Kujawa", email = "ZK_Jakub@proton.me" }, -] +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.12" dependencies = [ - "torch>=2.5.0", - "torchvision>=0.20.0", - "torchaudio>=2.5.0", + "aiofiles>=24.1.0", + "asyncpg>=0.30.0", + "datasets>=3.1.0", "easyocr>=1.7.2", + "fastapi[standard]>=0.115.5", + "lightning>=2.4.0", + "lingua-language-detector>=2.0.2", + "numpy>=2.1.3", "pdf2image>=1.17.0", - "fastapi[standard]>=0.115.3", - "python-multipart>=0.0.16", "pillow>=11.0.0", - "numpy>=2.1.2", - "rich>=13.9.3", - "transformers>=4.46.0", - "lightning>=2.4.0", - "datasets>=3.1.0", - "python-dotenv>=1.0.1", + "psutil>=6.1.0", "psycopg2-binary>=2.9.10", - "sqlalchemy[asyncio]>=2.0.36", - "asyncpg>=0.30.0", "pytesseract>=0.3.13", - "langchain>=0.3.9", - "langchain-ollama>=0.2.0", - "psutil>=6.1.0", - "aiofiles>=24.1.0", + "python-dotenv>=1.0.1", + "python-multipart>=0.0.18", + "rich>=13.9.4", + "sqlalchemy[asyncio]>=2.0.36", + "torch>=2.5.1", + "torchaudio>=2.5.1", + "torchvision>=0.20.1", + "transformers>=4.46.3", ] -requires-python = ">=3.12,<3.13" -readme = "README.md" -license = { text = "MIT" } - - -[tool.pdm] -distribution = false diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index bd91efd..0000000 --- a/requirements.txt +++ /dev/null @@ -1,25 +0,0 @@ -# This file is @generated by PDM. -# Please do not edit it manually. - -aiofiles>=24.1.0 -asyncpg>=0.30.0 -datasets>=3.1.0 -easyocr>=1.7.2 -fastapi[standard]>=0.115.3 -langchain>=0.3.9 -langchain-ollama>=0.2.0 -lightning>=2.4.0 -numpy>=2.1.2 -pdf2image>=1.17.0 -pillow>=11.0.0 -psutil>=6.1.0 -psycopg2-binary>=2.9.10 -pytesseract>=0.3.13 -python-dotenv>=1.0.1 -python-multipart>=0.0.16 -rich>=13.9.3 -sqlalchemy[asyncio]>=2.0.36 -torch>=2.5.0 -torchaudio>=2.5.0 -torchvision>=0.20.0 -transformers>=4.46.0 diff --git a/setup-services.sh b/setup-services.sh index 9253d8c..0c23d15 100755 --- a/setup-services.sh +++ b/setup-services.sh @@ -5,7 +5,7 @@ usage() { echo "Usage: $0 [-f|--force] [-d|--detach] [-p|--password PASSWORD] [-r|--rebuild]" echo "Options:" echo " -f, --force Remove existing models and clone again" - echo " -d, --detach Run in detached mode" + echo " -d, --detach Run in detached mode" echo " -p, --password Set PostgreSQL password" echo " -r, --rebuild Rebuild docker images" echo " -h, --help Display this help message" @@ -77,4 +77,4 @@ elif [ "$REBUILD" = false ]; then else echo "Starting services..." docker-compose up -fi \ No newline at end of file +fi diff --git a/src/configs/model_config.py b/src/configs/model_config.py index 3f96599..c923311 100644 --- a/src/configs/model_config.py +++ b/src/configs/model_config.py @@ -1,6 +1,8 @@ from dataclasses import dataclass, field from pathlib import Path +import psutil + @dataclass(frozen=True) class ModelConfig: @@ -26,7 +28,31 @@ class ModelConfig: "questionnaire", "resume", "memo", - ] + ], ) SUMMARIZER_URL: str = "http://summarizer:6060/summarize" + + # LLM specific parameters + + # Ollama configuration + OLLAMA_BASE_URL: str = "http://ollama:11434" + MODEL_NAME: str = "llama3.2:3b" + + # Summary constraints + MAX_INPUT_LENGTH: int = 10000 + DEFAULT_MAX_LENGTH: int = 200 + DEFAULT_MIN_LENGTH: int = 50 + + # Model parameters + TEMPERATURE: float = 0.7 + TOP_P: float = 0.9 + FREQUENCY_PENALTY: float = 0.0 + PRESENCE_PENALTY: float = 0.0 + + # Llama specific parameters + NUM_CTX: int = 4096 # Context window size + NUM_GPU: int = 0 + NUM_THREAD: int = field( + default_factory=lambda: psutil.cpu_count(logical=False) or 1, + ) diff --git a/src/configs/ocr_config.py b/src/configs/ocr_config.py index 636eb25..c15cab6 100644 --- a/src/configs/ocr_config.py +++ b/src/configs/ocr_config.py @@ -1,6 +1,6 @@ from dataclasses import dataclass from pathlib import Path -from typing import Final, Set +from typing import Final BYTE_MEGABYTE: Final[int] = 1024 * 1024 @@ -14,14 +14,14 @@ class OCRConfig: TARGET_SIZE: int = 1240 MAX_WORKERS: int = 4 LOG_DIR: Path = Path("/app/data/logs/ocr") - ACCEPTED_FILE_TYPES: Set[str] = frozenset( + ACCEPTED_FILE_TYPES: frozenset[str] = frozenset( { "image/jpeg", "image/png", "image/jpg", "image/webp", "application/pdf", - } + }, ) PROCESSOR_URL: str = "http://processor:9090/text-preprocess" UPLOAD_DIR: Path = Path("/app/data/uploads") diff --git a/src/configs/summarization_config.py b/src/configs/summarization_config.py index cd7da42..8462c6d 100644 --- a/src/configs/summarization_config.py +++ b/src/configs/summarization_config.py @@ -1,4 +1,4 @@ -from dataclasses import dataclass +from dataclasses import dataclass, field from pathlib import Path import psutil @@ -29,4 +29,6 @@ class SummarizationConfig: # Llama specific parameters NUM_CTX: int = 4096 # Context window size NUM_GPU: int = 0 - NUM_THREAD: int = psutil.cpu_count(logical=False) # Number of CPU threads to use + NUM_THREAD: int = field( + default_factory=lambda: psutil.cpu_count(logical=False) or 1, + ) diff --git a/src/database/__init__.py b/src/database/__init__.py index 66d9651..663661f 100644 --- a/src/database/__init__.py +++ b/src/database/__init__.py @@ -20,20 +20,20 @@ ) __all__ = [ + "Base", + "ConnectionError", "DatabaseConfig", "DatabaseConnection", "DatabaseError", - "ConnectionError", - "DocumentError", - "DocumentNotFoundError", - "DocumentSaveError", - "DocumentUpdateError", - "Base", "Document", - "DocumentRepository", "DocumentBase", "DocumentCreate", - "DocumentUpdate", + "DocumentError", + "DocumentNotFoundError", + "DocumentRepository", "DocumentResponse", + "DocumentSaveError", + "DocumentUpdate", + "DocumentUpdateError", "get_repository", ] diff --git a/src/database/connections.py b/src/database/connections.py index ef063c5..f66c68d 100644 --- a/src/database/connections.py +++ b/src/database/connections.py @@ -1,7 +1,7 @@ import logging +from collections.abc import AsyncGenerator from contextlib import asynccontextmanager from datetime import datetime -from typing import AsyncGenerator from sqlalchemy import text from sqlalchemy.engine import URL @@ -14,7 +14,7 @@ from configs.database_config import DatabaseConfig -from .exceptions import ConnectionError +from .exceptions import ConnectionError as DBConnectionError config = DatabaseConfig.from_env() config.LOG_DIR.mkdir(parents=True, exist_ok=True) @@ -25,7 +25,8 @@ datefmt="%Y-%m-%d %H:%M:%S", handlers=[ logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", ), logging.StreamHandler(), ], @@ -37,7 +38,7 @@ class DatabaseConnection: """Manages database connection and session creation.""" - def __init__(self): + def __init__(self) -> None: """Initialize database connection manager.""" self.engine = self._create_engine() self.async_session_maker = async_sessionmaker( @@ -69,8 +70,9 @@ def _create_engine(self) -> AsyncEngine: ) except Exception as e: - logger.error("Failed to create database engine: %s", str(e)) - raise ConnectionError("Failed to establish database connection") from e + logger.exception("Failed to create database engine") + error_msg = "Failed to establish database connection" + raise DBConnectionError(error_msg) from e async def verify_connection(self) -> None: """Verify database connection.""" @@ -79,8 +81,9 @@ async def verify_connection(self) -> None: await conn.execute(text("SELECT 1")) logger.info("Database connection verified successfully") except Exception as e: - logger.error("Failed to verify database connection: %s", str(e)) - raise ConnectionError("Failed to verify database connection") from e + logger.exception("Failed to verify database connection") + error_msg = "Failed to verify database connection" + raise DBConnectionError(error_msg) from e @asynccontextmanager async def get_session(self) -> AsyncGenerator[AsyncSession, None]: @@ -88,9 +91,9 @@ async def get_session(self) -> AsyncGenerator[AsyncSession, None]: async with self.async_session_maker() as session: try: yield session - except Exception as e: + except Exception: await session.rollback() - logger.error("Database session error: %s", str(e)) + logger.exception("Database session error") raise finally: await session.close() diff --git a/src/database/dependencies.py b/src/database/dependencies.py index 95c7dc6..a1d6a82 100644 --- a/src/database/dependencies.py +++ b/src/database/dependencies.py @@ -1,4 +1,4 @@ -from typing import AsyncGenerator +from collections.abc import AsyncGenerator from fastapi import Depends from sqlalchemy.ext.asyncio import AsyncSession diff --git a/src/database/exceptions.py b/src/database/exceptions.py index a261b33..b2375ad 100644 --- a/src/database/exceptions.py +++ b/src/database/exceptions.py @@ -1,10 +1,21 @@ -from typing import Optional +from __future__ import annotations class DatabaseError(Exception): """Base exception for database operations.""" - def __init__(self, message: str, original_error: Optional[Exception] = None): + def __init__( + self, + message: str, + original_error: Exception | None = None, + ) -> None: + """Initialize DatabaseError exception. + + Args: + message: Error message to display + original_error: Original exception that caused this error, if any + + """ super().__init__(message) self.original_error = original_error @@ -12,28 +23,18 @@ def __init__(self, message: str, original_error: Optional[Exception] = None): class ConnectionError(DatabaseError): """Raised when database connection fails.""" - pass - class DocumentError(DatabaseError): """Base exception for document-related operations.""" - pass - class DocumentNotFoundError(DocumentError): """Raised when a document is not found.""" - pass - class DocumentSaveError(DocumentError): """Raised when saving a document fails.""" - pass - class DocumentUpdateError(DocumentError): """Raised when updating a document fails.""" - - pass diff --git a/src/database/models.py b/src/database/models.py index 6a1c935..f21b7fc 100644 --- a/src/database/models.py +++ b/src/database/models.py @@ -1,5 +1,6 @@ +from __future__ import annotations + from datetime import datetime -from typing import Optional from sqlalchemy import TIMESTAMP, Integer, String from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column @@ -8,8 +9,6 @@ class Base(DeclarativeBase): """Base class for all database models.""" - pass - class Document(Base): """Document model with improved type hints and validation.""" @@ -17,13 +16,26 @@ class Document(Base): __tablename__ = "documents" id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True) - file_name: Mapped[str] = mapped_column(String(255), nullable=False, unique=True) - file_path: Mapped[str] = mapped_column(String(255), nullable=False, unique=True) + file_name: Mapped[str] = mapped_column( + String(255), + nullable=False, + unique=True, + ) + file_path: Mapped[str] = mapped_column( + String(255), + nullable=False, + unique=True, + ) created_at: Mapped[datetime] = mapped_column( - TIMESTAMP, nullable=False, default=datetime.utcnow + TIMESTAMP, + nullable=False, + default=datetime.utcnow, + ) + classification: Mapped[str | None] = mapped_column( + String(255), + nullable=True, ) - classification: Mapped[Optional[str]] = mapped_column(String(255), nullable=True) - summary: Mapped[Optional[str]] = mapped_column(String, nullable=True) + summary: Mapped[str | None] = mapped_column(String, nullable=True) def to_dict(self) -> dict: """Convert document to dictionary.""" diff --git a/src/database/repository.py b/src/database/repository.py index 8c46b46..a56f9f4 100644 --- a/src/database/repository.py +++ b/src/database/repository.py @@ -1,9 +1,10 @@ +from __future__ import annotations + from datetime import datetime -from typing import Sequence +from typing import TYPE_CHECKING from sqlalchemy import select from sqlalchemy.exc import SQLAlchemyError -from sqlalchemy.ext.asyncio import AsyncSession from .exceptions import ( DocumentError, @@ -12,23 +13,30 @@ DocumentUpdateError, ) from .models import Document -from .schemas import DocumentCreate, DocumentUpdate + +if TYPE_CHECKING: + from collections.abc import Sequence + + from sqlalchemy.ext.asyncio import AsyncSession + + from .schemas import DocumentCreate, DocumentUpdate class DocumentRepository: """Repository for document-related database operations.""" - def __init__(self, session: AsyncSession): + def __init__(self, session: AsyncSession) -> None: """Initialize repository with database session.""" self.session = session async def create(self, document: DocumentCreate) -> Document: """Create a new document record.""" try: + now = datetime.now().astimezone() db_document = Document( file_name=document.file_name, file_path=document.file_path, - created_at=document.created_at or datetime.now(datetime.timezone.utc), + created_at=document.created_at or now, classification=document.classification, summary=document.summary, ) @@ -37,12 +45,15 @@ async def create(self, document: DocumentCreate) -> Document: await self.session.commit() await self.session.refresh(db_document) - return db_document - except SQLAlchemyError as e: + error_msg = f"Failed to save document {document.file_name}" raise DocumentSaveError( - f"Failed to save document {document.file_name}", original_error=e - ) + error_msg, + original_error=e, + ) from e + + else: + return db_document async def get_by_id(self, document_id: int) -> Document: """Retrieve document by ID.""" @@ -51,11 +62,15 @@ async def get_by_id(self, document_id: int) -> Document: document = result.scalar_one_or_none() if not document: - raise DocumentNotFoundError(f"Document with ID {document_id} not found") + error_msg = f"Document with ID {document_id} not found" + raise DocumentNotFoundError(error_msg) return document async def get_by_filename( - self, file_name: str, *, return_bool: bool = False + self, + file_name: str, + *, + return_bool: bool = False, ) -> Document | bool: """Retrieve document by filename.""" query = select(Document).filter(Document.file_name == file_name) @@ -65,7 +80,8 @@ async def get_by_filename( if not document: if return_bool: return False - raise DocumentNotFoundError(f"Document {file_name} not found") + error_msg = f"Document {file_name} not found" + raise DocumentNotFoundError(error_msg) return document @@ -75,7 +91,11 @@ async def get_all(self) -> Sequence[Document]: result = await self.session.execute(query) return result.scalars().all() - async def update(self, document_id: int, update_data: DocumentUpdate) -> Document: + async def update( + self, + document_id: int, + update_data: DocumentUpdate, + ) -> Document: """Update document attributes.""" try: document = await self.get_by_id(document_id) @@ -87,46 +107,72 @@ async def update(self, document_id: int, update_data: DocumentUpdate) -> Documen await self.session.commit() await self.session.refresh(document) - return document - except SQLAlchemyError as e: + error_msg = f"Failed to update document {document_id}" raise DocumentUpdateError( - f"Failed to update document {document_id}", original_error=e - ) + error_msg, + original_error=e, + ) from e + + else: + return document async def update_classification( - self, file_name: str, classification: str + self, + file_name: str, + classification: str, ) -> Document: """Update document classification.""" try: - document = await self.get_by_filename(file_name) + document = await self.get_by_filename( + file_name, + return_bool=False, + ) + + if not isinstance(document, Document): + error_msg = f"Document {file_name} not found" + raise DocumentNotFoundError(error_msg) + document.classification = classification await self.session.commit() await self.session.refresh(document) - return document - except SQLAlchemyError as e: + error_msg = f"Failed to update classification for {file_name}" raise DocumentUpdateError( - f"Failed to update classification for {file_name}", original_error=e - ) + error_msg, + original_error=e, + ) from e + + else: + return document async def update_summary(self, file_name: str, summary: str) -> Document: """Update document summary.""" try: - document = await self.get_by_filename(file_name) + document = await self.get_by_filename( + file_name, + return_bool=False, + ) + if not isinstance(document, Document): + error_msg = f"Document {file_name} not found" + raise DocumentNotFoundError(error_msg) + document.summary = summary await self.session.commit() await self.session.refresh(document) - return document - except SQLAlchemyError as e: + error_msg = f"Failed to update summary for {file_name}" raise DocumentUpdateError( - f"Failed to update summary for {file_name}", original_error=e - ) + error_msg, + original_error=e, + ) from e + + else: + return document async def delete(self, document_id: int) -> None: """Delete document by ID.""" @@ -136,6 +182,8 @@ async def delete(self, document_id: int) -> None: await self.session.commit() except SQLAlchemyError as e: + error_msg = f"Failed to delete document {document_id}" raise DocumentError( - f"Failed to delete document {document_id}", original_error=e - ) + error_msg, + original_error=e, + ) from e diff --git a/src/database/schemas.py b/src/database/schemas.py index 4a90c39..c32a171 100644 --- a/src/database/schemas.py +++ b/src/database/schemas.py @@ -1,5 +1,6 @@ +from __future__ import annotations + from datetime import datetime -from typing import Optional from pydantic import BaseModel, Field @@ -10,25 +11,25 @@ class DocumentBase(BaseModel): file_name: str = Field(..., description="Name of the document file") file_path: str = Field(..., description="Path to the document file") created_at: datetime = Field( - default_factory=datetime.utcnow, description="Document creation timestamp" + default_factory=datetime.utcnow, + description="Document creation timestamp", ) - classification: Optional[str] = Field( - None, description="Document classification category" + classification: str | None = Field( + None, + description="Document classification category", ) - summary: Optional[str] = Field(None, description="Document summary text") + summary: str | None = Field(None, description="Document summary text") class DocumentCreate(DocumentBase): """Schema for creating a new document.""" - pass - class DocumentUpdate(BaseModel): """Schema for updating document attributes.""" - classification: Optional[str] = None - summary: Optional[str] = None + classification: str | None = None + summary: str | None = None class DocumentResponse(DocumentBase): diff --git a/src/ocr/__init__.py b/src/ocr/__init__.py new file mode 100644 index 0000000..705c02d --- /dev/null +++ b/src/ocr/__init__.py @@ -0,0 +1 @@ +# src/ocr/__init__.py diff --git a/src/ocr/optimized_ocr.py b/src/ocr/easy_ocr_wrapper.py similarity index 85% rename from src/ocr/optimized_ocr.py rename to src/ocr/easy_ocr_wrapper.py index 757b3f1..2c55582 100644 --- a/src/ocr/optimized_ocr.py +++ b/src/ocr/easy_ocr_wrapper.py @@ -7,13 +7,20 @@ from PIL import Image from configs.ocr_config import OCRConfig -from payload.ocr_models import OCRResponse, OCRResult +from payload.ocr_models import OCRResponse +from payload.shared_models import OCRResult class ImagePreprocessor: """Handle image preprocessing operations.""" def __init__(self, target_size: int) -> None: + """Initialize the image preprocessor. + + Args: + target_size: Maximum dimension size to resize images to + + """ self.target_size = target_size self._clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) @@ -24,15 +31,15 @@ def resize_image(self, image: Image.Image) -> Image.Image: width, height = image.size scale = min(self.target_size / width, self.target_size / height) - new_size = tuple(int(dim * scale) for dim in (width, height)) + new_size = (int(width * scale), int(height * scale)) return image.resize(new_size, resample=Image.Resampling.LANCZOS) def enhance_image(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]: """Apply image enhancement techniques.""" enhanced = self._clahe.apply(image) - - return cv2.fastNlMeansDenoising(enhanced) + denoised = cv2.fastNlMeansDenoising(enhanced) + return np.array(denoised, dtype=np.uint8) def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: """Complete image preprocessing pipeline.""" @@ -45,7 +52,7 @@ def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: return self.enhance_image(image_array) -class OptimizedOCR: +class EasyOCRWrapper: """Optimized OCR processing with performance enhancements.""" def __init__(self, config: OCRConfig) -> None: @@ -83,11 +90,12 @@ def _process_single(self, image: NDArray[np.uint8]) -> list[OCRResult]: for bbox, word, _ in results ] except Exception as e: - logging.error("Error processing image: %s", str(e)) + logging.exception("Error processing image: %s", str(e)) return [] def process_batch( - self, images: list[Image.Image] + self, + images: list[Image.Image], ) -> tuple[OCRResponse, list[Image.Image]]: """Process multiple images in optimized batch.""" processed = [self.preprocessor.preprocess(image) for image in images] diff --git a/src/ocr/ocr.py b/src/ocr/ocr.py index 8f6fe17..cfec679 100644 --- a/src/ocr/ocr.py +++ b/src/ocr/ocr.py @@ -1,23 +1,40 @@ +from __future__ import annotations + import base64 import io import logging from datetime import datetime from pathlib import Path -from typing import AsyncGenerator, Optional +from typing import TYPE_CHECKING import aiofiles -import requests -from fastapi import Depends, FastAPI, HTTPException, UploadFile, status +import aiohttp +from fastapi import ( + Depends, + FastAPI, + HTTPException, + UploadFile, + status, +) from pdf2image import convert_from_bytes from pdf2image.exceptions import PDFPageCountError from PIL import Image -from tesseract import TesseractOCR +from tesseract_wrapper import TesseractWrapper from configs.ocr_config import OCRConfig -from database import DocumentCreate, DocumentError, DocumentRepository, get_repository -from database.models import Document +from database import ( + DocumentCreate, + DocumentError, + DocumentRepository, + get_repository, +) from utils.utils import get_unique_filename +if TYPE_CHECKING: + from collections.abc import AsyncGenerator + + from database.models import Document + config = OCRConfig() config.LOG_DIR.mkdir(parents=True, exist_ok=True) config.UPLOAD_DIR.mkdir(parents=True, exist_ok=True) @@ -29,7 +46,8 @@ datefmt="%Y-%m-%d %H:%M:%S", handlers=[ logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" + config.LOG_DIR / f"{datetime.now(tz=datetime.UTC):%Y-%m-%d}.log", + mode="a", ), logging.StreamHandler(), ], @@ -38,25 +56,39 @@ logger = logging.getLogger(__name__) app = FastAPI() -# optimizer = OptimizedOCR(config=config) -optimizer = TesseractOCR(config=config) +# optimizer = EasyOCRWrapper(config=config) +optimizer = TesseractWrapper(config=config) class OCRProcessor: """Handle OCR processing operations.""" - def __init__(self, document_repository: DocumentRepository): + def __init__(self, document_repository: DocumentRepository) -> None: """Initialize OCR processor with repository.""" self.repository = document_repository - async def validate_file(self, file: UploadFile) -> Optional[str]: + async def validate_file(self, file: UploadFile) -> str: """Validate uploaded file against constraints.""" logger.info("Validating file: %s", file.filename) + if not file.filename: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Filename is required", + ) new_filename = file.filename - if await self.repository.get_by_filename(file.filename, return_bool=True): - logger.info("File already exists: %s, making it unique", file.filename) - new_filename = await get_unique_filename(file.filename, self.repository) + if await self.repository.get_by_filename( + file.filename, + return_bool=True, + ): + logger.info( + "File already exists: %s, making it unique", + file.filename, + ) + new_filename = await get_unique_filename( + file.filename, + self.repository, + ) logger.info("New unique filename: %s", new_filename) if file.content_type not in config.ACCEPTED_FILE_TYPES: @@ -66,6 +98,12 @@ async def validate_file(self, file: UploadFile) -> Optional[str]: detail="Unsupported file type", ) + if not file.size: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Empty file", + ) + if file.size > config.FILE_SIZE_LIMIT: logger.error("File size too large: %s bytes", file.size) raise HTTPException( @@ -82,12 +120,12 @@ async def validate_file(self, file: UploadFile) -> Optional[str]: status_code=status.HTTP_400_BAD_REQUEST, detail=f"PDF exceeds {config.MAX_PDF_PAGES} pages", ) - except PDFPageCountError as e: - logger.error("PDF processing error: %s", str(e)) + except PDFPageCountError as err: + logger.exception("PDF processing error") raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid or corrupted PDF file", - ) from e + ) from err finally: file.file.seek(0) @@ -109,11 +147,12 @@ def convert_to_base64(images: list[Image.Image]) -> list[str]: encoded_images = [] for img in images: - if img.mode in ("RGBA", "P"): - img = img.convert("RGB") + converted_img = img + if converted_img.mode in ("RGBA", "P"): + converted_img = converted_img.convert("RGB") with io.BytesIO() as buffer: - img.save(buffer, format="JPEG") + converted_img.save(buffer, format="JPEG") img_byte_arr = buffer.getvalue() encoded = base64.b64encode(img_byte_arr).decode("utf-8") @@ -124,31 +163,34 @@ def convert_to_base64(images: list[Image.Image]) -> list[str]: async def save_document(self, file_name: str) -> Document: """Save document metadata to database.""" try: - document = await self.repository.create( + return await self.repository.create( DocumentCreate( file_name=file_name, file_path=str(config.UPLOAD_DIR / file_name), - ) + classification="", + summary="", + ), ) - return document - except DocumentError as e: - logger.error("Failed to save document: %s", str(e)) + except DocumentError as err: + logger.exception("Failed to save document") raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to save document", - ) from e + ) from err @app.get("/documents") async def get_docs( - repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), + repository: AsyncGenerator[DocumentRepository, None] = Depends( + get_repository, + ), ) -> list[dict]: """Get all documents.""" try: documents = await repository.get_all() return [doc.to_dict() for doc in documents] except DocumentError as e: - logger.error("Failed to retrieve documents: %s", str(e)) + logger.exception("Failed to retrieve documents: %s", str(e)) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to retrieve documents", @@ -158,7 +200,9 @@ async def get_docs( @app.post("/ocr") async def process_document( file: UploadFile, - repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), + repository: AsyncGenerator[DocumentRepository, None] = Depends( + get_repository, + ), ) -> dict[str, str]: """Process document for OCR and forward results.""" logger.info("Processing document: %s", file.filename) @@ -194,54 +238,55 @@ async def process_document( # Forward to processor service try: - response = requests.post( - config.PROCESSOR_URL, - json={ - "ocr_result": ocr_response.model_dump(exclude={"page_count"})[ - "results" - ], - "images": encoded_images, - "file_name": file.filename, - }, - timeout=300, - ) - - # If processor request fails, raises HTTPException - response.raise_for_status() - - return response.json() - - except (requests.RequestException, HTTPException) as e: + timeout = aiohttp.ClientTimeout(total=480) + async with ( + aiohttp.ClientSession() as session, + session.post( + config.PROCESSOR_URL, + json={ + "ocr_result": ocr_response.model_dump( + exclude={"page_count"}, + )["results"], + "images": encoded_images, + "file_name": file.filename, + }, + timeout=timeout, + ) as response, + ): + response.raise_for_status() + return await response.json() + + except (aiohttp.ClientError, HTTPException) as e: await cleanup(repository, document_id, output_file) - logger.error("Downstream processing failed: %s", str(e)) + logger.exception("Downstream processing failed") raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Document processing failed in downstream service", - ) + ) from e except Exception as e: await cleanup(repository, document_id, output_file) - logger.error("Processing error: %s", str(e)) + logger.exception("Processing error") raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Document processing failed", - ) + ) from e async def cleanup( repository: DocumentRepository, - document_id: Optional[int], - output_file: Optional[Path], + document_id: int | None, + output_file: Path | None, ) -> None: """Clean up resources on error.""" if document_id: try: await repository.delete(document_id) except DocumentError as e: - logger.error("Failed to delete document: %s", str(e)) + logger.exception("Failed to delete document: %s", str(e)) if output_file and output_file.exists(): try: output_file.unlink() except OSError as e: - logger.error("Failed to delete file: %s", str(e)) + logger.exception("Failed to delete file: %s", str(e)) diff --git a/src/ocr/tesseract.py b/src/ocr/tesseract_wrapper.py similarity index 72% rename from src/ocr/tesseract.py rename to src/ocr/tesseract_wrapper.py index 35ca7fd..43c347a 100644 --- a/src/ocr/tesseract.py +++ b/src/ocr/tesseract_wrapper.py @@ -1,19 +1,32 @@ +from __future__ import annotations + import logging +from typing import TYPE_CHECKING import cv2 import numpy as np import pytesseract -from numpy.typing import NDArray from PIL import Image -from configs.ocr_config import OCRConfig -from payload.ocr_models import OCRResponse, OCRResult +from payload.ocr_models import OCRResponse +from payload.shared_models import OCRResult + +if TYPE_CHECKING: + from numpy.typing import NDArray + + from configs.ocr_config import OCRConfig class ImagePreprocessor: """Handle image preprocessing operations.""" def __init__(self, target_size: int) -> None: + """Initialize image preprocessor. + + Args: + target_size: Maximum size for image dimension. + + """ self.target_size = target_size self._clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) @@ -24,15 +37,19 @@ def resize_image(self, image: Image.Image) -> Image.Image: width, height = image.size scale = min(self.target_size / width, self.target_size / height) - new_size = tuple(int(dim * scale) for dim in (width, height)) + new_size = (int(width * scale), int(height * scale)) return image.resize(new_size, resample=Image.Resampling.LANCZOS) def enhance_image(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]: """Apply image enhancement techniques.""" # Convert to grayscale if not already - if len(image.shape) == 3: - image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) + CHANNELS_RGB = 3 + if len(image.shape) == CHANNELS_RGB: + image = np.asarray( + cv2.cvtColor(image, cv2.COLOR_RGB2GRAY), + dtype=np.uint8, + ) # Apply CLAHE for contrast enhancement enhanced = self._clahe.apply(image) @@ -41,9 +58,14 @@ def enhance_image(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]: denoised = cv2.fastNlMeansDenoising(enhanced) # Binarization using Otsu's method - _, binary = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) + _, binary = cv2.threshold( + denoised, + 0, + 255, + cv2.THRESH_BINARY + cv2.THRESH_OTSU, + ) - return binary + return np.asarray(binary, dtype=np.uint8) def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: """Complete image preprocessing pipeline.""" @@ -57,7 +79,7 @@ def preprocess(self, image: Image.Image) -> NDArray[np.uint8]: return self.enhance_image(image_array) -class TesseractOCR: +class TesseractWrapper: """OCR processing with Tesseract.""" def __init__(self, config: OCRConfig) -> None: @@ -79,28 +101,33 @@ def create_bounding_box( Returns: list[int]: Standardized bounding box [x_min, y_min, x_max, y_max] + """ if isinstance(bbox_data, tuple) and len(bbox_data) == 4: # Handle Tesseract format (x, y, width, height) x, y, w, h = bbox_data return [int(x), int(y), int(x + w), int(y + h)] - else: - # Handle original format (list of coordinate tuples) - xs, ys = zip(*bbox_data) - return [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))] + # Handle original format (list of coordinate tuples) + xs, ys = zip(*bbox_data) + return [int(min(xs)), int(min(ys)), int(max(xs)), int(max(ys))] def _process_single(self, image: NDArray[np.uint8]) -> list[OCRResult]: """Process a single image with Tesseract.""" try: results = pytesseract.image_to_data( - image, output_type=pytesseract.Output.DICT, config=self.custom_config + image, + output_type=pytesseract.Output.DICT, + config=self.custom_config, ) ocr_results = [] n_boxes = len(results["text"]) for i in range(n_boxes): - if int(results["conf"][i]) < 0 or not results["text"][i].strip(): + if ( + int(results["conf"][i]) < 0 + or not results["text"][i].strip() + ): continue # Create bbox_data tuple for compatibility @@ -110,21 +137,26 @@ def _process_single(self, image: NDArray[np.uint8]) -> list[OCRResult]: results["top"][i], results["width"][i], results["height"][i], - ) + ), ) ocr_results.append( - OCRResult(bounding_box=bbox, word=results["text"][i].strip()) + OCRResult( + bounding_box=bbox, + word=results["text"][i].strip(), + ), ) - return ocr_results - except Exception as e: - logging.error("Error processing image: %s", str(e)) + logging.exception("Error processing image: %s", str(e)) return [] + else: + return ocr_results + def process_batch( - self, images: list[Image.Image] + self, + images: list[Image.Image], ) -> tuple[OCRResponse, list[Image.Image]]: """Process multiple images in optimized batch.""" # Preprocess all images diff --git a/src/payload/model_models.py b/src/payload/model_models.py deleted file mode 100644 index eab2f64..0000000 --- a/src/payload/model_models.py +++ /dev/null @@ -1,39 +0,0 @@ -from dataclasses import dataclass - -import torch -from pydantic import BaseModel, ConfigDict - - -@dataclass -class PagePrediction: - """Stores prediction results for a single page.""" - - page_number: int - logits: torch.Tensor - confidence: float - predicted_class: str - text_length: int - - -class ProcessorResult(BaseModel): - """Result data for document processing.""" - - input_ids: list - attention_mask: list - bbox: list - pixel_values: list - file_name: str - text: str - - model_config = ConfigDict( - arbitrary_types_allowed=True, - json_schema_extra={ - "example": { - "input_ids": [[1, 2, 3, 4, 5]], - "attention_mask": [[1, 1, 1, 1, 1]], - "bbox": [[0, 0, 100, 50]], - "pixel_values": [[0, 0, 0, 255, 255, 255]], - "file_name": "example.pdf", - } - }, - ) diff --git a/src/payload/ocr_models.py b/src/payload/ocr_models.py index a127e8d..59ca23c 100644 --- a/src/payload/ocr_models.py +++ b/src/payload/ocr_models.py @@ -1,33 +1,14 @@ from pydantic import BaseModel, ConfigDict, Field - -class OCRResult(BaseModel): - """Structured OCR result using Pydantic BaseModel.""" - - bounding_box: list[int] = Field( - ..., - description="Coordinates of bounding box [x_min, y_min, x_max, y_max]", - min_items=4, - max_items=4, - ) - word: str = Field(..., description="Recognized text") - - model_config = ConfigDict( - frozen=True, - json_schema_extra={ - "example": { - "bounding_box": [100, 100, 200, 150], - "word": "Example", - } - }, - ) +from .shared_models import OCRResult class OCRResponse(BaseModel): """Response model for OCR processing.""" results: list[list[OCRResult]] = Field( - ..., description="list of OCR results from the document" + ..., + description="list of OCR results from the document", ) page_count: int = Field(1, description="Number of pages processed", ge=1) diff --git a/src/payload/predictor_models.py b/src/payload/predictor_models.py new file mode 100644 index 0000000..022c6c7 --- /dev/null +++ b/src/payload/predictor_models.py @@ -0,0 +1,14 @@ +from dataclasses import dataclass + +import torch + + +@dataclass +class PagePrediction: + """Stores prediction results for a single page.""" + + page_number: int + logits: torch.Tensor + confidence: float + predicted_class: str + text_length: int diff --git a/src/payload/processor_models.py b/src/payload/processor_models.py index c0e8b3e..7751e02 100644 --- a/src/payload/processor_models.py +++ b/src/payload/processor_models.py @@ -1,38 +1,6 @@ -import torch from pydantic import BaseModel, ConfigDict, Field - -class BoundingBox(BaseModel): - """Represents a bounding box for OCR results.""" - - coordinates: list[int] = Field( - ..., - min_items=4, - max_items=4, - description="Coordinates in format [x_min, y_min, x_max, y_max]", - ) - - -class OCRResult(BaseModel): - """Structured OCR result using Pydantic BaseModel.""" - - bounding_box: list[int] = Field( - ..., - description="Coordinates of bounding box [x_min, y_min, x_max, y_max]", - min_items=4, - max_items=4, - ) - word: str = Field(..., description="Recognized text") - - model_config = ConfigDict( - frozen=True, - json_schema_extra={ - "example": { - "bounding_box": [100, 100, 200, 150], - "word": "Example", - } - }, - ) +from .shared_models import OCRResult class ProcessorInput(BaseModel): @@ -45,29 +13,30 @@ class ProcessorInput(BaseModel): model_config = ConfigDict( json_schema_extra={ "example": { - "ocr_result": [{"word": "Example", "bounding_box": [0, 0, 100, 50]}], + "ocr_result": [ + {"word": "Example", "bounding_box": [0, 0, 100, 50]}, + ], "images": ["base64_encoded_image_string"], - } - } + }, + }, ) -class ProcessorResult(BaseModel): +class ProcessorOutput(BaseModel): """Result data for document processing.""" - input_ids: torch.Tensor - attention_mask: torch.Tensor - bbox: torch.Tensor - pixel_values: torch.Tensor + input_ids: list + attention_mask: list + bbox: list + pixel_values: list model_config = ConfigDict( - arbitrary_types_allowed=True, json_schema_extra={ "example": { "input_ids": [[1, 2, 3, 4, 5]], "attention_mask": [[1, 1, 1, 1, 1]], "bbox": [[0, 0, 100, 50]], "pixel_values": [[0, 0, 0, 255, 255, 255]], - } + }, }, ) diff --git a/src/payload/shared_models.py b/src/payload/shared_models.py new file mode 100644 index 0000000..0703db3 --- /dev/null +++ b/src/payload/shared_models.py @@ -0,0 +1,51 @@ +from __future__ import annotations + +from pydantic import BaseModel, ConfigDict, Field + + +class OCRResult(BaseModel): + """Structured OCR result using Pydantic BaseModel.""" + + bounding_box: list[int] = Field( + default=..., + min_length=4, + max_length=4, + description="Coordinates in format [x_min, y_min, x_max, y_max]", + ) + word: str = Field(..., description="Recognized text") + + model_config = ConfigDict( + frozen=True, + json_schema_extra={ + "example": { + "bounding_box": [100, 100, 200, 150], + "word": "Example", + }, + }, + ) + + +class ProcessorResult(BaseModel): + """Result data for document processing.""" + + input_ids: list | None + attention_mask: list | None + bbox: list | None + pixel_values: list | None + file_name: str = Field(..., description="Name of the processed file") + text: str = Field(..., description="Text extracted from OCR") + language: str = Field(..., description="Detected language") + + model_config = ConfigDict( + json_schema_extra={ + "example": { + "input_ids": [[1, 2, 3, 4, 5]], + "attention_mask": [[1, 1, 1, 1, 1]], + "bbox": [[0, 0, 100, 50]], + "pixel_values": [[0, 0, 0, 255, 255, 255]], + "file_name": "example.pdf", + "text": "Example text", + "language": "en", + }, + }, + ) diff --git a/src/payload/summarizer_models.py b/src/payload/summarizer_models.py index b28419a..44f64d5 100644 --- a/src/payload/summarizer_models.py +++ b/src/payload/summarizer_models.py @@ -1,5 +1,3 @@ -# src/summarization/summarizer.py - from pydantic import BaseModel, Field @@ -8,4 +6,13 @@ class SummarizationRequest(BaseModel): file_name: str = Field(..., description="Name of the file to summarize") text: str = Field(..., description="Text content to summarize") - classification: str = Field(..., description="Predicted classes for the text") + classification: str = Field( + ..., description="Predicted classes for the text" + ) + + +class SummaryResponse(BaseModel): + """Structured response from the summarization model.""" + + summary: str = Field(..., description="Generated summary text") + word_count: int = Field(..., description="Number of words in summary") diff --git a/src/predictor/layoutlm_wrapper.py b/src/predictor/layoutlm_wrapper.py new file mode 100644 index 0000000..58512f8 --- /dev/null +++ b/src/predictor/layoutlm_wrapper.py @@ -0,0 +1,139 @@ +import lightning.pytorch as pl +import torch +from torchmetrics import Accuracy +from transformers import LayoutLMv3ForSequenceClassification + +from configs.model_config import ModelConfig + + +class LayoutLMV3Wrapper(pl.LightningModule): + """PyTorch Lightning module for document classification using LayoutLMv3.""" + + def __init__(self, config: ModelConfig) -> None: + """Initialize the model. + + Args: + n_classes: Number of document classes to predict + + """ + super().__init__() + self.n_classes = len(config.DOCUMENT_CLASSES) + self.model = LayoutLMv3ForSequenceClassification.from_pretrained( + "/app/data/models/layoutlmv3-base-finetuned-rvlcdip", + num_labels=self.n_classes, + use_safetensors=True, + ) + self.config = config + self.model.config.id2label = dict(enumerate(config.DOCUMENT_CLASSES)) + self.model.config.label2id = { + v: k for k, v in enumerate(config.DOCUMENT_CLASSES) + } + self.train_accuracy = Accuracy( + task="multiclass", + num_classes=self.n_classes, + ) + self.val_accuracy = Accuracy( + task="multiclass", + num_classes=self.n_classes, + ) + + def forward( + self, + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + bbox: torch.Tensor, + pixel_values: torch.Tensor, + ) -> object: + """Forward pass through the model. + + Args: + input_ids: Input token IDs + attention_mask: Attention mask + bbox: Bounding box coordinates + pixel_values: Image pixel values + + Returns: + Model output containing logits and loss + + """ + return self.model( + input_ids, + attention_mask=attention_mask, + bbox=bbox, + pixel_values=pixel_values, + ) + + def training_step( + self, + batch: dict[str, torch.Tensor], + batch_idx: int, # noqa: ARG002 + ) -> torch.Tensor: + """Training step for one batch. + + Args: + batch: Dictionary containing batch data + batch_idx: Index of current batch (unused) + + Returns: + Training loss + + """ + input_ids = batch["input_ids"] + attention_mask = batch["attention_mask"] + bbox = batch["bbox"] + pixel_values = batch["pixel_values"] + labels = batch["labels"] + + output = self(input_ids, attention_mask, bbox, pixel_values, labels) + + self.log("train_loss", output.loss) + self.log( + "train_acc", + self.train_accuracy(output.logits, labels), + on_step=True, + on_epoch=True, + ) + + return output.loss + + def validation_step( + self, + batch: dict[str, torch.Tensor], + batch_idx: int, # noqa: ARG002 + ) -> torch.Tensor: + """Execute validation step for one batch. + + Args: + batch: Dictionary containing batch data + batch_idx: Index of current batch (unused) + + Returns: + Validation loss + + """ + input_ids = batch["input_ids"] + attention_mask = batch["attention_mask"] + bbox = batch["bbox"] + pixel_values = batch["pixel_values"] + labels = batch["labels"] + + output = self(input_ids, attention_mask, bbox, pixel_values, labels) + + self.log("val_loss", output.loss) + self.log( + "val_acc", + self.val_accuracy(output.logits, labels), + on_step=False, + on_epoch=True, + ) + + return output.loss + + def configure_optimizers(self) -> torch.optim.Optimizer: + """Configure optimizers for training. + + Returns: + Adam optimizer instance + + """ + return torch.optim.Adam(self.model.parameters(), lr=1e-5) diff --git a/src/predictor/llm_model.py b/src/predictor/llm_model.py new file mode 100644 index 0000000..5a87484 --- /dev/null +++ b/src/predictor/llm_model.py @@ -0,0 +1,352 @@ +from __future__ import annotations + +import json +import logging +import re +from datetime import datetime +from typing import Any, NotRequired, TypedDict + +import aiohttp +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel, Field + +from configs.model_config import ModelConfig + +config = ModelConfig() +config.LOG_DIR.mkdir(parents=True, exist_ok=True) + +logging.basicConfig( + level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", + ), + logging.StreamHandler(), + ], +) + +logger = logging.getLogger(__name__) +app = FastAPI() + + +class ClassificationResponse(BaseModel): + """Structured response from the classification model.""" + + class_label: str = Field(..., description="Predicted document class") + confidence: float = Field(..., description="Prediction confidence score") + + +class OllamaOptions(TypedDict): + """Type definition for Ollama API options.""" + + temperature: float + top_p: float + frequency_penalty: float + presence_penalty: float + num_ctx: int + num_gpu: int + num_thread: int + + +class OllamaRequest(TypedDict, total=False): + """Type definition for Ollama API request.""" + + model: str # required + prompt: str # required + format: NotRequired[str] + options: NotRequired[OllamaOptions] + system: NotRequired[str] + stream: NotRequired[bool] + raw: NotRequired[bool] + keep_alive: NotRequired[str | int] + + +class LLMModelWrapper: + """Document classification using direct Ollama integration.""" + + CLASSIFICATION_SYSTEM_PROMPT = """You are a document classification expert tasked with precise analysis. + Core Requirements: + 1. Analyze text provided in {language} + 2. Classify into categories: {categories} + 3. Output JSON format: {{"class_label": "category", "confidence": number}} + + Guidelines: + - Evaluate based on content, style, terminology and format + - Look for distinctive markers and key phrases + - Consider document structure and formatting patterns + - Maintain consistent standards across documents + - Use confidence scores that realistically reflect certainty + - Confidence range: 0-100 + - Return clean JSON only, no other text""" + + CLASSIFICATION_PROMPT = """Task Analysis: + You are examining a document in {language} to determine its category from: {categories} + + Document Classification Guidelines: + 1. Analyze these key aspects: + - Subject matter and main themes + - Technical terminology usage + - Writing style and tone + - Document structure and sections + - Target audience indicators + - Domain-specific formatting + + 2. Evidence Collection: + - Identify definitive category markers + - Note absence of expected features + - Compare against typical examples + - Check for mixed/ambiguous signals + - Evaluate consistency throughout + + 3. Confidence Scoring: + - 90-100: Unambiguous match with strong indicators + - 70-89: Clear match with some uncertainty + - 50-69: Probable match with mixed signals + - Below 50: Significant uncertainty + + Input Document: + {text} + + Required Response Format: + - Pure JSON object + - Must include class_label and confidence + - Example: {{"class_label": "example_category", "confidence": 85}} + - No explanatory text outside JSON + + Respond with classification:""" + + def __init__(self, config: ModelConfig) -> None: + """Initialize classifier with configuration.""" + self.config = config + self.base_url = f"{config.OLLAMA_BASE_URL}/api/generate" + + def _prepare_request( + self, + text: str, + language: str, + ) -> OllamaRequest: + """Prepare the request payload for Ollama API.""" + system_prompt = self.CLASSIFICATION_SYSTEM_PROMPT.format( + language=language, + categories=self.config.DOCUMENT_CLASSES, + ) + + user_prompt = self.CLASSIFICATION_PROMPT.format( + text=text, + language=language, + categories=self.config.DOCUMENT_CLASSES, + ) + + return { + "model": self.config.MODEL_NAME, + "prompt": user_prompt, + "system": system_prompt, + "format": "json", + "stream": False, + "options": { + "temperature": self.config.TEMPERATURE, + "top_p": self.config.TOP_P, + "frequency_penalty": self.config.FREQUENCY_PENALTY, + "presence_penalty": self.config.PRESENCE_PENALTY, + "num_ctx": self.config.NUM_CTX, + "num_gpu": self.config.NUM_GPU, + "num_thread": self.config.NUM_THREAD, + }, + "keep_alive": "15m", + } + + def _process_raw_response(self, content: str) -> ClassificationResponse: + """Process raw response when JSON parsing fails. + + Args: + content: Raw response content from the model + + Returns: + Structured classification response + + Raises: + ValueError: If unable to extract valid classification + + """ + # Remove any potential markdown code blocks + content = re.sub(r"```json\s*|\s*```", "", content) + + # Try to find class and confidence using regex + class_match = re.search( + r"class_label[\"']?\s*:\s*[\"']([^\"']+)[\"']", + content, + ) + conf_match = re.search( + r"confidence[\"']?\s*:\s*(0?\.\d+|1\.0?|1|0)", + content, + ) + + if not (class_match and conf_match): + raise ValueError( + "Unable to extract valid classification from response", + ) + + class_label = class_match.group(1) + confidence = float(conf_match.group(1)) + + if class_label not in self.config.DOCUMENT_CLASSES: + raise ValueError(f"Invalid class label: {class_label}") + + if not 0 <= confidence <= 100: + logger.warning( + "Invalid confidence score: %s, calculating...", + confidence, + ) + confidence = min(100, confidence) + + return ClassificationResponse( + class_label=class_label, + confidence=confidence, + ) + + def _validate_classification_response( + self, + response_data: dict[str, Any], + ) -> ClassificationResponse: + """Validate and process the classification response. + + Args: + response_data: Parsed JSON response + + Returns: + Validated classification response + + Raises: + ValueError: If response doesn't meet requirements + + """ + if not isinstance(response_data, dict): + raise ValueError("Response must be a JSON object") + + if ( + "class_label" not in response_data + or "confidence" not in response_data + ): + raise ValueError( + 'Response must contain "class_label" and "confidence" fields', + ) + + class_label = response_data["class_label"] + confidence = response_data["confidence"] + + if not isinstance(class_label, str) or not isinstance( + confidence, + (int, float), + ): + raise ValueError("Invalid field types in response") + + if class_label not in self.config.DOCUMENT_CLASSES: + raise ValueError(f"Invalid class label: {class_label}") + + if not 0 <= confidence <= 100: + logger.warning( + "Invalid confidence score: %s, calculating...", + confidence, + ) + confidence = min(100, confidence) + + return ClassificationResponse( + class_label=class_label, + confidence=float(confidence), + ) + + async def predict_class( + self, + text: str, + language: str, + ) -> str: + """Predict document class using the LLM model. + + Args: + text: Document text to classify + language: Language of the document + + Returns: + Predicted document class in format "class_label|confidence" + + Raises: + HTTPException: If classification fails + + """ + + def _raise_invalid_response(): + msg = "Invalid response format from Ollama" + raise ValueError(msg) + + def _raise_empty_response(): + msg = "Empty response from Ollama" + raise ValueError(msg) + + try: + request_data = self._prepare_request(text, language) + + timeout = aiohttp.ClientTimeout(total=300) + async with ( + aiohttp.ClientSession(timeout=timeout) as session, + session.post( + self.base_url, + json=request_data, + ) as response, + ): + response.raise_for_status() + result = await response.json() + + if not isinstance(result, dict) or "response" not in result: + _raise_invalid_response() + + content = result["response"].strip() + if not content: + _raise_empty_response() + + try: + # Try to parse as JSON first + response_data = json.loads(content) + classification = self._validate_classification_response( + response_data, + ) + except (json.JSONDecodeError, ValueError) as e: + logger.warning( + "Failed to parse JSON response, falling back to raw " + "processing: %s", + str(e), + ) + # Fall back to raw response processing + classification = self._process_raw_response(content) + + # Return in the expected format "class_label|confidence" + return ( + f"{classification.class_label}|{classification.confidence}" + ) + + except aiohttp.ClientError as e: + logger.exception("Ollama API communication error") + raise HTTPException( + status_code=500, + detail=f"Failed to communicate with Ollama: {e!s}", + ) from e + + except ValueError as e: + logger.exception("Invalid response format from Ollama") + raise HTTPException( + status_code=500, + detail=str(e), + ) from e + + except Exception as e: + logger.exception("Classification failed") + raise HTTPException( + status_code=500, + detail=f"Classification failed: {e!s}", + ) from e + + +# Create model instance +llm_model = LLMModelWrapper(config) diff --git a/src/predictor/model.py b/src/predictor/model.py deleted file mode 100644 index 20c69a3..0000000 --- a/src/predictor/model.py +++ /dev/null @@ -1,264 +0,0 @@ -import logging -from datetime import datetime -from typing import Any, AsyncGenerator - -import lightning.pytorch as pl -import requests -import torch -import torch.nn.functional as F -from fastapi import Depends, FastAPI, HTTPException -from torchmetrics import Accuracy -from transformers import LayoutLMv3ForSequenceClassification, PreTrainedModel - -from configs.model_config import ModelConfig -from database import DocumentError, DocumentRepository, get_repository -from payload.model_models import PagePrediction, ProcessorResult - -config = ModelConfig() -config.LOG_DIR.mkdir(parents=True, exist_ok=True) - -logging.basicConfig( - level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", - datefmt="%Y-%m-%d %H:%M:%S", - handlers=[ - logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" - ), - logging.StreamHandler(), - ], -) - -logger = logging.getLogger(__name__) - -app = FastAPI() - - -class ModelModule(pl.LightningModule): - def __init__(self, n_classes: int = 15): - super().__init__() - self.model = LayoutLMv3ForSequenceClassification.from_pretrained( - "/app/data/models/layoutlmv3-base-finetuned-rvlcdip", - num_labels=n_classes, - use_safetensors=True, - ) - self.model.config.id2label = { - k: v for k, v in enumerate(config.DOCUMENT_CLASSES) - } - self.model.config.label2id = { - v: k for k, v in enumerate(config.DOCUMENT_CLASSES) - } - self.train_accuracy = Accuracy(task="multiclass", num_classes=n_classes) - self.val_accuracy = Accuracy(task="multiclass", num_classes=n_classes) - - def forward(self, input_ids, attention_mask, bbox, pixel_values): - return self.model( - input_ids, - attention_mask=attention_mask, - bbox=bbox, - pixel_values=pixel_values, - ) - - def training_step(self, batch, batch_idx): - input_ids = batch["input_ids"] - attention_mask = batch["attention_mask"] - bbox = batch["bbox"] - pixel_values = batch["pixel_values"] - labels = batch["labels"] - - output = self(input_ids, attention_mask, bbox, pixel_values, labels) - - self.log("train_loss", output.loss) - self.log( - "train_acc", - self.train_accuracy(output.logits, labels), - on_step=True, - on_epoch=True, - ) - - return output.loss - - def validation_step(self, batch, batch_idx): - input_ids = batch["input_ids"] - attention_mask = batch["attention_mask"] - bbox = batch["bbox"] - pixel_values = batch["pixel_values"] - labels = batch["labels"] - - output = self(input_ids, attention_mask, bbox, pixel_values, labels) - - self.log("val_loss", output.loss) - self.log( - "val_acc", - self.val_accuracy(output.logits, labels), - on_step=False, - on_epoch=True, - ) - - return output.loss - - def configure_optimizers(self): - optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-5) - return optimizer - - -model = ModelModule(n_classes=len(config.DOCUMENT_CLASSES)) -model.eval() - - -def _calculate_page_weights(page_predictions: list[PagePrediction]) -> torch.Tensor: - """Calculate weights for each page based on multiple factors. - - Args: - page_predictions: List of predictions for each page - - Returns: - Tensor of normalized weights for each page - """ - text_lengths = torch.tensor([pred.text_length for pred in page_predictions]) - confidences = torch.tensor([pred.confidence for pred in page_predictions]) - - if text_lengths.max() > 0: - normalized_lengths = text_lengths / text_lengths.max() - else: - normalized_lengths = torch.ones_like(text_lengths) - - weights = (normalized_lengths * confidences) + 1e-6 - - for i, (raw_weight, length, conf) in enumerate( - zip(weights, text_lengths, confidences) - ): - logger.debug( - f"Page {i+1} pre-normalization: " - f"weight={raw_weight:.4f}, " - f"text_length={length}, " - f"confidence={conf:.4f}" - ) - - temperature = 1.0 - normalized_weights = F.softmax(weights / temperature, dim=0) - - for i, weight in enumerate(normalized_weights): - logger.debug(f"Page {i+1} final weight: {weight:.4f}") - - return normalized_weights - - -def aggregate_predictions( - model: PreTrainedModel, page_predictions: list[PagePrediction] -) -> dict[str, Any]: - """Aggregate predictions from multiple pages using weighted voting. - - Args: - page_predictions: List of predictions for each page - - Returns: - Dictionary containing final classification results - """ - if not page_predictions: - raise ValueError("No valid predictions to aggregate") - - weights = _calculate_page_weights(page_predictions) - - stacked_logits = torch.stack([pred.logits for pred in page_predictions]) - weighted_logits = (stacked_logits * weights.unsqueeze(-1)).sum(dim=0) - - probabilities = F.softmax(weighted_logits, dim=-1) - confidence, predicted_class = torch.max(probabilities, dim=-1) - - return { - "predicted_class": model.config.id2label[predicted_class.item()], - "confidence": confidence.item(), - "page_predictions": [ - { - "page": pred.page_number, - "class": pred.predicted_class, - "confidence": pred.confidence, - "weight": weight.item(), - } - for pred, weight in zip(page_predictions, weights) - ], - "probability_distribution": { - model.config.id2label[i]: prob.item() - for i, prob in enumerate(probabilities) - }, - } - - -@app.post("/predict-class") -async def predict( - data: ProcessorResult, - repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), -) -> dict[str, str]: - """ - Predict document class from processed data. - - Args: - data: Processed data from document processor - repository: Document repository instance - """ - - try: - logger.info("Received data for prediction") - input_ids = torch.tensor(data.input_ids) - attention_mask = torch.tensor(data.attention_mask) - bbox = torch.tensor(data.bbox) - pixel_values = torch.tensor(data.pixel_values) - - with torch.inference_mode(): - output = model(input_ids, attention_mask, bbox, pixel_values) - - probabilities = F.softmax(output.logits, dim=-1) - confidence, predicted_class = torch.max(probabilities, dim=-1) - - predictions = [] - for i in range(output.logits.size(0)): - pred_class = predicted_class[i].item() - conf = confidence[i].item() - text_length = torch.sum(attention_mask[i]).item() - - predictions.append( - PagePrediction( - page_number=i, - logits=output.logits[i], - confidence=conf, - predicted_class=model.model.config.id2label[pred_class], - text_length=text_length, - ) - ) - - detailed_results = aggregate_predictions(model.model, predictions) - - logger.debug("Prediction results: %s", detailed_results) - logger.info("Predicted class: %s", detailed_results["predicted_class"]) - - try: - await repository.update_classification( - data.file_name, - detailed_results["predicted_class"], - ) - except DocumentError as e: - logger.error("Failed to update classification: %s", str(e)) - raise HTTPException( - status_code=500, - detail="Failed to update classification", - ) from e - - response = requests.post( - config.SUMMARIZER_URL, - json={ - "file_name": data.file_name, - "text": data.text, - "classification": detailed_results["predicted_class"], - }, - timeout=300, - ) - - return response.json() - - except Exception as e: - logger.exception("Prediction failed") - raise HTTPException( - status_code=500, - detail=str(e), - ) from e diff --git a/src/predictor/predictor.py b/src/predictor/predictor.py new file mode 100644 index 0000000..4612836 --- /dev/null +++ b/src/predictor/predictor.py @@ -0,0 +1,271 @@ +import logging +from collections.abc import AsyncGenerator +from datetime import datetime +from typing import Any + +import aiohttp +import torch +import torch.nn.functional as f +from fastapi import Depends, FastAPI, HTTPException +from layoutlm_wrapper import LayoutLMV3Wrapper +from lingua import Language +from llm_model import LLMModelWrapper +from transformers import PreTrainedModel + +from configs.model_config import ModelConfig +from database import DocumentError, DocumentRepository, get_repository +from payload.predictor_models import PagePrediction +from payload.shared_models import ProcessorResult + +config = ModelConfig() +config.LOG_DIR.mkdir(parents=True, exist_ok=True) + +logging.basicConfig( + level=logging.DEBUG if config.LOG_LEVEL == "DEBUG" else logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + handlers=[ + logging.FileHandler( + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", + ), + logging.StreamHandler(), + ], +) + + +logger = logging.getLogger(__name__) + +app = FastAPI() + + +layoutlm_model = LayoutLMV3Wrapper(config) +layoutlm_model.eval() + +llm_model = LLMModelWrapper(config) + + +def _calculate_page_weights( + page_predictions: list[PagePrediction], +) -> torch.Tensor: + """Calculate weights for each page based on multiple factors. + + Args: + page_predictions: List of predictions for each page + + Returns: + Tensor of normalized weights for each page + + """ + text_lengths = torch.tensor([pred.text_length for pred in page_predictions]) + confidences = torch.tensor([pred.confidence for pred in page_predictions]) + + if text_lengths.max() > 0: + normalized_lengths = text_lengths / text_lengths.max() + else: + normalized_lengths = torch.ones_like(text_lengths) + + weights = (normalized_lengths * confidences) + 1e-6 + + for i, (raw_weight, length, conf) in enumerate( + zip(weights, text_lengths, confidences), + ): + logger.debug( + "Page %(page)d pre-normalization: weight=%(weight).4f, text_length=%(length)d, confidence=%(conf).4f", + { + "page": i + 1, + "weight": raw_weight, + "length": length, + "conf": conf, + }, + ) + + temperature = 1.0 + normalized_weights = f.softmax(weights / temperature, dim=0) + + for i, weight in enumerate(normalized_weights): + logger.debug( + "Page %(page)d final weight: %(weight).4f", + {"page": i + 1, "weight": weight}, + ) + + return normalized_weights + + +def aggregate_predictions( + model: PreTrainedModel, + page_predictions: list[PagePrediction], +) -> dict[str, Any]: + """Aggregate predictions from multiple pages using weighted voting. + + Args: + model: Pre-trained model containing label mapping configuration + page_predictions: List of predictions for each page + + Returns: + Dictionary containing final classification results + + """ + if not page_predictions: + msg = "No valid predictions to aggregate" + raise ValueError(msg) + + weights = _calculate_page_weights(page_predictions) + + stacked_logits = torch.stack([pred.logits for pred in page_predictions]) + weighted_logits = (stacked_logits * weights.unsqueeze(-1)).sum(dim=0) + + probabilities = f.softmax(weighted_logits, dim=-1) + confidence, predicted_class = torch.max(probabilities, dim=-1) + + return { + "predicted_class": model.config.id2label[int(predicted_class.item())], + "confidence": confidence.item(), + "page_predictions": [ + { + "page": pred.page_number, + "class": pred.predicted_class, + "confidence": pred.confidence, + "weight": weight.item(), + } + for pred, weight in zip(page_predictions, weights) + ], + "probability_distribution": { + model.config.id2label[i]: prob.item() + for i, prob in enumerate(probabilities) + }, + } + + +@app.post("/predict-class") +async def predict( + data: ProcessorResult, + repository: AsyncGenerator[DocumentRepository, None] = Depends( + get_repository, + ), +) -> dict[str, str]: + """Predict document class from processed data. + + Args: + data: Processed data from document processor + repository: Document repository instance + + Returns: + Dictionary containing prediction results and summary + + """ + try: + logger.info("Received data for prediction") + + # Initialize variables for prediction results + detailed_results = None + + # Choose prediction method based on language + if getattr(Language, data.language) != Language.ENGLISH: + # Use LLM for non-English documents + logger.info("Using LLM model for non-English document") + prediction_result = await llm_model.predict_class( + data.text, + data.language, + ) + logger.debug("LLM prediction result: %s", prediction_result) + # Parse the LLM output (format: "class_label|confidence_score") + predicted_class, confidence = prediction_result.split("|") + confidence = float(confidence) / 100 + + detailed_results = { + "predicted_class": predicted_class, + "confidence": confidence, + "page_predictions": [ + { + "page": 0, + "class": predicted_class, + "confidence": confidence, + "weight": 1.0, + }, + ], + "probability_distribution": { + predicted_class: confidence, + }, + } + else: + # Use LayoutLM for English documents + logger.info("Using LayoutLM model for English document") + input_ids = torch.tensor(data.input_ids) + attention_mask = torch.tensor(data.attention_mask) + bbox = torch.tensor(data.bbox) + pixel_values = torch.tensor(data.pixel_values) + + with torch.inference_mode(): + output = layoutlm_model( + input_ids, + attention_mask, + bbox, + pixel_values, + ) + + probabilities = f.softmax(output.logits, dim=-1) + confidence, predicted_class = torch.max(probabilities, dim=-1) + + predictions = [] + for i in range(output.logits.size(0)): + pred_class = int(predicted_class[i].item()) + conf = confidence[i].item() + text_length = int(torch.sum(attention_mask[i]).item()) + + predictions.append( + PagePrediction( + page_number=i, + logits=output.logits[i], + confidence=conf, + predicted_class=layoutlm_model.model.config.id2label[ + pred_class + ], + text_length=text_length, + ), + ) + + detailed_results = aggregate_predictions( + layoutlm_model.model, + predictions, + ) + + logger.debug("Prediction results: %s", detailed_results) + logger.info("Predicted class: %s", detailed_results["predicted_class"]) + + # Update classification in repository + try: + await repository.update_classification( + data.file_name, + detailed_results["predicted_class"], + ) + except DocumentError as e: + logger.exception("Failed to update classification") + raise HTTPException( + status_code=500, + detail="Failed to update classification", + ) from e + + # Send to summarizer + timeout = aiohttp.ClientTimeout(total=480) + async with ( + aiohttp.ClientSession() as session, + session.post( + config.SUMMARIZER_URL, + json={ + "file_name": data.file_name, + "text": data.text, + "classification": detailed_results["predicted_class"], + }, + timeout=timeout, + ) as response, + ): + response.raise_for_status() + return await response.json() + + except Exception as e: + logger.exception("Prediction failed") + raise HTTPException( + status_code=500, + detail=str(e), + ) from e diff --git a/src/processor/dataset.py b/src/processor/dataset.py index 423599a..41ec4ac 100644 --- a/src/processor/dataset.py +++ b/src/processor/dataset.py @@ -1,16 +1,22 @@ +from __future__ import annotations + import base64 import io import logging from datetime import datetime -from typing import Optional +from typing import TYPE_CHECKING import torch from PIL import Image from torch.utils.data import Dataset -from transformers import ProcessorMixin from configs.processor_config import ProcessorConfig -from payload.processor_models import OCRResult, ProcessorInput + +if TYPE_CHECKING: + from transformers import ProcessorMixin + + from payload.processor_models import ProcessorInput + from payload.shared_models import OCRResult config = ProcessorConfig() config.LOG_DIR.mkdir(parents=True, exist_ok=True) @@ -21,7 +27,8 @@ datefmt="%Y-%m-%d %H:%M:%S", handlers=[ logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", ), logging.StreamHandler(), ], @@ -38,24 +45,27 @@ def __init__( processor: ProcessorMixin, data: ProcessorInput, config: ProcessorConfig, - labels: Optional[list[int]] = None, + labels: list[int] | None = None, *, - encodings: Optional[dict[str, torch.Tensor]] = None, + encodings: dict[str, torch.Tensor] | None = None, ) -> None: - """ - Initialize document classification dataset. + """Initialize document classification dataset. Args: processor: LayoutLMv3 processor instance data: Validated input data config: Processing configuration labels: Optional classification labels + encodings: Pre-computed encodings (optional) + """ self.processor = processor self.config = config self.labels = labels self.encodings = ( - encodings if encodings is not None else self._prepare_encodings(data) + encodings + if encodings is not None + else self._prepare_encodings(data) ) @classmethod @@ -65,8 +75,7 @@ def get_encodings( data: ProcessorInput, config: ProcessorConfig, ) -> dict[str, torch.Tensor]: - """ - Get document encodings without instantiating the full dataset. + """Get document encodings without instantiating the full dataset. This method processes the input data and returns only the encodings, which is useful when you don't need the full dataset functionality. @@ -81,6 +90,7 @@ def get_encodings( Raises: ValueError: If encoding preparation fails + """ temp_instance = cls( processor=processor, @@ -89,23 +99,36 @@ def get_encodings( encodings={}, ) - return temp_instance._prepare_encodings(data) + return temp_instance.prepare_encodings(data) + + def _check_images(self, images: list[Image.Image]) -> None: + """Check if images are valid.""" + if not images: + error_msg = "No valid images found in input data" + raise ValueError(error_msg) - def _prepare_encodings(self, data: ProcessorInput) -> dict[str, torch.Tensor]: + def prepare_encodings( + self, + data: ProcessorInput, + ) -> dict[str, torch.Tensor]: """Prepare encodings from input data for multiple pages.""" try: images = self._decode_images(data.images) - if not images: - raise ValueError("No valid images found in input data") + self._check_images(images) scales = self._calculate_scales(images[0].size) words_per_page, boxes_per_page = self._prepare_ocr_data( - data.ocr_result, scales + data.ocr_result, + scales, ) # Process each page separately page_encodings = [] - for img, words, boxes in zip(images, words_per_page, boxes_per_page): + for img, words, boxes in zip( + images, + words_per_page, + boxes_per_page, + ): encoding = self.processor( [img], # Processor expects a list of images words, @@ -120,14 +143,20 @@ def _prepare_encodings(self, data: ProcessorInput) -> dict[str, torch.Tensor]: # Combine encodings from all pages combined_encodings = { "input_ids": torch.cat( - [enc["input_ids"] for enc in page_encodings], dim=0 + [enc["input_ids"] for enc in page_encodings], + dim=0, ), "attention_mask": torch.cat( - [enc["attention_mask"] for enc in page_encodings], dim=0 + [enc["attention_mask"] for enc in page_encodings], + dim=0, + ), + "bbox": torch.cat( + [enc["bbox"] for enc in page_encodings], + dim=0, ), - "bbox": torch.cat([enc["bbox"] for enc in page_encodings], dim=0), "pixel_values": torch.cat( - [enc["pixel_values"] for enc in page_encodings], dim=0 + [enc["pixel_values"] for enc in page_encodings], + dim=0, ), } @@ -136,11 +165,12 @@ def _prepare_encodings(self, data: ProcessorInput) -> dict[str, torch.Tensor]: {k: v.shape for k, v in combined_encodings.items()}, ) - return combined_encodings - except Exception as e: + error_msg = f"Encoding preparation failed: {e!s}" logger.exception("Error preparing encodings") - raise ValueError(f"Encoding preparation failed: {str(e)}") from e + raise ValueError(error_msg) from e + else: + return combined_encodings @staticmethod def _decode_images(encoded_images: list[str]) -> list[Image.Image]: @@ -150,7 +180,10 @@ def _decode_images(encoded_images: list[str]) -> list[Image.Image]: for img in encoded_images ] - def _calculate_scales(self, image_size: tuple[int, int]) -> tuple[float, float]: + def _calculate_scales( + self, + image_size: tuple[int, int], + ) -> tuple[float, float]: """Calculate scaling factors for image resizing.""" width, height = image_size logger.debug("Image size: %s", image_size) @@ -162,7 +195,8 @@ def _calculate_scales(self, image_size: tuple[int, int]) -> tuple[float, float]: @staticmethod def _prepare_ocr_data( - ocr_results: list[list[OCRResult]], scales: tuple[float, float] + ocr_results: list[list[OCRResult]], + scales: tuple[float, float], ) -> tuple[list[str], list[list[int]]]: """Prepare OCR data with scaling.""" if not ocr_results: @@ -179,7 +213,8 @@ def _prepare_ocr_data( scaled_box = [ int(coord * scale) for coord, scale in zip( - result.bounding_box, [width_scale, height_scale] * 2 + result.bounding_box, + [width_scale, height_scale] * 2, ) ] tmp_box.append(scaled_box) diff --git a/src/processor/processor.py b/src/processor/processor.py index 184974a..d2c4d57 100644 --- a/src/processor/processor.py +++ b/src/processor/processor.py @@ -2,9 +2,10 @@ from datetime import datetime from pathlib import Path -import requests +import aiohttp from dataset import DocumentClassificationDataset from fastapi import FastAPI, HTTPException +from lingua import Language, LanguageDetectorBuilder from transformers import ( LayoutLMv3ImageProcessor, LayoutLMv3Processor, @@ -12,7 +13,7 @@ ) from configs.processor_config import ProcessorConfig -from payload.processor_models import ProcessorInput, ProcessorResult +from payload.processor_models import ProcessorInput, ProcessorOutput config = ProcessorConfig() # TMP solution to avoid error during testing @@ -28,7 +29,8 @@ datefmt="%Y-%m-%d %H:%M:%S", handlers=[ logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", ), logging.StreamHandler(), ], @@ -37,6 +39,11 @@ logger = logging.getLogger(__name__) app = FastAPI() +detector = ( + LanguageDetectorBuilder.from_all_languages() + .with_preloaded_language_models() + .build() +) class DocumentProcessor: @@ -46,33 +53,39 @@ def __init__(self) -> None: """Initialize document processor.""" self.processor = LayoutLMv3Processor( LayoutLMv3ImageProcessor(apply_ocr=False), - LayoutLMv3TokenizerFast.from_pretrained("/app/data/models/layoutlmv3-base"), + LayoutLMv3TokenizerFast.from_pretrained( + "/app/data/models/layoutlmv3-base", + ), ) - def process_document(self, input_data: ProcessorInput) -> ProcessorResult: - """ - Process document with LayoutLMv3. + def process_document(self, input_data: ProcessorInput) -> ProcessorOutput: + """Process document with LayoutLMv3. Args: input_data: Validated input data containing OCR results and images + """ try: - encodings: list[dict] = DocumentClassificationDataset.get_encodings( - self.processor, input_data, config + encodings: dict = DocumentClassificationDataset.get_encodings( + self.processor, + input_data, + config, ) - result = ProcessorResult( - input_ids=encodings["input_ids"], - attention_mask=encodings["attention_mask"], - bbox=encodings["bbox"], - pixel_values=encodings["pixel_values"], + result = ProcessorOutput( + input_ids=encodings["input_ids"].tolist(), + attention_mask=encodings["attention_mask"].tolist(), + bbox=encodings["bbox"].tolist(), + pixel_values=encodings["pixel_values"].tolist(), ) - return result - except Exception as e: logger.exception("Document processing failed") - raise HTTPException(status_code=500, detail=f"Processing failed: {str(e)}") + detail = f"Processing failed: {e!s}" + raise HTTPException(status_code=500, detail=detail) from e + + else: + return result # Create processor instance @@ -81,35 +94,79 @@ def process_document(self, input_data: ProcessorInput) -> ProcessorResult: @app.post("/text-preprocess") async def process_text(data: ProcessorInput) -> dict[str, str]: - """ - Process document text and layout. + """Process document text and layout. Args: data: Validated input data containing OCR results and images + """ try: + text = " ".join( + result.word + for ocr_result in data.ocr_result + for result in ocr_result + ) + + detected_language = detector.detect_language_of(text) + + if detected_language is None: + # Default to English if language detection fails + detected_language = Language.ENGLISH + + if detected_language != Language.ENGLISH: + timeout = aiohttp.ClientTimeout(total=480) + async with ( + aiohttp.ClientSession() as session, + session.post( + config.PREDICT_URL, + json={ + "input_ids": None, + "attention_mask": None, + "bbox": None, + "pixel_values": None, + "file_name": data.file_name, + "text": text, + "language": detected_language.name, + }, + timeout=timeout, + ) as response, + ): + response.raise_for_status() + return await response.json() + encodings = document_processor.process_document(data) - encodings = {k: v.tolist() for k, v in encodings.model_dump().items()} - - # logger.info( - # "Text from OCR: %s", " ".join(result.word for result in data.ocr_result[0]) - # ) - - response = requests.post( - config.PREDICT_URL, - json={ - "input_ids": encodings["input_ids"], - "attention_mask": encodings["attention_mask"], - "bbox": encodings["bbox"], - "pixel_values": encodings["pixel_values"], - "file_name": data.file_name, - "text": " ".join(result.word for result in data.ocr_result[0]), - }, - timeout=300, + encodings = encodings.model_dump() + + logger.debug( + "Text from OCR: %s", + " ".join( + result.word + for ocr_result in data.ocr_result + for result in ocr_result + ), ) - return response.json() + + timeout = aiohttp.ClientTimeout(total=480) + async with ( + aiohttp.ClientSession() as session, + session.post( + config.PREDICT_URL, + json={ + "input_ids": encodings["input_ids"], + "attention_mask": encodings["attention_mask"], + "bbox": encodings["bbox"], + "pixel_values": encodings["pixel_values"], + "file_name": data.file_name, + "text": text, + "language": detected_language.name, + }, + timeout=timeout, + ) as response, + ): + response.raise_for_status() + return await response.json() except Exception as e: logger.exception("Endpoint processing failed") - raise HTTPException(status_code=500, detail=str(e)) + raise HTTPException(status_code=500, detail=str(e)) from e diff --git a/src/summarization/summarizer.py b/src/summarization/summarizer.py index f002f03..1a7849b 100644 --- a/src/summarization/summarizer.py +++ b/src/summarization/summarizer.py @@ -1,18 +1,17 @@ +from __future__ import annotations + +import json import logging +import re from datetime import datetime -from typing import AsyncGenerator +from typing import Any, NotRequired, TypedDict, cast +import aiohttp from fastapi import Depends, FastAPI, HTTPException -from langchain.prompts import ( - ChatPromptTemplate, - HumanMessagePromptTemplate, - SystemMessagePromptTemplate, -) -from langchain_ollama.chat_models import ChatOllama from configs.summarization_config import SummarizationConfig from database import DocumentError, DocumentRepository, get_repository -from payload.summarizer_models import SummarizationRequest +from payload.summarizer_models import SummarizationRequest, SummaryResponse config = SummarizationConfig() config.LOG_DIR.mkdir(parents=True, exist_ok=True) @@ -23,70 +22,228 @@ datefmt="%Y-%m-%d %H:%M:%S", handlers=[ logging.FileHandler( - config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", mode="a" + config.LOG_DIR / f"{datetime.now():%Y-%m-%d}.log", + mode="a", ), logging.StreamHandler(), ], ) logger = logging.getLogger(__name__) - app = FastAPI() +class OllamaOptions(TypedDict): + """Type definition for Ollama API options.""" + + temperature: float + top_p: float + frequency_penalty: float + presence_penalty: float + num_ctx: int + num_gpu: int + num_thread: int + + +class OllamaRequest(TypedDict, total=False): + """Type definition for Ollama API request.""" + + model: str # required + prompt: str # required + format: NotRequired[str] + options: NotRequired[OllamaOptions] + system: NotRequired[str] + stream: NotRequired[bool] + raw: NotRequired[bool] + keep_alive: NotRequired[str | int] + + class Summarizer: - """Text summarization using Ollama and LangChain.""" - - SUMMARY_SYSTEM_PROMPT = """You are a precise summarization assistant that creates database-friendly summaries. Follow these rules exactly: - 1. Output only the summary text, no introductions or extra words - 2. Write complete sentences without periods at the end (use spaces between sentences) - 3. Stay strictly between {min_length} and {max_length} words - 4. Write in a formal tone appropriate for {classification} documents - 5. Use clear connecting words between sentences for flow""" - - SUMMARY_PROMPT = """ - Write a summary of the {classification} text below - The summary must be between {min_length} and {max_length} words - Do not use periods at the end of sentences, only between sentences - Focus on key information relevant to {classification} type - Only output the summary text, nothing else - - - + """Text summarization using direct Ollama integration.""" + + SUMMARY_SYSTEM_PROMPT = """You are an expert summarization analyst specializing in precise content distillation. + + Core Requirements: + 1. Process text in target format: {classification} + 2. Generate summaries between {min_length}-{max_length} words + 3. Output JSON format: {{"summary": "extracted key points", "word_count": number}} + + Technical Guidelines: + - Create self-contained, complete thought units + - Use professional language suited to {classification} context + - Employ clear transition phrases between ideas + - Maintain consistent technical depth throughout + - Structure content with logical progression + - Focus on essential information density + - Return only valid JSON output""" + + SUMMARY_PROMPT = """Document Analysis Parameters: + - Document Type: {classification} + - Length Constraints: {min_length} to {max_length} words + - Output Format: {{"summary": "content", "word_count": number}} + + Summarization Guidelines: + 1. Content Analysis: + - Identify core themes and key arguments + - Extract essential supporting evidence + - Preserve critical technical details + - Maintain original document tone + - Focus on {classification}-specific elements + + 2. Summary Construction: + - Begin with main thesis/findings + - Include critical methodology details + - Preserve key statistical data + - Connect ideas with clear transitions + - End with significant conclusions + + 3. Technical Requirements: + - Write complete semantic units + - Use precise technical terminology + - Maintain formal language register + - Apply consistent formatting + - Generate database-compatible output + + Source Document: {text} - - - - - Only output the summary - - No introduction or meta text - - No periods at end of sentences - - Must be {min_length}-{max_length} words - - - Summary:""" - - def __init__(self): - """Initialize summarizer with Ollama model.""" - self.llm = ChatOllama( - model=config.MODEL_NAME, - temperature=config.TEMPERATURE, - top_p=config.TOP_P, - base_url=config.OLLAMA_BASE_URL, - frequency_penalty=config.FREQUENCY_PENALTY, - presence_penalty=config.PRESENCE_PENALTY, - num_ctx=config.NUM_CTX, - num_gpu=config.NUM_GPU, - num_thread=config.NUM_THREAD, + + Response Specifications: + - Pure JSON structure + - Contains summary and word_count + - Meets length requirements + - No explanatory text + - No terminal periods except between thoughts + - Do not use points or bullet lists + + Generate summary:""" + + def __init__(self, config: SummarizationConfig) -> None: + """Initialize summarizer with configuration.""" + self.config = config + self.base_url = f"{config.OLLAMA_BASE_URL}/api/generate" + + def _prepare_request( + self, + text: str, + min_length: int, + max_length: int, + classification: str, + ) -> OllamaRequest: + """Prepare the request payload for Ollama API.""" + system_prompt = self.SUMMARY_SYSTEM_PROMPT.format( + min_length=min_length, + max_length=max_length, + classification=classification, + ) + + user_prompt = self.SUMMARY_PROMPT.format( + text=text, + min_length=min_length, + max_length=max_length, + classification=classification, ) - self.prompt = ChatPromptTemplate.from_messages( - [ - SystemMessagePromptTemplate.from_template(self.SUMMARY_SYSTEM_PROMPT), - HumanMessagePromptTemplate.from_template(self.SUMMARY_PROMPT), - ] + return { + "model": self.config.MODEL_NAME, + "prompt": user_prompt, + "system": system_prompt, + "format": "json", + "stream": False, + "options": { + "temperature": self.config.TEMPERATURE, + "top_p": self.config.TOP_P, + "frequency_penalty": self.config.FREQUENCY_PENALTY, + "presence_penalty": self.config.PRESENCE_PENALTY, + "num_ctx": self.config.NUM_CTX, + "num_gpu": self.config.NUM_GPU, + "num_thread": self.config.NUM_THREAD, + }, + "keep_alive": "15m", + } + + def _extract_json_from_text(self, text: str) -> dict[str, Any]: + """Extract JSON from text that might contain additional content. + + Args: + text: Text that might contain JSON + + Returns: + Extracted JSON as dict + + Raises: + ValueError: If no valid JSON found + + """ + # Remove any markdown code blocks + text = re.sub(r"```json\s*|\s*```", "", text) + + # Try to find JSON pattern + json_match = re.search(r"\{.*\}", text, re.DOTALL) + if not json_match: + raise ValueError("No JSON object found in response") + + try: + return cast(dict[str, Any], json.loads(json_match.group())) + except json.JSONDecodeError as e: + raise ValueError(f"Failed to parse JSON: {e!s}") from e + + def _process_raw_response(self, content: str) -> SummaryResponse: + """Process raw response when JSON parsing fails.""" + # Remove any potential markdown code blocks + content = re.sub(r"```json\s*|\s*```", "", content) + + # Try to find content that looks like a summary + text = re.sub(r"\s+", " ", content).strip() + + # Count words in the extracted text + word_count = len(text.split()) + + if not text: + raise ValueError("Unable to extract valid summary from response") + + return SummaryResponse( + summary=text, + word_count=word_count, ) - self.chain = self.prompt | self.llm + def _validate_summary_response( + self, + response_data: dict[str, Any], + min_length: int, + max_length: int, + ) -> SummaryResponse: + """Validate and process the summary response.""" + if not isinstance(response_data, dict): + raise ValueError("Response must be a JSON object") + + if "summary" not in response_data or "word_count" not in response_data: + raise ValueError( + 'Response must contain "summary" and "word_count" fields', + ) + + summary = response_data["summary"] + word_count = response_data["word_count"] + + if not isinstance(summary, str) or not isinstance( + word_count, + (int, float), + ): + raise ValueError("Invalid field types in response") + + # Convert word_count to int if it's a float + word_count = int(word_count) + + actual_word_count = len(summary.split()) + if actual_word_count < min_length or actual_word_count > max_length: + logger.warning( + "Summary length (%d words) outside allowed range", + actual_word_count, + ) + + return SummaryResponse( + summary=summary, + word_count=actual_word_count, + ) async def generate_summary( self, @@ -95,53 +252,95 @@ async def generate_summary( max_length: int = 300, classification: str = "unclassified", ) -> str: - """ - Generate a summary of the input text. + """Generate a summary of the input text.""" - Args: - text: Input text to summarize - min_length: Minimum summary length in words - max_length: Maximum summary length in words + def _validate_ollama_response(result: object) -> None: + """Validate Ollama API response format.""" + error_msg = "Invalid response format from Ollama" + if not isinstance(result, dict) or "response" not in result: + raise ValueError(error_msg) + + def _validate_content(content: str) -> None: + """Validate response content is not empty.""" + error_msg = "Empty response from Ollama" + if not content: + raise ValueError(error_msg) - Returns: - Generated summary text - """ try: - response = await self.chain.ainvoke( - { - "text": text, - "min_length": min_length, - "max_length": max_length, - "classification": classification, - } + request_data = self._prepare_request( + text, + min_length, + max_length, + classification, ) - return response.content.strip().replace(" \n", ". ") + + timeout = aiohttp.ClientTimeout(total=300) + async with ( + aiohttp.ClientSession(timeout=timeout) as session, + session.post(self.base_url, json=request_data) as response, + ): + response.raise_for_status() + result = await response.json() + + _validate_ollama_response(result) + + content = result["response"].strip() + _validate_content(content) + + logger.debug("Raw response from Ollama: %s", content) + + try: + # Try to extract and parse JSON from response + response_data = self._extract_json_from_text(content) + summary_response = self._validate_summary_response( + response_data, + min_length, + max_length, + ) + # Return only the summary text + return summary_response.summary.replace(" \n", ".") + + except (json.JSONDecodeError, ValueError) as e: + logger.warning( + "Failed to parse JSON response, falling back to raw " + "processing: %s", + str(e), + ) + # Fall back to raw response processing + summary_response = self._process_raw_response(content) + return summary_response.summary.replace(" \n", ".") + + except aiohttp.ClientError as e: + logger.exception("Ollama API communication error") + raise HTTPException( + status_code=500, + detail=f"Failed to communicate with Ollama: {e!s}", + ) from e + + except ValueError as e: + logger.exception("Invalid response format from Ollama") + raise HTTPException( + status_code=500, + detail=str(e), + ) from e + except Exception as e: - logger.error("Summarization failed: %s", str(e)) + logger.exception("Summarization failed") raise HTTPException( status_code=500, - detail="Summarization failed", - ) + detail=f"Summarization failed: {e!s}", + ) from e -summarizer = Summarizer() +summarizer = Summarizer(config) @app.post("/summarize") async def summarize_document( request: SummarizationRequest, - repository: AsyncGenerator[DocumentRepository, None] = Depends(get_repository), + repository: DocumentRepository = Depends(get_repository), ) -> dict[str, str]: - """ - Generate a summary for the given document. - - Args: - request: Summarization request containing text and parameters - repository: Document repository instance - - Returns: - Dictionary containing the generated summary - """ + """Generate a summary for the given document.""" try: summary = await summarizer.generate_summary( text=request.text, @@ -150,21 +349,25 @@ async def summarize_document( classification=request.classification, ) - # Update document in database with summary try: await repository.update_summary(request.file_name, summary) except DocumentError as e: - logger.error("Failed to update summary: %s", str(e)) + logger.exception("Failed to update summary") raise HTTPException( status_code=500, detail="Failed to save summary", - ) - - return {"summary": summary, "classification": request.classification} + ) from e except Exception as e: logger.exception("Summarization endpoint failed") raise HTTPException( status_code=500, detail=str(e), - ) + ) from e + + else: + return { + "file_name": request.file_name, + "summary": summary, + "classification": request.classification, + } diff --git a/src/utils/utils.py b/src/utils/utils.py index 730a290..006f69d 100644 --- a/src/utils/utils.py +++ b/src/utils/utils.py @@ -1,13 +1,16 @@ -import os import re -from typing import AsyncGenerator +from collections.abc import AsyncGenerator +from pathlib import Path +from typing import NoReturn from database.repository import DocumentRepository -def make_unique_filename(original_filename: str, existing_filenames: set[str]) -> str: - """ - Generate a unique filename by appending a number if the filename already exists. +def make_unique_filename( + original_filename: str, + existing_filenames: set[str], +) -> str: + """Generate a unique filename by appending a number if the filename already exists. Args: original_filename: The original filename to make unique @@ -23,12 +26,14 @@ def make_unique_filename(original_filename: str, existing_filenames: set[str]) - 'test (2).pdf' >>> make_unique_filename("my file.pdf", {"my file.pdf"}) 'my file (1).pdf' + """ if original_filename not in existing_filenames: return original_filename - # Split the filename into name and extension - name, ext = os.path.splitext(original_filename) + path = Path(original_filename) + name = path.stem + ext = path.suffix # Check if filename already ends with a number in parentheses pattern = r"(.*?)\s*(?:\((\d+)\))?$" @@ -52,8 +57,7 @@ async def get_unique_filename( repository: AsyncGenerator[DocumentRepository, None], max_attempts: int = 100, ) -> str: - """ - Generate a unique filename that doesn't exist in the database. + """Generate a unique filename that doesn't exist in the database. Args: filename: Original filename to make unique @@ -65,7 +69,13 @@ async def get_unique_filename( Raises: ValueError: If unable to generate unique filename within max_attempts + """ + # Create error message once + error_message = ( + "Unable to generate unique filename for {} within {} attempts" + ) + try: # Get all existing filenames from database documents = await repository.get_all() @@ -77,12 +87,16 @@ async def get_unique_filename( # Verify we didn't exceed max attempts (check the number in parentheses) match = re.search(r"\((\d+)\)", unique_name) if match and int(match.group(1)) > max_attempts: - raise ValueError( - f"Unable to generate unique filename for {filename} " - f"within {max_attempts} attempts" - ) + # Abstract raise to inner function + def raise_max_attempts() -> NoReturn: + raise ValueError(error_message.format(filename, max_attempts)) + + raise_max_attempts() - return unique_name + else: + return unique_name - except Exception as e: - raise ValueError(f"Error generating unique filename: {str(e)}") + except (StopAsyncIteration, AttributeError) as e: + # Distinguish exception source + error_msg = "Error generating unique filename: {}" + raise ValueError(error_msg.format(str(e))) from e diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..c4c048e --- /dev/null +++ b/uv.lock @@ -0,0 +1,2084 @@ +version = 1 +requires-python = ">=3.12" +resolution-markers = [ + "platform_system == 'Darwin'", + "platform_machine == 'aarch64' and platform_system == 'Linux'", + "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')", +] + +[[package]] +name = "aiofiles" +version = "24.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/03/a88171e277e8caa88a4c77808c20ebb04ba74cc4681bf1e9416c862de237/aiofiles-24.1.0.tar.gz", hash = "sha256:22a075c9e5a3810f0c2e48f3008c94d68c65d763b9b03857924c99e57355166c", size = 30247 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl", hash = "sha256:b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5", size = 15896 }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7f/55/e4373e888fdacb15563ef6fa9fa8c8252476ea071e96fb46defac9f18bf2/aiohappyeyeballs-2.4.4.tar.gz", hash = "sha256:5fdd7d87889c63183afc18ce9271f9b0a7d32c2303e394468dd45d514a757745", size = 21977 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/74/fbb6559de3607b3300b9be3cc64e97548d55678e44623db17820dbd20002/aiohappyeyeballs-2.4.4-py3-none-any.whl", hash = "sha256:a980909d50efcd44795c4afeca523296716d50cd756ddca6af8c65b996e27de8", size = 14756 }, +] + +[[package]] +name = "aiohttp" +version = "3.11.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/94/c4/3b5a937b16f6c2a0ada842a9066aad0b7a5708427d4a202a07bf09c67cbb/aiohttp-3.11.10.tar.gz", hash = "sha256:b1fc6b45010a8d0ff9e88f9f2418c6fd408c99c211257334aff41597ebece42e", size = 7668832 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/17/1dbe2f619f77795409c1a13ab395b98ed1b215d3e938cacde9b8ffdac53d/aiohttp-3.11.10-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b78f053a7ecfc35f0451d961dacdc671f4bcbc2f58241a7c820e9d82559844cf", size = 704448 }, + { url = "https://files.pythonhosted.org/packages/e3/9b/112247ad47e9d7f6640889c6e42cc0ded8c8345dd0033c66bcede799b051/aiohttp-3.11.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab7485222db0959a87fbe8125e233b5a6f01f4400785b36e8a7878170d8c3138", size = 463829 }, + { url = "https://files.pythonhosted.org/packages/8a/36/a64b583771fc673062a7a1374728a6241d49e2eda5a9041fbf248e18c804/aiohttp-3.11.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cf14627232dfa8730453752e9cdc210966490992234d77ff90bc8dc0dce361d5", size = 455774 }, + { url = "https://files.pythonhosted.org/packages/e5/75/ee1b8f510978b3de5f185c62535b135e4fc3f5a247ca0c2245137a02d800/aiohttp-3.11.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:076bc454a7e6fd646bc82ea7f98296be0b1219b5e3ef8a488afbdd8e81fbac50", size = 1682134 }, + { url = "https://files.pythonhosted.org/packages/87/46/65e8259432d5f73ca9ebf5edb645ef90e5303724e4e52477516cb4042240/aiohttp-3.11.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:482cafb7dc886bebeb6c9ba7925e03591a62ab34298ee70d3dd47ba966370d2c", size = 1736757 }, + { url = "https://files.pythonhosted.org/packages/03/f6/a6d1e791b7153fb2d101278f7146c0771b0e1569c547f8a8bc3035651984/aiohttp-3.11.10-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf3d1a519a324af764a46da4115bdbd566b3c73fb793ffb97f9111dbc684fc4d", size = 1793033 }, + { url = "https://files.pythonhosted.org/packages/a8/e9/1ac90733e36e7848693aece522936a13bf17eeb617da662f94adfafc1c25/aiohttp-3.11.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24213ba85a419103e641e55c27dc7ff03536c4873470c2478cce3311ba1eee7b", size = 1691609 }, + { url = "https://files.pythonhosted.org/packages/6d/a6/77b33da5a0bc04566c7ddcca94500f2c2a2334eecab4885387fffd1fc600/aiohttp-3.11.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b99acd4730ad1b196bfb03ee0803e4adac371ae8efa7e1cbc820200fc5ded109", size = 1619082 }, + { url = "https://files.pythonhosted.org/packages/48/94/5bf5f927d9a2fedd2c978adfb70a3680e16f46d178361685b56244eb52ed/aiohttp-3.11.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:14cdb5a9570be5a04eec2ace174a48ae85833c2aadc86de68f55541f66ce42ab", size = 1641186 }, + { url = "https://files.pythonhosted.org/packages/99/2d/e85103aa01d1064e51bc50cb51e7b40150a8ff5d34e5a3173a46b241860b/aiohttp-3.11.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7e97d622cb083e86f18317282084bc9fbf261801b0192c34fe4b1febd9f7ae69", size = 1646280 }, + { url = "https://files.pythonhosted.org/packages/7b/e0/44651fda8c1d865a51b3a81f1956ea55ce16fc568fe7a3e05db7fc22f139/aiohttp-3.11.10-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:012f176945af138abc10c4a48743327a92b4ca9adc7a0e078077cdb5dbab7be0", size = 1701862 }, + { url = "https://files.pythonhosted.org/packages/4e/1e/0804459ae325a5b95f6f349778fb465f29d2b863e522b6a349db0aaad54c/aiohttp-3.11.10-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44224d815853962f48fe124748227773acd9686eba6dc102578defd6fc99e8d9", size = 1734373 }, + { url = "https://files.pythonhosted.org/packages/07/87/b8f6721668cad74bcc9c7cfe6d0230b304d1250196b221e54294a0d78dbe/aiohttp-3.11.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c87bf31b7fdab94ae3adbe4a48e711bfc5f89d21cf4c197e75561def39e223bc", size = 1694343 }, + { url = "https://files.pythonhosted.org/packages/4b/20/42813fc60d9178ba9b1b86c58a5441ddb6cf8ffdfe66387345bff173bcff/aiohttp-3.11.10-cp312-cp312-win32.whl", hash = "sha256:06a8e2ee1cbac16fe61e51e0b0c269400e781b13bcfc33f5425912391a542985", size = 411118 }, + { url = "https://files.pythonhosted.org/packages/3a/51/df9c263c861ce93998b5ad2ba3212caab2112d5b66dbe91ddbe90c41ded4/aiohttp-3.11.10-cp312-cp312-win_amd64.whl", hash = "sha256:be2b516f56ea883a3e14dda17059716593526e10fb6303189aaf5503937db408", size = 437424 }, + { url = "https://files.pythonhosted.org/packages/8c/1d/88bfdbe28a3d1ba5b94a235f188f27726caf8ade9a0e13574848f44fe0fe/aiohttp-3.11.10-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8cc5203b817b748adccb07f36390feb730b1bc5f56683445bfe924fc270b8816", size = 697755 }, + { url = "https://files.pythonhosted.org/packages/86/00/4c4619d6fe5c5be32f74d1422fc719b3e6cd7097af0c9e03877ca9bd4ebc/aiohttp-3.11.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ef359ebc6949e3a34c65ce20230fae70920714367c63afd80ea0c2702902ccf", size = 460440 }, + { url = "https://files.pythonhosted.org/packages/aa/1c/2f927408f50593a29465d198ec3c57c835c8602330233163e8d89c1093db/aiohttp-3.11.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9bca390cb247dbfaec3c664326e034ef23882c3f3bfa5fbf0b56cad0320aaca5", size = 452726 }, + { url = "https://files.pythonhosted.org/packages/06/6a/ff00ed0a2ba45c34b3c366aa5b0004b1a4adcec5a9b5f67dd0648ee1c88a/aiohttp-3.11.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:811f23b3351ca532af598405db1093f018edf81368e689d1b508c57dcc6b6a32", size = 1664944 }, + { url = "https://files.pythonhosted.org/packages/02/c2/61923f2a7c2e14d7424b3a526e054f0358f57ccdf5573d4d3d033b01921a/aiohttp-3.11.10-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ddf5f7d877615f6a1e75971bfa5ac88609af3b74796ff3e06879e8422729fd01", size = 1717707 }, + { url = "https://files.pythonhosted.org/packages/8a/08/0d3d074b24d377569ec89d476a95ca918443099c0401bb31b331104e35d1/aiohttp-3.11.10-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6ab29b8a0beb6f8eaf1e5049252cfe74adbaafd39ba91e10f18caeb0e99ffb34", size = 1774890 }, + { url = "https://files.pythonhosted.org/packages/e8/49/052ada2b6e90ed65f0e6a7e548614621b5f8dcd193cb9415d2e6bcecc94a/aiohttp-3.11.10-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c49a76c1038c2dd116fa443eba26bbb8e6c37e924e2513574856de3b6516be99", size = 1676945 }, + { url = "https://files.pythonhosted.org/packages/7c/9e/0c48e1a48e072a869b8b5e3920c9f6a8092861524a4a6f159cd7e6fda939/aiohttp-3.11.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f3dc0e330575f5b134918976a645e79adf333c0a1439dcf6899a80776c9ab39", size = 1602959 }, + { url = "https://files.pythonhosted.org/packages/ab/98/791f979093ff7f67f80344c182cb0ca4c2c60daed397ecaf454cc8d7a5cd/aiohttp-3.11.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:efb15a17a12497685304b2d976cb4939e55137df7b09fa53f1b6a023f01fcb4e", size = 1618058 }, + { url = "https://files.pythonhosted.org/packages/7b/5d/2d4b05feb3fd68eb7c8335f73c81079b56e582633b91002da695ccb439ef/aiohttp-3.11.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:db1d0b28fcb7f1d35600150c3e4b490775251dea70f894bf15c678fdd84eda6a", size = 1616289 }, + { url = "https://files.pythonhosted.org/packages/50/83/68cc28c00fe681dce6150614f105efe98282da19252cd6e32dfa893bb328/aiohttp-3.11.10-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:15fccaf62a4889527539ecb86834084ecf6e9ea70588efde86e8bc775e0e7542", size = 1685239 }, + { url = "https://files.pythonhosted.org/packages/16/f9/68fc5c8928f63238ce9314f04f3f59d9190a4db924998bb9be99c7aacce8/aiohttp-3.11.10-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:593c114a2221444f30749cc5e5f4012488f56bd14de2af44fe23e1e9894a9c60", size = 1715078 }, + { url = "https://files.pythonhosted.org/packages/3f/e0/3dd3f0451c532c77e35780bafb2b6469a046bc15a6ec2e039475a1d2f161/aiohttp-3.11.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7852bbcb4d0d2f0c4d583f40c3bc750ee033265d80598d0f9cb6f372baa6b836", size = 1672544 }, + { url = "https://files.pythonhosted.org/packages/a5/b1/3530ab040dd5d7fb016b47115016f9b3a07ea29593b0e07e53dbe06a380c/aiohttp-3.11.10-cp313-cp313-win32.whl", hash = "sha256:65e55ca7debae8faaffee0ebb4b47a51b4075f01e9b641c31e554fd376595c6c", size = 409984 }, + { url = "https://files.pythonhosted.org/packages/49/1f/deed34e9fca639a7f873d01150d46925d3e1312051eaa591c1aa1f2e6ddc/aiohttp-3.11.10-cp313-cp313-win_amd64.whl", hash = "sha256:beb39a6d60a709ae3fb3516a1581777e7e8b76933bb88c8f4420d875bb0267c6", size = 435837 }, +] + +[[package]] +name = "aiosignal" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/b5/6d55e80f6d8a08ce22b982eafa278d823b541c925f11ee774b0b9c43473d/aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54", size = 19424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/6a/bc7e17a3e87a2985d3e8f4da4cd0f481060eb78fb08596c42be62c90a4d9/aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5", size = 7597 }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, +] + +[[package]] +name = "anyio" +version = "4.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f6/40/318e58f669b1a9e00f5c4453910682e2d9dd594334539c7b7817dabb765f/anyio-4.7.0.tar.gz", hash = "sha256:2f834749c602966b7d456a7567cafcb309f96482b5081d14ac93ccd457f9dd48", size = 177076 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/7a/4daaf3b6c08ad7ceffea4634ec206faeff697526421c20f07628c7372156/anyio-4.7.0-py3-none-any.whl", hash = "sha256:ea60c3723ab42ba6fff7e8ccb0488c898ec538ff4df1f1d5e642c3601d07e352", size = 93052 }, +] + +[[package]] +name = "asyncpg" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162 }, + { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025 }, + { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243 }, + { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059 }, + { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596 }, + { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632 }, + { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186 }, + { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064 }, + { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373 }, + { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745 }, + { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103 }, + { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471 }, + { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253 }, + { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720 }, + { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404 }, + { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623 }, +] + +[[package]] +name = "attrs" +version = "24.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 }, +] + +[[package]] +name = "certifi" +version = "2024.12.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 }, + { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 }, + { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 }, + { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 }, + { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 }, + { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 }, + { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 }, + { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 }, + { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 }, + { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 }, + { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 }, + { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 }, + { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 }, + { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 }, + { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 }, + { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 }, + { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 }, + { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 }, + { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 }, + { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 }, + { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 }, + { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 }, + { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 }, + { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 }, + { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 }, + { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 }, + { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 }, + { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 }, + { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 }, + { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 }, + { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 }, +] + +[[package]] +name = "click" +version = "8.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "platform_system == 'Windows'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "datasets" +version = "3.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "dill" }, + { name = "filelock" }, + { name = "fsspec", extra = ["http"] }, + { name = "huggingface-hub" }, + { name = "multiprocess" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "xxhash" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/48/744286c044e2b942d4fa67f92816126522ad1f0675def0ea3264e6242005/datasets-3.2.0.tar.gz", hash = "sha256:9a6e1a356052866b5dbdd9c9eedb000bf3fc43d986e3584d9b028f4976937229", size = 558366 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/84/0df6c5981f5fc722381662ff8cfbdf8aad64bec875f75d80b55bfef394ce/datasets-3.2.0-py3-none-any.whl", hash = "sha256:f3d2ba2698b7284a4518019658596a6a8bc79f31e51516524249d6c59cf0fe2a", size = 480647 }, +] + +[[package]] +name = "dill" +version = "0.3.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca", size = 184847 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7", size = 116252 }, +] + +[[package]] +name = "dnspython" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/4a/263763cb2ba3816dd94b08ad3a33d5fdae34ecb856678773cc40a3605829/dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1", size = 345197 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/1b/e0a87d256e40e8c888847551b20a017a6b98139178505dc7ffb96f04e954/dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86", size = 313632 }, +] + +[[package]] +name = "documentclassification" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "aiofiles" }, + { name = "asyncpg" }, + { name = "datasets" }, + { name = "easyocr" }, + { name = "fastapi", extra = ["standard"] }, + { name = "lightning" }, + { name = "lingua-language-detector" }, + { name = "numpy" }, + { name = "pdf2image" }, + { name = "pillow" }, + { name = "psutil" }, + { name = "psycopg2-binary" }, + { name = "pytesseract" }, + { name = "python-dotenv" }, + { name = "python-multipart" }, + { name = "rich" }, + { name = "sqlalchemy", extra = ["asyncio"] }, + { name = "torch" }, + { name = "torchaudio" }, + { name = "torchvision" }, + { name = "transformers" }, +] + +[package.metadata] +requires-dist = [ + { name = "aiofiles", specifier = ">=24.1.0" }, + { name = "asyncpg", specifier = ">=0.30.0" }, + { name = "datasets", specifier = ">=3.1.0" }, + { name = "easyocr", specifier = ">=1.7.2" }, + { name = "fastapi", extras = ["standard"], specifier = ">=0.115.5" }, + { name = "lightning", specifier = ">=2.4.0" }, + { name = "lingua-language-detector", specifier = ">=2.0.2" }, + { name = "numpy", specifier = ">=2.1.3" }, + { name = "pdf2image", specifier = ">=1.17.0" }, + { name = "pillow", specifier = ">=11.0.0" }, + { name = "psutil", specifier = ">=6.1.0" }, + { name = "psycopg2-binary", specifier = ">=2.9.10" }, + { name = "pytesseract", specifier = ">=0.3.13" }, + { name = "python-dotenv", specifier = ">=1.0.1" }, + { name = "python-multipart", specifier = ">=0.0.18" }, + { name = "rich", specifier = ">=13.9.4" }, + { name = "sqlalchemy", extras = ["asyncio"], specifier = ">=2.0.36" }, + { name = "torch", specifier = ">=2.5.1" }, + { name = "torchaudio", specifier = ">=2.5.1" }, + { name = "torchvision", specifier = ">=0.20.1" }, + { name = "transformers", specifier = ">=4.46.3" }, +] + +[[package]] +name = "easyocr" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ninja" }, + { name = "numpy" }, + { name = "opencv-python-headless" }, + { name = "pillow" }, + { name = "pyclipper" }, + { name = "python-bidi" }, + { name = "pyyaml" }, + { name = "scikit-image" }, + { name = "scipy" }, + { name = "shapely" }, + { name = "torch" }, + { name = "torchvision" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/84/4a2cab0e6adde6a85e7ba543862e5fc0250c51f3ac721a078a55cdcff250/easyocr-1.7.2-py3-none-any.whl", hash = "sha256:5be12f9b0e595d443c9c3d10b0542074b50f0ec2d98b141a109cd961fd1c177c", size = 2870178 }, +] + +[[package]] +name = "email-validator" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dnspython" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/ce/13508a1ec3f8bb981ae4ca79ea40384becc868bfae97fd1c942bb3a001b1/email_validator-2.2.0.tar.gz", hash = "sha256:cb690f344c617a714f22e66ae771445a1ceb46821152df8e165c5f9a364582b7", size = 48967 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/ee/bf0adb559ad3c786f12bcbc9296b3f5675f529199bef03e2df281fa1fadb/email_validator-2.2.0-py3-none-any.whl", hash = "sha256:561977c2d73ce3611850a06fa56b414621e0c8faa9d66f2611407d87465da631", size = 33521 }, +] + +[[package]] +name = "fastapi" +version = "0.115.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/93/72/d83b98cd106541e8f5e5bfab8ef2974ab45a62e8a6c5b5e6940f26d2ed4b/fastapi-0.115.6.tar.gz", hash = "sha256:9ec46f7addc14ea472958a96aae5b5de65f39721a46aaf5705c480d9a8b76654", size = 301336 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/b3/7e4df40e585df024fac2f80d1a2d579c854ac37109675db2b0cc22c0bb9e/fastapi-0.115.6-py3-none-any.whl", hash = "sha256:e9240b29e36fa8f4bb7290316988e90c381e5092e0cbe84e7818cc3713bcf305", size = 94843 }, +] + +[package.optional-dependencies] +standard = [ + { name = "email-validator" }, + { name = "fastapi-cli", extra = ["standard"] }, + { name = "httpx" }, + { name = "jinja2" }, + { name = "python-multipart" }, + { name = "uvicorn", extra = ["standard"] }, +] + +[[package]] +name = "fastapi-cli" +version = "0.0.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "rich-toolkit" }, + { name = "typer" }, + { name = "uvicorn", extra = ["standard"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/73/82a5831fbbf8ed75905bacf5b2d9d3dfd6f04d6968b29fe6f72a5ae9ceb1/fastapi_cli-0.0.7.tar.gz", hash = "sha256:02b3b65956f526412515907a0793c9094abd4bfb5457b389f645b0ea6ba3605e", size = 16753 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/e6/5daefc851b514ce2287d8f5d358ae4341089185f78f3217a69d0ce3a390c/fastapi_cli-0.0.7-py3-none-any.whl", hash = "sha256:d549368ff584b2804336c61f192d86ddea080c11255f375959627911944804f4", size = 10705 }, +] + +[package.optional-dependencies] +standard = [ + { name = "uvicorn", extra = ["standard"] }, +] + +[[package]] +name = "filelock" +version = "3.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 }, +] + +[[package]] +name = "frozenlist" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8f/ed/0f4cec13a93c02c47ec32d81d11c0c1efbadf4a471e3f3ce7cad366cbbd3/frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817", size = 39930 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/73/fa6d1a96ab7fd6e6d1c3500700963eab46813847f01ef0ccbaa726181dd5/frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21", size = 94026 }, + { url = "https://files.pythonhosted.org/packages/ab/04/ea8bf62c8868b8eada363f20ff1b647cf2e93377a7b284d36062d21d81d1/frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d", size = 54150 }, + { url = "https://files.pythonhosted.org/packages/d0/9a/8e479b482a6f2070b26bda572c5e6889bb3ba48977e81beea35b5ae13ece/frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e", size = 51927 }, + { url = "https://files.pythonhosted.org/packages/e3/12/2aad87deb08a4e7ccfb33600871bbe8f0e08cb6d8224371387f3303654d7/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a", size = 282647 }, + { url = "https://files.pythonhosted.org/packages/77/f2/07f06b05d8a427ea0060a9cef6e63405ea9e0d761846b95ef3fb3be57111/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a", size = 289052 }, + { url = "https://files.pythonhosted.org/packages/bd/9f/8bf45a2f1cd4aa401acd271b077989c9267ae8463e7c8b1eb0d3f561b65e/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee", size = 291719 }, + { url = "https://files.pythonhosted.org/packages/41/d1/1f20fd05a6c42d3868709b7604c9f15538a29e4f734c694c6bcfc3d3b935/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6", size = 267433 }, + { url = "https://files.pythonhosted.org/packages/af/f2/64b73a9bb86f5a89fb55450e97cd5c1f84a862d4ff90d9fd1a73ab0f64a5/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e", size = 283591 }, + { url = "https://files.pythonhosted.org/packages/29/e2/ffbb1fae55a791fd6c2938dd9ea779509c977435ba3940b9f2e8dc9d5316/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9", size = 273249 }, + { url = "https://files.pythonhosted.org/packages/2e/6e/008136a30798bb63618a114b9321b5971172a5abddff44a100c7edc5ad4f/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039", size = 271075 }, + { url = "https://files.pythonhosted.org/packages/ae/f0/4e71e54a026b06724cec9b6c54f0b13a4e9e298cc8db0f82ec70e151f5ce/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784", size = 285398 }, + { url = "https://files.pythonhosted.org/packages/4d/36/70ec246851478b1c0b59f11ef8ade9c482ff447c1363c2bd5fad45098b12/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631", size = 294445 }, + { url = "https://files.pythonhosted.org/packages/37/e0/47f87544055b3349b633a03c4d94b405956cf2437f4ab46d0928b74b7526/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f", size = 280569 }, + { url = "https://files.pythonhosted.org/packages/f9/7c/490133c160fb6b84ed374c266f42800e33b50c3bbab1652764e6e1fc498a/frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8", size = 44721 }, + { url = "https://files.pythonhosted.org/packages/b1/56/4e45136ffc6bdbfa68c29ca56ef53783ef4c2fd395f7cbf99a2624aa9aaa/frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f", size = 51329 }, + { url = "https://files.pythonhosted.org/packages/da/3b/915f0bca8a7ea04483622e84a9bd90033bab54bdf485479556c74fd5eaf5/frozenlist-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7a1a048f9215c90973402e26c01d1cff8a209e1f1b53f72b95c13db61b00f953", size = 91538 }, + { url = "https://files.pythonhosted.org/packages/c7/d1/a7c98aad7e44afe5306a2b068434a5830f1470675f0e715abb86eb15f15b/frozenlist-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dd47a5181ce5fcb463b5d9e17ecfdb02b678cca31280639255ce9d0e5aa67af0", size = 52849 }, + { url = "https://files.pythonhosted.org/packages/3a/c8/76f23bf9ab15d5f760eb48701909645f686f9c64fbb8982674c241fbef14/frozenlist-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1431d60b36d15cda188ea222033eec8e0eab488f39a272461f2e6d9e1a8e63c2", size = 50583 }, + { url = "https://files.pythonhosted.org/packages/1f/22/462a3dd093d11df623179d7754a3b3269de3b42de2808cddef50ee0f4f48/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6482a5851f5d72767fbd0e507e80737f9c8646ae7fd303def99bfe813f76cf7f", size = 265636 }, + { url = "https://files.pythonhosted.org/packages/80/cf/e075e407fc2ae7328155a1cd7e22f932773c8073c1fc78016607d19cc3e5/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44c49271a937625619e862baacbd037a7ef86dd1ee215afc298a417ff3270608", size = 270214 }, + { url = "https://files.pythonhosted.org/packages/a1/58/0642d061d5de779f39c50cbb00df49682832923f3d2ebfb0fedf02d05f7f/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:12f78f98c2f1c2429d42e6a485f433722b0061d5c0b0139efa64f396efb5886b", size = 273905 }, + { url = "https://files.pythonhosted.org/packages/ab/66/3fe0f5f8f2add5b4ab7aa4e199f767fd3b55da26e3ca4ce2cc36698e50c4/frozenlist-1.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ce3aa154c452d2467487765e3adc730a8c153af77ad84096bc19ce19a2400840", size = 250542 }, + { url = "https://files.pythonhosted.org/packages/f6/b8/260791bde9198c87a465224e0e2bb62c4e716f5d198fc3a1dacc4895dbd1/frozenlist-1.5.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b7dc0c4338e6b8b091e8faf0db3168a37101943e687f373dce00959583f7439", size = 267026 }, + { url = "https://files.pythonhosted.org/packages/2e/a4/3d24f88c527f08f8d44ade24eaee83b2627793fa62fa07cbb7ff7a2f7d42/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:45e0896250900b5aa25180f9aec243e84e92ac84bd4a74d9ad4138ef3f5c97de", size = 257690 }, + { url = "https://files.pythonhosted.org/packages/de/9a/d311d660420b2beeff3459b6626f2ab4fb236d07afbdac034a4371fe696e/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:561eb1c9579d495fddb6da8959fd2a1fca2c6d060d4113f5844b433fc02f2641", size = 253893 }, + { url = "https://files.pythonhosted.org/packages/c6/23/e491aadc25b56eabd0f18c53bb19f3cdc6de30b2129ee0bc39cd387cd560/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:df6e2f325bfee1f49f81aaac97d2aa757c7646534a06f8f577ce184afe2f0a9e", size = 267006 }, + { url = "https://files.pythonhosted.org/packages/08/c4/ab918ce636a35fb974d13d666dcbe03969592aeca6c3ab3835acff01f79c/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:140228863501b44b809fb39ec56b5d4071f4d0aa6d216c19cbb08b8c5a7eadb9", size = 276157 }, + { url = "https://files.pythonhosted.org/packages/c0/29/3b7a0bbbbe5a34833ba26f686aabfe982924adbdcafdc294a7a129c31688/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7707a25d6a77f5d27ea7dc7d1fc608aa0a478193823f88511ef5e6b8a48f9d03", size = 264642 }, + { url = "https://files.pythonhosted.org/packages/ab/42/0595b3dbffc2e82d7fe658c12d5a5bafcd7516c6bf2d1d1feb5387caa9c1/frozenlist-1.5.0-cp313-cp313-win32.whl", hash = "sha256:31a9ac2b38ab9b5a8933b693db4939764ad3f299fcaa931a3e605bc3460e693c", size = 44914 }, + { url = "https://files.pythonhosted.org/packages/17/c4/b7db1206a3fea44bf3b838ca61deb6f74424a8a5db1dd53ecb21da669be6/frozenlist-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:11aabdd62b8b9c4b84081a3c246506d1cddd2dd93ff0ad53ede5defec7886b28", size = 51167 }, + { url = "https://files.pythonhosted.org/packages/c6/c8/a5be5b7550c10858fcf9b0ea054baccab474da77d37f1e828ce043a3a5d4/frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3", size = 11901 }, +] + +[[package]] +name = "fsspec" +version = "2024.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/62/7c/12b0943011daaaa9c35c2a2e22e5eb929ac90002f08f1259d69aedad84de/fsspec-2024.9.0.tar.gz", hash = "sha256:4b0afb90c2f21832df142f292649035d80b421f60a9e1c027802e5a0da2b04e8", size = 286206 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/a0/6aaea0c2fbea2f89bfd5db25fb1e3481896a423002ebe4e55288907a97a3/fsspec-2024.9.0-py3-none-any.whl", hash = "sha256:a0947d552d8a6efa72cc2c730b12c41d043509156966cca4fb157b0f2a0c574b", size = 179253 }, +] + +[package.optional-dependencies] +http = [ + { name = "aiohttp" }, +] + +[[package]] +name = "greenlet" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/ff/df5fede753cc10f6a5be0931204ea30c35fa2f2ea7a35b25bdaf4fe40e46/greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467", size = 186022 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/ec/bad1ac26764d26aa1353216fcbfa4670050f66d445448aafa227f8b16e80/greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d", size = 274260 }, + { url = "https://files.pythonhosted.org/packages/66/d4/c8c04958870f482459ab5956c2942c4ec35cac7fe245527f1039837c17a9/greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79", size = 649064 }, + { url = "https://files.pythonhosted.org/packages/51/41/467b12a8c7c1303d20abcca145db2be4e6cd50a951fa30af48b6ec607581/greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa", size = 663420 }, + { url = "https://files.pythonhosted.org/packages/27/8f/2a93cd9b1e7107d5c7b3b7816eeadcac2ebcaf6d6513df9abaf0334777f6/greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441", size = 658035 }, + { url = "https://files.pythonhosted.org/packages/57/5c/7c6f50cb12be092e1dccb2599be5a942c3416dbcfb76efcf54b3f8be4d8d/greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36", size = 660105 }, + { url = "https://files.pythonhosted.org/packages/f1/66/033e58a50fd9ec9df00a8671c74f1f3a320564c6415a4ed82a1c651654ba/greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9", size = 613077 }, + { url = "https://files.pythonhosted.org/packages/19/c5/36384a06f748044d06bdd8776e231fadf92fc896bd12cb1c9f5a1bda9578/greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0", size = 1135975 }, + { url = "https://files.pythonhosted.org/packages/38/f9/c0a0eb61bdf808d23266ecf1d63309f0e1471f284300ce6dac0ae1231881/greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942", size = 1163955 }, + { url = "https://files.pythonhosted.org/packages/43/21/a5d9df1d21514883333fc86584c07c2b49ba7c602e670b174bd73cfc9c7f/greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01", size = 299655 }, + { url = "https://files.pythonhosted.org/packages/f3/57/0db4940cd7bb461365ca8d6fd53e68254c9dbbcc2b452e69d0d41f10a85e/greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1", size = 272990 }, + { url = "https://files.pythonhosted.org/packages/1c/ec/423d113c9f74e5e402e175b157203e9102feeb7088cee844d735b28ef963/greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff", size = 649175 }, + { url = "https://files.pythonhosted.org/packages/a9/46/ddbd2db9ff209186b7b7c621d1432e2f21714adc988703dbdd0e65155c77/greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a", size = 663425 }, + { url = "https://files.pythonhosted.org/packages/bc/f9/9c82d6b2b04aa37e38e74f0c429aece5eeb02bab6e3b98e7db89b23d94c6/greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e", size = 657736 }, + { url = "https://files.pythonhosted.org/packages/d9/42/b87bc2a81e3a62c3de2b0d550bf91a86939442b7ff85abb94eec3fc0e6aa/greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4", size = 660347 }, + { url = "https://files.pythonhosted.org/packages/37/fa/71599c3fd06336cdc3eac52e6871cfebab4d9d70674a9a9e7a482c318e99/greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e", size = 615583 }, + { url = "https://files.pythonhosted.org/packages/4e/96/e9ef85de031703ee7a4483489b40cf307f93c1824a02e903106f2ea315fe/greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1", size = 1133039 }, + { url = "https://files.pythonhosted.org/packages/87/76/b2b6362accd69f2d1889db61a18c94bc743e961e3cab344c2effaa4b4a25/greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c", size = 1160716 }, + { url = "https://files.pythonhosted.org/packages/1f/1b/54336d876186920e185066d8c3024ad55f21d7cc3683c856127ddb7b13ce/greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761", size = 299490 }, + { url = "https://files.pythonhosted.org/packages/5f/17/bea55bf36990e1638a2af5ba10c1640273ef20f627962cf97107f1e5d637/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011", size = 643731 }, + { url = "https://files.pythonhosted.org/packages/78/d2/aa3d2157f9ab742a08e0fd8f77d4699f37c22adfbfeb0c610a186b5f75e0/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13", size = 649304 }, + { url = "https://files.pythonhosted.org/packages/f1/8e/d0aeffe69e53ccff5a28fa86f07ad1d2d2d6537a9506229431a2a02e2f15/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475", size = 646537 }, + { url = "https://files.pythonhosted.org/packages/05/79/e15408220bbb989469c8871062c97c6c9136770657ba779711b90870d867/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b", size = 642506 }, + { url = "https://files.pythonhosted.org/packages/18/87/470e01a940307796f1d25f8167b551a968540fbe0551c0ebb853cb527dd6/greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822", size = 602753 }, + { url = "https://files.pythonhosted.org/packages/e2/72/576815ba674eddc3c25028238f74d7b8068902b3968cbe456771b166455e/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01", size = 1122731 }, + { url = "https://files.pythonhosted.org/packages/ac/38/08cc303ddddc4b3d7c628c3039a61a3aae36c241ed01393d00c2fd663473/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6", size = 1142112 }, +] + +[[package]] +name = "h11" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, +] + +[[package]] +name = "httpcore" +version = "1.0.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, +] + +[[package]] +name = "httptools" +version = "0.6.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/9a/ce5e1f7e131522e6d3426e8e7a490b3a01f39a6696602e1c4f33f9e94277/httptools-0.6.4.tar.gz", hash = "sha256:4e93eee4add6493b59a5c514da98c939b244fce4a0d8879cd3f466562f4b7d5c", size = 240639 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/0e/d0b71465c66b9185f90a091ab36389a7352985fe857e352801c39d6127c8/httptools-0.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df017d6c780287d5c80601dafa31f17bddb170232d85c066604d8558683711a2", size = 200683 }, + { url = "https://files.pythonhosted.org/packages/e2/b8/412a9bb28d0a8988de3296e01efa0bd62068b33856cdda47fe1b5e890954/httptools-0.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:85071a1e8c2d051b507161f6c3e26155b5c790e4e28d7f236422dbacc2a9cc44", size = 104337 }, + { url = "https://files.pythonhosted.org/packages/9b/01/6fb20be3196ffdc8eeec4e653bc2a275eca7f36634c86302242c4fbb2760/httptools-0.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69422b7f458c5af875922cdb5bd586cc1f1033295aa9ff63ee196a87519ac8e1", size = 508796 }, + { url = "https://files.pythonhosted.org/packages/f7/d8/b644c44acc1368938317d76ac991c9bba1166311880bcc0ac297cb9d6bd7/httptools-0.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16e603a3bff50db08cd578d54f07032ca1631450ceb972c2f834c2b860c28ea2", size = 510837 }, + { url = "https://files.pythonhosted.org/packages/52/d8/254d16a31d543073a0e57f1c329ca7378d8924e7e292eda72d0064987486/httptools-0.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec4f178901fa1834d4a060320d2f3abc5c9e39766953d038f1458cb885f47e81", size = 485289 }, + { url = "https://files.pythonhosted.org/packages/5f/3c/4aee161b4b7a971660b8be71a92c24d6c64372c1ab3ae7f366b3680df20f/httptools-0.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb89ecf8b290f2e293325c646a211ff1c2493222798bb80a530c5e7502494f", size = 489779 }, + { url = "https://files.pythonhosted.org/packages/12/b7/5cae71a8868e555f3f67a50ee7f673ce36eac970f029c0c5e9d584352961/httptools-0.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:db78cb9ca56b59b016e64b6031eda5653be0589dba2b1b43453f6e8b405a0970", size = 88634 }, + { url = "https://files.pythonhosted.org/packages/94/a3/9fe9ad23fd35f7de6b91eeb60848986058bd8b5a5c1e256f5860a160cc3e/httptools-0.6.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ade273d7e767d5fae13fa637f4d53b6e961fb7fd93c7797562663f0171c26660", size = 197214 }, + { url = "https://files.pythonhosted.org/packages/ea/d9/82d5e68bab783b632023f2fa31db20bebb4e89dfc4d2293945fd68484ee4/httptools-0.6.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:856f4bc0478ae143bad54a4242fccb1f3f86a6e1be5548fecfd4102061b3a083", size = 102431 }, + { url = "https://files.pythonhosted.org/packages/96/c1/cb499655cbdbfb57b577734fde02f6fa0bbc3fe9fb4d87b742b512908dff/httptools-0.6.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:322d20ea9cdd1fa98bd6a74b77e2ec5b818abdc3d36695ab402a0de8ef2865a3", size = 473121 }, + { url = "https://files.pythonhosted.org/packages/af/71/ee32fd358f8a3bb199b03261f10921716990808a675d8160b5383487a317/httptools-0.6.4-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4d87b29bd4486c0093fc64dea80231f7c7f7eb4dc70ae394d70a495ab8436071", size = 473805 }, + { url = "https://files.pythonhosted.org/packages/8a/0a/0d4df132bfca1507114198b766f1737d57580c9ad1cf93c1ff673e3387be/httptools-0.6.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:342dd6946aa6bda4b8f18c734576106b8a31f2fe31492881a9a160ec84ff4bd5", size = 448858 }, + { url = "https://files.pythonhosted.org/packages/1e/6a/787004fdef2cabea27bad1073bf6a33f2437b4dbd3b6fb4a9d71172b1c7c/httptools-0.6.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b36913ba52008249223042dca46e69967985fb4051951f94357ea681e1f5dc0", size = 452042 }, + { url = "https://files.pythonhosted.org/packages/4d/dc/7decab5c404d1d2cdc1bb330b1bf70e83d6af0396fd4fc76fc60c0d522bf/httptools-0.6.4-cp313-cp313-win_amd64.whl", hash = "sha256:28908df1b9bb8187393d5b5db91435ccc9c8e891657f9cbb42a2541b44c82fc8", size = 87682 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[[package]] +name = "huggingface-hub" +version = "0.27.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/c6/e3709b61de8e7832dbe19f0d9637e81356cede733d99359fbce125423774/huggingface_hub-0.27.0.tar.gz", hash = "sha256:902cce1a1be5739f5589e560198a65a8edcfd3b830b1666f36e4b961f0454fac", size = 379286 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/8c/fbdc0a88a622d9fa54e132d7bf3ee03ec602758658a2db5b339a65be2cfe/huggingface_hub-0.27.0-py3-none-any.whl", hash = "sha256:8f2e834517f1f1ddf1ecc716f91b120d7333011b7485f665a9a412eacb1a2a81", size = 450537 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "imageio" +version = "2.36.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/70/aa/2e7a49259339e691ff2b477ae0696b1784a09313c5872700bbbdd00a3030/imageio-2.36.1.tar.gz", hash = "sha256:e4e1d231f47f9a9e16100b0f7ce1a86e8856fb4d1c0fa2c4365a316f1746be62", size = 389522 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/f9/f78e7f5ac8077c481bf6b43b8bc736605363034b3d5eb3ce8eb79f53f5f1/imageio-2.36.1-py3-none-any.whl", hash = "sha256:20abd2cae58e55ca1af8a8dcf43293336a59adf0391f1917bf8518633cfc2cdf", size = 315435 }, +] + +[[package]] +name = "jinja2" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/55/39036716d19cab0747a5020fc7e907f362fbf48c984b14e62127f7e68e5d/jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369", size = 240245 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/80/3a54838c3fb461f6fec263ebf3a3a41771bd05190238de3486aae8540c36/jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d", size = 133271 }, +] + +[[package]] +name = "lazy-loader" +version = "0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097 }, +] + +[[package]] +name = "lightning" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fsspec", extra = ["http"] }, + { name = "lightning-utilities" }, + { name = "packaging" }, + { name = "pytorch-lightning" }, + { name = "pyyaml" }, + { name = "torch" }, + { name = "torchmetrics" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/56/d0/78ea244ac044cd4df15aa8294a50ff3561fb177e7e5ba788aaa542046cae/lightning-2.4.0.tar.gz", hash = "sha256:9156604cc56e4b2b603f34fa7f0fe5107375c8e6d85e74544b319a15faa9ed0e", size = 620632 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/2c/85eaf42c983b0cd81bcda5876da2c8e2a9fd347908666ea9855724369171/lightning-2.4.0-py3-none-any.whl", hash = "sha256:560163af9711cf59055c448232c473150a299089efce0d2be3cc3288082d8768", size = 810971 }, +] + +[[package]] +name = "lightning-utilities" +version = "0.11.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "setuptools" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8c/4d/54d38e237ab437f25f191602373d99b89d1d047ad2a3bb5ad0d84ea5daa6/lightning_utilities-0.11.9.tar.gz", hash = "sha256:f5052b81344cc2684aa9afd74b7ce8819a8f49a858184ec04548a5a109dfd053", size = 29362 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/f3/1305321a12c984405e26fc64b5d521569e9872fb811f4aace8e168099160/lightning_utilities-0.11.9-py3-none-any.whl", hash = "sha256:ac6d4e9e28faf3ff4be997876750fee10dc604753dbc429bf3848a95c5d7e0d2", size = 28356 }, +] + +[[package]] +name = "lingua-language-detector" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/af/e4a17f42a0fd58704dd0d65c9ac9c09c3305553d684089c15f3642d51ae4/lingua_language_detector-2.0.2-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:f5abfba01b9d1d4e23c647871203692f6e14cbd41a5d99a19ae3504e987a175c", size = 73635170 }, + { url = "https://files.pythonhosted.org/packages/42/15/8bf4abfe7147649c1f18521a65c790dcc646e2cc56e26bd02f5217d6b1d1/lingua_language_detector-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:afb62a4ec7f758d1bc12e0bcb6178d762d4ca26cb5e005f5a24f79ef52f47dec", size = 74094414 }, + { url = "https://files.pythonhosted.org/packages/87/35/e1b4194d241faea2bbe6237e2b6f6ed0b891a935eb5e1db8eae5345abc44/lingua_language_detector-2.0.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3a9395f4030cf6eaaa7e432cb167fbaa577109c38114ab1dbdfdd75693b3048b", size = 74747657 }, + { url = "https://files.pythonhosted.org/packages/a0/cc/d2db3b36a34b956604020e7ee2db9065b4f41a0697c4b8f69012d1cbfaec/lingua_language_detector-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed54511cc9e4bb721c7f0530870494918985fabf3a30c1fe9a26649416ed83c7", size = 74657135 }, + { url = "https://files.pythonhosted.org/packages/3e/bb/636205c1f3395481a364c47cc2e825d220165b0f9ebe0f9b4afa1eb539d9/lingua_language_detector-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1571a68601a60b3eaf246ce9c2ad7b9d515609116f3a01c7536f20e2f9e7437", size = 74693279 }, + { url = "https://files.pythonhosted.org/packages/11/69/21eca49d91a8a0828c80991ff44de88d87c017ec010d2966e8628ad5e849/lingua_language_detector-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:652936f5e109784528f643062c704ad02572994cf05cfb7c609f96f0ae6259ed", size = 74624105 }, + { url = "https://files.pythonhosted.org/packages/94/55/21540e557afbf1111b7dba64d8d5d9de4faa285f61e17e71bf3507262fcc/lingua_language_detector-2.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5fcc06b49c65cf6083afc7b6bd6ea26a43da8107d849842e4647a19c0ce68f66", size = 74612463 }, + { url = "https://files.pythonhosted.org/packages/31/06/aa8f42beefe7601343349ab2815c07d07e40f4348d482eec7b581553f8d0/lingua_language_detector-2.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9012c74eea7d07c63c47fceaa3a6bc1e216954107b08beb421b64c717912be0d", size = 74669817 }, + { url = "https://files.pythonhosted.org/packages/a3/2a/d4b0df117a457a5953926299b02b64ee3337cfa31dcc85a7ee968dee8a56/lingua_language_detector-2.0.2-cp312-none-win32.whl", hash = "sha256:9a256aadabf76a915910dd430724592f417942a443dc980a325a154c3f93f547", size = 73223556 }, + { url = "https://files.pythonhosted.org/packages/6c/80/d3dcbdcde9012b2e0b29374aee89e55159e528a9590d380ae85381588fb8/lingua_language_detector-2.0.2-cp312-none-win_amd64.whl", hash = "sha256:72866175ff3d78b3d9244932ffbbb731471bca3758a2a825c60331ecdfb10851", size = 73329056 }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198 }, +] + +[[package]] +name = "multidict" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/be/504b89a5e9ca731cd47487e91c469064f8ae5af93b7259758dcfc2b9c848/multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a", size = 64002 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/16/92057c74ba3b96d5e211b553895cd6dc7cc4d1e43d9ab8fafc727681ef71/multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa", size = 48713 }, + { url = "https://files.pythonhosted.org/packages/94/3d/37d1b8893ae79716179540b89fc6a0ee56b4a65fcc0d63535c6f5d96f217/multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436", size = 29516 }, + { url = "https://files.pythonhosted.org/packages/a2/12/adb6b3200c363062f805275b4c1e656be2b3681aada66c80129932ff0bae/multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761", size = 29557 }, + { url = "https://files.pythonhosted.org/packages/47/e9/604bb05e6e5bce1e6a5cf80a474e0f072e80d8ac105f1b994a53e0b28c42/multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e", size = 130170 }, + { url = "https://files.pythonhosted.org/packages/7e/13/9efa50801785eccbf7086b3c83b71a4fb501a4d43549c2f2f80b8787d69f/multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef", size = 134836 }, + { url = "https://files.pythonhosted.org/packages/bf/0f/93808b765192780d117814a6dfcc2e75de6dcc610009ad408b8814dca3ba/multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95", size = 133475 }, + { url = "https://files.pythonhosted.org/packages/d3/c8/529101d7176fe7dfe1d99604e48d69c5dfdcadb4f06561f465c8ef12b4df/multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925", size = 131049 }, + { url = "https://files.pythonhosted.org/packages/ca/0c/fc85b439014d5a58063e19c3a158a889deec399d47b5269a0f3b6a2e28bc/multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966", size = 120370 }, + { url = "https://files.pythonhosted.org/packages/db/46/d4416eb20176492d2258fbd47b4abe729ff3b6e9c829ea4236f93c865089/multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305", size = 125178 }, + { url = "https://files.pythonhosted.org/packages/5b/46/73697ad7ec521df7de5531a32780bbfd908ded0643cbe457f981a701457c/multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2", size = 119567 }, + { url = "https://files.pythonhosted.org/packages/cd/ed/51f060e2cb0e7635329fa6ff930aa5cffa17f4c7f5c6c3ddc3500708e2f2/multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2", size = 129822 }, + { url = "https://files.pythonhosted.org/packages/df/9e/ee7d1954b1331da3eddea0c4e08d9142da5f14b1321c7301f5014f49d492/multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6", size = 128656 }, + { url = "https://files.pythonhosted.org/packages/77/00/8538f11e3356b5d95fa4b024aa566cde7a38aa7a5f08f4912b32a037c5dc/multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3", size = 125360 }, + { url = "https://files.pythonhosted.org/packages/be/05/5d334c1f2462d43fec2363cd00b1c44c93a78c3925d952e9a71caf662e96/multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133", size = 26382 }, + { url = "https://files.pythonhosted.org/packages/a3/bf/f332a13486b1ed0496d624bcc7e8357bb8053823e8cd4b9a18edc1d97e73/multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1", size = 28529 }, + { url = "https://files.pythonhosted.org/packages/22/67/1c7c0f39fe069aa4e5d794f323be24bf4d33d62d2a348acdb7991f8f30db/multidict-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d569388c381b24671589335a3be6e1d45546c2988c2ebe30fdcada8457a31008", size = 48771 }, + { url = "https://files.pythonhosted.org/packages/3c/25/c186ee7b212bdf0df2519eacfb1981a017bda34392c67542c274651daf23/multidict-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:052e10d2d37810b99cc170b785945421141bf7bb7d2f8799d431e7db229c385f", size = 29533 }, + { url = "https://files.pythonhosted.org/packages/67/5e/04575fd837e0958e324ca035b339cea174554f6f641d3fb2b4f2e7ff44a2/multidict-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f90c822a402cb865e396a504f9fc8173ef34212a342d92e362ca498cad308e28", size = 29595 }, + { url = "https://files.pythonhosted.org/packages/d3/b2/e56388f86663810c07cfe4a3c3d87227f3811eeb2d08450b9e5d19d78876/multidict-6.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b225d95519a5bf73860323e633a664b0d85ad3d5bede6d30d95b35d4dfe8805b", size = 130094 }, + { url = "https://files.pythonhosted.org/packages/6c/ee/30ae9b4186a644d284543d55d491fbd4239b015d36b23fea43b4c94f7052/multidict-6.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23bfd518810af7de1116313ebd9092cb9aa629beb12f6ed631ad53356ed6b86c", size = 134876 }, + { url = "https://files.pythonhosted.org/packages/84/c7/70461c13ba8ce3c779503c70ec9d0345ae84de04521c1f45a04d5f48943d/multidict-6.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c09fcfdccdd0b57867577b719c69e347a436b86cd83747f179dbf0cc0d4c1f3", size = 133500 }, + { url = "https://files.pythonhosted.org/packages/4a/9f/002af221253f10f99959561123fae676148dd730e2daa2cd053846a58507/multidict-6.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf6bea52ec97e95560af5ae576bdac3aa3aae0b6758c6efa115236d9e07dae44", size = 131099 }, + { url = "https://files.pythonhosted.org/packages/82/42/d1c7a7301d52af79d88548a97e297f9d99c961ad76bbe6f67442bb77f097/multidict-6.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57feec87371dbb3520da6192213c7d6fc892d5589a93db548331954de8248fd2", size = 120403 }, + { url = "https://files.pythonhosted.org/packages/68/f3/471985c2c7ac707547553e8f37cff5158030d36bdec4414cb825fbaa5327/multidict-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0c3f390dc53279cbc8ba976e5f8035eab997829066756d811616b652b00a23a3", size = 125348 }, + { url = "https://files.pythonhosted.org/packages/67/2c/e6df05c77e0e433c214ec1d21ddd203d9a4770a1f2866a8ca40a545869a0/multidict-6.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:59bfeae4b25ec05b34f1956eaa1cb38032282cd4dfabc5056d0a1ec4d696d3aa", size = 119673 }, + { url = "https://files.pythonhosted.org/packages/c5/cd/bc8608fff06239c9fb333f9db7743a1b2eafe98c2666c9a196e867a3a0a4/multidict-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b2f59caeaf7632cc633b5cf6fc449372b83bbdf0da4ae04d5be36118e46cc0aa", size = 129927 }, + { url = "https://files.pythonhosted.org/packages/44/8e/281b69b7bc84fc963a44dc6e0bbcc7150e517b91df368a27834299a526ac/multidict-6.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:37bb93b2178e02b7b618893990941900fd25b6b9ac0fa49931a40aecdf083fe4", size = 128711 }, + { url = "https://files.pythonhosted.org/packages/12/a4/63e7cd38ed29dd9f1881d5119f272c898ca92536cdb53ffe0843197f6c85/multidict-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4e9f48f58c2c523d5a06faea47866cd35b32655c46b443f163d08c6d0ddb17d6", size = 125519 }, + { url = "https://files.pythonhosted.org/packages/38/e0/4f5855037a72cd8a7a2f60a3952d9aa45feedb37ae7831642102604e8a37/multidict-6.1.0-cp313-cp313-win32.whl", hash = "sha256:3a37ffb35399029b45c6cc33640a92bef403c9fd388acce75cdc88f58bd19a81", size = 26426 }, + { url = "https://files.pythonhosted.org/packages/7e/a5/17ee3a4db1e310b7405f5d25834460073a8ccd86198ce044dfaf69eac073/multidict-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9aa71e15d9d9beaad2c6b9319edcdc0a49a43ef5c0a4c8265ca9ee7d6c67774", size = 28531 }, + { url = "https://files.pythonhosted.org/packages/99/b7/b9e70fde2c0f0c9af4cc5277782a89b66d35948ea3369ec9f598358c3ac5/multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506", size = 10051 }, +] + +[[package]] +name = "multiprocess" +version = "0.70.16" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", hash = "sha256:161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1", size = 1772603 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", hash = "sha256:c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02", size = 134824 }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", hash = "sha256:af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a", size = 143519 }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", hash = "sha256:fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e", size = 146741 }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", hash = "sha256:a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435", size = 132628 }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3", size = 133351 }, +] + +[[package]] +name = "networkx" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 }, +] + +[[package]] +name = "ninja" +version = "1.11.1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/8f/21a2701f95b7d0d5137736561b3427ece0c4a1e085d4a223b92d16ab7d8b/ninja-1.11.1.3.tar.gz", hash = "sha256:edfa0d2e9d7ead1635b03e40a32ad56cc8f56798b6e2e9848d8300b174897076", size = 129532 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/ba/0069cd4a83d68f7b0308be70e219b15d675e50c8ea28763a3f0373c45bfc/ninja-1.11.1.3-py3-none-macosx_10_9_universal2.whl", hash = "sha256:2b4879ea3f1169f3d855182c57dcc84d1b5048628c8b7be0d702b81882a37237", size = 279132 }, + { url = "https://files.pythonhosted.org/packages/72/6b/3805be87df8417a0c7b21078c8045f2a1e59b34f371bfe4cb4fb0d6df7f2/ninja-1.11.1.3-py3-none-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:bc3ebc8b2e47716149f3541742b5cd8e0b08f51013b825c05baca3e34854370d", size = 472101 }, + { url = "https://files.pythonhosted.org/packages/6b/35/a8e38d54768e67324e365e2a41162be298f51ec93e6bd4b18d237d7250d8/ninja-1.11.1.3-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a27e78ca71316c8654965ee94b286a98c83877bfebe2607db96897bbfe458af0", size = 422884 }, + { url = "https://files.pythonhosted.org/packages/2f/99/7996457319e139c02697fb2aa28e42fe32bb0752cef492edc69d56a3552e/ninja-1.11.1.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2883ea46b3c5079074f56820f9989c6261fcc6fd873d914ee49010ecf283c3b2", size = 157046 }, + { url = "https://files.pythonhosted.org/packages/6d/8b/93f38e5cddf76ccfdab70946515b554f25d2b4c95ef9b2f9cfbc43fa7cc1/ninja-1.11.1.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c4bdb9fd2d0c06501ae15abfd23407660e95659e384acd36e013b6dd7d8a8e4", size = 180014 }, + { url = "https://files.pythonhosted.org/packages/7d/1d/713884d0fa3c972164f69d552e0701d30e2bf25eba9ef160bfb3dc69926a/ninja-1.11.1.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:114ed5c61c8474df6a69ab89097a20749b769e2c219a452cb2fadc49b0d581b0", size = 157098 }, + { url = "https://files.pythonhosted.org/packages/c7/22/ecb0f70e77c9e22ee250aa717a608a142756833a34d43943d7d658ee0e56/ninja-1.11.1.3-py3-none-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fa2247fce98f683bc712562d82b22b8a0a5c000738a13147ca2d1b68c122298", size = 130089 }, + { url = "https://files.pythonhosted.org/packages/ec/a6/3ee846c20ab6ad95b90c5c8703c76cb1f39cc8ce2d1ae468956e3b1b2581/ninja-1.11.1.3-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:a38c6c6c8032bed68b70c3b065d944c35e9f903342875d3a3218c1607987077c", size = 372508 }, + { url = "https://files.pythonhosted.org/packages/95/0d/aa44abe4141f29148ce671ac8c92045878906b18691c6f87a29711c2ff1c/ninja-1.11.1.3-py3-none-musllinux_1_1_i686.whl", hash = "sha256:56ada5d33b8741d298836644042faddebc83ee669782d661e21563034beb5aba", size = 419369 }, + { url = "https://files.pythonhosted.org/packages/f7/ec/48bf5105568ac9bd2016b701777bdd5000cc09a14ac837fef9f15e8d634e/ninja-1.11.1.3-py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:53409151da081f3c198bb0bfc220a7f4e821e022c5b7d29719adda892ddb31bb", size = 420304 }, + { url = "https://files.pythonhosted.org/packages/18/e5/69df63976cf971a03379899f8520a036c9dbab26330b37197512aed5b3df/ninja-1.11.1.3-py3-none-musllinux_1_1_s390x.whl", hash = "sha256:1ad2112c2b0159ed7c4ae3731595191b1546ba62316fc40808edecd0306fefa3", size = 416056 }, + { url = "https://files.pythonhosted.org/packages/6f/4f/bdb401af7ed0e24a3fef058e13a149f2de1ce4b176699076993615d55610/ninja-1.11.1.3-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:28aea3c1c280cba95b8608d50797169f3a34280e3e9a6379b6e340f0c9eaeeb0", size = 379725 }, + { url = "https://files.pythonhosted.org/packages/bd/68/05e7863bf13128c61652eeb3ec7096c3d3a602f32f31752dbfb034e3fa07/ninja-1.11.1.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b6966f83064a88a51693073eea3decd47e08c3965241e09578ef7aa3a7738329", size = 434881 }, + { url = "https://files.pythonhosted.org/packages/bd/ad/edc0d1efe77f29f45bbca2e1dab07ef597f61a88de6e4bccffc0aec2256c/ninja-1.11.1.3-py3-none-win32.whl", hash = "sha256:a4a3b71490557e18c010cbb26bd1ea9a0c32ee67e8f105e9731515b6e0af792e", size = 255988 }, + { url = "https://files.pythonhosted.org/packages/03/93/09a9f7672b4f97438aca6217ac54212a63273f1cd3b46b731d0bb22c53e7/ninja-1.11.1.3-py3-none-win_amd64.whl", hash = "sha256:04d48d14ea7ba11951c156599ab526bdda575450797ff57c6fdf99b2554d09c7", size = 296502 }, + { url = "https://files.pythonhosted.org/packages/d9/9d/0cc1e82849070ff3cbee69f326cb48a839407bcd15d8844443c30a5e7509/ninja-1.11.1.3-py3-none-win_arm64.whl", hash = "sha256:17978ad611d8ead578d83637f5ae80c2261b033db0b493a7ce94f88623f29e1b", size = 270571 }, +] + +[[package]] +name = "numpy" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/1b/1d565e0f6e156e1522ab564176b8b29d71e13d8caf003a08768df3d5cec5/numpy-2.2.0.tar.gz", hash = "sha256:140dd80ff8981a583a60980be1a655068f8adebf7a45a06a6858c873fcdcd4a0", size = 20225497 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/bc/a20dc4e1d051149052762e7647455311865d11c603170c476d1e910a353e/numpy-2.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cff210198bb4cae3f3c100444c5eaa573a823f05c253e7188e1362a5555235b3", size = 20909153 }, + { url = "https://files.pythonhosted.org/packages/60/3d/ac4fb63f36db94f4c7db05b45e3ecb3f88f778ca71850664460c78cfde41/numpy-2.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b92a5828bd4d9aa0952492b7de803135038de47343b2aa3cc23f3b71a3dc4e", size = 14095021 }, + { url = "https://files.pythonhosted.org/packages/41/6d/a654d519d24e4fcc7a83d4a51209cda086f26cf30722b3d8ffc1aa9b775e/numpy-2.2.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:ebe5e59545401fbb1b24da76f006ab19734ae71e703cdb4a8b347e84a0cece67", size = 5125491 }, + { url = "https://files.pythonhosted.org/packages/e6/22/fab7e1510a62e5092f4e6507a279020052b89f11d9cfe52af7f52c243b04/numpy-2.2.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e2b8cd48a9942ed3f85b95ca4105c45758438c7ed28fff1e4ce3e57c3b589d8e", size = 6658534 }, + { url = "https://files.pythonhosted.org/packages/fc/29/a3d938ddc5a534cd53df7ab79d20a68db8c67578de1df0ae0118230f5f54/numpy-2.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57fcc997ffc0bef234b8875a54d4058afa92b0b0c4223fc1f62f24b3b5e86038", size = 14046306 }, + { url = "https://files.pythonhosted.org/packages/90/24/d0bbb56abdd8934f30384632e3c2ca1ebfeb5d17e150c6e366ba291de36b/numpy-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85ad7d11b309bd132d74397fcf2920933c9d1dc865487128f5c03d580f2c3d03", size = 16095819 }, + { url = "https://files.pythonhosted.org/packages/99/9c/58a673faa9e8a0e77248e782f7a17410cf7259b326265646fd50ed49c4e1/numpy-2.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cb24cca1968b21355cc6f3da1a20cd1cebd8a023e3c5b09b432444617949085a", size = 15243215 }, + { url = "https://files.pythonhosted.org/packages/9c/61/f311693f78cbf635cfb69ce9e1e857ff83937a27d93c96ac5932fd33e330/numpy-2.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0798b138c291d792f8ea40fe3768610f3c7dd2574389e37c3f26573757c8f7ef", size = 17860175 }, + { url = "https://files.pythonhosted.org/packages/11/3e/491c34262cb1fc9dd13a00beb80d755ee0517b17db20e54cac7aa524533e/numpy-2.2.0-cp312-cp312-win32.whl", hash = "sha256:afe8fb968743d40435c3827632fd36c5fbde633b0423da7692e426529b1759b1", size = 6273281 }, + { url = "https://files.pythonhosted.org/packages/89/ea/00537f599eb230771157bc509f6ea5b2dddf05d4b09f9d2f1d7096a18781/numpy-2.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:3a4199f519e57d517ebd48cb76b36c82da0360781c6a0353e64c0cac30ecaad3", size = 12613227 }, + { url = "https://files.pythonhosted.org/packages/bd/4c/0d1eef206545c994289e7a9de21b642880a11e0ed47a2b0c407c688c4f69/numpy-2.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f8c8b141ef9699ae777c6278b52c706b653bf15d135d302754f6b2e90eb30367", size = 20895707 }, + { url = "https://files.pythonhosted.org/packages/16/cb/88f6c1e6df83002c421d5f854ccf134aa088aa997af786a5dac3f32ec99b/numpy-2.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f0986e917aca18f7a567b812ef7ca9391288e2acb7a4308aa9d265bd724bdae", size = 14110592 }, + { url = "https://files.pythonhosted.org/packages/b4/54/817e6894168a43f33dca74199ba0dd0f1acd99aa6323ed6d323d63d640a2/numpy-2.2.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:1c92113619f7b272838b8d6702a7f8ebe5edea0df48166c47929611d0b4dea69", size = 5110858 }, + { url = "https://files.pythonhosted.org/packages/c7/99/00d8a1a8eb70425bba7880257ed73fed08d3e8d05da4202fb6b9a81d5ee4/numpy-2.2.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5a145e956b374e72ad1dff82779177d4a3c62bc8248f41b80cb5122e68f22d13", size = 6645143 }, + { url = "https://files.pythonhosted.org/packages/34/86/5b9c2b7c56e7a9d9297a0a4be0b8433f498eba52a8f5892d9132b0f64627/numpy-2.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18142b497d70a34b01642b9feabb70156311b326fdddd875a9981f34a369b671", size = 14042812 }, + { url = "https://files.pythonhosted.org/packages/df/54/13535f74391dbe5f479ceed96f1403267be302c840040700d4fd66688089/numpy-2.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7d41d1612c1a82b64697e894b75db6758d4f21c3ec069d841e60ebe54b5b571", size = 16093419 }, + { url = "https://files.pythonhosted.org/packages/dd/37/dfb2056842ac61315f225aa56f455da369f5223e4c5a38b91d20da1b628b/numpy-2.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a98f6f20465e7618c83252c02041517bd2f7ea29be5378f09667a8f654a5918d", size = 15238969 }, + { url = "https://files.pythonhosted.org/packages/5a/3d/d20d24ee313992f0b7e7b9d9eef642d9b545d39d5b91c4a2cc8c98776328/numpy-2.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e09d40edfdb4e260cb1567d8ae770ccf3b8b7e9f0d9b5c2a9992696b30ce2742", size = 17855705 }, + { url = "https://files.pythonhosted.org/packages/5b/40/944c9ee264f875a2db6f79380944fd2b5bb9d712bb4a134d11f45ad5b693/numpy-2.2.0-cp313-cp313-win32.whl", hash = "sha256:3905a5fffcc23e597ee4d9fb3fcd209bd658c352657548db7316e810ca80458e", size = 6270078 }, + { url = "https://files.pythonhosted.org/packages/30/04/e1ee6f8b22034302d4c5c24e15782bdedf76d90b90f3874ed0b48525def0/numpy-2.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a184288538e6ad699cbe6b24859206e38ce5fba28f3bcfa51c90d0502c1582b2", size = 12605791 }, + { url = "https://files.pythonhosted.org/packages/ef/fb/51d458625cd6134d60ac15180ae50995d7d21b0f2f92a6286ae7b0792d19/numpy-2.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7832f9e8eb00be32f15fdfb9a981d6955ea9adc8574c521d48710171b6c55e95", size = 20920160 }, + { url = "https://files.pythonhosted.org/packages/b4/34/162ae0c5d2536ea4be98c813b5161c980f0443cd5765fde16ddfe3450140/numpy-2.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f0dd071b95bbca244f4cb7f70b77d2ff3aaaba7fa16dc41f58d14854a6204e6c", size = 14119064 }, + { url = "https://files.pythonhosted.org/packages/17/6c/4195dd0e1c41c55f466d516e17e9e28510f32af76d23061ea3da67438e3c/numpy-2.2.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b0b227dcff8cdc3efbce66d4e50891f04d0a387cce282fe1e66199146a6a8fca", size = 5152778 }, + { url = "https://files.pythonhosted.org/packages/2f/47/ea804ae525832c8d05ed85b560dfd242d34e4bb0962bc269ccaa720fb934/numpy-2.2.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ab153263a7c5ccaf6dfe7e53447b74f77789f28ecb278c3b5d49db7ece10d6d", size = 6667605 }, + { url = "https://files.pythonhosted.org/packages/76/99/34d20e50b3d894bb16b5374bfbee399ab8ff3a33bf1e1f0b8acfe7bbd70d/numpy-2.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e500aba968a48e9019e42c0c199b7ec0696a97fa69037bea163b55398e390529", size = 14013275 }, + { url = "https://files.pythonhosted.org/packages/69/8f/a1df7bd02d434ab82539517d1b98028985700cfc4300bc5496fb140ca648/numpy-2.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:440cfb3db4c5029775803794f8638fbdbf71ec702caf32735f53b008e1eaece3", size = 16074900 }, + { url = "https://files.pythonhosted.org/packages/04/94/b419e7a76bf21a00fcb03c613583f10e389fdc8dfe420412ff5710c8ad3d/numpy-2.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a55dc7a7f0b6198b07ec0cd445fbb98b05234e8b00c5ac4874a63372ba98d4ab", size = 15219122 }, + { url = "https://files.pythonhosted.org/packages/65/d9/dddf398b2b6c5d750892a207a469c2854a8db0f033edaf72103af8cf05aa/numpy-2.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4bddbaa30d78c86329b26bd6aaaea06b1e47444da99eddac7bf1e2fab717bd72", size = 17851668 }, + { url = "https://files.pythonhosted.org/packages/d4/dc/09a4e5819a9782a213c0eb4eecacdc1cd75ad8dac99279b04cfccb7eeb0a/numpy-2.2.0-cp313-cp313t-win32.whl", hash = "sha256:30bf971c12e4365153afb31fc73f441d4da157153f3400b82db32d04de1e4066", size = 6325288 }, + { url = "https://files.pythonhosted.org/packages/ce/e1/e0d06ec34036c92b43aef206efe99a5f5f04e12c776eab82a36e00c40afc/numpy-2.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d35717333b39d1b6bb8433fa758a55f1081543de527171543a2b710551d40881", size = 12692303 }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.4.5.8" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/7f/7fbae15a3982dc9595e49ce0f19332423b260045d0a6afe93cdbe2f1f624/nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0f8aa1706812e00b9f19dfe0cdb3999b092ccb8ca168c0db5b8ea712456fd9b3", size = 363333771 }, + { url = "https://files.pythonhosted.org/packages/ae/71/1c91302526c45ab494c23f61c7a84aa568b8c1f9d196efa5993957faf906/nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b", size = 363438805 }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/b5/9fb3d00386d3361b03874246190dfec7b206fd74e6e287b26a8fcb359d95/nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:79279b35cf6f91da114182a5ce1864997fd52294a87a16179ce275773799458a", size = 12354556 }, + { url = "https://files.pythonhosted.org/packages/67/42/f4f60238e8194a3106d06a058d494b18e006c10bb2b915655bd9f6ea4cb1/nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb", size = 13813957 }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/aa/083b01c427e963ad0b314040565ea396f914349914c298556484f799e61b/nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0eedf14185e04b76aa05b1fea04133e59f465b6f960c0cbf4e37c3cb6b0ea198", size = 24133372 }, + { url = "https://files.pythonhosted.org/packages/2c/14/91ae57cd4db3f9ef7aa99f4019cfa8d54cb4caa7e00975df6467e9725a9f/nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338", size = 24640306 }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/aa/b656d755f474e2084971e9a297def515938d56b466ab39624012070cb773/nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:961fe0e2e716a2a1d967aab7caee97512f71767f852f67432d572e36cb3a11f3", size = 894177 }, + { url = "https://files.pythonhosted.org/packages/ea/27/1795d86fe88ef397885f2e580ac37628ed058a92ed2c39dc8eac3adf0619/nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5", size = 883737 }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.1.0.70" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/fd/713452cd72343f682b1c7b9321e23829f00b842ceaedcda96e742ea0b0b3/nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f", size = 664752741 }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.2.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/8a/0e728f749baca3fbeffad762738276e5df60851958be7783af121a7221e7/nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5dad8008fc7f92f5ddfa2101430917ce2ffacd86824914c82e28990ad7f00399", size = 211422548 }, + { url = "https://files.pythonhosted.org/packages/27/94/3266821f65b92b3138631e9c8e7fe1fb513804ac934485a8d05776e1dd43/nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9", size = 211459117 }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.5.147" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/9c/a79180e4d70995fdf030c6946991d0171555c6edf95c265c6b2bf7011112/nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1f173f09e3e3c76ab084aba0de819c49e56614feae5c12f69883f4ae9bb5fad9", size = 56314811 }, + { url = "https://files.pythonhosted.org/packages/8a/6d/44ad094874c6f1b9c654f8ed939590bdc408349f137f9b98a3a23ccec411/nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b", size = 56305206 }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.6.1.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12" }, + { name = "nvidia-cusparse-cu12" }, + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/6b/a5c33cf16af09166845345275c34ad2190944bcc6026797a39f8e0a282e0/nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d338f155f174f90724bbde3758b7ac375a70ce8e706d70b018dd3375545fc84e", size = 127634111 }, + { url = "https://files.pythonhosted.org/packages/3a/e1/5b9089a4b2a4790dfdea8b3a006052cfecff58139d5a4e34cb1a51df8d6f/nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl", hash = "sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260", size = 127936057 }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.3.1.170" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/a9/c0d2f83a53d40a4a41be14cea6a0bf9e668ffcf8b004bd65633f433050c0/nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_aarch64.whl", hash = "sha256:9d32f62896231ebe0480efd8a7f702e143c98cfaa0e8a76df3386c1ba2b54df3", size = 207381987 }, + { url = "https://files.pythonhosted.org/packages/db/f7/97a9ea26ed4bbbfc2d470994b8b4f338ef663be97b8f677519ac195e113d/nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1", size = 207454763 }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.21.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/99/12cd266d6233f47d00daf3a72739872bdc10267d0383508b0b9c84a18bb6/nvidia_nccl_cu12-2.21.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0", size = 188654414 }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/45/239d52c05074898a80a900f49b1615d81c07fceadd5ad6c4f86a987c0bc4/nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83", size = 20552510 }, + { url = "https://files.pythonhosted.org/packages/ff/ff/847841bacfbefc97a00036e0fce5a0f086b640756dc38caea5e1bb002655/nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57", size = 21066810 }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/39/471f581edbb7804b39e8063d92fc8305bdc7a80ae5c07dbe6ea5c50d14a5/nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7959ad635db13edf4fc65c06a6e9f9e55fc2f92596db928d169c0bb031e88ef3", size = 100417 }, + { url = "https://files.pythonhosted.org/packages/87/20/199b8713428322a2f22b722c62b8cc278cc53dffa9705d744484b5035ee9/nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a", size = 99144 }, +] + +[[package]] +name = "opencv-python-headless" +version = "4.10.0.84" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/7e/d20f68a5f1487adf19d74378d349932a386b1ece3be9be9915e5986db468/opencv-python-headless-4.10.0.84.tar.gz", hash = "sha256:f2017c6101d7c2ef8d7bc3b414c37ff7f54d64413a1847d89970b6b7069b4e1a", size = 95117755 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/9b/583c8d9259f6fc19413f83fd18dd8e6cbc8eefb0b4dc6da52dd151fe3272/opencv_python_headless-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a4f4bcb07d8f8a7704d9c8564c224c8b064c63f430e95b61ac0bffaa374d330e", size = 54835657 }, + { url = "https://files.pythonhosted.org/packages/c0/7b/b4c67f5dad7a9a61c47f7a39e4050e8a4628bd64b3c3daaeb755d759f928/opencv_python_headless-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:5ae454ebac0eb0a0b932e3406370aaf4212e6a3fdb5038cc86c7aea15a6851da", size = 56475470 }, + { url = "https://files.pythonhosted.org/packages/91/61/f838ce2046f3ec3591ea59ea3549085e399525d3b4558c4ed60b55ed88c0/opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46071015ff9ab40fccd8a163da0ee14ce9846349f06c6c8c0f2870856ffa45db", size = 29329705 }, + { url = "https://files.pythonhosted.org/packages/d1/09/248f86a404567303cdf120e4a301f389b68e3b18e5c0cc428de327da609c/opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:377d08a7e48a1405b5e84afcbe4798464ce7ee17081c1c23619c8b398ff18295", size = 49858781 }, + { url = "https://files.pythonhosted.org/packages/30/c0/66f88d58500e990a9a0a5c06f98862edf1d0a3a430781218a8c193948438/opencv_python_headless-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:9092404b65458ed87ce932f613ffbb1106ed2c843577501e5768912360fc50ec", size = 28675298 }, + { url = "https://files.pythonhosted.org/packages/26/d0/22f68eb23eea053a31655960f133c0be9726c6a881547e6e9e7e2a946c4f/opencv_python_headless-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:afcf28bd1209dd58810d33defb622b325d3cbe49dcd7a43a902982c33e5fad05", size = 38754031 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, +] + +[[package]] +name = "pdf2image" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/d8/b280f01045555dc257b8153c00dee3bc75830f91a744cd5f84ef3a0a64b1/pdf2image-1.17.0.tar.gz", hash = "sha256:eaa959bc116b420dd7ec415fcae49b98100dda3dd18cd2fdfa86d09f112f6d57", size = 12811 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/33/61766ae033518957f877ab246f87ca30a85b778ebaad65b7f74fa7e52988/pdf2image-1.17.0-py3-none-any.whl", hash = "sha256:ecdd58d7afb810dffe21ef2b1bbc057ef434dabbac6c33778a38a3f7744a27e2", size = 11618 }, +] + +[[package]] +name = "pillow" +version = "11.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/26/0d95c04c868f6bdb0c447e3ee2de5564411845e36a858cfd63766bc7b563/pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739", size = 46737780 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a3/26e606ff0b2daaf120543e537311fa3ae2eb6bf061490e4fea51771540be/pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923", size = 3147642 }, + { url = "https://files.pythonhosted.org/packages/4f/d5/1caabedd8863526a6cfa44ee7a833bd97f945dc1d56824d6d76e11731939/pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903", size = 2978999 }, + { url = "https://files.pythonhosted.org/packages/d9/ff/5a45000826a1aa1ac6874b3ec5a856474821a1b59d838c4f6ce2ee518fe9/pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4", size = 4196794 }, + { url = "https://files.pythonhosted.org/packages/9d/21/84c9f287d17180f26263b5f5c8fb201de0f88b1afddf8a2597a5c9fe787f/pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f", size = 4300762 }, + { url = "https://files.pythonhosted.org/packages/84/39/63fb87cd07cc541438b448b1fed467c4d687ad18aa786a7f8e67b255d1aa/pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9", size = 4210468 }, + { url = "https://files.pythonhosted.org/packages/7f/42/6e0f2c2d5c60f499aa29be14f860dd4539de322cd8fb84ee01553493fb4d/pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7", size = 4381824 }, + { url = "https://files.pythonhosted.org/packages/31/69/1ef0fb9d2f8d2d114db982b78ca4eeb9db9a29f7477821e160b8c1253f67/pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6", size = 4296436 }, + { url = "https://files.pythonhosted.org/packages/44/ea/dad2818c675c44f6012289a7c4f46068c548768bc6c7f4e8c4ae5bbbc811/pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc", size = 4429714 }, + { url = "https://files.pythonhosted.org/packages/af/3a/da80224a6eb15bba7a0dcb2346e2b686bb9bf98378c0b4353cd88e62b171/pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6", size = 2249631 }, + { url = "https://files.pythonhosted.org/packages/57/97/73f756c338c1d86bb802ee88c3cab015ad7ce4b838f8a24f16b676b1ac7c/pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47", size = 2567533 }, + { url = "https://files.pythonhosted.org/packages/0b/30/2b61876e2722374558b871dfbfcbe4e406626d63f4f6ed92e9c8e24cac37/pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25", size = 2254890 }, + { url = "https://files.pythonhosted.org/packages/63/24/e2e15e392d00fcf4215907465d8ec2a2f23bcec1481a8ebe4ae760459995/pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699", size = 3147300 }, + { url = "https://files.pythonhosted.org/packages/43/72/92ad4afaa2afc233dc44184adff289c2e77e8cd916b3ddb72ac69495bda3/pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38", size = 2978742 }, + { url = "https://files.pythonhosted.org/packages/9e/da/c8d69c5bc85d72a8523fe862f05ababdc52c0a755cfe3d362656bb86552b/pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2", size = 4194349 }, + { url = "https://files.pythonhosted.org/packages/cd/e8/686d0caeed6b998351d57796496a70185376ed9c8ec7d99e1d19ad591fc6/pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2", size = 4298714 }, + { url = "https://files.pythonhosted.org/packages/ec/da/430015cec620d622f06854be67fd2f6721f52fc17fca8ac34b32e2d60739/pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527", size = 4208514 }, + { url = "https://files.pythonhosted.org/packages/44/ae/7e4f6662a9b1cb5f92b9cc9cab8321c381ffbee309210940e57432a4063a/pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa", size = 4380055 }, + { url = "https://files.pythonhosted.org/packages/74/d5/1a807779ac8a0eeed57f2b92a3c32ea1b696e6140c15bd42eaf908a261cd/pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f", size = 4296751 }, + { url = "https://files.pythonhosted.org/packages/38/8c/5fa3385163ee7080bc13026d59656267daaaaf3c728c233d530e2c2757c8/pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb", size = 4430378 }, + { url = "https://files.pythonhosted.org/packages/ca/1d/ad9c14811133977ff87035bf426875b93097fb50af747793f013979facdb/pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798", size = 2249588 }, + { url = "https://files.pythonhosted.org/packages/fb/01/3755ba287dac715e6afdb333cb1f6d69740a7475220b4637b5ce3d78cec2/pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de", size = 2567509 }, + { url = "https://files.pythonhosted.org/packages/c0/98/2c7d727079b6be1aba82d195767d35fcc2d32204c7a5820f822df5330152/pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84", size = 2254791 }, + { url = "https://files.pythonhosted.org/packages/eb/38/998b04cc6f474e78b563716b20eecf42a2fa16a84589d23c8898e64b0ffd/pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b", size = 3150854 }, + { url = "https://files.pythonhosted.org/packages/13/8e/be23a96292113c6cb26b2aa3c8b3681ec62b44ed5c2bd0b258bd59503d3c/pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003", size = 2982369 }, + { url = "https://files.pythonhosted.org/packages/97/8a/3db4eaabb7a2ae8203cd3a332a005e4aba00067fc514aaaf3e9721be31f1/pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2", size = 4333703 }, + { url = "https://files.pythonhosted.org/packages/28/ac/629ffc84ff67b9228fe87a97272ab125bbd4dc462745f35f192d37b822f1/pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a", size = 4412550 }, + { url = "https://files.pythonhosted.org/packages/d6/07/a505921d36bb2df6868806eaf56ef58699c16c388e378b0dcdb6e5b2fb36/pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8", size = 4461038 }, + { url = "https://files.pythonhosted.org/packages/d6/b9/fb620dd47fc7cc9678af8f8bd8c772034ca4977237049287e99dda360b66/pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8", size = 2253197 }, + { url = "https://files.pythonhosted.org/packages/df/86/25dde85c06c89d7fc5db17940f07aae0a56ac69aa9ccb5eb0f09798862a8/pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904", size = 2572169 }, + { url = "https://files.pythonhosted.org/packages/51/85/9c33f2517add612e17f3381aee7c4072779130c634921a756c97bc29fb49/pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3", size = 2256828 }, +] + +[[package]] +name = "propcache" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/c8/2a13f78d82211490855b2fb303b6721348d0787fdd9a12ac46d99d3acde1/propcache-0.2.1.tar.gz", hash = "sha256:3f77ce728b19cb537714499928fe800c3dda29e8d9428778fc7c186da4c09a64", size = 41735 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/28/1d205fe49be8b1b4df4c50024e62480a442b1a7b818e734308bb0d17e7fb/propcache-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:081a430aa8d5e8876c6909b67bd2d937bfd531b0382d3fdedb82612c618bc41a", size = 79588 }, + { url = "https://files.pythonhosted.org/packages/21/ee/fc4d893f8d81cd4971affef2a6cb542b36617cd1d8ce56b406112cb80bf7/propcache-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2ccec9ac47cf4e04897619c0e0c1a48c54a71bdf045117d3a26f80d38ab1fb0", size = 45825 }, + { url = "https://files.pythonhosted.org/packages/4a/de/bbe712f94d088da1d237c35d735f675e494a816fd6f54e9db2f61ef4d03f/propcache-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:14d86fe14b7e04fa306e0c43cdbeebe6b2c2156a0c9ce56b815faacc193e320d", size = 45357 }, + { url = "https://files.pythonhosted.org/packages/7f/14/7ae06a6cf2a2f1cb382586d5a99efe66b0b3d0c6f9ac2f759e6f7af9d7cf/propcache-0.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:049324ee97bb67285b49632132db351b41e77833678432be52bdd0289c0e05e4", size = 241869 }, + { url = "https://files.pythonhosted.org/packages/cc/59/227a78be960b54a41124e639e2c39e8807ac0c751c735a900e21315f8c2b/propcache-0.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cd9a1d071158de1cc1c71a26014dcdfa7dd3d5f4f88c298c7f90ad6f27bb46d", size = 247884 }, + { url = "https://files.pythonhosted.org/packages/84/58/f62b4ffaedf88dc1b17f04d57d8536601e4e030feb26617228ef930c3279/propcache-0.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98110aa363f1bb4c073e8dcfaefd3a5cea0f0834c2aab23dda657e4dab2f53b5", size = 248486 }, + { url = "https://files.pythonhosted.org/packages/1c/07/ebe102777a830bca91bbb93e3479cd34c2ca5d0361b83be9dbd93104865e/propcache-0.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:647894f5ae99c4cf6bb82a1bb3a796f6e06af3caa3d32e26d2350d0e3e3faf24", size = 243649 }, + { url = "https://files.pythonhosted.org/packages/ed/bc/4f7aba7f08f520376c4bb6a20b9a981a581b7f2e385fa0ec9f789bb2d362/propcache-0.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfd3223c15bebe26518d58ccf9a39b93948d3dcb3e57a20480dfdd315356baff", size = 229103 }, + { url = "https://files.pythonhosted.org/packages/fe/d5/04ac9cd4e51a57a96f78795e03c5a0ddb8f23ec098b86f92de028d7f2a6b/propcache-0.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d71264a80f3fcf512eb4f18f59423fe82d6e346ee97b90625f283df56aee103f", size = 226607 }, + { url = "https://files.pythonhosted.org/packages/e3/f0/24060d959ea41d7a7cc7fdbf68b31852331aabda914a0c63bdb0e22e96d6/propcache-0.2.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e73091191e4280403bde6c9a52a6999d69cdfde498f1fdf629105247599b57ec", size = 221153 }, + { url = "https://files.pythonhosted.org/packages/77/a7/3ac76045a077b3e4de4859a0753010765e45749bdf53bd02bc4d372da1a0/propcache-0.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3935bfa5fede35fb202c4b569bb9c042f337ca4ff7bd540a0aa5e37131659348", size = 222151 }, + { url = "https://files.pythonhosted.org/packages/e7/af/5e29da6f80cebab3f5a4dcd2a3240e7f56f2c4abf51cbfcc99be34e17f0b/propcache-0.2.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f508b0491767bb1f2b87fdfacaba5f7eddc2f867740ec69ece6d1946d29029a6", size = 233812 }, + { url = "https://files.pythonhosted.org/packages/8c/89/ebe3ad52642cc5509eaa453e9f4b94b374d81bae3265c59d5c2d98efa1b4/propcache-0.2.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1672137af7c46662a1c2be1e8dc78cb6d224319aaa40271c9257d886be4363a6", size = 238829 }, + { url = "https://files.pythonhosted.org/packages/e9/2f/6b32f273fa02e978b7577159eae7471b3cfb88b48563b1c2578b2d7ca0bb/propcache-0.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b74c261802d3d2b85c9df2dfb2fa81b6f90deeef63c2db9f0e029a3cac50b518", size = 230704 }, + { url = "https://files.pythonhosted.org/packages/5c/2e/f40ae6ff5624a5f77edd7b8359b208b5455ea113f68309e2b00a2e1426b6/propcache-0.2.1-cp312-cp312-win32.whl", hash = "sha256:d09c333d36c1409d56a9d29b3a1b800a42c76a57a5a8907eacdbce3f18768246", size = 40050 }, + { url = "https://files.pythonhosted.org/packages/3b/77/a92c3ef994e47180862b9d7d11e37624fb1c00a16d61faf55115d970628b/propcache-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:c214999039d4f2a5b2073ac506bba279945233da8c786e490d411dfc30f855c1", size = 44117 }, + { url = "https://files.pythonhosted.org/packages/0f/2a/329e0547cf2def8857157f9477669043e75524cc3e6251cef332b3ff256f/propcache-0.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aca405706e0b0a44cc6bfd41fbe89919a6a56999157f6de7e182a990c36e37bc", size = 77002 }, + { url = "https://files.pythonhosted.org/packages/12/2d/c4df5415e2382f840dc2ecbca0eeb2293024bc28e57a80392f2012b4708c/propcache-0.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:12d1083f001ace206fe34b6bdc2cb94be66d57a850866f0b908972f90996b3e9", size = 44639 }, + { url = "https://files.pythonhosted.org/packages/d0/5a/21aaa4ea2f326edaa4e240959ac8b8386ea31dedfdaa636a3544d9e7a408/propcache-0.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d93f3307ad32a27bda2e88ec81134b823c240aa3abb55821a8da553eed8d9439", size = 44049 }, + { url = "https://files.pythonhosted.org/packages/4e/3e/021b6cd86c0acc90d74784ccbb66808b0bd36067a1bf3e2deb0f3845f618/propcache-0.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba278acf14471d36316159c94a802933d10b6a1e117b8554fe0d0d9b75c9d536", size = 224819 }, + { url = "https://files.pythonhosted.org/packages/3c/57/c2fdeed1b3b8918b1770a133ba5c43ad3d78e18285b0c06364861ef5cc38/propcache-0.2.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4e6281aedfca15301c41f74d7005e6e3f4ca143584ba696ac69df4f02f40d629", size = 229625 }, + { url = "https://files.pythonhosted.org/packages/9d/81/70d4ff57bf2877b5780b466471bebf5892f851a7e2ca0ae7ffd728220281/propcache-0.2.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5b750a8e5a1262434fb1517ddf64b5de58327f1adc3524a5e44c2ca43305eb0b", size = 232934 }, + { url = "https://files.pythonhosted.org/packages/3c/b9/bb51ea95d73b3fb4100cb95adbd4e1acaf2cbb1fd1083f5468eeb4a099a8/propcache-0.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf72af5e0fb40e9babf594308911436c8efde3cb5e75b6f206c34ad18be5c052", size = 227361 }, + { url = "https://files.pythonhosted.org/packages/f1/20/3c6d696cd6fd70b29445960cc803b1851a1131e7a2e4ee261ee48e002bcd/propcache-0.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2d0a12018b04f4cb820781ec0dffb5f7c7c1d2a5cd22bff7fb055a2cb19ebce", size = 213904 }, + { url = "https://files.pythonhosted.org/packages/a1/cb/1593bfc5ac6d40c010fa823f128056d6bc25b667f5393781e37d62f12005/propcache-0.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e800776a79a5aabdb17dcc2346a7d66d0777e942e4cd251defeb084762ecd17d", size = 212632 }, + { url = "https://files.pythonhosted.org/packages/6d/5c/e95617e222be14a34c709442a0ec179f3207f8a2b900273720501a70ec5e/propcache-0.2.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:4160d9283bd382fa6c0c2b5e017acc95bc183570cd70968b9202ad6d8fc48dce", size = 207897 }, + { url = "https://files.pythonhosted.org/packages/8e/3b/56c5ab3dc00f6375fbcdeefdede5adf9bee94f1fab04adc8db118f0f9e25/propcache-0.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:30b43e74f1359353341a7adb783c8f1b1c676367b011709f466f42fda2045e95", size = 208118 }, + { url = "https://files.pythonhosted.org/packages/86/25/d7ef738323fbc6ebcbce33eb2a19c5e07a89a3df2fded206065bd5e868a9/propcache-0.2.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:58791550b27d5488b1bb52bc96328456095d96206a250d28d874fafe11b3dfaf", size = 217851 }, + { url = "https://files.pythonhosted.org/packages/b3/77/763e6cef1852cf1ba740590364ec50309b89d1c818e3256d3929eb92fabf/propcache-0.2.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:0f022d381747f0dfe27e99d928e31bc51a18b65bb9e481ae0af1380a6725dd1f", size = 222630 }, + { url = "https://files.pythonhosted.org/packages/4f/e9/0f86be33602089c701696fbed8d8c4c07b6ee9605c5b7536fd27ed540c5b/propcache-0.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:297878dc9d0a334358f9b608b56d02e72899f3b8499fc6044133f0d319e2ec30", size = 216269 }, + { url = "https://files.pythonhosted.org/packages/cc/02/5ac83217d522394b6a2e81a2e888167e7ca629ef6569a3f09852d6dcb01a/propcache-0.2.1-cp313-cp313-win32.whl", hash = "sha256:ddfab44e4489bd79bda09d84c430677fc7f0a4939a73d2bba3073036f487a0a6", size = 39472 }, + { url = "https://files.pythonhosted.org/packages/f4/33/d6f5420252a36034bc8a3a01171bc55b4bff5df50d1c63d9caa50693662f/propcache-0.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:556fc6c10989f19a179e4321e5d678db8eb2924131e64652a51fe83e4c3db0e1", size = 43363 }, + { url = "https://files.pythonhosted.org/packages/41/b6/c5319caea262f4821995dca2107483b94a3345d4607ad797c76cb9c36bcc/propcache-0.2.1-py3-none-any.whl", hash = "sha256:52277518d6aae65536e9cea52d4e7fd2f7a66f4aa2d30ed3f2fcea620ace3c54", size = 11818 }, +] + +[[package]] +name = "psutil" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/10/2a30b13c61e7cf937f4adf90710776b7918ed0a9c434e2c38224732af310/psutil-6.1.0.tar.gz", hash = "sha256:353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a", size = 508565 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/9e/8be43078a171381953cfee33c07c0d628594b5dbfc5157847b85022c2c1b/psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688", size = 247762 }, + { url = "https://files.pythonhosted.org/packages/1d/cb/313e80644ea407f04f6602a9e23096540d9dc1878755f3952ea8d3d104be/psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e", size = 248777 }, + { url = "https://files.pythonhosted.org/packages/65/8e/bcbe2025c587b5d703369b6a75b65d41d1367553da6e3f788aff91eaf5bd/psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38", size = 284259 }, + { url = "https://files.pythonhosted.org/packages/58/4d/8245e6f76a93c98aab285a43ea71ff1b171bcd90c9d238bf81f7021fb233/psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b", size = 287255 }, + { url = "https://files.pythonhosted.org/packages/27/c2/d034856ac47e3b3cdfa9720d0e113902e615f4190d5d1bdb8df4b2015fb2/psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a", size = 288804 }, + { url = "https://files.pythonhosted.org/packages/ea/55/5389ed243c878725feffc0d6a3bc5ef6764312b6fc7c081faaa2cfa7ef37/psutil-6.1.0-cp37-abi3-win32.whl", hash = "sha256:1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e", size = 250386 }, + { url = "https://files.pythonhosted.org/packages/11/91/87fa6f060e649b1e1a7b19a4f5869709fbf750b7c8c262ee776ec32f3028/psutil-6.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be", size = 254228 }, +] + +[[package]] +name = "psycopg2-binary" +version = "2.9.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/bdc8274dc0585090b4e3432267d7be4dfbfd8971c0fa59167c711105a6bf/psycopg2-binary-2.9.10.tar.gz", hash = "sha256:4b3df0e6990aa98acda57d983942eff13d824135fe2250e6522edaa782a06de2", size = 385764 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/7d/465cc9795cf76f6d329efdafca74693714556ea3891813701ac1fee87545/psycopg2_binary-2.9.10-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:880845dfe1f85d9d5f7c412efea7a08946a46894537e4e5d091732eb1d34d9a0", size = 3044771 }, + { url = "https://files.pythonhosted.org/packages/8b/31/6d225b7b641a1a2148e3ed65e1aa74fc86ba3fee850545e27be9e1de893d/psycopg2_binary-2.9.10-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9440fa522a79356aaa482aa4ba500b65f28e5d0e63b801abf6aa152a29bd842a", size = 3275336 }, + { url = "https://files.pythonhosted.org/packages/30/b7/a68c2b4bff1cbb1728e3ec864b2d92327c77ad52edcd27922535a8366f68/psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3923c1d9870c49a2d44f795df0c889a22380d36ef92440ff618ec315757e539", size = 2851637 }, + { url = "https://files.pythonhosted.org/packages/0b/b1/cfedc0e0e6f9ad61f8657fd173b2f831ce261c02a08c0b09c652b127d813/psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7b2c956c028ea5de47ff3a8d6b3cc3330ab45cf0b7c3da35a2d6ff8420896526", size = 3082097 }, + { url = "https://files.pythonhosted.org/packages/18/ed/0a8e4153c9b769f59c02fb5e7914f20f0b2483a19dae7bf2db54b743d0d0/psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f758ed67cab30b9a8d2833609513ce4d3bd027641673d4ebc9c067e4d208eec1", size = 3264776 }, + { url = "https://files.pythonhosted.org/packages/10/db/d09da68c6a0cdab41566b74e0a6068a425f077169bed0946559b7348ebe9/psycopg2_binary-2.9.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cd9b4f2cfab88ed4a9106192de509464b75a906462fb846b936eabe45c2063e", size = 3020968 }, + { url = "https://files.pythonhosted.org/packages/94/28/4d6f8c255f0dfffb410db2b3f9ac5218d959a66c715c34cac31081e19b95/psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dc08420625b5a20b53551c50deae6e231e6371194fa0651dbe0fb206452ae1f", size = 2872334 }, + { url = "https://files.pythonhosted.org/packages/05/f7/20d7bf796593c4fea95e12119d6cc384ff1f6141a24fbb7df5a668d29d29/psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7cd730dfa7c36dbe8724426bf5612798734bff2d3c3857f36f2733f5bfc7c00", size = 2822722 }, + { url = "https://files.pythonhosted.org/packages/4d/e4/0c407ae919ef626dbdb32835a03b6737013c3cc7240169843965cada2bdf/psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:155e69561d54d02b3c3209545fb08938e27889ff5a10c19de8d23eb5a41be8a5", size = 2920132 }, + { url = "https://files.pythonhosted.org/packages/2d/70/aa69c9f69cf09a01da224909ff6ce8b68faeef476f00f7ec377e8f03be70/psycopg2_binary-2.9.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3cc28a6fd5a4a26224007712e79b81dbaee2ffb90ff406256158ec4d7b52b47", size = 2959312 }, + { url = "https://files.pythonhosted.org/packages/d3/bd/213e59854fafe87ba47814bf413ace0dcee33a89c8c8c814faca6bc7cf3c/psycopg2_binary-2.9.10-cp312-cp312-win32.whl", hash = "sha256:ec8a77f521a17506a24a5f626cb2aee7850f9b69a0afe704586f63a464f3cd64", size = 1025191 }, + { url = "https://files.pythonhosted.org/packages/92/29/06261ea000e2dc1e22907dbbc483a1093665509ea586b29b8986a0e56733/psycopg2_binary-2.9.10-cp312-cp312-win_amd64.whl", hash = "sha256:18c5ee682b9c6dd3696dad6e54cc7ff3a1a9020df6a5c0f861ef8bfd338c3ca0", size = 1164031 }, + { url = "https://files.pythonhosted.org/packages/3e/30/d41d3ba765609c0763505d565c4d12d8f3c79793f0d0f044ff5a28bf395b/psycopg2_binary-2.9.10-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:26540d4a9a4e2b096f1ff9cce51253d0504dca5a85872c7f7be23be5a53eb18d", size = 3044699 }, + { url = "https://files.pythonhosted.org/packages/35/44/257ddadec7ef04536ba71af6bc6a75ec05c5343004a7ec93006bee66c0bc/psycopg2_binary-2.9.10-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e217ce4d37667df0bc1c397fdcd8de5e81018ef305aed9415c3b093faaeb10fb", size = 3275245 }, + { url = "https://files.pythonhosted.org/packages/1b/11/48ea1cd11de67f9efd7262085588790a95d9dfcd9b8a687d46caf7305c1a/psycopg2_binary-2.9.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:245159e7ab20a71d989da00f280ca57da7641fa2cdcf71749c193cea540a74f7", size = 2851631 }, + { url = "https://files.pythonhosted.org/packages/62/e0/62ce5ee650e6c86719d621a761fe4bc846ab9eff8c1f12b1ed5741bf1c9b/psycopg2_binary-2.9.10-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c4ded1a24b20021ebe677b7b08ad10bf09aac197d6943bfe6fec70ac4e4690d", size = 3082140 }, + { url = "https://files.pythonhosted.org/packages/27/ce/63f946c098611f7be234c0dd7cb1ad68b0b5744d34f68062bb3c5aa510c8/psycopg2_binary-2.9.10-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3abb691ff9e57d4a93355f60d4f4c1dd2d68326c968e7db17ea96df3c023ef73", size = 3264762 }, + { url = "https://files.pythonhosted.org/packages/43/25/c603cd81402e69edf7daa59b1602bd41eb9859e2824b8c0855d748366ac9/psycopg2_binary-2.9.10-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8608c078134f0b3cbd9f89b34bd60a943b23fd33cc5f065e8d5f840061bd0673", size = 3020967 }, + { url = "https://files.pythonhosted.org/packages/5f/d6/8708d8c6fca531057fa170cdde8df870e8b6a9b136e82b361c65e42b841e/psycopg2_binary-2.9.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:230eeae2d71594103cd5b93fd29d1ace6420d0b86f4778739cb1a5a32f607d1f", size = 2872326 }, + { url = "https://files.pythonhosted.org/packages/ce/ac/5b1ea50fc08a9df82de7e1771537557f07c2632231bbab652c7e22597908/psycopg2_binary-2.9.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bb89f0a835bcfc1d42ccd5f41f04870c1b936d8507c6df12b7737febc40f0909", size = 2822712 }, + { url = "https://files.pythonhosted.org/packages/c4/fc/504d4503b2abc4570fac3ca56eb8fed5e437bf9c9ef13f36b6621db8ef00/psycopg2_binary-2.9.10-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f0c2d907a1e102526dd2986df638343388b94c33860ff3bbe1384130828714b1", size = 2920155 }, + { url = "https://files.pythonhosted.org/packages/b2/d1/323581e9273ad2c0dbd1902f3fb50c441da86e894b6e25a73c3fda32c57e/psycopg2_binary-2.9.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f8157bed2f51db683f31306aa497311b560f2265998122abe1dce6428bd86567", size = 2959356 }, +] + +[[package]] +name = "pyarrow" +version = "18.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7f/7b/640785a9062bb00314caa8a387abce547d2a420cf09bd6c715fe659ccffb/pyarrow-18.1.0.tar.gz", hash = "sha256:9386d3ca9c145b5539a1cfc75df07757dff870168c959b473a0bccbc3abc8c73", size = 1118671 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/50/12829e7111b932581e51dda51d5cb39207a056c30fe31ef43f14c63c4d7e/pyarrow-18.1.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:9f3a76670b263dc41d0ae877f09124ab96ce10e4e48f3e3e4257273cee61ad0d", size = 29514620 }, + { url = "https://files.pythonhosted.org/packages/d1/41/468c944eab157702e96abab3d07b48b8424927d4933541ab43788bb6964d/pyarrow-18.1.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:da31fbca07c435be88a0c321402c4e31a2ba61593ec7473630769de8346b54ee", size = 30856494 }, + { url = "https://files.pythonhosted.org/packages/68/f9/29fb659b390312a7345aeb858a9d9c157552a8852522f2c8bad437c29c0a/pyarrow-18.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:543ad8459bc438efc46d29a759e1079436290bd583141384c6f7a1068ed6f992", size = 39203624 }, + { url = "https://files.pythonhosted.org/packages/6e/f6/19360dae44200e35753c5c2889dc478154cd78e61b1f738514c9f131734d/pyarrow-18.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0743e503c55be0fdb5c08e7d44853da27f19dc854531c0570f9f394ec9671d54", size = 40139341 }, + { url = "https://files.pythonhosted.org/packages/bb/e6/9b3afbbcf10cc724312e824af94a2e993d8ace22994d823f5c35324cebf5/pyarrow-18.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d4b3d2a34780645bed6414e22dda55a92e0fcd1b8a637fba86800ad737057e33", size = 38618629 }, + { url = "https://files.pythonhosted.org/packages/3a/2e/3b99f8a3d9e0ccae0e961978a0d0089b25fb46ebbcfb5ebae3cca179a5b3/pyarrow-18.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c52f81aa6f6575058d8e2c782bf79d4f9fdc89887f16825ec3a66607a5dd8e30", size = 40078661 }, + { url = "https://files.pythonhosted.org/packages/76/52/f8da04195000099d394012b8d42c503d7041b79f778d854f410e5f05049a/pyarrow-18.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:0ad4892617e1a6c7a551cfc827e072a633eaff758fa09f21c4ee548c30bcaf99", size = 25092330 }, + { url = "https://files.pythonhosted.org/packages/cb/87/aa4d249732edef6ad88899399047d7e49311a55749d3c373007d034ee471/pyarrow-18.1.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:84e314d22231357d473eabec709d0ba285fa706a72377f9cc8e1cb3c8013813b", size = 29497406 }, + { url = "https://files.pythonhosted.org/packages/3c/c7/ed6adb46d93a3177540e228b5ca30d99fc8ea3b13bdb88b6f8b6467e2cb7/pyarrow-18.1.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:f591704ac05dfd0477bb8f8e0bd4b5dc52c1cadf50503858dce3a15db6e46ff2", size = 30835095 }, + { url = "https://files.pythonhosted.org/packages/41/d7/ed85001edfb96200ff606943cff71d64f91926ab42828676c0fc0db98963/pyarrow-18.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acb7564204d3c40babf93a05624fc6a8ec1ab1def295c363afc40b0c9e66c191", size = 39194527 }, + { url = "https://files.pythonhosted.org/packages/59/16/35e28eab126342fa391593415d79477e89582de411bb95232f28b131a769/pyarrow-18.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74de649d1d2ccb778f7c3afff6085bd5092aed4c23df9feeb45dd6b16f3811aa", size = 40131443 }, + { url = "https://files.pythonhosted.org/packages/0c/95/e855880614c8da20f4cd74fa85d7268c725cf0013dc754048593a38896a0/pyarrow-18.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:f96bd502cb11abb08efea6dab09c003305161cb6c9eafd432e35e76e7fa9b90c", size = 38608750 }, + { url = "https://files.pythonhosted.org/packages/54/9d/f253554b1457d4fdb3831b7bd5f8f00f1795585a606eabf6fec0a58a9c38/pyarrow-18.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:36ac22d7782554754a3b50201b607d553a8d71b78cdf03b33c1125be4b52397c", size = 40066690 }, + { url = "https://files.pythonhosted.org/packages/2f/58/8912a2563e6b8273e8aa7b605a345bba5a06204549826f6493065575ebc0/pyarrow-18.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:25dbacab8c5952df0ca6ca0af28f50d45bd31c1ff6fcf79e2d120b4a65ee7181", size = 25081054 }, + { url = "https://files.pythonhosted.org/packages/82/f9/d06ddc06cab1ada0c2f2fd205ac8c25c2701182de1b9c4bf7a0a44844431/pyarrow-18.1.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6a276190309aba7bc9d5bd2933230458b3521a4317acfefe69a354f2fe59f2bc", size = 29525542 }, + { url = "https://files.pythonhosted.org/packages/ab/94/8917e3b961810587ecbdaa417f8ebac0abb25105ae667b7aa11c05876976/pyarrow-18.1.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ad514dbfcffe30124ce655d72771ae070f30bf850b48bc4d9d3b25993ee0e386", size = 30829412 }, + { url = "https://files.pythonhosted.org/packages/5e/e3/3b16c3190f3d71d3b10f6758d2d5f7779ef008c4fd367cedab3ed178a9f7/pyarrow-18.1.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aebc13a11ed3032d8dd6e7171eb6e86d40d67a5639d96c35142bd568b9299324", size = 39119106 }, + { url = "https://files.pythonhosted.org/packages/1d/d6/5d704b0d25c3c79532f8c0639f253ec2803b897100f64bcb3f53ced236e5/pyarrow-18.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d6cf5c05f3cee251d80e98726b5c7cc9f21bab9e9783673bac58e6dfab57ecc8", size = 40090940 }, + { url = "https://files.pythonhosted.org/packages/37/29/366bc7e588220d74ec00e497ac6710c2833c9176f0372fe0286929b2d64c/pyarrow-18.1.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:11b676cd410cf162d3f6a70b43fb9e1e40affbc542a1e9ed3681895f2962d3d9", size = 38548177 }, + { url = "https://files.pythonhosted.org/packages/c8/11/fabf6ecabb1fe5b7d96889228ca2a9158c4c3bb732e3b8ee3f7f6d40b703/pyarrow-18.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:b76130d835261b38f14fc41fdfb39ad8d672afb84c447126b84d5472244cfaba", size = 40043567 }, +] + +[[package]] +name = "pyclipper" +version = "1.3.0.post6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/b2/550fe500e49c464d73fabcb8cb04d47e4885d6ca4cfc1f5b0a125a95b19a/pyclipper-1.3.0.post6.tar.gz", hash = "sha256:42bff0102fa7a7f2abdd795a2594654d62b786d0c6cd67b72d469114fdeb608c", size = 165909 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c8/197d9a1d8354922d24d11d22fb2e0cc1ebc182f8a30496b7ddbe89467ce1/pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:6363b9d79ba1b5d8f32d1623e797c1e9f994600943402e68d5266067bdde173e", size = 270487 }, + { url = "https://files.pythonhosted.org/packages/8e/8e/eb14eadf054494ad81446e21c4ea163b941747610b0eb9051644395f567e/pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:32cd7fb9c1c893eb87f82a072dbb5e26224ea7cebbad9dc306d67e1ac62dd229", size = 143469 }, + { url = "https://files.pythonhosted.org/packages/cf/e5/6c4a8df6e904c133bb4c5309d211d31c751db60cbd36a7250c02b05494a1/pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3aab10e3c10ed8fa60c608fb87c040089b83325c937f98f06450cf9fcfdaf1d", size = 944206 }, + { url = "https://files.pythonhosted.org/packages/76/65/cb014acc41cd5bf6bbfa4671c7faffffb9cee01706642c2dec70c5209ac8/pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58eae2ff92a8cae1331568df076c4c5775bf946afab0068b217f0cf8e188eb3c", size = 963797 }, + { url = "https://files.pythonhosted.org/packages/80/ec/b40cd81ab7598984167508a5369a2fa31a09fe3b3e3d0b73aa50e06d4b3f/pyclipper-1.3.0.post6-cp312-cp312-win32.whl", hash = "sha256:793b0aa54b914257aa7dc76b793dd4dcfb3c84011d48df7e41ba02b571616eaf", size = 99456 }, + { url = "https://files.pythonhosted.org/packages/24/3a/7d6292e3c94fb6b872d8d7e80d909dc527ee6b0af73b753c63fdde65a7da/pyclipper-1.3.0.post6-cp312-cp312-win_amd64.whl", hash = "sha256:d3f9da96f83b8892504923beb21a481cd4516c19be1d39eb57a92ef1c9a29548", size = 110278 }, + { url = "https://files.pythonhosted.org/packages/8c/b3/75232906bd13f869600d23bdb8fe6903cc899fa7e96981ae4c9b7d9c409e/pyclipper-1.3.0.post6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f129284d2c7bcd213d11c0f35e1ae506a1144ce4954e9d1734d63b120b0a1b58", size = 268254 }, + { url = "https://files.pythonhosted.org/packages/0b/db/35843050a3dd7586781497a21ca6c8d48111afb66061cb40c3d3c288596d/pyclipper-1.3.0.post6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:188fbfd1d30d02247f92c25ce856f5f3c75d841251f43367dbcf10935bc48f38", size = 142204 }, + { url = "https://files.pythonhosted.org/packages/7c/d7/1faa0ff35caa02cb32cb0583688cded3f38788f33e02bfe6461fbcc1bee1/pyclipper-1.3.0.post6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6d129d0c2587f2f5904d201a4021f859afbb45fada4261c9fdedb2205b09d23", size = 943835 }, + { url = "https://files.pythonhosted.org/packages/31/10/c0bf140bee2844e2c0617fdcc8a4e8daf98e71710046b06034e6f1963404/pyclipper-1.3.0.post6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c9c80b5c46eef38ba3f12dd818dc87f5f2a0853ba914b6f91b133232315f526", size = 962510 }, + { url = "https://files.pythonhosted.org/packages/85/6f/8c6afc49b51b1bf16d5903ecd5aee657cf88f52c83cb5fabf771deeba728/pyclipper-1.3.0.post6-cp313-cp313-win32.whl", hash = "sha256:b15113ec4fc423b58e9ae80aa95cf5a0802f02d8f02a98a46af3d7d66ff0cc0e", size = 98836 }, + { url = "https://files.pythonhosted.org/packages/d5/19/9ff4551b42f2068686c50c0d199072fa67aee57fc5cf86770cacf71efda3/pyclipper-1.3.0.post6-cp313-cp313-win_amd64.whl", hash = "sha256:e5ff68fa770ac654c7974fc78792978796f068bd274e95930c0691c31e192889", size = 109672 }, +] + +[[package]] +name = "pydantic" +version = "2.10.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/45/0f/27908242621b14e649a84e62b133de45f84c255eecb350ab02979844a788/pydantic-2.10.3.tar.gz", hash = "sha256:cb5ac360ce894ceacd69c403187900a02c4b20b693a9dd1d643e1effab9eadf9", size = 786486 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/51/72c18c55cf2f46ff4f91ebcc8f75aa30f7305f3d726be3f4ebffb4ae972b/pydantic-2.10.3-py3-none-any.whl", hash = "sha256:be04d85bbc7b65651c5f8e6b9976ed9c6f41782a55524cef079a34a0bb82144d", size = 456997 }, +] + +[[package]] +name = "pydantic-core" +version = "2.27.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/9f/7de1f19b6aea45aeb441838782d68352e71bfa98ee6fa048d5041991b33e/pydantic_core-2.27.1.tar.gz", hash = "sha256:62a763352879b84aa31058fc931884055fd75089cccbd9d58bb6afd01141b235", size = 412785 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/51/2e9b3788feb2aebff2aa9dfbf060ec739b38c05c46847601134cc1fed2ea/pydantic_core-2.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9cbd94fc661d2bab2bc702cddd2d3370bbdcc4cd0f8f57488a81bcce90c7a54f", size = 1895239 }, + { url = "https://files.pythonhosted.org/packages/7b/9e/f8063952e4a7d0127f5d1181addef9377505dcce3be224263b25c4f0bfd9/pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f8c4718cd44ec1580e180cb739713ecda2bdee1341084c1467802a417fe0f02", size = 1805070 }, + { url = "https://files.pythonhosted.org/packages/2c/9d/e1d6c4561d262b52e41b17a7ef8301e2ba80b61e32e94520271029feb5d8/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15aae984e46de8d376df515f00450d1522077254ef6b7ce189b38ecee7c9677c", size = 1828096 }, + { url = "https://files.pythonhosted.org/packages/be/65/80ff46de4266560baa4332ae3181fffc4488ea7d37282da1a62d10ab89a4/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ba5e3963344ff25fc8c40da90f44b0afca8cfd89d12964feb79ac1411a260ac", size = 1857708 }, + { url = "https://files.pythonhosted.org/packages/d5/ca/3370074ad758b04d9562b12ecdb088597f4d9d13893a48a583fb47682cdf/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:992cea5f4f3b29d6b4f7f1726ed8ee46c8331c6b4eed6db5b40134c6fe1768bb", size = 2037751 }, + { url = "https://files.pythonhosted.org/packages/b1/e2/4ab72d93367194317b99d051947c071aef6e3eb95f7553eaa4208ecf9ba4/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0325336f348dbee6550d129b1627cb8f5351a9dc91aad141ffb96d4937bd9529", size = 2733863 }, + { url = "https://files.pythonhosted.org/packages/8a/c6/8ae0831bf77f356bb73127ce5a95fe115b10f820ea480abbd72d3cc7ccf3/pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7597c07fbd11515f654d6ece3d0e4e5093edc30a436c63142d9a4b8e22f19c35", size = 2161161 }, + { url = "https://files.pythonhosted.org/packages/f1/f4/b2fe73241da2429400fc27ddeaa43e35562f96cf5b67499b2de52b528cad/pydantic_core-2.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3bbd5d8cc692616d5ef6fbbbd50dbec142c7e6ad9beb66b78a96e9c16729b089", size = 1993294 }, + { url = "https://files.pythonhosted.org/packages/77/29/4bb008823a7f4cc05828198153f9753b3bd4c104d93b8e0b1bfe4e187540/pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:dc61505e73298a84a2f317255fcc72b710b72980f3a1f670447a21efc88f8381", size = 2001468 }, + { url = "https://files.pythonhosted.org/packages/f2/a9/0eaceeba41b9fad851a4107e0cf999a34ae8f0d0d1f829e2574f3d8897b0/pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:e1f735dc43da318cad19b4173dd1ffce1d84aafd6c9b782b3abc04a0d5a6f5bb", size = 2091413 }, + { url = "https://files.pythonhosted.org/packages/d8/36/eb8697729725bc610fd73940f0d860d791dc2ad557faaefcbb3edbd2b349/pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f4e5658dbffe8843a0f12366a4c2d1c316dbe09bb4dfbdc9d2d9cd6031de8aae", size = 2154735 }, + { url = "https://files.pythonhosted.org/packages/52/e5/4f0fbd5c5995cc70d3afed1b5c754055bb67908f55b5cb8000f7112749bf/pydantic_core-2.27.1-cp312-none-win32.whl", hash = "sha256:672ebbe820bb37988c4d136eca2652ee114992d5d41c7e4858cdd90ea94ffe5c", size = 1833633 }, + { url = "https://files.pythonhosted.org/packages/ee/f2/c61486eee27cae5ac781305658779b4a6b45f9cc9d02c90cb21b940e82cc/pydantic_core-2.27.1-cp312-none-win_amd64.whl", hash = "sha256:66ff044fd0bb1768688aecbe28b6190f6e799349221fb0de0e6f4048eca14c16", size = 1986973 }, + { url = "https://files.pythonhosted.org/packages/df/a6/e3f12ff25f250b02f7c51be89a294689d175ac76e1096c32bf278f29ca1e/pydantic_core-2.27.1-cp312-none-win_arm64.whl", hash = "sha256:9a3b0793b1bbfd4146304e23d90045f2a9b5fd5823aa682665fbdaf2a6c28f3e", size = 1883215 }, + { url = "https://files.pythonhosted.org/packages/0f/d6/91cb99a3c59d7b072bded9959fbeab0a9613d5a4935773c0801f1764c156/pydantic_core-2.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f216dbce0e60e4d03e0c4353c7023b202d95cbaeff12e5fd2e82ea0a66905073", size = 1895033 }, + { url = "https://files.pythonhosted.org/packages/07/42/d35033f81a28b27dedcade9e967e8a40981a765795c9ebae2045bcef05d3/pydantic_core-2.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a2e02889071850bbfd36b56fd6bc98945e23670773bc7a76657e90e6b6603c08", size = 1807542 }, + { url = "https://files.pythonhosted.org/packages/41/c2/491b59e222ec7e72236e512108ecad532c7f4391a14e971c963f624f7569/pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42b0e23f119b2b456d07ca91b307ae167cc3f6c846a7b169fca5326e32fdc6cf", size = 1827854 }, + { url = "https://files.pythonhosted.org/packages/e3/f3/363652651779113189cefdbbb619b7b07b7a67ebb6840325117cc8cc3460/pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:764be71193f87d460a03f1f7385a82e226639732214b402f9aa61f0d025f0737", size = 1857389 }, + { url = "https://files.pythonhosted.org/packages/5f/97/be804aed6b479af5a945daec7538d8bf358d668bdadde4c7888a2506bdfb/pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c00666a3bd2f84920a4e94434f5974d7bbc57e461318d6bb34ce9cdbbc1f6b2", size = 2037934 }, + { url = "https://files.pythonhosted.org/packages/42/01/295f0bd4abf58902917e342ddfe5f76cf66ffabfc57c2e23c7681a1a1197/pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ccaa88b24eebc0f849ce0a4d09e8a408ec5a94afff395eb69baf868f5183107", size = 2735176 }, + { url = "https://files.pythonhosted.org/packages/9d/a0/cd8e9c940ead89cc37812a1a9f310fef59ba2f0b22b4e417d84ab09fa970/pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c65af9088ac534313e1963443d0ec360bb2b9cba6c2909478d22c2e363d98a51", size = 2160720 }, + { url = "https://files.pythonhosted.org/packages/73/ae/9d0980e286627e0aeca4c352a60bd760331622c12d576e5ea4441ac7e15e/pydantic_core-2.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:206b5cf6f0c513baffaeae7bd817717140770c74528f3e4c3e1cec7871ddd61a", size = 1992972 }, + { url = "https://files.pythonhosted.org/packages/bf/ba/ae4480bc0292d54b85cfb954e9d6bd226982949f8316338677d56541b85f/pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:062f60e512fc7fff8b8a9d680ff0ddaaef0193dba9fa83e679c0c5f5fbd018bc", size = 2001477 }, + { url = "https://files.pythonhosted.org/packages/55/b7/e26adf48c2f943092ce54ae14c3c08d0d221ad34ce80b18a50de8ed2cba8/pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:a0697803ed7d4af5e4c1adf1670af078f8fcab7a86350e969f454daf598c4960", size = 2091186 }, + { url = "https://files.pythonhosted.org/packages/ba/cc/8491fff5b608b3862eb36e7d29d36a1af1c945463ca4c5040bf46cc73f40/pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:58ca98a950171f3151c603aeea9303ef6c235f692fe555e883591103da709b23", size = 2154429 }, + { url = "https://files.pythonhosted.org/packages/78/d8/c080592d80edd3441ab7f88f865f51dae94a157fc64283c680e9f32cf6da/pydantic_core-2.27.1-cp313-none-win32.whl", hash = "sha256:8065914ff79f7eab1599bd80406681f0ad08f8e47c880f17b416c9f8f7a26d05", size = 1833713 }, + { url = "https://files.pythonhosted.org/packages/83/84/5ab82a9ee2538ac95a66e51f6838d6aba6e0a03a42aa185ad2fe404a4e8f/pydantic_core-2.27.1-cp313-none-win_amd64.whl", hash = "sha256:ba630d5e3db74c79300d9a5bdaaf6200172b107f263c98a0539eeecb857b2337", size = 1987897 }, + { url = "https://files.pythonhosted.org/packages/df/c3/b15fb833926d91d982fde29c0624c9f225da743c7af801dace0d4e187e71/pydantic_core-2.27.1-cp313-none-win_arm64.whl", hash = "sha256:45cf8588c066860b623cd11c4ba687f8d7175d5f7ef65f7129df8a394c502de5", size = 1882983 }, +] + +[[package]] +name = "pygments" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", size = 4891905 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", size = 1205513 }, +] + +[[package]] +name = "pytesseract" +version = "0.3.13" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/a6/7d679b83c285974a7cb94d739b461fa7e7a9b17a3abfd7bf6cbc5c2394b0/pytesseract-0.3.13.tar.gz", hash = "sha256:4bf5f880c99406f52a3cfc2633e42d9dc67615e69d8a509d74867d3baddb5db9", size = 17689 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/33/8312d7ce74670c9d39a532b2c246a853861120486be9443eebf048043637/pytesseract-0.3.13-py3-none-any.whl", hash = "sha256:7a99c6c2ac598360693d83a416e36e0b33a67638bb9d77fdcac094a3589d4b34", size = 14705 }, +] + +[[package]] +name = "python-bidi" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/b5/c1684fb8120ad868b43e4b037ac83aafaa70724cdb078d066bae836c31f6/python_bidi-0.6.3.tar.gz", hash = "sha256:e12114969001a328aea859f79efc30ab9c15241befb86e07029d8961d97fae36", size = 45054 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/15/4f316e1b463ea71b4533e904548f47000f9e20ad394b3e8c83ac65638534/python_bidi-0.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4bdc9dc1143c558ca6931d6712339a30470959f2b7eecb3d0687db7075c20a87", size = 257039 }, + { url = "https://files.pythonhosted.org/packages/ad/2a/9b54acafa641c360ba3a632726046a8da38da1f3ed7b816ae6eec748ca95/python_bidi-0.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0775499b8037103278f05b2bf92d25bf04f40a9f77884ec3d42b01a1e52a40fe", size = 252791 }, + { url = "https://files.pythonhosted.org/packages/ca/b2/55f4d18760dac53e542817b3a2e11e3d5ae631678f2c2248c6f1e67336ea/python_bidi-0.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb3091aa5efbfc4da6fd52a2fccbf7853c6dc253ddaf9a189bcf3c4345865aa9", size = 294297 }, + { url = "https://files.pythonhosted.org/packages/63/7b/d1ca351cdab44300296a4b758a370bf923666deaa4d19819a7fc4478dc52/python_bidi-0.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c75a9b68b3f5a8da9a33fe37607d9b267a8a3c5806d283a4a47365256773dd1e", size = 297650 }, + { url = "https://files.pythonhosted.org/packages/e4/9e/bcb93f0e30abbd9fbbda736402e3ee86566b1253ea57d1e9b465eb4b62a0/python_bidi-0.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:208e09819ee0485c2ed4dc1932c39fc073dac3f2cb70b6d2ae0b7296e86831e6", size = 323959 }, + { url = "https://files.pythonhosted.org/packages/26/dd/e795e1186ba6b9e3ebb9bc316c6572036e59d0c2841a5e182403d483eb57/python_bidi-0.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e17b67d86cd38f2bebc4a46090f83cabb0d1da3a3c920c68efe8093ae1a8d0d1", size = 327207 }, + { url = "https://files.pythonhosted.org/packages/c9/27/fc5777273bcb3de7b82524852995edd67dc9948ed916a3f9236714628ae3/python_bidi-0.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:933a17938f767fa64a8365732eba787a81c26214d89e1b3abe87912325ba26a9", size = 286371 }, + { url = "https://files.pythonhosted.org/packages/e9/11/90b4072461759074564a29d05a83128f02214fea1012ca0984d3a5a7fdbb/python_bidi-0.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:772efb3e0ef17396bfd9d47da4805c74ed6c04f27cac08d7757f76602837fb9d", size = 300797 }, + { url = "https://files.pythonhosted.org/packages/61/2c/d50a50adf51b6c53022b9ad247d65cad50acde94f877fbab49a8854ccaae/python_bidi-0.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9a99114f33f8c0273a61b4afe7d4d715e098318ee4e5ce8f6bb5da8dcd3f95c7", size = 468349 }, + { url = "https://files.pythonhosted.org/packages/68/46/a9d285552961670aedc0bbac403defa7c9c4b17ab6957ef0b7db05d12eec/python_bidi-0.6.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b30e620d39e85a30bb42f460fd8b5274caf261517edeb853b975d9ea1939b6bd", size = 549521 }, + { url = "https://files.pythonhosted.org/packages/36/3a/5b6b6b73a210cc99b1d1ea697741fc4fc1853aa788b3db1737bfdcaabc75/python_bidi-0.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bee94e3152a6c9ba731e086c9cc6203904290506ba52c505a2e59abab481eb13", size = 471509 }, + { url = "https://files.pythonhosted.org/packages/dd/5a/d3d0588caeb041bbf85b421b30a7a9893057c72fcddcaaf2d54289123487/python_bidi-0.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:926164ec594e9ea9a64faf54273c711d5e3233bcc6ef8966c6eeaddfb3b3075f", size = 451688 }, + { url = "https://files.pythonhosted.org/packages/1d/1f/0539881d381dda2a281056ccfb55905439bad86cfb2787792065a2d8d08b/python_bidi-0.6.3-cp312-none-win32.whl", hash = "sha256:cea395a7daee14c7d50a7e20890d12b9ff1938d81b23eb564f1707a175c37202", size = 151600 }, + { url = "https://files.pythonhosted.org/packages/aa/e7/b4f6a71a7e7aec0e17c36bfca2ff5d962b86b0e04e278de6fc6c0cd6d643/python_bidi-0.6.3-cp312-none-win_amd64.whl", hash = "sha256:350e6c76f942465871f2b473a2076f5002f1df06e4c7abee3029ccca5f006786", size = 156933 }, + { url = "https://files.pythonhosted.org/packages/61/77/957be8fa4f681c31af11323376ecd2dcac6cfbadb12e8555e2b826cf6653/python_bidi-0.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:617d4391b19969de725922a256599e8218fc9c1ef0ff85884f1698fff482a977", size = 256754 }, + { url = "https://files.pythonhosted.org/packages/39/7e/b66b86a1aca9725366b6f4fd549ff36162de7acd53ba13de7704cbc56968/python_bidi-0.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:81f418d54948542b21c03cd8ce622a480ead85fc53175a124c4562bdf55cec49", size = 252526 }, + { url = "https://files.pythonhosted.org/packages/cb/c9/149957c1d75156bf617fd9824b92b7468926a4ba90e74cf1254acffb31de/python_bidi-0.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0999b77af58396cfd789c8d068bac78d2d51363265aaf1369622099be9e0eb32", size = 294071 }, + { url = "https://files.pythonhosted.org/packages/63/50/29ba7d99cb23138da8ce070a677cc1eaaa1545f18cb54350d702366e94f3/python_bidi-0.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f5a0e852e8451147d96876f8233a9db6ed28c914d9767a6696cbc899e7df00c2", size = 297250 }, + { url = "https://files.pythonhosted.org/packages/c5/4b/793e5fe37dc59ec9c48349bfa6373aa771a02dc2270b14a90fa6d14a7920/python_bidi-0.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:905e212b12c9edfaa3a916a3acd11426b89507ed0f31641257ad586467602e8d", size = 323242 }, + { url = "https://files.pythonhosted.org/packages/b8/ae/f0be940ac876ef120e26a40b3614996e2ae55c8abdd0e98e7e102207309a/python_bidi-0.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:144adab8dc3a8560e294461114ce6dafec1a986cde6297994c1d31b3252f3298", size = 326738 }, + { url = "https://files.pythonhosted.org/packages/9a/1f/7757dacc33e95e38fd47f02dcb6d4f67ffce0ea432ae7299568129aa55a8/python_bidi-0.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abdbd5c265d64251798243d97228bb78441a1320fe3cf51c9a31191c56407839", size = 286038 }, + { url = "https://files.pythonhosted.org/packages/7a/b0/be55c786d54e8d37e38ca5199727619d616312daeefa8a0be21ef1366412/python_bidi-0.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:65f824a878a593121570ce3da847d3b9ac50521782c433996d7f81f770d3ed00", size = 300370 }, + { url = "https://files.pythonhosted.org/packages/e1/c8/3d89cef5bd8ebe6fa262f5035763ef99878a7634455a6b0eeb2abf0f1c0d/python_bidi-0.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c7dcbc7eb70a0c7c66ed5219213ee2afcc815988cb9e4b134631579c4ae46980", size = 467798 }, + { url = "https://files.pythonhosted.org/packages/44/52/9b7ee589eae15637722e17b7fcfa7f1ad7ead4b623c46fed23eaa687144c/python_bidi-0.6.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ccbf53bc71a0a1b7f77524d1c2e51b245ae23a4f16afb80728071e21c187a768", size = 549247 }, + { url = "https://files.pythonhosted.org/packages/c8/08/6cf732e0945e1aa03e189c61288f1d67acd051ffbaae84cb85e329d22d33/python_bidi-0.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:702527506ca97bf549710ce03d89a2577ebe35e34c42eaecfbacb0862ba06dc6", size = 471227 }, + { url = "https://files.pythonhosted.org/packages/06/b6/929538d89494ae493bd67ed671e9a01c88b9054a5dc85dd4f400641cbbe7/python_bidi-0.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1563a8d9cfaeeeb5b4fc806f52a500b19893c63652bbd497dd6ed9def7b9ee8e", size = 451042 }, + { url = "https://files.pythonhosted.org/packages/af/a4/d5e062e07fbf070c8982468280bae6418c513628df7881fdf46a5a02fba4/python_bidi-0.6.3-cp313-none-win32.whl", hash = "sha256:f9b8e024eeaddecb4ca189e3199181985fab20c224db9a1f08db48b905c9905a", size = 151261 }, + { url = "https://files.pythonhosted.org/packages/b3/54/0b698ac336192ef5ae5c055ff60fa7d15f2411ce107129d3703323196ef2/python_bidi-0.6.3-cp313-none-win_amd64.whl", hash = "sha256:36b3fb05ef990613a81a23822246eaf6eef29af5182f8d8cdd174be13c92d1cc", size = 156666 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-dotenv" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 }, +] + +[[package]] +name = "python-multipart" +version = "0.0.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 }, +] + +[[package]] +name = "pytorch-lightning" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fsspec", extra = ["http"] }, + { name = "lightning-utilities" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "torch" }, + { name = "torchmetrics" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/f0/3207bd5019c43899efbb5444da263577497a5c4dc82719633a3bf63d8f45/pytorch-lightning-2.4.0.tar.gz", hash = "sha256:6aa897fd9d6dfa7b7b49f37c2f04e13592861831d08deae584dfda423fdb71c8", size = 625320 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/d2/ecd65ff1e0b1ca79f9785dd65d5ced7ec2643a828068aaa24e47e4c84a14/pytorch_lightning-2.4.0-py3-none-any.whl", hash = "sha256:9ac7935229ac022ef06994c928217ed37f525ac6700f7d4fc57009624570e655", size = 815151 }, +] + +[[package]] +name = "pytz" +version = "2024.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, +] + +[[package]] +name = "regex" +version = "2024.11.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/5f/bd69653fbfb76cf8604468d3b4ec4c403197144c7bfe0e6a5fc9e02a07cb/regex-2024.11.6.tar.gz", hash = "sha256:7ab159b063c52a0333c884e4679f8d7a85112ee3078fe3d9004b2dd875585519", size = 399494 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/30/9a87ce8336b172cc232a0db89a3af97929d06c11ceaa19d97d84fa90a8f8/regex-2024.11.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:52fb28f528778f184f870b7cf8f225f5eef0a8f6e3778529bdd40c7b3920796a", size = 483781 }, + { url = "https://files.pythonhosted.org/packages/01/e8/00008ad4ff4be8b1844786ba6636035f7ef926db5686e4c0f98093612add/regex-2024.11.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdd6028445d2460f33136c55eeb1f601ab06d74cb3347132e1c24250187500d9", size = 288455 }, + { url = "https://files.pythonhosted.org/packages/60/85/cebcc0aff603ea0a201667b203f13ba75d9fc8668fab917ac5b2de3967bc/regex-2024.11.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805e6b60c54bf766b251e94526ebad60b7de0c70f70a4e6210ee2891acb70bf2", size = 284759 }, + { url = "https://files.pythonhosted.org/packages/94/2b/701a4b0585cb05472a4da28ee28fdfe155f3638f5e1ec92306d924e5faf0/regex-2024.11.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b85c2530be953a890eaffde05485238f07029600e8f098cdf1848d414a8b45e4", size = 794976 }, + { url = "https://files.pythonhosted.org/packages/4b/bf/fa87e563bf5fee75db8915f7352e1887b1249126a1be4813837f5dbec965/regex-2024.11.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb26437975da7dc36b7efad18aa9dd4ea569d2357ae6b783bf1118dabd9ea577", size = 833077 }, + { url = "https://files.pythonhosted.org/packages/a1/56/7295e6bad94b047f4d0834e4779491b81216583c00c288252ef625c01d23/regex-2024.11.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abfa5080c374a76a251ba60683242bc17eeb2c9818d0d30117b4486be10c59d3", size = 823160 }, + { url = "https://files.pythonhosted.org/packages/fb/13/e3b075031a738c9598c51cfbc4c7879e26729c53aa9cca59211c44235314/regex-2024.11.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b7fa6606c2881c1db9479b0eaa11ed5dfa11c8d60a474ff0e095099f39d98e", size = 796896 }, + { url = "https://files.pythonhosted.org/packages/24/56/0b3f1b66d592be6efec23a795b37732682520b47c53da5a32c33ed7d84e3/regex-2024.11.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c32f75920cf99fe6b6c539c399a4a128452eaf1af27f39bce8909c9a3fd8cbe", size = 783997 }, + { url = "https://files.pythonhosted.org/packages/f9/a1/eb378dada8b91c0e4c5f08ffb56f25fcae47bf52ad18f9b2f33b83e6d498/regex-2024.11.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:982e6d21414e78e1f51cf595d7f321dcd14de1f2881c5dc6a6e23bbbbd68435e", size = 781725 }, + { url = "https://files.pythonhosted.org/packages/83/f2/033e7dec0cfd6dda93390089864732a3409246ffe8b042e9554afa9bff4e/regex-2024.11.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a7c2155f790e2fb448faed6dd241386719802296ec588a8b9051c1f5c481bc29", size = 789481 }, + { url = "https://files.pythonhosted.org/packages/83/23/15d4552ea28990a74e7696780c438aadd73a20318c47e527b47a4a5a596d/regex-2024.11.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149f5008d286636e48cd0b1dd65018548944e495b0265b45e1bffecce1ef7f39", size = 852896 }, + { url = "https://files.pythonhosted.org/packages/e3/39/ed4416bc90deedbfdada2568b2cb0bc1fdb98efe11f5378d9892b2a88f8f/regex-2024.11.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e5364a4502efca094731680e80009632ad6624084aff9a23ce8c8c6820de3e51", size = 860138 }, + { url = "https://files.pythonhosted.org/packages/93/2d/dd56bb76bd8e95bbce684326302f287455b56242a4f9c61f1bc76e28360e/regex-2024.11.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0a86e7eeca091c09e021db8eb72d54751e527fa47b8d5787caf96d9831bd02ad", size = 787692 }, + { url = "https://files.pythonhosted.org/packages/0b/55/31877a249ab7a5156758246b9c59539abbeba22461b7d8adc9e8475ff73e/regex-2024.11.6-cp312-cp312-win32.whl", hash = "sha256:32f9a4c643baad4efa81d549c2aadefaeba12249b2adc5af541759237eee1c54", size = 262135 }, + { url = "https://files.pythonhosted.org/packages/38/ec/ad2d7de49a600cdb8dd78434a1aeffe28b9d6fc42eb36afab4a27ad23384/regex-2024.11.6-cp312-cp312-win_amd64.whl", hash = "sha256:a93c194e2df18f7d264092dc8539b8ffb86b45b899ab976aa15d48214138e81b", size = 273567 }, + { url = "https://files.pythonhosted.org/packages/90/73/bcb0e36614601016552fa9344544a3a2ae1809dc1401b100eab02e772e1f/regex-2024.11.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a6ba92c0bcdf96cbf43a12c717eae4bc98325ca3730f6b130ffa2e3c3c723d84", size = 483525 }, + { url = "https://files.pythonhosted.org/packages/0f/3f/f1a082a46b31e25291d830b369b6b0c5576a6f7fb89d3053a354c24b8a83/regex-2024.11.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:525eab0b789891ac3be914d36893bdf972d483fe66551f79d3e27146191a37d4", size = 288324 }, + { url = "https://files.pythonhosted.org/packages/09/c9/4e68181a4a652fb3ef5099e077faf4fd2a694ea6e0f806a7737aff9e758a/regex-2024.11.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:086a27a0b4ca227941700e0b31425e7a28ef1ae8e5e05a33826e17e47fbfdba0", size = 284617 }, + { url = "https://files.pythonhosted.org/packages/fc/fd/37868b75eaf63843165f1d2122ca6cb94bfc0271e4428cf58c0616786dce/regex-2024.11.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bde01f35767c4a7899b7eb6e823b125a64de314a8ee9791367c9a34d56af18d0", size = 795023 }, + { url = "https://files.pythonhosted.org/packages/c4/7c/d4cd9c528502a3dedb5c13c146e7a7a539a3853dc20209c8e75d9ba9d1b2/regex-2024.11.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b583904576650166b3d920d2bcce13971f6f9e9a396c673187f49811b2769dc7", size = 833072 }, + { url = "https://files.pythonhosted.org/packages/4f/db/46f563a08f969159c5a0f0e722260568425363bea43bb7ae370becb66a67/regex-2024.11.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c4de13f06a0d54fa0d5ab1b7138bfa0d883220965a29616e3ea61b35d5f5fc7", size = 823130 }, + { url = "https://files.pythonhosted.org/packages/db/60/1eeca2074f5b87df394fccaa432ae3fc06c9c9bfa97c5051aed70e6e00c2/regex-2024.11.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cde6e9f2580eb1665965ce9bf17ff4952f34f5b126beb509fee8f4e994f143c", size = 796857 }, + { url = "https://files.pythonhosted.org/packages/10/db/ac718a08fcee981554d2f7bb8402f1faa7e868c1345c16ab1ebec54b0d7b/regex-2024.11.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d7f453dca13f40a02b79636a339c5b62b670141e63efd511d3f8f73fba162b3", size = 784006 }, + { url = "https://files.pythonhosted.org/packages/c2/41/7da3fe70216cea93144bf12da2b87367590bcf07db97604edeea55dac9ad/regex-2024.11.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59dfe1ed21aea057a65c6b586afd2a945de04fc7db3de0a6e3ed5397ad491b07", size = 781650 }, + { url = "https://files.pythonhosted.org/packages/a7/d5/880921ee4eec393a4752e6ab9f0fe28009435417c3102fc413f3fe81c4e5/regex-2024.11.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b97c1e0bd37c5cd7902e65f410779d39eeda155800b65fc4d04cc432efa9bc6e", size = 789545 }, + { url = "https://files.pythonhosted.org/packages/dc/96/53770115e507081122beca8899ab7f5ae28ae790bfcc82b5e38976df6a77/regex-2024.11.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d1e379028e0fc2ae3654bac3cbbef81bf3fd571272a42d56c24007979bafb6", size = 853045 }, + { url = "https://files.pythonhosted.org/packages/31/d3/1372add5251cc2d44b451bd94f43b2ec78e15a6e82bff6a290ef9fd8f00a/regex-2024.11.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:13291b39131e2d002a7940fb176e120bec5145f3aeb7621be6534e46251912c4", size = 860182 }, + { url = "https://files.pythonhosted.org/packages/ed/e3/c446a64984ea9f69982ba1a69d4658d5014bc7a0ea468a07e1a1265db6e2/regex-2024.11.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f51f88c126370dcec4908576c5a627220da6c09d0bff31cfa89f2523843316d", size = 787733 }, + { url = "https://files.pythonhosted.org/packages/2b/f1/e40c8373e3480e4f29f2692bd21b3e05f296d3afebc7e5dcf21b9756ca1c/regex-2024.11.6-cp313-cp313-win32.whl", hash = "sha256:63b13cfd72e9601125027202cad74995ab26921d8cd935c25f09c630436348ff", size = 262122 }, + { url = "https://files.pythonhosted.org/packages/45/94/bc295babb3062a731f52621cdc992d123111282e291abaf23faa413443ea/regex-2024.11.6-cp313-cp313-win_amd64.whl", hash = "sha256:2b3361af3198667e99927da8b84c1b010752fa4b1115ee30beaa332cabc3ef1a", size = 273545 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "rich" +version = "13.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, +] + +[[package]] +name = "rich-toolkit" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/88/58c193e2e353b0ef8b4b9a91031bbcf8a9a3b431f5ebb4f55c3f3b1992e8/rich_toolkit-0.12.0.tar.gz", hash = "sha256:facb0b40418010309f77abd44e2583b4936656f6ee5c8625da807564806a6c40", size = 71673 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/3c/3b66696fc8a6c980674851108d7d57fbcbfedbefb3d8b61a64166dc9b18e/rich_toolkit-0.12.0-py3-none-any.whl", hash = "sha256:a2da4416384410ae871e890db7edf8623e1f5e983341dbbc8cc03603ce24f0ab", size = 13012 }, +] + +[[package]] +name = "safetensors" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/46/a1c56ed856c6ac3b1a8b37abe5be0cac53219367af1331e721b04d122577/safetensors-0.4.5.tar.gz", hash = "sha256:d73de19682deabb02524b3d5d1f8b3aaba94c72f1bbfc7911b9b9d5d391c0310", size = 65702 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/ac/5a63082f931e99200db95fd46fb6734f050bb6e96bf02521904c6518b7aa/safetensors-0.4.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:473300314e026bd1043cef391bb16a8689453363381561b8a3e443870937cc1e", size = 392015 }, + { url = "https://files.pythonhosted.org/packages/73/95/ab32aa6e9bdc832ff87784cdf9da26192b93de3ef82b8d1ada8f345c5044/safetensors-0.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:801183a0f76dc647f51a2d9141ad341f9665602a7899a693207a82fb102cc53e", size = 381774 }, + { url = "https://files.pythonhosted.org/packages/d6/6c/7e04b7626809fc63f3698f4c50e43aff2864b40089aa4506c918a75b8eed/safetensors-0.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1524b54246e422ad6fb6aea1ac71edeeb77666efa67230e1faf6999df9b2e27f", size = 441134 }, + { url = "https://files.pythonhosted.org/packages/58/2b/ffe7c86a277e6c1595fbdf415cfe2903f253f574a5405e93fda8baaa582c/safetensors-0.4.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b3139098e3e8b2ad7afbca96d30ad29157b50c90861084e69fcb80dec7430461", size = 438467 }, + { url = "https://files.pythonhosted.org/packages/67/9c/f271bd804e08c7fda954d17b70ff281228a88077337a9e70feace4f4cc93/safetensors-0.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65573dc35be9059770808e276b017256fa30058802c29e1038eb1c00028502ea", size = 476566 }, + { url = "https://files.pythonhosted.org/packages/4c/ad/4cf76a3e430a8a26108407fa6cb93e6f80d996a5cb75d9540c8fe3862990/safetensors-0.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd33da8e9407559f8779c82a0448e2133737f922d71f884da27184549416bfed", size = 492253 }, + { url = "https://files.pythonhosted.org/packages/d9/40/a6f75ea449a9647423ec8b6f72c16998d35aa4b43cb38536ac060c5c7bf5/safetensors-0.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3685ce7ed036f916316b567152482b7e959dc754fcc4a8342333d222e05f407c", size = 434769 }, + { url = "https://files.pythonhosted.org/packages/52/47/d4b49b1231abf3131f7bb0bc60ebb94b27ee33e0a1f9569da05f8ac65dee/safetensors-0.4.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dde2bf390d25f67908278d6f5d59e46211ef98e44108727084d4637ee70ab4f1", size = 457166 }, + { url = "https://files.pythonhosted.org/packages/c3/cd/006468b03b0fa42ff82d795d47c4193e99001e96c3f08bd62ef1b5cab586/safetensors-0.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7469d70d3de970b1698d47c11ebbf296a308702cbaae7fcb993944751cf985f4", size = 619280 }, + { url = "https://files.pythonhosted.org/packages/22/4d/b6208d918e83daa84b424c0ac3191ae61b44b3191613a3a5a7b38f94b8ad/safetensors-0.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3a6ba28118636a130ccbb968bc33d4684c48678695dba2590169d5ab03a45646", size = 605390 }, + { url = "https://files.pythonhosted.org/packages/e8/20/bf0e01825dc01ed75538021a98b9a046e60ead63c6c6700764c821a8c873/safetensors-0.4.5-cp312-none-win32.whl", hash = "sha256:c859c7ed90b0047f58ee27751c8e56951452ed36a67afee1b0a87847d065eec6", size = 273250 }, + { url = "https://files.pythonhosted.org/packages/f1/5f/ab6b6cec85b40789801f35b7d2fb579ae242d8193929974a106d5ff5c835/safetensors-0.4.5-cp312-none-win_amd64.whl", hash = "sha256:b5a8810ad6a6f933fff6c276eae92c1da217b39b4d8b1bc1c0b8af2d270dc532", size = 286307 }, + { url = "https://files.pythonhosted.org/packages/90/61/0e27b1403e311cba0be20026bee4ee822d90eda7dad372179e7f18bb99f3/safetensors-0.4.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:25e5f8e2e92a74f05b4ca55686234c32aac19927903792b30ee6d7bd5653d54e", size = 392062 }, + { url = "https://files.pythonhosted.org/packages/b1/9f/cc31fafc9f5d79da10a83a820ca37f069bab0717895ad8cbcacf629dd1c5/safetensors-0.4.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:81efb124b58af39fcd684254c645e35692fea81c51627259cdf6d67ff4458916", size = 382517 }, + { url = "https://files.pythonhosted.org/packages/a4/c7/4fda8a0ebb96662550433378f4a74c677fa5fc4d0a43a7ec287d1df254a9/safetensors-0.4.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:585f1703a518b437f5103aa9cf70e9bd437cb78eea9c51024329e4fb8a3e3679", size = 441378 }, + { url = "https://files.pythonhosted.org/packages/14/31/9abb431f6209de9c80dab83e1112ebd769f1e32e7ab7ab228a02424a4693/safetensors-0.4.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4b99fbf72e3faf0b2f5f16e5e3458b93b7d0a83984fe8d5364c60aa169f2da89", size = 438831 }, + { url = "https://files.pythonhosted.org/packages/37/37/99bfb195578a808b8d045159ee9264f8da58d017ac0701853dcacda14d4e/safetensors-0.4.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b17b299ca9966ca983ecda1c0791a3f07f9ca6ab5ded8ef3d283fff45f6bcd5f", size = 477112 }, + { url = "https://files.pythonhosted.org/packages/7d/05/fac3ef107e60d2a78532bed171a91669d4bb259e1236f5ea8c67a6976c75/safetensors-0.4.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:76ded72f69209c9780fdb23ea89e56d35c54ae6abcdec67ccb22af8e696e449a", size = 493373 }, + { url = "https://files.pythonhosted.org/packages/cf/7a/825800ee8c68214b4fd3506d5e19209338c69b41e01c6e14dd13969cc8b9/safetensors-0.4.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2783956926303dcfeb1de91a4d1204cd4089ab441e622e7caee0642281109db3", size = 435422 }, + { url = "https://files.pythonhosted.org/packages/5e/6c/7a3233c08bde558d6c33a41219119866cb596139a4673cc6c24024710ffd/safetensors-0.4.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d94581aab8c6b204def4d7320f07534d6ee34cd4855688004a4354e63b639a35", size = 457382 }, + { url = "https://files.pythonhosted.org/packages/a0/58/0b7bcba3788ff503990cf9278d611b56c029400612ba93e772c987b5aa03/safetensors-0.4.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:67e1e7cb8678bb1b37ac48ec0df04faf689e2f4e9e81e566b5c63d9f23748523", size = 619301 }, + { url = "https://files.pythonhosted.org/packages/82/cc/9c2cf58611daf1c83ce5d37f9de66353e23fcda36008b13fd3409a760aa3/safetensors-0.4.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:dbd280b07e6054ea68b0cb4b16ad9703e7d63cd6890f577cb98acc5354780142", size = 605580 }, +] + +[[package]] +name = "scikit-image" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "imageio" }, + { name = "lazy-loader" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "scipy" }, + { name = "tifffile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e6/8d/383e5438c807804b66d68ed2c09202d185ea781b6022aa8b9fac3851137f/scikit_image-0.25.0.tar.gz", hash = "sha256:58d94fea11b6b3306b3770417dc1cbca7fa9bcbd6a13945d7910399c88c2018c", size = 22696477 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/6a/a8df6953a85042a8a219c97e1758486b997c9dd319e1c474362229406e57/scikit_image-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7e63f18b10f9b74590d2ca62cbc4147e696a5e72cfcbcd4af52395fd94fcdc6e", size = 13981411 }, + { url = "https://files.pythonhosted.org/packages/dd/4c/e40a77c57a6b90dda710bc64ed761c93e7b3dd1cef3815675a2bc6807755/scikit_image-0.25.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bad4af5edf58775607c153af5bc3f193c2b67261ea9817b62362c746e439d094", size = 13230600 }, + { url = "https://files.pythonhosted.org/packages/63/3f/fac8e1eefbe4a885fa1c9a384db8e11e47c19ab5558b25f370ade3901868/scikit_image-0.25.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44f7681ff99eed2c33d993bc4bfc17b62e6cadbca1081c7fdbb3607ce89b15e6", size = 14173033 }, + { url = "https://files.pythonhosted.org/packages/47/fe/f09efbf54782996a7f1d3db0e33cb9097f3cc6033392fb53459d7254fa7c/scikit_image-0.25.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:758f55d858aa796114a4275051ca4bb41d8b40c53eb78cb60f0b1ed235d4144b", size = 15002211 }, + { url = "https://files.pythonhosted.org/packages/89/30/4f95a7462411def5563c01d56674bd122bd6db55ae1e8c31ad68586e2d27/scikit_image-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:4f7178c6fb6163710571522847326ad936a603646255b22d3d76b6ba58153890", size = 12894520 }, + { url = "https://files.pythonhosted.org/packages/bc/e4/066d0ed167eb146877c50109e94ec254e266391f385c72d545f34cf51755/scikit_image-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d3b08a8894190bc49038dc1a61f6ef0991ff520e5268604abd7ad217f693a0cc", size = 13917192 }, + { url = "https://files.pythonhosted.org/packages/3f/7c/ada573675ad528caff75c8b175c2e28e62c65c7192cf2292a25c3d9774fa/scikit_image-0.25.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:8438eac699c8b2820e5956960191d0c3b302bf9c4d42dbf194a229db04abacc3", size = 13191642 }, + { url = "https://files.pythonhosted.org/packages/cf/c4/16dbe7f7ef7b675c7a11dd51280f09001abca9f3cd4f455f342765b81b43/scikit_image-0.25.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9920673ef08ea44026c80deb14cf84d5c0cc1a68efad914c126b76110ed017a8", size = 14113112 }, + { url = "https://files.pythonhosted.org/packages/8c/d2/84d658db2abecac5f7225213a69d211d95157e8fa155b4e017903549a922/scikit_image-0.25.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fe2f05cda852a5f90872054dd3709e9c4e670fc7332aef169867944e1b37431", size = 14974308 }, + { url = "https://files.pythonhosted.org/packages/b0/0d/4f017d5b85bf742624f8ccd6a03fb9cbf90704b52dbaefa7ffdb28e34775/scikit_image-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ede552097ee281d01b25dc4ce121fdc17b6a43c36bbc3c13e39f0e3d8fb5239", size = 12880013 }, +] + +[[package]] +name = "scipy" +version = "1.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/62/11/4d44a1f274e002784e4dbdb81e0ea96d2de2d1045b2132d5af62cc31fd28/scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417", size = 58620554 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/04/2bdacc8ac6387b15db6faa40295f8bd25eccf33f1f13e68a72dc3c60a99e/scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d", size = 39128781 }, + { url = "https://files.pythonhosted.org/packages/c8/53/35b4d41f5fd42f5781dbd0dd6c05d35ba8aa75c84ecddc7d44756cd8da2e/scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07", size = 29939542 }, + { url = "https://files.pythonhosted.org/packages/66/67/6ef192e0e4d77b20cc33a01e743b00bc9e68fb83b88e06e636d2619a8767/scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5", size = 23148375 }, + { url = "https://files.pythonhosted.org/packages/f6/32/3a6dedd51d68eb7b8e7dc7947d5d841bcb699f1bf4463639554986f4d782/scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc", size = 25578573 }, + { url = "https://files.pythonhosted.org/packages/f0/5a/efa92a58dc3a2898705f1dc9dbaf390ca7d4fba26d6ab8cfffb0c72f656f/scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310", size = 35319299 }, + { url = "https://files.pythonhosted.org/packages/8e/ee/8a26858ca517e9c64f84b4c7734b89bda8e63bec85c3d2f432d225bb1886/scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066", size = 40849331 }, + { url = "https://files.pythonhosted.org/packages/a5/cd/06f72bc9187840f1c99e1a8750aad4216fc7dfdd7df46e6280add14b4822/scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1", size = 42544049 }, + { url = "https://files.pythonhosted.org/packages/aa/7d/43ab67228ef98c6b5dd42ab386eae2d7877036970a0d7e3dd3eb47a0d530/scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f", size = 44521212 }, + { url = "https://files.pythonhosted.org/packages/50/ef/ac98346db016ff18a6ad7626a35808f37074d25796fd0234c2bb0ed1e054/scipy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1729560c906963fc8389f6aac023739ff3983e727b1a4d87696b7bf108316a79", size = 39091068 }, + { url = "https://files.pythonhosted.org/packages/b9/cc/70948fe9f393b911b4251e96b55bbdeaa8cca41f37c26fd1df0232933b9e/scipy-1.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:4079b90df244709e675cdc8b93bfd8a395d59af40b72e339c2287c91860deb8e", size = 29875417 }, + { url = "https://files.pythonhosted.org/packages/3b/2e/35f549b7d231c1c9f9639f9ef49b815d816bf54dd050da5da1c11517a218/scipy-1.14.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf28db0f24a38b2a0ca33a85a54852586e43cf6fd876365c86e0657cfe7d73", size = 23084508 }, + { url = "https://files.pythonhosted.org/packages/3f/d6/b028e3f3e59fae61fb8c0f450db732c43dd1d836223a589a8be9f6377203/scipy-1.14.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0c2f95de3b04e26f5f3ad5bb05e74ba7f68b837133a4492414b3afd79dfe540e", size = 25503364 }, + { url = "https://files.pythonhosted.org/packages/a7/2f/6c142b352ac15967744d62b165537a965e95d557085db4beab2a11f7943b/scipy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b99722ea48b7ea25e8e015e8341ae74624f72e5f21fc2abd45f3a93266de4c5d", size = 35292639 }, + { url = "https://files.pythonhosted.org/packages/56/46/2449e6e51e0d7c3575f289f6acb7f828938eaab8874dbccfeb0cd2b71a27/scipy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5149e3fd2d686e42144a093b206aef01932a0059c2a33ddfa67f5f035bdfe13e", size = 40798288 }, + { url = "https://files.pythonhosted.org/packages/32/cd/9d86f7ed7f4497c9fd3e39f8918dd93d9f647ba80d7e34e4946c0c2d1a7c/scipy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4f5a7c49323533f9103d4dacf4e4f07078f360743dec7f7596949149efeec06", size = 42524647 }, + { url = "https://files.pythonhosted.org/packages/f5/1b/6ee032251bf4cdb0cc50059374e86a9f076308c1512b61c4e003e241efb7/scipy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:baff393942b550823bfce952bb62270ee17504d02a1801d7fd0719534dfb9c84", size = 44469524 }, +] + +[[package]] +name = "setuptools" +version = "75.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/54/292f26c208734e9a7f067aea4a7e282c080750c4546559b58e2e45413ca0/setuptools-75.6.0.tar.gz", hash = "sha256:8199222558df7c86216af4f84c30e9b34a61d8ba19366cc914424cdbd28252f6", size = 1337429 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/21/47d163f615df1d30c094f6c8bbb353619274edccf0327b185cc2493c2c33/setuptools-75.6.0-py3-none-any.whl", hash = "sha256:ce74b49e8f7110f9bf04883b730f4765b774ef3ef28f722cce7c273d253aaf7d", size = 1224032 }, +] + +[[package]] +name = "shapely" +version = "2.0.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4a/89/0d20bac88016be35ff7d3c0c2ae64b477908f1b1dfa540c5d69ac7af07fe/shapely-2.0.6.tar.gz", hash = "sha256:997f6159b1484059ec239cacaa53467fd8b5564dabe186cd84ac2944663b0bf6", size = 282361 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/77/efd9f9d4b6a762f976f8b082f54c9be16f63050389500fb52e4f6cc07c1a/shapely-2.0.6-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cec9193519940e9d1b86a3b4f5af9eb6910197d24af02f247afbfb47bcb3fab0", size = 1450326 }, + { url = "https://files.pythonhosted.org/packages/68/53/5efa6e7a4036a94fe6276cf7bbb298afded51ca3396b03981ad680c8cc7d/shapely-2.0.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83b94a44ab04a90e88be69e7ddcc6f332da7c0a0ebb1156e1c4f568bbec983c3", size = 1298480 }, + { url = "https://files.pythonhosted.org/packages/88/a2/1be1db4fc262e536465a52d4f19d85834724fedf2299a1b9836bc82fe8fa/shapely-2.0.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:537c4b2716d22c92036d00b34aac9d3775e3691f80c7aa517c2c290351f42cd8", size = 2439311 }, + { url = "https://files.pythonhosted.org/packages/d5/7d/9a57e187cbf2fbbbdfd4044a4f9ce141c8d221f9963750d3b001f0ec080d/shapely-2.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fea108334be345c283ce74bf064fa00cfdd718048a8af7343c59eb40f59726", size = 2524835 }, + { url = "https://files.pythonhosted.org/packages/6d/0a/f407509ab56825f39bf8cfce1fb410238da96cf096809c3e404e5bc71ea1/shapely-2.0.6-cp312-cp312-win32.whl", hash = "sha256:42fd4cd4834747e4990227e4cbafb02242c0cffe9ce7ef9971f53ac52d80d55f", size = 1295613 }, + { url = "https://files.pythonhosted.org/packages/7b/b3/857afd9dfbfc554f10d683ac412eac6fa260d1f4cd2967ecb655c57e831a/shapely-2.0.6-cp312-cp312-win_amd64.whl", hash = "sha256:665990c84aece05efb68a21b3523a6b2057e84a1afbef426ad287f0796ef8a48", size = 1442539 }, + { url = "https://files.pythonhosted.org/packages/34/e8/d164ef5b0eab86088cde06dee8415519ffd5bb0dd1bd9d021e640e64237c/shapely-2.0.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:42805ef90783ce689a4dde2b6b2f261e2c52609226a0438d882e3ced40bb3013", size = 1445344 }, + { url = "https://files.pythonhosted.org/packages/ce/e2/9fba7ac142f7831757a10852bfa465683724eadbc93d2d46f74a16f9af04/shapely-2.0.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6d2cb146191a47bd0cee8ff5f90b47547b82b6345c0d02dd8b25b88b68af62d7", size = 1296182 }, + { url = "https://files.pythonhosted.org/packages/cf/dc/790d4bda27d196cd56ec66975eaae3351c65614cafd0e16ddde39ec9fb92/shapely-2.0.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3fdef0a1794a8fe70dc1f514440aa34426cc0ae98d9a1027fb299d45741c381", size = 2423426 }, + { url = "https://files.pythonhosted.org/packages/af/b0/f8169f77eac7392d41e231911e0095eb1148b4d40c50ea9e34d999c89a7e/shapely-2.0.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c665a0301c645615a107ff7f52adafa2153beab51daf34587170d85e8ba6805", size = 2513249 }, + { url = "https://files.pythonhosted.org/packages/f6/1d/a8c0e9ab49ff2f8e4dedd71b0122eafb22a18ad7e9d256025e1f10c84704/shapely-2.0.6-cp313-cp313-win32.whl", hash = "sha256:0334bd51828f68cd54b87d80b3e7cee93f249d82ae55a0faf3ea21c9be7b323a", size = 1294848 }, + { url = "https://files.pythonhosted.org/packages/23/38/2bc32dd1e7e67a471d4c60971e66df0bdace88656c47a9a728ace0091075/shapely-2.0.6-cp313-cp313-win_amd64.whl", hash = "sha256:d37d070da9e0e0f0a530a621e17c0b8c3c9d04105655132a87cfff8bd77cc4c2", size = 1441371 }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.36" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "greenlet", marker = "(python_full_version < '3.13' and platform_machine == 'AMD64') or (python_full_version < '3.13' and platform_machine == 'WIN32') or (python_full_version < '3.13' and platform_machine == 'aarch64') or (python_full_version < '3.13' and platform_machine == 'amd64') or (python_full_version < '3.13' and platform_machine == 'ppc64le') or (python_full_version < '3.13' and platform_machine == 'win32') or (python_full_version < '3.13' and platform_machine == 'x86_64')" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/65/9cbc9c4c3287bed2499e05033e207473504dc4df999ce49385fb1f8b058a/sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5", size = 9574485 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/bf/005dc47f0e57556e14512d5542f3f183b94fde46e15ff1588ec58ca89555/SQLAlchemy-2.0.36-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7b64e6ec3f02c35647be6b4851008b26cff592a95ecb13b6788a54ef80bbdd4", size = 2092378 }, + { url = "https://files.pythonhosted.org/packages/94/65/f109d5720779a08e6e324ec89a744f5f92c48bd8005edc814bf72fbb24e5/SQLAlchemy-2.0.36-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46331b00096a6db1fdc052d55b101dbbfc99155a548e20a0e4a8e5e4d1362855", size = 2082778 }, + { url = "https://files.pythonhosted.org/packages/60/f6/d9aa8c49c44f9b8c9b9dada1f12fa78df3d4c42aa2de437164b83ee1123c/SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdf3386a801ea5aba17c6410dd1dc8d39cf454ca2565541b5ac42a84e1e28f53", size = 3232191 }, + { url = "https://files.pythonhosted.org/packages/8a/ab/81d4514527c068670cb1d7ab62a81a185df53a7c379bd2a5636e83d09ede/SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9dfa18ff2a67b09b372d5db8743c27966abf0e5344c555d86cc7199f7ad83a", size = 3243044 }, + { url = "https://files.pythonhosted.org/packages/35/b4/f87c014ecf5167dc669199cafdb20a7358ff4b1d49ce3622cc48571f811c/SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:90812a8933df713fdf748b355527e3af257a11e415b613dd794512461eb8a686", size = 3178511 }, + { url = "https://files.pythonhosted.org/packages/ea/09/badfc9293bc3ccba6ede05e5f2b44a760aa47d84da1fc5a326e963e3d4d9/SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1bc330d9d29c7f06f003ab10e1eaced295e87940405afe1b110f2eb93a233588", size = 3205147 }, + { url = "https://files.pythonhosted.org/packages/c8/60/70e681de02a13c4b27979b7b78da3058c49bacc9858c89ba672e030f03f2/SQLAlchemy-2.0.36-cp312-cp312-win32.whl", hash = "sha256:79d2e78abc26d871875b419e1fd3c0bca31a1cb0043277d0d850014599626c2e", size = 2062709 }, + { url = "https://files.pythonhosted.org/packages/b7/ed/f6cd9395e41bfe47dd253d74d2dfc3cab34980d4e20c8878cb1117306085/SQLAlchemy-2.0.36-cp312-cp312-win_amd64.whl", hash = "sha256:b544ad1935a8541d177cb402948b94e871067656b3a0b9e91dbec136b06a2ff5", size = 2088433 }, + { url = "https://files.pythonhosted.org/packages/78/5c/236398ae3678b3237726819b484f15f5c038a9549da01703a771f05a00d6/SQLAlchemy-2.0.36-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b5cc79df7f4bc3d11e4b542596c03826063092611e481fcf1c9dfee3c94355ef", size = 2087651 }, + { url = "https://files.pythonhosted.org/packages/a8/14/55c47420c0d23fb67a35af8be4719199b81c59f3084c28d131a7767b0b0b/SQLAlchemy-2.0.36-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3c01117dd36800f2ecaa238c65365b7b16497adc1522bf84906e5710ee9ba0e8", size = 2078132 }, + { url = "https://files.pythonhosted.org/packages/3d/97/1e843b36abff8c4a7aa2e37f9bea364f90d021754c2de94d792c2d91405b/SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9bc633f4ee4b4c46e7adcb3a9b5ec083bf1d9a97c1d3854b92749d935de40b9b", size = 3164559 }, + { url = "https://files.pythonhosted.org/packages/7b/c5/07f18a897b997f6d6b234fab2bf31dccf66d5d16a79fe329aefc95cd7461/SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e46ed38affdfc95d2c958de328d037d87801cfcbea6d421000859e9789e61c2", size = 3177897 }, + { url = "https://files.pythonhosted.org/packages/b3/cd/e16f3cbefd82b5c40b33732da634ec67a5f33b587744c7ab41699789d492/SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b2985c0b06e989c043f1dc09d4fe89e1616aadd35392aea2844f0458a989eacf", size = 3111289 }, + { url = "https://files.pythonhosted.org/packages/15/85/5b8a3b0bc29c9928aa62b5c91fcc8335f57c1de0a6343873b5f372e3672b/SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a121d62ebe7d26fec9155f83f8be5189ef1405f5973ea4874a26fab9f1e262c", size = 3139491 }, + { url = "https://files.pythonhosted.org/packages/a1/95/81babb6089938680dfe2cd3f88cd3fd39cccd1543b7cb603b21ad881bff1/SQLAlchemy-2.0.36-cp313-cp313-win32.whl", hash = "sha256:0572f4bd6f94752167adfd7c1bed84f4b240ee6203a95e05d1e208d488d0d436", size = 2060439 }, + { url = "https://files.pythonhosted.org/packages/c1/ce/5f7428df55660d6879d0522adc73a3364970b5ef33ec17fa125c5dbcac1d/SQLAlchemy-2.0.36-cp313-cp313-win_amd64.whl", hash = "sha256:8c78ac40bde930c60e0f78b3cd184c580f89456dd87fc08f9e3ee3ce8765ce88", size = 2084574 }, + { url = "https://files.pythonhosted.org/packages/b8/49/21633706dd6feb14cd3f7935fc00b60870ea057686035e1a99ae6d9d9d53/SQLAlchemy-2.0.36-py3-none-any.whl", hash = "sha256:fddbe92b4760c6f5d48162aef14824add991aeda8ddadb3c31d56eb15ca69f8e", size = 1883787 }, +] + +[package.optional-dependencies] +asyncio = [ + { name = "greenlet" }, +] + +[[package]] +name = "starlette" +version = "0.41.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1a/4c/9b5764bd22eec91c4039ef4c55334e9187085da2d8a2df7bd570869aae18/starlette-0.41.3.tar.gz", hash = "sha256:0e4ab3d16522a255be6b28260b938eae2482f98ce5cc934cb08dce8dc3ba5835", size = 2574159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/00/2b325970b3060c7cecebab6d295afe763365822b1306a12eeab198f74323/starlette-0.41.3-py3-none-any.whl", hash = "sha256:44cedb2b7c77a9de33a8b74b2b90e9f50d11fcf25d8270ea525ad71a25374ff7", size = 73225 }, +] + +[[package]] +name = "sympy" +version = "1.13.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/99/5a5b6f19ff9f083671ddf7b9632028436167cd3d33e11015754e41b249a4/sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f", size = 7533040 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/fe/81695a1aa331a842b582453b605175f419fe8540355886031328089d840a/sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8", size = 6189177 }, +] + +[[package]] +name = "tifffile" +version = "2024.12.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/37/c9/fc4e490c5b0ccad68c98ea1d6e0f409bd7d50e2e8fc30a0725594d3104ff/tifffile-2024.12.12.tar.gz", hash = "sha256:c38e929bf74c04b6c8708d87f16b32c85c6d7c2514b99559ea3db8003ba4edda", size = 365416 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/1e/76cbc758f6865a9da18001ac70d1a4154603b71e233f704401fc7d62493e/tifffile-2024.12.12-py3-none-any.whl", hash = "sha256:6ff0f196a46a75c8c0661c70995e06ea4d08a81fe343193e69f1673f4807d508", size = 227538 }, +] + +[[package]] +name = "tokenizers" +version = "0.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/41/c2be10975ca37f6ec40d7abd7e98a5213bb04f284b869c1a24e6504fd94d/tokenizers-0.21.0.tar.gz", hash = "sha256:ee0894bf311b75b0c03079f33859ae4b2334d675d4e93f5a4132e1eae2834fe4", size = 343021 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/5c/8b09607b37e996dc47e70d6a7b6f4bdd4e4d5ab22fe49d7374565c7fefaf/tokenizers-0.21.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:3c4c93eae637e7d2aaae3d376f06085164e1660f89304c0ab2b1d08a406636b2", size = 2647461 }, + { url = "https://files.pythonhosted.org/packages/22/7a/88e58bb297c22633ed1c9d16029316e5b5ac5ee44012164c2edede599a5e/tokenizers-0.21.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:f53ea537c925422a2e0e92a24cce96f6bc5046bbef24a1652a5edc8ba975f62e", size = 2563639 }, + { url = "https://files.pythonhosted.org/packages/f7/14/83429177c19364df27d22bc096d4c2e431e0ba43e56c525434f1f9b0fd00/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b177fb54c4702ef611de0c069d9169f0004233890e0c4c5bd5508ae05abf193", size = 2903304 }, + { url = "https://files.pythonhosted.org/packages/7e/db/3433eab42347e0dc5452d8fcc8da03f638c9accffefe5a7c78146666964a/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6b43779a269f4629bebb114e19c3fca0223296ae9fea8bb9a7a6c6fb0657ff8e", size = 2804378 }, + { url = "https://files.pythonhosted.org/packages/57/8b/7da5e6f89736c2ade02816b4733983fca1c226b0c42980b1ae9dc8fcf5cc/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9aeb255802be90acfd363626753fda0064a8df06031012fe7d52fd9a905eb00e", size = 3095488 }, + { url = "https://files.pythonhosted.org/packages/4d/f6/5ed6711093dc2c04a4e03f6461798b12669bc5a17c8be7cce1240e0b5ce8/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d8b09dbeb7a8d73ee204a70f94fc06ea0f17dcf0844f16102b9f414f0b7463ba", size = 3121410 }, + { url = "https://files.pythonhosted.org/packages/81/42/07600892d48950c5e80505b81411044a2d969368cdc0d929b1c847bf6697/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:400832c0904f77ce87c40f1a8a27493071282f785724ae62144324f171377273", size = 3388821 }, + { url = "https://files.pythonhosted.org/packages/22/06/69d7ce374747edaf1695a4f61b83570d91cc8bbfc51ccfecf76f56ab4aac/tokenizers-0.21.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e84ca973b3a96894d1707e189c14a774b701596d579ffc7e69debfc036a61a04", size = 3008868 }, + { url = "https://files.pythonhosted.org/packages/c8/69/54a0aee4d576045b49a0eb8bffdc495634309c823bf886042e6f46b80058/tokenizers-0.21.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eb7202d231b273c34ec67767378cd04c767e967fda12d4a9e36208a34e2f137e", size = 8975831 }, + { url = "https://files.pythonhosted.org/packages/f7/f3/b776061e4f3ebf2905ba1a25d90380aafd10c02d406437a8ba22d1724d76/tokenizers-0.21.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:089d56db6782a73a27fd8abf3ba21779f5b85d4a9f35e3b493c7bbcbbf0d539b", size = 8920746 }, + { url = "https://files.pythonhosted.org/packages/d8/ee/ce83d5ec8b6844ad4c3ecfe3333d58ecc1adc61f0878b323a15355bcab24/tokenizers-0.21.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:c87ca3dc48b9b1222d984b6b7490355a6fdb411a2d810f6f05977258400ddb74", size = 9161814 }, + { url = "https://files.pythonhosted.org/packages/18/07/3e88e65c0ed28fa93aa0c4d264988428eef3df2764c3126dc83e243cb36f/tokenizers-0.21.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4145505a973116f91bc3ac45988a92e618a6f83eb458f49ea0790df94ee243ff", size = 9357138 }, + { url = "https://files.pythonhosted.org/packages/15/b0/dc4572ca61555fc482ebc933f26cb407c6aceb3dc19c301c68184f8cad03/tokenizers-0.21.0-cp39-abi3-win32.whl", hash = "sha256:eb1702c2f27d25d9dd5b389cc1f2f51813e99f8ca30d9e25348db6585a97e24a", size = 2202266 }, + { url = "https://files.pythonhosted.org/packages/44/69/d21eb253fa91622da25585d362a874fa4710be600f0ea9446d8d0217cec1/tokenizers-0.21.0-cp39-abi3-win_amd64.whl", hash = "sha256:87841da5a25a3a5f70c102de371db120f41873b854ba65e52bccd57df5a3780c", size = 2389192 }, +] + +[[package]] +name = "torch" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton", marker = "python_full_version < '3.13' and platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/5c/36c114d120bfe10f9323ed35061bc5878cc74f3f594003854b0ea298942f/torch-2.5.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:ed231a4b3a5952177fafb661213d690a72caaad97d5824dd4fc17ab9e15cec03", size = 906389343 }, + { url = "https://files.pythonhosted.org/packages/6d/69/d8ada8b6e0a4257556d5b4ddeb4345ea8eeaaef3c98b60d1cca197c7ad8e/torch-2.5.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:3f4b7f10a247e0dcd7ea97dc2d3bfbfc90302ed36d7f3952b0008d0df264e697", size = 91811673 }, + { url = "https://files.pythonhosted.org/packages/5f/ba/607d013b55b9fd805db2a5c2662ec7551f1910b4eef39653eeaba182c5b2/torch-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:73e58e78f7d220917c5dbfad1a40e09df9929d3b95d25e57d9f8558f84c9a11c", size = 203046841 }, + { url = "https://files.pythonhosted.org/packages/57/6c/bf52ff061da33deb9f94f4121fde7ff3058812cb7d2036c97bc167793bd1/torch-2.5.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:8c712df61101964eb11910a846514011f0b6f5920c55dbf567bff8a34163d5b1", size = 63858109 }, + { url = "https://files.pythonhosted.org/packages/69/72/20cb30f3b39a9face296491a86adb6ff8f1a47a897e4d14667e6cf89d5c3/torch-2.5.1-cp313-cp313-manylinux1_x86_64.whl", hash = "sha256:9b61edf3b4f6e3b0e0adda8b3960266b9009d02b37555971f4d1c8f7a05afed7", size = 906393265 }, +] + +[[package]] +name = "torchaudio" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "torch" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/ab/151037a41e2cf4a5d489dfe5e7196b755e0fd83958d5ca7ad8ed85afcb1c/torchaudio-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f1cbfdfd1bbdfbe7289d47a74f36ff6c5d87c3205606202fef5a7fb693f61cf0", size = 1798042 }, + { url = "https://files.pythonhosted.org/packages/34/1c/345d11bf492a1414dced70a9572ff1eb2c73013578d24fb4d728a91a09d1/torchaudio-2.5.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:9c8fb06fbd8d2016e7b7caf15a3231867c792a2e3b0f2f8f9013633e9c2ce412", size = 3371851 }, + { url = "https://files.pythonhosted.org/packages/1c/74/a27c6d0d4c4fad90462f08e99222d3557f118beb8fb560b87d607a727a0a/torchaudio-2.5.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:6bb65416405f40e00b20701257c16e7493bfdd7188e02e87cc5b389c31c10c2c", size = 1668849 }, + { url = "https://files.pythonhosted.org/packages/99/a1/4220b73ba6e083229099892d9126e01836afe96cf7e2fbfe60b327506f49/torchaudio-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:ec8f12d6be12aed248a0d65a76c7bb341ee5eef969fe2e9dc3154c7cfba1bdf4", size = 2435747 }, +] + +[[package]] +name = "torchmetrics" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lightning-utilities" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/88/9b0c5542ce845d153eaa7a7eb8e4fad34347b13b5997bf1d744d64410072/torchmetrics-1.6.0.tar.gz", hash = "sha256:aebba248708fb90def20cccba6f55bddd134a58de43fb22b0c5ca0f3a89fa984", size = 538824 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/1a/9728a502f377ab8cff1fd15c625aa2919a183fa113ebcefa2cd38edff28b/torchmetrics-1.6.0-py3-none-any.whl", hash = "sha256:a508cdd87766cedaaf55a419812bf9f493aff8fffc02cc19df5a8e2e7ccb942a", size = 926379 }, +] + +[[package]] +name = "torchvision" +version = "0.20.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, + { name = "torch" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/eb/4ba19616378f2bc085999432fded2b7dfdbdccc6dd0fc293203452508100/torchvision-0.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a31256ff945d64f006bb306813a7c95a531fe16bfb2535c837dd4c104533d7a", size = 1787553 }, + { url = "https://files.pythonhosted.org/packages/d4/75/00a852275ade58d3dc474530f7a7b6bc999a817148f0eb59d4fde12eb955/torchvision-0.20.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:17cd78adddf81dac57d7dccc9277a4d686425b1c55715f308769770cb26cad5c", size = 7240323 }, + { url = "https://files.pythonhosted.org/packages/af/f0/ca1445406eb12cbeb7a41fc833a1941ede78e7c55621198b83ecd7bcfd0f/torchvision-0.20.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:9f853ba4497ac4691815ad41b523ee23cf5ba4f87b1ce869d704052e233ca8b7", size = 14266936 }, + { url = "https://files.pythonhosted.org/packages/c3/18/00993d420b1d6e88582e51d4bc82c824c99a2e9c045d50eaf9b34fff729a/torchvision-0.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:4a330422c36dbfc946d3a6c1caec3489db07ecdf3675d83369adb2e5a0ca17c4", size = 1562392 }, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "platform_system == 'Windows'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 }, +] + +[[package]] +name = "transformers" +version = "4.47.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/15/1a/936aeb4f88112f670b604f5748034568dbc2b9bbb457a8d4518b1a15510a/transformers-4.47.1.tar.gz", hash = "sha256:6c29c05a5f595e278481166539202bf8641281536df1c42357ee58a45d0a564a", size = 8707421 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/3a/8bdab26e09c5a242182b7ba9152e216d5ab4ae2d78c4298eb4872549cd35/transformers-4.47.1-py3-none-any.whl", hash = "sha256:d2f5d19bb6283cd66c893ec7e6d931d6370bbf1cc93633326ff1f41a40046c9c", size = 10133598 }, +] + +[[package]] +name = "triton" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/eb/65f5ba83c2a123f6498a3097746607e5b2f16add29e36765305e4ac7fdd8/triton-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8182f42fd8080a7d39d666814fa36c5e30cc00ea7eeeb1a2983dbb4c99a0fdc", size = 209551444 }, +] + +[[package]] +name = "typer" +version = "0.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/dca7b219718afd37a0068f4f2530a727c2b74a8b6e8e0c0080a4c0de4fcd/typer-0.15.1.tar.gz", hash = "sha256:a0588c0a7fa68a1978a069818657778f86abe6ff5ea6abf472f940a08bfe4f0a", size = 99789 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/cc/0a838ba5ca64dc832aa43f727bd586309846b0ffb2ce52422543e6075e8a/typer-0.15.1-py3-none-any.whl", hash = "sha256:7994fb7b8155b64d3402518560648446072864beefd44aa2dc36972a5972e847", size = 44908 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2024.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 }, +] + +[[package]] +name = "urllib3" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 }, +] + +[[package]] +name = "uvicorn" +version = "0.34.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4b/4d/938bd85e5bf2edeec766267a5015ad969730bb91e31b44021dfe8b22df6c/uvicorn-0.34.0.tar.gz", hash = "sha256:404051050cd7e905de2c9a7e61790943440b3416f49cb409f965d9dcd0fa73e9", size = 76568 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl", hash = "sha256:023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4", size = 62315 }, +] + +[package.optional-dependencies] +standard = [ + { name = "colorama", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/c0/854216d09d33c543f12a44b393c402e89a920b1a0a7dc634c42de91b9cf6/uvloop-0.21.0.tar.gz", hash = "sha256:3bf12b0fda68447806a7ad847bfa591613177275d35b6724b1ee573faa3704e3", size = 2492741 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/4c/03f93178830dc7ce8b4cdee1d36770d2f5ebb6f3d37d354e061eefc73545/uvloop-0.21.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:359ec2c888397b9e592a889c4d72ba3d6befba8b2bb01743f72fffbde663b59c", size = 1471284 }, + { url = "https://files.pythonhosted.org/packages/43/3e/92c03f4d05e50f09251bd8b2b2b584a2a7f8fe600008bcc4523337abe676/uvloop-0.21.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7089d2dc73179ce5ac255bdf37c236a9f914b264825fdaacaded6990a7fb4c2", size = 821349 }, + { url = "https://files.pythonhosted.org/packages/a6/ef/a02ec5da49909dbbfb1fd205a9a1ac4e88ea92dcae885e7c961847cd51e2/uvloop-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4dcdbd9ae0a372f2167a207cd98c9f9a1ea1188a8a526431eef2f8116cc8d", size = 4580089 }, + { url = "https://files.pythonhosted.org/packages/06/a7/b4e6a19925c900be9f98bec0a75e6e8f79bb53bdeb891916609ab3958967/uvloop-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86975dca1c773a2c9864f4c52c5a55631038e387b47eaf56210f873887b6c8dc", size = 4693770 }, + { url = "https://files.pythonhosted.org/packages/ce/0c/f07435a18a4b94ce6bd0677d8319cd3de61f3a9eeb1e5f8ab4e8b5edfcb3/uvloop-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:461d9ae6660fbbafedd07559c6a2e57cd553b34b0065b6550685f6653a98c1cb", size = 4451321 }, + { url = "https://files.pythonhosted.org/packages/8f/eb/f7032be105877bcf924709c97b1bf3b90255b4ec251f9340cef912559f28/uvloop-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:183aef7c8730e54c9a3ee3227464daed66e37ba13040bb3f350bc2ddc040f22f", size = 4659022 }, + { url = "https://files.pythonhosted.org/packages/3f/8d/2cbef610ca21539f0f36e2b34da49302029e7c9f09acef0b1c3b5839412b/uvloop-0.21.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bfd55dfcc2a512316e65f16e503e9e450cab148ef11df4e4e679b5e8253a5281", size = 1468123 }, + { url = "https://files.pythonhosted.org/packages/93/0d/b0038d5a469f94ed8f2b2fce2434a18396d8fbfb5da85a0a9781ebbdec14/uvloop-0.21.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:787ae31ad8a2856fc4e7c095341cccc7209bd657d0e71ad0dc2ea83c4a6fa8af", size = 819325 }, + { url = "https://files.pythonhosted.org/packages/50/94/0a687f39e78c4c1e02e3272c6b2ccdb4e0085fda3b8352fecd0410ccf915/uvloop-0.21.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ee4d4ef48036ff6e5cfffb09dd192c7a5027153948d85b8da7ff705065bacc6", size = 4582806 }, + { url = "https://files.pythonhosted.org/packages/d2/19/f5b78616566ea68edd42aacaf645adbf71fbd83fc52281fba555dc27e3f1/uvloop-0.21.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3df876acd7ec037a3d005b3ab85a7e4110422e4d9c1571d4fc89b0fc41b6816", size = 4701068 }, + { url = "https://files.pythonhosted.org/packages/47/57/66f061ee118f413cd22a656de622925097170b9380b30091b78ea0c6ea75/uvloop-0.21.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd53ecc9a0f3d87ab847503c2e1552b690362e005ab54e8a48ba97da3924c0dc", size = 4454428 }, + { url = "https://files.pythonhosted.org/packages/63/9a/0962b05b308494e3202d3f794a6e85abe471fe3cafdbcf95c2e8c713aabd/uvloop-0.21.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a5c39f217ab3c663dc699c04cbd50c13813e31d917642d459fdcec07555cc553", size = 4660018 }, +] + +[[package]] +name = "watchfiles" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/7e/4569184ea04b501840771b8fcecee19b2233a8b72c196061263c0ef23c0b/watchfiles-1.0.3.tar.gz", hash = "sha256:f3ff7da165c99a5412fe5dd2304dd2dbaaaa5da718aad942dcb3a178eaa70c56", size = 38185 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/a9/c8b5ab33444306e1a324cb2b51644f8458dd459e30c3841f925012893e6a/watchfiles-1.0.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:93436ed550e429da007fbafb723e0769f25bae178fbb287a94cb4ccdf42d3af3", size = 391395 }, + { url = "https://files.pythonhosted.org/packages/ad/d3/403af5f07359863c03951796ddab265ee8cce1a6147510203d0bf43950e7/watchfiles-1.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c18f3502ad0737813c7dad70e3e1cc966cc147fbaeef47a09463bbffe70b0a00", size = 381432 }, + { url = "https://files.pythonhosted.org/packages/f6/5f/921f2f2beabaf24b1ad81ac22bb69df8dd5771fdb68d6f34a5912a420941/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a5bc3ca468bb58a2ef50441f953e1f77b9a61bd1b8c347c8223403dc9b4ac9a", size = 441448 }, + { url = "https://files.pythonhosted.org/packages/63/d7/67d0d750b246f248ccdb400a85a253e93e419ea5b6cbe968fa48b97a5f30/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0d1ec043f02ca04bf21b1b32cab155ce90c651aaf5540db8eb8ad7f7e645cba8", size = 446852 }, + { url = "https://files.pythonhosted.org/packages/53/7c/d7cd94c7d0905f1e2f1c2232ea9bc39b1a48affd007e09c547ead96edb8f/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f58d3bfafecf3d81c15d99fc0ecf4319e80ac712c77cf0ce2661c8cf8bf84066", size = 471662 }, + { url = "https://files.pythonhosted.org/packages/26/81/738f8e66f7525753996b8aa292f78dcec1ef77887d62e6cdfb04cc2f352f/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1df924ba82ae9e77340101c28d56cbaff2c991bd6fe8444a545d24075abb0a87", size = 493765 }, + { url = "https://files.pythonhosted.org/packages/d2/50/78e21f5da24ab39114e9b24f7b0945ea1c6fc7bc9ae86cd87f8eaeb47325/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:632a52dcaee44792d0965c17bdfe5dc0edad5b86d6a29e53d6ad4bf92dc0ff49", size = 490558 }, + { url = "https://files.pythonhosted.org/packages/a8/93/1873fea6354b2858eae8970991d64e9a449d87726d596490d46bf00af8ed/watchfiles-1.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bf4b459d94a0387617a1b499f314aa04d8a64b7a0747d15d425b8c8b151da0", size = 442808 }, + { url = "https://files.pythonhosted.org/packages/4f/b4/2fc4c92fb28b029f66d04a4d430fe929284e9ff717b04bb7a3bb8a7a5605/watchfiles-1.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ca94c85911601b097d53caeeec30201736ad69a93f30d15672b967558df02885", size = 615287 }, + { url = "https://files.pythonhosted.org/packages/1e/d4/93da24db39257e440240d338b617c5153ad11d361c34108f5c0e1e0743eb/watchfiles-1.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:65ab1fb635476f6170b07e8e21db0424de94877e4b76b7feabfe11f9a5fc12b5", size = 612812 }, + { url = "https://files.pythonhosted.org/packages/c6/67/9fd3661c2dc0309abd6021876653d91e8b64fb279529e2cadaa3520ef3e3/watchfiles-1.0.3-cp312-cp312-win32.whl", hash = "sha256:49bc1bc26abf4f32e132652f4b3bfeec77d8f8f62f57652703ef127e85a3e38d", size = 271642 }, + { url = "https://files.pythonhosted.org/packages/ae/aa/8c887edb78cd67f5d4d6a35c3aeb46d748643ebf962163130fb1871e2ee0/watchfiles-1.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:48681c86f2cb08348631fed788a116c89c787fdf1e6381c5febafd782f6c3b44", size = 285505 }, + { url = "https://files.pythonhosted.org/packages/7b/31/d212fa6390f0e73a91913ada0b925b294a78d67794795371208baf73f0b5/watchfiles-1.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:9e080cf917b35b20c889225a13f290f2716748362f6071b859b60b8847a6aa43", size = 277263 }, + { url = "https://files.pythonhosted.org/packages/36/77/0ceb864c854c59bc5326484f88a900c70b4a05e3792e0ce340689988dd5e/watchfiles-1.0.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e153a690b7255c5ced17895394b4f109d5dcc2a4f35cb809374da50f0e5c456a", size = 391061 }, + { url = "https://files.pythonhosted.org/packages/00/66/327046cfe276a6e4af1a9a58fc99321e25783e501dc68c4c82de2d1bd3a7/watchfiles-1.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ac1be85fe43b4bf9a251978ce5c3bb30e1ada9784290441f5423a28633a958a7", size = 381177 }, + { url = "https://files.pythonhosted.org/packages/66/8a/420e2833deaa88e8ca7d94a497ec60fde610c66206a1776f049dc5ad3a4e/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2ec98e31e1844eac860e70d9247db9d75440fc8f5f679c37d01914568d18721", size = 441293 }, + { url = "https://files.pythonhosted.org/packages/58/56/2627795ecdf3f0f361458cfa74c583d5041615b9ad81bc25f8c66a6c44a2/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0179252846be03fa97d4d5f8233d1c620ef004855f0717712ae1c558f1974a16", size = 446209 }, + { url = "https://files.pythonhosted.org/packages/8f/d0/11c8dcd8a9995f0c075d76f1d06068bbb7a17583a19c5be75361497a4074/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:995c374e86fa82126c03c5b4630c4e312327ecfe27761accb25b5e1d7ab50ec8", size = 471227 }, + { url = "https://files.pythonhosted.org/packages/cb/8f/baa06574eaf48173882c4cdc3636993d0854661be7d88193e015ef996c73/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29b9cb35b7f290db1c31fb2fdf8fc6d3730cfa4bca4b49761083307f441cac5a", size = 493205 }, + { url = "https://files.pythonhosted.org/packages/ee/e8/9af886b4d3daa281047b542ffd2eb8f76dae9dd6ca0e21c5df4593b98574/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f8dc09ae69af50bead60783180f656ad96bd33ffbf6e7a6fce900f6d53b08f1", size = 489090 }, + { url = "https://files.pythonhosted.org/packages/81/02/62085db54b151fc02e22d47b288d19e99031dc9af73151289a7ab6621f9a/watchfiles-1.0.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:489b80812f52a8d8c7b0d10f0d956db0efed25df2821c7a934f6143f76938bd6", size = 442610 }, + { url = "https://files.pythonhosted.org/packages/61/81/980439c5d3fd3c69ba7124a56e1016d0b824ced2192ffbfe7062d53f524b/watchfiles-1.0.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:228e2247de583475d4cebf6b9af5dc9918abb99d1ef5ee737155bb39fb33f3c0", size = 614781 }, + { url = "https://files.pythonhosted.org/packages/55/98/e11401d8e9cd5d2bd0e95e9bf750f397489681965ee0c72fb84732257912/watchfiles-1.0.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1550be1a5cb3be08a3fb84636eaafa9b7119b70c71b0bed48726fd1d5aa9b868", size = 612637 }, + { url = "https://files.pythonhosted.org/packages/50/be/8393b68f2add0f839be6863f151bd6a7b242efc6eb2ce0c9f7d135d529cc/watchfiles-1.0.3-cp313-cp313-win32.whl", hash = "sha256:16db2d7e12f94818cbf16d4c8938e4d8aaecee23826344addfaaa671a1527b07", size = 271170 }, + { url = "https://files.pythonhosted.org/packages/f0/da/725f97a8b1b4e7b3e4331cce3ef921b12568af3af403b9f0f61ede036898/watchfiles-1.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:160eff7d1267d7b025e983ca8460e8cc67b328284967cbe29c05f3c3163711a3", size = 285246 }, +] + +[[package]] +name = "websockets" +version = "14.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/1b/380b883ce05bb5f45a905b61790319a28958a9ab1e4b6b95ff5464b60ca1/websockets-14.1.tar.gz", hash = "sha256:398b10c77d471c0aab20a845e7a60076b6390bfdaac7a6d2edb0d2c59d75e8d8", size = 162840 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/64/55698544ce29e877c9188f1aee9093712411a8fc9732cca14985e49a8e9c/websockets-14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed907449fe5e021933e46a3e65d651f641975a768d0649fee59f10c2985529ed", size = 161957 }, + { url = "https://files.pythonhosted.org/packages/a2/b1/b088f67c2b365f2c86c7b48edb8848ac27e508caf910a9d9d831b2f343cb/websockets-14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:87e31011b5c14a33b29f17eb48932e63e1dcd3fa31d72209848652310d3d1f0d", size = 159620 }, + { url = "https://files.pythonhosted.org/packages/c1/89/2a09db1bbb40ba967a1b8225b07b7df89fea44f06de9365f17f684d0f7e6/websockets-14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bc6ccf7d54c02ae47a48ddf9414c54d48af9c01076a2e1023e3b486b6e72c707", size = 159852 }, + { url = "https://files.pythonhosted.org/packages/ca/c1/f983138cd56e7d3079f1966e81f77ce6643f230cd309f73aa156bb181749/websockets-14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9777564c0a72a1d457f0848977a1cbe15cfa75fa2f67ce267441e465717dcf1a", size = 169675 }, + { url = "https://files.pythonhosted.org/packages/c1/c8/84191455d8660e2a0bdb33878d4ee5dfa4a2cedbcdc88bbd097303b65bfa/websockets-14.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a655bde548ca98f55b43711b0ceefd2a88a71af6350b0c168aa77562104f3f45", size = 168619 }, + { url = "https://files.pythonhosted.org/packages/8d/a7/62e551fdcd7d44ea74a006dc193aba370505278ad76efd938664531ce9d6/websockets-14.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3dfff83ca578cada2d19e665e9c8368e1598d4e787422a460ec70e531dbdd58", size = 169042 }, + { url = "https://files.pythonhosted.org/packages/ad/ed/1532786f55922c1e9c4d329608e36a15fdab186def3ca9eb10d7465bc1cc/websockets-14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6a6c9bcf7cdc0fd41cc7b7944447982e8acfd9f0d560ea6d6845428ed0562058", size = 169345 }, + { url = "https://files.pythonhosted.org/packages/ea/fb/160f66960d495df3de63d9bcff78e1b42545b2a123cc611950ffe6468016/websockets-14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4b6caec8576e760f2c7dd878ba817653144d5f369200b6ddf9771d64385b84d4", size = 168725 }, + { url = "https://files.pythonhosted.org/packages/cf/53/1bf0c06618b5ac35f1d7906444b9958f8485682ab0ea40dee7b17a32da1e/websockets-14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb6d38971c800ff02e4a6afd791bbe3b923a9a57ca9aeab7314c21c84bf9ff05", size = 168712 }, + { url = "https://files.pythonhosted.org/packages/e5/22/5ec2f39fff75f44aa626f86fa7f20594524a447d9c3be94d8482cd5572ef/websockets-14.1-cp312-cp312-win32.whl", hash = "sha256:1d045cbe1358d76b24d5e20e7b1878efe578d9897a25c24e6006eef788c0fdf0", size = 162838 }, + { url = "https://files.pythonhosted.org/packages/74/27/28f07df09f2983178db7bf6c9cccc847205d2b92ced986cd79565d68af4f/websockets-14.1-cp312-cp312-win_amd64.whl", hash = "sha256:90f4c7a069c733d95c308380aae314f2cb45bd8a904fb03eb36d1a4983a4993f", size = 163277 }, + { url = "https://files.pythonhosted.org/packages/34/77/812b3ba5110ed8726eddf9257ab55ce9e85d97d4aa016805fdbecc5e5d48/websockets-14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3630b670d5057cd9e08b9c4dab6493670e8e762a24c2c94ef312783870736ab9", size = 161966 }, + { url = "https://files.pythonhosted.org/packages/8d/24/4fcb7aa6986ae7d9f6d083d9d53d580af1483c5ec24bdec0978307a0f6ac/websockets-14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36ebd71db3b89e1f7b1a5deaa341a654852c3518ea7a8ddfdf69cc66acc2db1b", size = 159625 }, + { url = "https://files.pythonhosted.org/packages/f8/47/2a0a3a2fc4965ff5b9ce9324d63220156bd8bedf7f90824ab92a822e65fd/websockets-14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5b918d288958dc3fa1c5a0b9aa3256cb2b2b84c54407f4813c45d52267600cd3", size = 159857 }, + { url = "https://files.pythonhosted.org/packages/dd/c8/d7b425011a15e35e17757e4df75b25e1d0df64c0c315a44550454eaf88fc/websockets-14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00fe5da3f037041da1ee0cf8e308374e236883f9842c7c465aa65098b1c9af59", size = 169635 }, + { url = "https://files.pythonhosted.org/packages/93/39/6e3b5cffa11036c40bd2f13aba2e8e691ab2e01595532c46437b56575678/websockets-14.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8149a0f5a72ca36720981418eeffeb5c2729ea55fa179091c81a0910a114a5d2", size = 168578 }, + { url = "https://files.pythonhosted.org/packages/cf/03/8faa5c9576299b2adf34dcccf278fc6bbbcda8a3efcc4d817369026be421/websockets-14.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77569d19a13015e840b81550922056acabc25e3f52782625bc6843cfa034e1da", size = 169018 }, + { url = "https://files.pythonhosted.org/packages/8c/05/ea1fec05cc3a60defcdf0bb9f760c3c6bd2dd2710eff7ac7f891864a22ba/websockets-14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cf5201a04550136ef870aa60ad3d29d2a59e452a7f96b94193bee6d73b8ad9a9", size = 169383 }, + { url = "https://files.pythonhosted.org/packages/21/1d/eac1d9ed787f80754e51228e78855f879ede1172c8b6185aca8cef494911/websockets-14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:88cf9163ef674b5be5736a584c999e98daf3aabac6e536e43286eb74c126b9c7", size = 168773 }, + { url = "https://files.pythonhosted.org/packages/0e/1b/e808685530185915299740d82b3a4af3f2b44e56ccf4389397c7a5d95d39/websockets-14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:836bef7ae338a072e9d1863502026f01b14027250a4545672673057997d5c05a", size = 168757 }, + { url = "https://files.pythonhosted.org/packages/b6/19/6ab716d02a3b068fbbeb6face8a7423156e12c446975312f1c7c0f4badab/websockets-14.1-cp313-cp313-win32.whl", hash = "sha256:0d4290d559d68288da9f444089fd82490c8d2744309113fc26e2da6e48b65da6", size = 162834 }, + { url = "https://files.pythonhosted.org/packages/6c/fd/ab6b7676ba712f2fc89d1347a4b5bdc6aa130de10404071f2b2606450209/websockets-14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8621a07991add373c3c5c2cf89e1d277e49dc82ed72c75e3afc74bd0acc446f0", size = 163277 }, + { url = "https://files.pythonhosted.org/packages/b0/0b/c7e5d11020242984d9d37990310520ed663b942333b83a033c2f20191113/websockets-14.1-py3-none-any.whl", hash = "sha256:4d4fc827a20abe6d544a119896f6b78ee13fe81cbfef416f3f2ddf09a03f0e2e", size = 156277 }, +] + +[[package]] +name = "xxhash" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/5e/d6e5258d69df8b4ed8c83b6664f2b47d30d2dec551a29ad72a6c69eafd31/xxhash-3.5.0.tar.gz", hash = "sha256:84f2caddf951c9cbf8dc2e22a89d4ccf5d86391ac6418fe81e3c67d0cf60b45f", size = 84241 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/0e/1bfce2502c57d7e2e787600b31c83535af83746885aa1a5f153d8c8059d6/xxhash-3.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:14470ace8bd3b5d51318782cd94e6f94431974f16cb3b8dc15d52f3b69df8e00", size = 31969 }, + { url = "https://files.pythonhosted.org/packages/3f/d6/8ca450d6fe5b71ce521b4e5db69622383d039e2b253e9b2f24f93265b52c/xxhash-3.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:59aa1203de1cb96dbeab595ded0ad0c0056bb2245ae11fac11c0ceea861382b9", size = 30787 }, + { url = "https://files.pythonhosted.org/packages/5b/84/de7c89bc6ef63d750159086a6ada6416cc4349eab23f76ab870407178b93/xxhash-3.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08424f6648526076e28fae6ea2806c0a7d504b9ef05ae61d196d571e5c879c84", size = 220959 }, + { url = "https://files.pythonhosted.org/packages/fe/86/51258d3e8a8545ff26468c977101964c14d56a8a37f5835bc0082426c672/xxhash-3.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:61a1ff00674879725b194695e17f23d3248998b843eb5e933007ca743310f793", size = 200006 }, + { url = "https://files.pythonhosted.org/packages/02/0a/96973bd325412feccf23cf3680fd2246aebf4b789122f938d5557c54a6b2/xxhash-3.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2f2c61bee5844d41c3eb015ac652a0229e901074951ae48581d58bfb2ba01be", size = 428326 }, + { url = "https://files.pythonhosted.org/packages/11/a7/81dba5010f7e733de88af9555725146fc133be97ce36533867f4c7e75066/xxhash-3.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d32a592cac88d18cc09a89172e1c32d7f2a6e516c3dfde1b9adb90ab5df54a6", size = 194380 }, + { url = "https://files.pythonhosted.org/packages/fb/7d/f29006ab398a173f4501c0e4977ba288f1c621d878ec217b4ff516810c04/xxhash-3.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70dabf941dede727cca579e8c205e61121afc9b28516752fd65724be1355cc90", size = 207934 }, + { url = "https://files.pythonhosted.org/packages/8a/6e/6e88b8f24612510e73d4d70d9b0c7dff62a2e78451b9f0d042a5462c8d03/xxhash-3.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e5d0ddaca65ecca9c10dcf01730165fd858533d0be84c75c327487c37a906a27", size = 216301 }, + { url = "https://files.pythonhosted.org/packages/af/51/7862f4fa4b75a25c3b4163c8a873f070532fe5f2d3f9b3fc869c8337a398/xxhash-3.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e5b5e16c5a480fe5f59f56c30abdeba09ffd75da8d13f6b9b6fd224d0b4d0a2", size = 203351 }, + { url = "https://files.pythonhosted.org/packages/22/61/8d6a40f288f791cf79ed5bb113159abf0c81d6efb86e734334f698eb4c59/xxhash-3.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149b7914451eb154b3dfaa721315117ea1dac2cc55a01bfbd4df7c68c5dd683d", size = 210294 }, + { url = "https://files.pythonhosted.org/packages/17/02/215c4698955762d45a8158117190261b2dbefe9ae7e5b906768c09d8bc74/xxhash-3.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:eade977f5c96c677035ff39c56ac74d851b1cca7d607ab3d8f23c6b859379cab", size = 414674 }, + { url = "https://files.pythonhosted.org/packages/31/5c/b7a8db8a3237cff3d535261325d95de509f6a8ae439a5a7a4ffcff478189/xxhash-3.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fa9f547bd98f5553d03160967866a71056a60960be00356a15ecc44efb40ba8e", size = 192022 }, + { url = "https://files.pythonhosted.org/packages/78/e3/dd76659b2811b3fd06892a8beb850e1996b63e9235af5a86ea348f053e9e/xxhash-3.5.0-cp312-cp312-win32.whl", hash = "sha256:f7b58d1fd3551b8c80a971199543379be1cee3d0d409e1f6d8b01c1a2eebf1f8", size = 30170 }, + { url = "https://files.pythonhosted.org/packages/d9/6b/1c443fe6cfeb4ad1dcf231cdec96eb94fb43d6498b4469ed8b51f8b59a37/xxhash-3.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:fa0cafd3a2af231b4e113fba24a65d7922af91aeb23774a8b78228e6cd785e3e", size = 30040 }, + { url = "https://files.pythonhosted.org/packages/0f/eb/04405305f290173acc0350eba6d2f1a794b57925df0398861a20fbafa415/xxhash-3.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:586886c7e89cb9828bcd8a5686b12e161368e0064d040e225e72607b43858ba2", size = 26796 }, + { url = "https://files.pythonhosted.org/packages/c9/b8/e4b3ad92d249be5c83fa72916c9091b0965cb0faeff05d9a0a3870ae6bff/xxhash-3.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37889a0d13b0b7d739cfc128b1c902f04e32de17b33d74b637ad42f1c55101f6", size = 31795 }, + { url = "https://files.pythonhosted.org/packages/fc/d8/b3627a0aebfbfa4c12a41e22af3742cf08c8ea84f5cc3367b5de2d039cce/xxhash-3.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:97a662338797c660178e682f3bc180277b9569a59abfb5925e8620fba00b9fc5", size = 30792 }, + { url = "https://files.pythonhosted.org/packages/c3/cc/762312960691da989c7cd0545cb120ba2a4148741c6ba458aa723c00a3f8/xxhash-3.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f85e0108d51092bdda90672476c7d909c04ada6923c14ff9d913c4f7dc8a3bc", size = 220950 }, + { url = "https://files.pythonhosted.org/packages/fe/e9/cc266f1042c3c13750e86a535496b58beb12bf8c50a915c336136f6168dc/xxhash-3.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd2fd827b0ba763ac919440042302315c564fdb797294d86e8cdd4578e3bc7f3", size = 199980 }, + { url = "https://files.pythonhosted.org/packages/bf/85/a836cd0dc5cc20376de26b346858d0ac9656f8f730998ca4324921a010b9/xxhash-3.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82085c2abec437abebf457c1d12fccb30cc8b3774a0814872511f0f0562c768c", size = 428324 }, + { url = "https://files.pythonhosted.org/packages/b4/0e/15c243775342ce840b9ba34aceace06a1148fa1630cd8ca269e3223987f5/xxhash-3.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07fda5de378626e502b42b311b049848c2ef38784d0d67b6f30bb5008642f8eb", size = 194370 }, + { url = "https://files.pythonhosted.org/packages/87/a1/b028bb02636dfdc190da01951d0703b3d904301ed0ef6094d948983bef0e/xxhash-3.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c279f0d2b34ef15f922b77966640ade58b4ccdfef1c4d94b20f2a364617a493f", size = 207911 }, + { url = "https://files.pythonhosted.org/packages/80/d5/73c73b03fc0ac73dacf069fdf6036c9abad82de0a47549e9912c955ab449/xxhash-3.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:89e66ceed67b213dec5a773e2f7a9e8c58f64daeb38c7859d8815d2c89f39ad7", size = 216352 }, + { url = "https://files.pythonhosted.org/packages/b6/2a/5043dba5ddbe35b4fe6ea0a111280ad9c3d4ba477dd0f2d1fe1129bda9d0/xxhash-3.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bcd51708a633410737111e998ceb3b45d3dbc98c0931f743d9bb0a209033a326", size = 203410 }, + { url = "https://files.pythonhosted.org/packages/a2/b2/9a8ded888b7b190aed75b484eb5c853ddd48aa2896e7b59bbfbce442f0a1/xxhash-3.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ff2c0a34eae7df88c868be53a8dd56fbdf592109e21d4bfa092a27b0bf4a7bf", size = 210322 }, + { url = "https://files.pythonhosted.org/packages/98/62/440083fafbc917bf3e4b67c2ade621920dd905517e85631c10aac955c1d2/xxhash-3.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:4e28503dccc7d32e0b9817aa0cbfc1f45f563b2c995b7a66c4c8a0d232e840c7", size = 414725 }, + { url = "https://files.pythonhosted.org/packages/75/db/009206f7076ad60a517e016bb0058381d96a007ce3f79fa91d3010f49cc2/xxhash-3.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a6c50017518329ed65a9e4829154626f008916d36295b6a3ba336e2458824c8c", size = 192070 }, + { url = "https://files.pythonhosted.org/packages/1f/6d/c61e0668943a034abc3a569cdc5aeae37d686d9da7e39cf2ed621d533e36/xxhash-3.5.0-cp313-cp313-win32.whl", hash = "sha256:53a068fe70301ec30d868ece566ac90d873e3bb059cf83c32e76012c889b8637", size = 30172 }, + { url = "https://files.pythonhosted.org/packages/96/14/8416dce965f35e3d24722cdf79361ae154fa23e2ab730e5323aa98d7919e/xxhash-3.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:80babcc30e7a1a484eab952d76a4f4673ff601f54d5142c26826502740e70b43", size = 30041 }, + { url = "https://files.pythonhosted.org/packages/27/ee/518b72faa2073f5aa8e3262408d284892cb79cf2754ba0c3a5870645ef73/xxhash-3.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:4811336f1ce11cac89dcbd18f3a25c527c16311709a89313c3acaf771def2d4b", size = 26801 }, +] + +[[package]] +name = "yarl" +version = "1.18.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/9d/4b94a8e6d2b51b599516a5cb88e5bc99b4d8d4583e468057eaa29d5f0918/yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1", size = 181062 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/85/bd2e2729752ff4c77338e0102914897512e92496375e079ce0150a6dc306/yarl-1.18.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1dd4bdd05407ced96fed3d7f25dbbf88d2ffb045a0db60dbc247f5b3c5c25d50", size = 142644 }, + { url = "https://files.pythonhosted.org/packages/ff/74/1178322cc0f10288d7eefa6e4a85d8d2e28187ccab13d5b844e8b5d7c88d/yarl-1.18.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7c33dd1931a95e5d9a772d0ac5e44cac8957eaf58e3c8da8c1414de7dd27c576", size = 94962 }, + { url = "https://files.pythonhosted.org/packages/be/75/79c6acc0261e2c2ae8a1c41cf12265e91628c8c58ae91f5ff59e29c0787f/yarl-1.18.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b411eddcfd56a2f0cd6a384e9f4f7aa3efee14b188de13048c25b5e91f1640", size = 92795 }, + { url = "https://files.pythonhosted.org/packages/6b/32/927b2d67a412c31199e83fefdce6e645247b4fb164aa1ecb35a0f9eb2058/yarl-1.18.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:436c4fc0a4d66b2badc6c5fc5ef4e47bb10e4fd9bf0c79524ac719a01f3607c2", size = 332368 }, + { url = "https://files.pythonhosted.org/packages/19/e5/859fca07169d6eceeaa4fde1997c91d8abde4e9a7c018e371640c2da2b71/yarl-1.18.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e35ef8683211db69ffe129a25d5634319a677570ab6b2eba4afa860f54eeaf75", size = 342314 }, + { url = "https://files.pythonhosted.org/packages/08/75/76b63ccd91c9e03ab213ef27ae6add2e3400e77e5cdddf8ed2dbc36e3f21/yarl-1.18.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:84b2deecba4a3f1a398df819151eb72d29bfeb3b69abb145a00ddc8d30094512", size = 341987 }, + { url = "https://files.pythonhosted.org/packages/1a/e1/a097d5755d3ea8479a42856f51d97eeff7a3a7160593332d98f2709b3580/yarl-1.18.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e5a1fea0fd4f5bfa7440a47eff01d9822a65b4488f7cff83155a0f31a2ecba", size = 336914 }, + { url = "https://files.pythonhosted.org/packages/0b/42/e1b4d0e396b7987feceebe565286c27bc085bf07d61a59508cdaf2d45e63/yarl-1.18.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d0e883008013c0e4aef84dcfe2a0b172c4d23c2669412cf5b3371003941f72bb", size = 325765 }, + { url = "https://files.pythonhosted.org/packages/7e/18/03a5834ccc9177f97ca1bbb245b93c13e58e8225276f01eedc4cc98ab820/yarl-1.18.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5a3f356548e34a70b0172d8890006c37be92995f62d95a07b4a42e90fba54272", size = 344444 }, + { url = "https://files.pythonhosted.org/packages/c8/03/a713633bdde0640b0472aa197b5b86e90fbc4c5bc05b727b714cd8a40e6d/yarl-1.18.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ccd17349166b1bee6e529b4add61727d3f55edb7babbe4069b5764c9587a8cc6", size = 340760 }, + { url = "https://files.pythonhosted.org/packages/eb/99/f6567e3f3bbad8fd101886ea0276c68ecb86a2b58be0f64077396cd4b95e/yarl-1.18.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b958ddd075ddba5b09bb0be8a6d9906d2ce933aee81100db289badbeb966f54e", size = 346484 }, + { url = "https://files.pythonhosted.org/packages/8e/a9/84717c896b2fc6cb15bd4eecd64e34a2f0a9fd6669e69170c73a8b46795a/yarl-1.18.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c7d79f7d9aabd6011004e33b22bc13056a3e3fb54794d138af57f5ee9d9032cb", size = 359864 }, + { url = "https://files.pythonhosted.org/packages/1e/2e/d0f5f1bef7ee93ed17e739ec8dbcb47794af891f7d165fa6014517b48169/yarl-1.18.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4891ed92157e5430874dad17b15eb1fda57627710756c27422200c52d8a4e393", size = 364537 }, + { url = "https://files.pythonhosted.org/packages/97/8a/568d07c5d4964da5b02621a517532adb8ec5ba181ad1687191fffeda0ab6/yarl-1.18.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ce1af883b94304f493698b00d0f006d56aea98aeb49d75ec7d98cd4a777e9285", size = 357861 }, + { url = "https://files.pythonhosted.org/packages/7d/e3/924c3f64b6b3077889df9a1ece1ed8947e7b61b0a933f2ec93041990a677/yarl-1.18.3-cp312-cp312-win32.whl", hash = "sha256:f91c4803173928a25e1a55b943c81f55b8872f0018be83e3ad4938adffb77dd2", size = 84097 }, + { url = "https://files.pythonhosted.org/packages/34/45/0e055320daaabfc169b21ff6174567b2c910c45617b0d79c68d7ab349b02/yarl-1.18.3-cp312-cp312-win_amd64.whl", hash = "sha256:7e2ee16578af3b52ac2f334c3b1f92262f47e02cc6193c598502bd46f5cd1477", size = 90399 }, + { url = "https://files.pythonhosted.org/packages/30/c7/c790513d5328a8390be8f47be5d52e141f78b66c6c48f48d241ca6bd5265/yarl-1.18.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:90adb47ad432332d4f0bc28f83a5963f426ce9a1a8809f5e584e704b82685dcb", size = 140789 }, + { url = "https://files.pythonhosted.org/packages/30/aa/a2f84e93554a578463e2edaaf2300faa61c8701f0898725842c704ba5444/yarl-1.18.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:913829534200eb0f789d45349e55203a091f45c37a2674678744ae52fae23efa", size = 94144 }, + { url = "https://files.pythonhosted.org/packages/c6/fc/d68d8f83714b221a85ce7866832cba36d7c04a68fa6a960b908c2c84f325/yarl-1.18.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ef9f7768395923c3039055c14334ba4d926f3baf7b776c923c93d80195624782", size = 91974 }, + { url = "https://files.pythonhosted.org/packages/56/4e/d2563d8323a7e9a414b5b25341b3942af5902a2263d36d20fb17c40411e2/yarl-1.18.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a19f62ff30117e706ebc9090b8ecc79aeb77d0b1f5ec10d2d27a12bc9f66d0", size = 333587 }, + { url = "https://files.pythonhosted.org/packages/25/c9/cfec0bc0cac8d054be223e9f2c7909d3e8442a856af9dbce7e3442a8ec8d/yarl-1.18.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e17c9361d46a4d5addf777c6dd5eab0715a7684c2f11b88c67ac37edfba6c482", size = 344386 }, + { url = "https://files.pythonhosted.org/packages/ab/5d/4c532190113b25f1364d25f4c319322e86232d69175b91f27e3ebc2caf9a/yarl-1.18.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a74a13a4c857a84a845505fd2d68e54826a2cd01935a96efb1e9d86c728e186", size = 345421 }, + { url = "https://files.pythonhosted.org/packages/23/d1/6cdd1632da013aa6ba18cee4d750d953104a5e7aac44e249d9410a972bf5/yarl-1.18.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41f7ce59d6ee7741af71d82020346af364949314ed3d87553763a2df1829cc58", size = 339384 }, + { url = "https://files.pythonhosted.org/packages/9a/c4/6b3c39bec352e441bd30f432cda6ba51681ab19bb8abe023f0d19777aad1/yarl-1.18.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f52a265001d830bc425f82ca9eabda94a64a4d753b07d623a9f2863fde532b53", size = 326689 }, + { url = "https://files.pythonhosted.org/packages/23/30/07fb088f2eefdc0aa4fc1af4e3ca4eb1a3aadd1ce7d866d74c0f124e6a85/yarl-1.18.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:82123d0c954dc58db301f5021a01854a85bf1f3bb7d12ae0c01afc414a882ca2", size = 345453 }, + { url = "https://files.pythonhosted.org/packages/63/09/d54befb48f9cd8eec43797f624ec37783a0266855f4930a91e3d5c7717f8/yarl-1.18.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2ec9bbba33b2d00999af4631a3397d1fd78290c48e2a3e52d8dd72db3a067ac8", size = 341872 }, + { url = "https://files.pythonhosted.org/packages/91/26/fd0ef9bf29dd906a84b59f0cd1281e65b0c3e08c6aa94b57f7d11f593518/yarl-1.18.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fbd6748e8ab9b41171bb95c6142faf068f5ef1511935a0aa07025438dd9a9bc1", size = 347497 }, + { url = "https://files.pythonhosted.org/packages/d9/b5/14ac7a256d0511b2ac168d50d4b7d744aea1c1aa20c79f620d1059aab8b2/yarl-1.18.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:877d209b6aebeb5b16c42cbb377f5f94d9e556626b1bfff66d7b0d115be88d0a", size = 359981 }, + { url = "https://files.pythonhosted.org/packages/ca/b3/d493221ad5cbd18bc07e642894030437e405e1413c4236dd5db6e46bcec9/yarl-1.18.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b464c4ab4bfcb41e3bfd3f1c26600d038376c2de3297760dfe064d2cb7ea8e10", size = 366229 }, + { url = "https://files.pythonhosted.org/packages/04/56/6a3e2a5d9152c56c346df9b8fb8edd2c8888b1e03f96324d457e5cf06d34/yarl-1.18.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8d39d351e7faf01483cc7ff7c0213c412e38e5a340238826be7e0e4da450fdc8", size = 360383 }, + { url = "https://files.pythonhosted.org/packages/fd/b7/4b3c7c7913a278d445cc6284e59b2e62fa25e72758f888b7a7a39eb8423f/yarl-1.18.3-cp313-cp313-win32.whl", hash = "sha256:61ee62ead9b68b9123ec24bc866cbef297dd266175d53296e2db5e7f797f902d", size = 310152 }, + { url = "https://files.pythonhosted.org/packages/f5/d5/688db678e987c3e0fb17867970700b92603cadf36c56e5fb08f23e822a0c/yarl-1.18.3-cp313-cp313-win_amd64.whl", hash = "sha256:578e281c393af575879990861823ef19d66e2b1d0098414855dd367e234f5b3c", size = 315723 }, + { url = "https://files.pythonhosted.org/packages/f5/4b/a06e0ec3d155924f77835ed2d167ebd3b211a7b0853da1cf8d8414d784ef/yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b", size = 45109 }, +]