mindee-lite 5.0.0a1__py3-none-any.whl

docs/conf.py

@@ -0,0 +1,76 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = "Mindee Python Client"
+copyright = "2022, Mindee"
+author = "Mindee"
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx_autodoc_typehints",
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_rtd_theme"
+html_theme_options = {
+    "body_max_width": "none",
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = []
+
+# A list of paths that contain extra files not directly related to the documentation.
+html_extra_path = ["extras"]
+
+
+# -- autodoc -----------------------------------------------------------------
+
+autodoc_member_order = "groupwise"
+# autodoc_class_signature = "separated" # breaks new syntaxes
+
+# Hides prepended module names wich caused some classes to overflow on the right of the screen.
+add_module_names = False
+autodoc_typehints = "description"
+autodoc_default_options = {"exclude-members": "__init__"}
+
+# -- autodoc-typehints -------------------------------------------------------
+
+typehints_defaults = "comma"
+suppress_warnings = ["ref.python"]

local_test/future_code_sample.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from mindee.v1.client import Client, InferenceParameters
+from mindee.v2.product.extraction.extraction_response import ExtractionResponse
+from tests.v1.product import PRODUCT_DATA_DIR
+from tests.test_inputs import FILE_TYPES_DIR
+
+default_sample_path: Path = (
+    PRODUCT_DATA_DIR / "financial_document" / "default_sample.jpg"
+)
+blank_sample_path: Path = FILE_TYPES_DIR / "pdf" / "blank_1.pdf"
+
+v2_client = Client("mk_IEn6iaNKYIgeP5hfRS4BkaZMkSINZw0C")
+default_sample = v2_client.source_from_path(default_sample_path)
+options = InferenceParameters(model_id="94340559-b994-45e6-8b5c-be626027f1b2")
+
+response_default: ExtractionResponse = v2_client.enqueue_and_get_inference(
+    default_sample, options
+)
+# response: PollingResponse = v2_client.enqueue(input_doc, options)
+# print(response.raw_http)
+with open("local_test/default_sample.json", "w", encoding="utf-8") as out_file:
+    out_file.write(str(response_default.raw_http))
+
+blank_sample = v2_client.source_from_path(blank_sample_path)
+response_blank: ExtractionResponse = v2_client.enqueue_and_get_inference(
+    blank_sample, options
+)
+
+with open("local_test/blank.json", "w", encoding="utf-8") as out_file:
+    out_file.write(str(response_blank.raw_http))

local_test/libless_test.py

@@ -0,0 +1,56 @@
+import json
+import time
+import requests
+from pathlib import Path
+
+
+def send_file_with_polling(
+        file_path: str,
+        model_id: str,
+        api_key: str,
+        max_retries: int = 30,
+        polling_interval: int = 2,
+) -> dict:
+    upload_file = Path(file_path)
+    headers = {"Authorization": api_key}
+    form_data = {"model_id": model_id, "rag": False}
+    with upload_file.open("rb") as fh:
+        files = {"file": (upload_file.name, fh)}
+        print(f"Enqueuing file: {upload_file}")
+        response = requests.post(
+            url="http://127.0.0.1:3915/v2/inferences/enqueue",
+            files=files,
+            data=form_data,
+            headers=headers,
+        )
+    response.raise_for_status()
+    job_data = response.json().get("job")
+    polling_url = job_data.get("polling_url")
+
+    # Important to wait before attempting to poll
+    time.sleep(3)
+
+    # Poll for completion
+    for attempt in range(max_retries):
+        print(f"Polling on: {polling_url}")
+        poll_response = requests.get(polling_url, headers=headers, allow_redirects=False)
+        poll_data = poll_response.json()
+        job_status = poll_data.get("job", {}).get("status")
+        if poll_response.status_code == 302 or job_status == "Processed":
+            result_url = poll_data.get("job", {}).get("result_url")
+            print(f"Get result from: {result_url}")
+            result_response = requests.get(result_url, headers=headers)
+            result_data = result_response.json()
+            return result_data
+        # still processing, wait before next poll
+        time.sleep(polling_interval)
+    # If we've exhausted all retries
+    raise TimeoutError(f"Polling timed out after {max_retries} attempts")
+
+
+response = send_file_with_polling(
+    file_path="/home/seb/work/mindee/client-lib-test-data/v2/products/financial_document/default_sample.jpg",
+    model_id="d52d4a67-5d9e-43bf-9203-0675d3bf1d6d",
+    api_key="md_9yc6r4cjdhxamdn1l6nbg7vnaj2y8psb",
+)
+print(json.dumps(response, indent=2))

local_test/load_prediction.py

@@ -0,0 +1,13 @@
+import mindee
+from pathlib import Path
+
+mindee_client = mindee.Client()
+
+in_path = "/home/seb/work/mindee/client-lib-test-data/products/us_healthcare_cards/response_v1/complete.json"
+with open(in_path, "r", encoding="utf-8") as in_file:
+    print(in_file.read())
+result = mindee_client.load_prediction(mindee.product.us.HealthcareCardV1, mindee.LocalResponse(in_path))
+output_path = Path("local_test").resolve() / "out.txt"
+output_path.parent.mkdir(parents=True, exist_ok=True)
+with open(output_path, "w", encoding="utf-8") as out_file:
+    out_file.write(str(result.document))

local_test/modsearch.py

@@ -0,0 +1,7 @@
+from mindee.v2.client import Client
+
+
+m_client = Client()
+
+models = m_client.search_models(model_type="crop")
+print(models)

local_test/quick_findocV2_test.py

@@ -0,0 +1,26 @@
+from mindee.v1.client import Client, InferenceParameters, PollingOptions
+import os
+from mindee.logger import logger
+
+LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG").upper()
+
+logger.info("Initializing Mindee client")
+mindee_client = Client("md_afm8g0osoy5g9nxqr8lbrgyxhtz280zc")
+
+input_doc = mindee_client.source_from_path(
+    "/home/seb/Downloads/cd457d57-dca6-4d65-a68d-e77215ba58ff.pdf"
+)
+
+result = mindee_client.enqueue_and_get_inference(
+    input_doc,
+    InferenceParameters(
+        model_id="b4126d15-3dd9-412f-8f78-7c4982583794",
+        confidence=True,
+        polling_options=PollingOptions(1, 1),
+    ),
+)
+
+print(result.raw_http)
+
+# Print the document-level summary
+# print(result.document.inference.prediction)

local_test/quick_findoc_test.py

@@ -0,0 +1,20 @@
+from mindee.v1.client import Client, AsyncPredictResponse
+from mindee.v1 import product
+
+# Init a new client
+mindee_client = Client()
+
+with open("/home/seb/Documents/lucca/5091817238976J.pdf", "rb") as f_rb:
+    input_doc = mindee_client.source_from_bytes(f_rb.read(), "filename.pdf")
+
+# Load a file from disk and parse it.
+result: AsyncPredictResponse = mindee_client.parse(
+    product.FinancialDocumentV1,
+    input_doc,
+)
+
+# Print a summary of the API result
+print(result.raw_http)
+
+# Print the document-level summary
+# print(result.document.inference.prediction)

local_test/script_bashir.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from typing import Any, BinaryIO
+
+from mindee import (
+    ClassificationParameters,
+    ClassificationResponse,
+    Client,
+    CropParameters,
+    CropResponse,
+    ExtractionParameters,
+    ExtractionResponse,
+    JobResponse,
+    LocalResponse,
+    OCRParameters,
+    OCRResponse,
+    PathInput,
+    SplitParameters,
+    SplitResponse,
+)
+import os
+
+from mindee.input import BaseParameters
+from mindee.parsing.common.common_response import CommonResponse
+
+
+def full_parse(params, input_source) -> ExtractionResponse:
+    return mindee_client.enqueue_and_get_result(
+        ExtractionResponse,
+        input_source,
+        params,
+    )
+
+
+def enqueue_only(params, input_source) -> JobResponse:
+    return mindee_client.enqueue(
+        input_source,
+        params,
+    )
+
+
+def setup_params(
+    param_type: type[
+        ClassificationParameters
+        | CropParameters
+        | ExtractionParameters
+        | OCRParameters
+        | SplitParameters
+    ],
+    rag: bool = False,
+    raw_text: bool = False,
+    polygon: bool = False,
+    confidence: bool = False,
+    data_schema: str = None,
+    text_context: str = None,
+    alias: str = None,
+) -> BaseParameters:
+    kwargs: dict[str, Any] = {"close_file": False}
+    if alias:
+        kwargs["alias"] = alias
+    if param_type == ExtractionParameters:
+        kwargs = kwargs | {
+            "rag": rag,
+            "raw_text": raw_text,
+            "polygon": polygon,
+            "confidence": confidence,
+            "text_context": text_context,
+            "data_schema": data_schema,
+        }
+    return param_type(model_id=model_id, **kwargs)
+
+
+def setup_input(path):
+    return PathInput(path)
+
+
+def deserialize_webhook(
+    response: BinaryIO | str | Path | bytes,
+    product_type: type[
+        ClassificationResponse
+        | CropResponse
+        | ExtractionResponse
+        | JobResponse
+        | OCRResponse
+        | SplitResponse
+    ],
+) -> CommonResponse:
+    local_response = LocalResponse(response)
+    return local_response.deserialize_response(product_type)
+
+
+os.environ["MINDEE_V2_BASE_URL"] = "http://localhost:3915/v2"
+
+input_path = "/home/seb/Documents/blank_1.pdf"
+model_id = "762d24e7-666c-411d-abb4-947190f64538"
+api_key = "md_X1OvEuBk_ZMJBwII4wu5hb2e3sWlnQeAHaBwRyySbFM"
+
+mindee_client = Client(api_key)  # API key can be set from env `MINDEE_V2_API_KEY`
+
+params = setup_params(ExtractionParameters)
+local_input = setup_input(input_path)
+
+# Example with inference
+response_full_parse = full_parse(params, local_input)
+print(response_full_parse)
+
+job_response = enqueue_only(params, local_input)
+# Print job ID
+print(job_response.job.id)
+
+# For webhook deserialization:
+# webhook_response = deserialize_webhook(webhook_source, InferenceResponse)
+# print(webhook_response)

local_test/script_crop.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import mindee
+from mindee import CropParameters, CropResponse
+import os
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+client = mindee.Client("my_api_key")
+model_id = "model_id"
+local_input = mindee.PathInput("path/to/my/file.ext")
+output_path = Path(dir_path) / "cropped_files"
+
+params = CropParameters(model_id, close_file=False)
+
+result = client.enqueue_and_get_result(CropResponse, local_input, params)
+
+crop_files = result.extract_from_file(local_input)
+
+output_path.mkdir(parents=True, exist_ok=True)
+crop_files.save_all_to_disk(output_path)

local_test/script_split.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import mindee
+from mindee import SplitParameters, SplitResponse
+import os
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+client = mindee.Client("my_api_key")
+model_id = "model_id"
+local_input = mindee.PathInput("path/to/my/file.ext")
+output_path = Path(dir_path) / "split_files"
+
+params = SplitParameters(model_id, close_file=False)
+
+result = client.enqueue_and_get_result(SplitResponse, local_input, params)
+
+split_files = result.extract_from_file(local_input)
+
+output_path.mkdir(parents=True, exist_ok=True)
+split_files.save_all_to_disk(output_path)

local_test/test_demo.py

@@ -0,0 +1,4 @@
+import mindee
+
+client = mindee.Client("my_api_key")
+document = mindee.PathInput("/path/to/my/file.ext")

local_test/test_exp_syntax.py

@@ -0,0 +1,37 @@
+from mindee.v1.client import Client, InferenceParameters, InferenceResponse, PathInput
+
+input_path = "/home/seb/Documents/blank_1.pdf"
+api_key = "md_sMAC68Ixx5vvkp9aXCKn7pDUg2Rcx76H"
+model_id = "8fde5151-aa18-4c70-9289-fa04e50ca3b9"
+
+# Init a new client
+mindee_client = Client(api_key)
+
+# Set inference parameters
+params = InferenceParameters(
+    # ID of the model, required.
+    model_id=model_id,
+    # Options: set to `True` or `False` to override defaults
+    # Enhance extraction accuracy with Retrieval-Augmented Generation.
+    rag=None,
+    # Extract the full text content from the document as strings.
+    raw_text=None,
+    # Calculate bounding box polygons for all fields.
+    polygon=None,
+    # Boost the precision and accuracy of all extractions.
+    # Calculate confidence scores for all fields.
+    confidence=None,
+)
+
+# Load a file from disk
+input_source = PathInput(input_path)
+
+# Send for processing
+response = mindee_client.enqueue_and_get_result(
+    InferenceResponse,
+    input_source,
+    params,
+)
+
+# Print a brief summary of the parsed data
+print(response.inference)

local_test/test_rag_and_options.py

@@ -0,0 +1,41 @@
+from mindee.logger import logger
+from mindee.v1.client import Client, InferenceParameters, PathInput, PollingOptions
+
+input_path = (
+    "/home/seb/Downloads/0657_2025-08-01 CARLOS LLOMPART CABELLO_AAACOMPA00387.pdf"
+)
+api_key = "mk_IEn6iaNKYIgeP5hfRS4BkaZMkSINZw0C"
+model_id = "019a21ef-e0cc-4cc9-9694-57ff588b60f8"
+LOG_FORMAT = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+
+# Init a new client
+mindee_client = Client(api_key)
+
+logger.info("Starting Mindee inference for %s with model %s", input_path, model_id)
+
+
+# Set inference parameters
+params = InferenceParameters(
+    # ID of the model, required.
+    model_id=model_id,
+    # Options: set to `True` or `False` to override defaults
+    # Enhance extraction accuracy with Retrieval-Augmented Generation.
+    rag=True,
+    # Extract the full text content from the document as strings.
+    raw_text=True,
+    # Calculate bounding box polygons for all fields.
+    polygon=False,
+    # Boost the precision and accuracy of all extractions.
+    # Calculate confidence scores for all fields.
+    confidence=False,
+    polling_options=PollingOptions(max_retries=2000),
+)
+
+# Load a file from disk
+input_source = PathInput(input_path)
+
+# Send for processing
+response = mindee_client.enqueue_and_get_inference(input_source, params)
+
+# Print a brief summary of the parsed data
+print(response.raw_http)

local_test/test_sid.py

@@ -0,0 +1,30 @@
+from mindee.v1.client import Client, InferenceParameters, PollingOptions
+import os
+from mindee.logger import logger
+
+LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG").upper()
+
+model_id = "YOUR-MODEL-ID"
+filepath = "/path/to/your/file.ext"
+api_key = "YOUR_APIKEY"
+
+logger.info("Initializing Mindee client")
+mindee_client = Client(api_key)
+
+input_doc = mindee_client.source_from_path(filepath)
+
+result = mindee_client.enqueue_and_get_inference(
+    input_doc,
+    InferenceParameters(
+        model_id=model_id,
+        confidence=False,
+        polygon=False,
+        raw_text=False,
+        rag=False,
+        alias=None,
+        text_context=None,
+        webhook_ids=[],
+    ),
+)
+
+print(result.raw_http)

local_test/test_split.py

@@ -0,0 +1,12 @@
+from mindee.v1.client import Client
+from mindee.input import SplitParameters
+from mindee.v2 import SplitResponse
+
+client = Client("md_sMAC68Ixx5vvkp9aXCKn7pDUg2Rcx76H")
+input_source = client.source_from_path(
+    "./tests/data/v1/products/invoice_splitter/default_sample.pdf"
+)
+response = client.enqueue_and_get_result(
+    SplitResponse, input_source, SplitParameters("7cfb736e-651e-4407-a82d-f437025810a0")
+)
+print(response.inference)

local_test/test_split_syntax.py

@@ -0,0 +1,27 @@
+from mindee.v1.client import Client, SplitParameters, SplitResponse, PathInput
+
+input_path = "/home/seb/Documents/blank_1.pdf"
+api_key = "md_sMAC68Ixx5vvkp9aXCKn7pDUg2Rcx76H"
+model_id = "788c19ba-8005-4e63-ae83-80253fb7c27d"
+
+# Init a new client
+mindee_client = Client(api_key)
+
+# Set inference parameters
+params = SplitParameters(
+    # ID of the model, required.
+    model_id=model_id,
+)
+
+# Load a file from disk
+input_source = PathInput(input_path)
+
+# Send for processing
+response = mindee_client.enqueue_and_get_result(
+    SplitResponse,
+    input_source,
+    params,
+)
+
+# Print a brief summary of the parsed data
+print(response.inference)

mindee/__init__.py

@@ -0,0 +1,53 @@
+from mindee.client_options.polling_options import PollingOptions
+from mindee.input import PageOptions
+from mindee.input.base_64_input import Base64Input
+from mindee.input.bytes_input import BytesInput
+from mindee.input.file_input import FileInput
+from mindee.input.local_input_source import LocalInputSource
+from mindee.input.local_response import LocalResponse
+from mindee.input.path_input import PathInput
+from mindee.input.url_input_source import URLInputSource
+from mindee.v1 import product
+from mindee.v2.parsing.job.job_response import JobResponse
+from mindee.v2.product.classification.classification_response import (
+    ClassificationResponse,
+)
+from mindee.v2.product.classification.params.classification_parameters import (
+    ClassificationParameters,
+)
+from mindee.v2.product.crop.crop_response import CropResponse
+from mindee.v2.product.crop.params.crop_parameters import CropParameters
+from mindee.v2.product.extraction.extraction_response import ExtractionResponse
+from mindee.v2.product.extraction.extraction_result import ExtractionResult
+from mindee.v2.product.extraction.params.extraction_parameters import (
+    ExtractionParameters,
+)
+from mindee.v2.product.ocr.ocr_response import OCRResponse
+from mindee.v2.product.ocr.params.ocr_parameters import OCRParameters
+from mindee.v2.product.split.params.split_parameters import SplitParameters
+from mindee.v2.product.split.split_response import SplitResponse
+
+__all__ = [
+    "Base64Input",
+    "BytesInput",
+    "ClassificationParameters",
+    "ClassificationResponse",
+    "CropParameters",
+    "CropResponse",
+    "ExtractionParameters",
+    "ExtractionResponse",
+    "ExtractionResult",
+    "FileInput",
+    "JobResponse",
+    "LocalInputSource",
+    "LocalResponse",
+    "OCRParameters",
+    "OCRResponse",
+    "PageOptions",
+    "PathInput",
+    "PollingOptions",
+    "SplitParameters",
+    "SplitResponse",
+    "URLInputSource",
+    "product",
+]

mindee/__main__.py

@@ -0,0 +1,4 @@
+from mindee.cli import main
+
+if __name__ == "__main__":
+    main()

mindee/cli.py

@@ -0,0 +1,7 @@
+from mindee.v1.commands.cli_parser import MindeeParser
+
+
+def main() -> None:
+    """Run the Command Line Interface."""
+    parser = MindeeParser()
+    parser.call_parse()

mindee/client_mixin.py

@@ -0,0 +1,23 @@
+from mindee.error import MindeeClientError
+
+
+class ClientMixin:
+    """Mixin for clients V1 & V2 common static methods."""
+
+    @staticmethod
+    def _validate_async_params(
+        initial_delay_sec: float, delay_sec: float, max_retries: int
+    ) -> None:
+        min_delay = 1
+        min_initial_delay = 1
+        min_retries = 1
+        if delay_sec < min_delay:
+            raise MindeeClientError(
+                f"Cannot set auto-parsing delay to less than {min_delay} second(s)."
+            )
+        if initial_delay_sec < min_initial_delay:
+            raise MindeeClientError(
+                f"Cannot set initial parsing delay to less than {min_initial_delay} second(s)."
+            )
+        if max_retries < min_retries:
+            raise MindeeClientError(f"Cannot set retries to less than {min_retries}.")

mindee/client_options/polling_options.py

@@ -0,0 +1,19 @@
+class PollingOptions:
+    """Options for asynchronous polling."""
+
+    initial_delay_sec: float
+    """Initial delay before the first polling attempt."""
+    delay_sec: float
+    """Delay between each polling attempt."""
+    max_retries: int
+    """Total number of polling attempts."""
+
+    def __init__(
+        self,
+        initial_delay_sec: float = 2,
+        delay_sec: float = 1.5,
+        max_retries: int = 80,
+    ):
+        self.initial_delay_sec = initial_delay_sec
+        self.delay_sec = delay_sec
+        self.max_retries = max_retries

mindee/dependencies/__init__.py

@@ -0,0 +1,9 @@
+from mindee.dependencies.checkers import PILLOW_AVAILABLE, PYPDFIUM2_AVAILABLE
+from mindee.dependencies.decorators import requires_pillow, requires_pypdfium2
+
+__all__ = [
+    "PILLOW_AVAILABLE",
+    "PYPDFIUM2_AVAILABLE",
+    "requires_pillow",
+    "requires_pypdfium2",
+]