docling-pp-ocrv6 0.1.0__py3-none-any.whl

docling_pp_ocrv6/__init__.py

@@ -0,0 +1,8 @@
+"""A docling OCR plugin for PaddlePaddle PP-OCRv6."""
+
+__version__ = "0.1.0"
+
+from docling_pp_ocrv6.model import PPOCRv6Model
+from docling_pp_ocrv6.options import PPOCRv6Options
+
+__all__ = ["PPOCRv6Model", "PPOCRv6Options"]

docling_pp_ocrv6/model.py

@@ -0,0 +1,275 @@
+"""PP-OCRv6 OCR engine for the docling standard pipeline.
+
+Runs PaddlePaddle PP-OCRv6 detection and recognition ONNX models locally via
+RapidOCR (onnxruntime) and returns the recognised text as ``TextCell`` objects
+that docling merges with its standard-pipeline output.
+
+The detection and recognition ONNX models are downloaded from HuggingFace on
+first use and cached under docling's model cache. The recognition character
+dictionary is extracted from the recognition model's ``inference.yml``. Angle
+classification uses RapidOCR's bundled cls model unless an explicit path is
+given.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import yaml
+from docling.datamodel.accelerator_options import AcceleratorDevice
+from docling.datamodel.settings import settings
+from docling.models.base_ocr_model import BaseOcrModel
+from docling.utils.accelerator_utils import decide_device
+from docling.utils.profiling import TimeRecorder
+from docling_core.types.doc import BoundingBox, CoordOrigin
+from docling_core.types.doc.page import BoundingRectangle, TextCell
+
+from docling_pp_ocrv6.options import PPOCRv6Options
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from docling.datamodel.accelerator_options import AcceleratorOptions
+    from docling.datamodel.base_models import Page
+    from docling.datamodel.document import ConversionResult
+    from docling.datamodel.pipeline_options import OcrOptions
+
+logger = logging.getLogger(__name__)
+
+_ONNX_FILE = "inference.onnx"
+_CONFIG_FILE = "inference.yml"
+_REC_KEYS_FILE = "ppocrv6_keys.txt"
+
+
+class PPOCRv6Model(BaseOcrModel):
+    """OCR engine running PP-OCRv6 ONNX models through RapidOCR."""
+
+    _model_repo_folder = "PPOCRv6"
+
+    def __init__(
+        self,
+        enabled: bool,  # noqa: FBT001
+        artifacts_path: Path | None,
+        options: PPOCRv6Options,
+        accelerator_options: AcceleratorOptions,
+    ) -> None:
+        """Initialise the OCR engine, downloading models on first use when enabled."""
+        super().__init__(
+            enabled=enabled,
+            artifacts_path=artifacts_path,
+            options=options,
+            accelerator_options=accelerator_options,
+        )
+        self.options: PPOCRv6Options
+        self.scale = 3  # multiplier for 72 dpi == 216 dpi.
+
+        if not self.enabled:
+            return
+
+        try:
+            from rapidocr import EngineType, RapidOCR  # noqa: PLC0415
+        except ImportError as err:
+            msg = (
+                "RapidOCR is not installed. Install it via "
+                "`pip install rapidocr onnxruntime` (or `onnxruntime-gpu` for CUDA) "
+                "to use the PP-OCRv6 OCR engine."
+            )
+            raise ImportError(msg) from err
+
+        device = decide_device(accelerator_options.device)
+        use_cuda = str(AcceleratorDevice.CUDA.value).lower() in device
+        use_dml = accelerator_options.device == AcceleratorDevice.AUTO
+        gpu_id = int(device.split(":")[1]) if (use_cuda and ":" in device) else 0
+
+        det_path, rec_path, rec_keys_path, cls_path = self._resolve_models()
+        logger.info(
+            "Loading PP-OCRv6 (device=%s, cuda=%s): det=%s rec=%s",
+            device,
+            use_cuda,
+            det_path,
+            rec_path,
+        )
+
+        params: dict = {
+            "Global.text_score": self.options.text_score,
+            "EngineConfig.onnxruntime.intra_op_num_threads": accelerator_options.num_threads,
+            "Det.model_path": str(det_path),
+            "Det.engine_type": EngineType.ONNXRUNTIME,
+            "Det.use_cuda": use_cuda,
+            "Det.use_dml": use_dml,
+            "Rec.model_path": str(rec_path),
+            "Rec.rec_keys_path": str(rec_keys_path),
+            "Rec.engine_type": EngineType.ONNXRUNTIME,
+            "Rec.use_cuda": use_cuda,
+            "Rec.use_dml": use_dml,
+            "Cls.engine_type": EngineType.ONNXRUNTIME,
+            "Cls.use_cuda": use_cuda,
+            "Cls.use_dml": use_dml,
+            "EngineConfig.onnxruntime.use_cuda": use_cuda,
+            "EngineConfig.onnxruntime.cuda_ep_cfg.device_id": gpu_id,
+        }
+        # When no explicit cls model is given, let RapidOCR use its bundled cls model.
+        if cls_path is not None:
+            params["Cls.model_path"] = str(cls_path)
+
+        if self.options.rapidocr_params:
+            params.update(self.options.rapidocr_params)
+
+        self.reader = RapidOCR(params=params)
+
+    def _resolve_models(self) -> tuple[Path, Path, Path, Path | None]:
+        """Resolve detection, recognition, rec-keys and (optional) cls model paths.
+
+        Explicit option paths win; otherwise models are downloaded from
+        HuggingFace and cached. The recognition character dictionary is
+        extracted from the recognition model's ``inference.yml`` when not
+        provided explicitly.
+        """
+        local_dir = self.download_models(
+            det_repo=self.options.det_repo,
+            rec_repo=self.options.rec_repo,
+        )
+
+        det_path = Path(self.options.det_model_path) if self.options.det_model_path else local_dir / "det" / _ONNX_FILE
+        rec_path = Path(self.options.rec_model_path) if self.options.rec_model_path else local_dir / "rec" / _ONNX_FILE
+
+        if self.options.rec_keys_path:
+            rec_keys_path = Path(self.options.rec_keys_path)
+        else:
+            rec_keys_path = self._ensure_rec_keys(local_dir / "rec")
+
+        cls_path = Path(self.options.cls_model_path) if self.options.cls_model_path else None
+
+        for path in (det_path, rec_path, rec_keys_path):
+            if not path.exists():
+                logger.warning("PP-OCRv6 model path does not exist: %s", path)
+
+        return det_path, rec_path, rec_keys_path, cls_path
+
+    @staticmethod
+    def _ensure_rec_keys(rec_dir: Path) -> Path:
+        """Extract the recognition character dictionary into a RapidOCR keys file.
+
+        PaddleX exports embed the dictionary as ``PostProcess.character_dict``
+        inside ``inference.yml``; RapidOCR expects a plain text file with one
+        character per line.
+        """
+        keys_path = rec_dir / _REC_KEYS_FILE
+        if keys_path.exists():
+            return keys_path
+
+        config = yaml.safe_load((rec_dir / _CONFIG_FILE).read_text(encoding="utf-8"))
+        chars = config.get("PostProcess", {}).get("character_dict")
+        if not chars:
+            msg = f"No 'PostProcess.character_dict' found in {rec_dir / _CONFIG_FILE}"
+            raise ValueError(msg)
+
+        keys_path.write_text("\n".join(chars) + "\n", encoding="utf-8")
+        logger.info("Wrote PP-OCRv6 recognition dictionary (%d entries) to %s", len(chars), keys_path)
+        return keys_path
+
+    @staticmethod
+    def download_models(
+        det_repo: str = "PaddlePaddle/PP-OCRv6_medium_det_onnx",
+        rec_repo: str = "PaddlePaddle/PP-OCRv6_medium_rec_onnx",
+        local_dir: Path | None = None,
+        force: bool = False,  # noqa: FBT001, FBT002
+    ) -> Path:
+        """Download the PP-OCRv6 detection and recognition ONNX models from HuggingFace.
+
+        Returns the local directory containing ``det/`` and ``rec/`` sub-folders.
+        Pre-fetching at image-build time avoids blocking the first request on the
+        download. Pass ``force=True`` to re-download even when a cached copy exists
+        (e.g. to repair a corrupted file).
+        """
+        from huggingface_hub import hf_hub_download  # noqa: PLC0415
+
+        if local_dir is None:
+            local_dir = settings.cache_dir / "models" / PPOCRv6Model._model_repo_folder
+
+        det_dir = local_dir / "det"
+        rec_dir = local_dir / "rec"
+        det_dir.mkdir(parents=True, exist_ok=True)
+        rec_dir.mkdir(parents=True, exist_ok=True)
+
+        hf_hub_download(det_repo, _ONNX_FILE, local_dir=det_dir, force_download=force)
+        hf_hub_download(rec_repo, _ONNX_FILE, local_dir=rec_dir, force_download=force)
+        hf_hub_download(rec_repo, _CONFIG_FILE, local_dir=rec_dir, force_download=force)
+
+        return local_dir
+
+    def __call__(self, conv_res: ConversionResult, page_batch: Iterable[Page]) -> Iterable[Page]:
+        """Run OCR on each page crop and yield pages with recognised text cells."""
+        if not self.enabled:
+            yield from page_batch
+            return
+
+        for page in page_batch:
+            if page._backend is None or not page._backend.is_valid():  # noqa: SLF001
+                yield page
+                continue
+
+            with TimeRecorder(conv_res, "ocr"):
+                ocr_rects = self.get_ocr_rects(page)
+                all_ocr_cells: list[TextCell] = []
+                cell_idx = 0
+
+                for ocr_rect in ocr_rects:
+                    if ocr_rect.area() == 0:
+                        continue
+                    high_res_image = page._backend.get_page_image(scale=self.scale, cropbox=ocr_rect)  # noqa: SLF001
+                    im = np.array(high_res_image)
+                    # cast: RapidOCR's return type is a union of stage-specific outputs
+                    result = cast(
+                        "Any",
+                        self.reader(
+                            im,
+                            use_det=self.options.use_det,
+                            use_cls=self.options.use_cls,
+                            use_rec=self.options.use_rec,
+                        ),
+                    )
+                    # a disabled stage means the matching attribute is absent
+                    boxes = getattr(result, "boxes", None) if result is not None else None
+                    txts = getattr(result, "txts", None)
+                    scores = getattr(result, "scores", None)
+                    if boxes is None or txts is None or scores is None:
+                        continue
+
+                    for box, text, score in zip(boxes.tolist(), txts, scores, strict=False):
+                        all_ocr_cells.append(
+                            TextCell(
+                                index=cell_idx,
+                                text=text,
+                                orig=text,
+                                confidence=score,
+                                from_ocr=True,
+                                rect=BoundingRectangle.from_bounding_box(
+                                    BoundingBox.from_tuple(
+                                        coord=(
+                                            (box[0][0] / self.scale) + ocr_rect.l,
+                                            (box[0][1] / self.scale) + ocr_rect.t,
+                                            (box[2][0] / self.scale) + ocr_rect.l,
+                                            (box[2][1] / self.scale) + ocr_rect.t,
+                                        ),
+                                        origin=CoordOrigin.TOPLEFT,
+                                    )
+                                ),
+                            )
+                        )
+                        cell_idx += 1
+
+                self.post_process_cells(all_ocr_cells, page)
+
+            if settings.debug.visualize_ocr:
+                self.draw_ocr_rects_and_cells(conv_res, page, ocr_rects)
+
+            yield page
+
+    @classmethod
+    def get_options_type(cls) -> type[OcrOptions]:
+        """Return the options class for this OCR engine."""
+        return PPOCRv6Options

docling_pp_ocrv6/options.py

@@ -0,0 +1,91 @@
+"""Configuration model for the PP-OCRv6 OCR engine."""
+
+from __future__ import annotations
+
+import os
+from typing import ClassVar, Literal
+
+from docling.datamodel.pipeline_options import OcrOptions
+from pydantic import ConfigDict, Field
+
+_DEFAULT_DET_REPO = "PaddlePaddle/PP-OCRv6_medium_det_onnx"
+_DEFAULT_REC_REPO = "PaddlePaddle/PP-OCRv6_medium_rec_onnx"
+
+# PP-OCRv6 medium is a single multilingual model covering Latin-script
+# European languages (and many more); ``lang`` is only a passthrough hint to
+# docling and does not switch models. The default leads with German and
+# includes the common European languages.
+_DEFAULT_LANGS = "de,en,fr,it,es,nl,pt,pl,sv,da,fi,nb,cs,ro,hu"
+
+
+def _env_bool(name: str, default: bool) -> bool:  # noqa: FBT001
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+class PPOCRv6Options(OcrOptions):
+    """Options for the PP-OCRv6 OCR engine.
+
+    The engine runs PaddlePaddle's PP-OCRv6 detection and recognition ONNX
+    models locally through RapidOCR (onnxruntime). Models are downloaded from
+    HuggingFace on first use and cached. GPU is used automatically when the
+    docling accelerator device resolves to CUDA and ``onnxruntime-gpu`` is
+    installed.
+
+    All options fall back to environment variables when not set explicitly,
+    allowing configuration without code changes (e.g. in Docker / Compose
+    deployments).
+
+    Attributes:
+        lang: Language hint list (passed to docling). PP-OCRv6 medium is a
+            single multilingual model, so this does not switch models; it
+            recognises its supported languages automatically. Defaults to a
+            German-led set of common European languages. Falls back to the
+            ``PPOCRV6_LANG`` env var as a comma-separated string.
+        text_score: Minimum recognition confidence; lower-scoring cells are
+            dropped by RapidOCR. Falls back to ``PPOCRV6_TEXT_SCORE``.
+        use_det: Run the text-detection stage. Falls back to ``PPOCRV6_USE_DET``.
+        use_cls: Run the angle-classification stage (RapidOCR's bundled cls
+            model). Falls back to ``PPOCRV6_USE_CLS``.
+        use_rec: Run the text-recognition stage. Falls back to
+            ``PPOCRV6_USE_REC``.
+        det_repo: HuggingFace repo id for the detection ONNX model.
+            Falls back to ``PPOCRV6_DET_REPO``.
+        rec_repo: HuggingFace repo id for the recognition ONNX model.
+            Falls back to ``PPOCRV6_REC_REPO``.
+        det_model_path: Explicit local path to a detection ONNX file. When set,
+            no detection model is downloaded. Falls back to ``PPOCRV6_DET_MODEL_PATH``.
+        rec_model_path: Explicit local path to a recognition ONNX file. When set,
+            no recognition model is downloaded. Falls back to ``PPOCRV6_REC_MODEL_PATH``.
+        rec_keys_path: Explicit local path to the recognition character
+            dictionary (one character per line). When unset it is extracted
+            from the recognition model's ``inference.yml``. Falls back to
+            ``PPOCRV6_REC_KEYS_PATH``.
+        cls_model_path: Explicit local path to an angle-classification ONNX
+            file. When unset, RapidOCR's bundled cls model is used. Falls back
+            to ``PPOCRV6_CLS_MODEL_PATH``.
+        rapidocr_params: Extra RapidOCR ``params`` overrides merged on top of
+            the engine defaults.
+    """
+
+    kind: ClassVar[Literal["pp-ocrv6"]] = "pp-ocrv6"
+
+    lang: list[str] = Field(default_factory=lambda: os.environ.get("PPOCRV6_LANG", _DEFAULT_LANGS).split(","))
+    text_score: float = Field(default_factory=lambda: float(os.environ.get("PPOCRV6_TEXT_SCORE", "0.5")))
+    use_det: bool = Field(default_factory=lambda: _env_bool("PPOCRV6_USE_DET", default=True))
+    use_cls: bool = Field(default_factory=lambda: _env_bool("PPOCRV6_USE_CLS", default=True))
+    use_rec: bool = Field(default_factory=lambda: _env_bool("PPOCRV6_USE_REC", default=True))
+
+    det_repo: str = Field(default_factory=lambda: os.environ.get("PPOCRV6_DET_REPO", _DEFAULT_DET_REPO))
+    rec_repo: str = Field(default_factory=lambda: os.environ.get("PPOCRV6_REC_REPO", _DEFAULT_REC_REPO))
+
+    det_model_path: str | None = Field(default_factory=lambda: os.environ.get("PPOCRV6_DET_MODEL_PATH") or None)
+    rec_model_path: str | None = Field(default_factory=lambda: os.environ.get("PPOCRV6_REC_MODEL_PATH") or None)
+    rec_keys_path: str | None = Field(default_factory=lambda: os.environ.get("PPOCRV6_REC_KEYS_PATH") or None)
+    cls_model_path: str | None = Field(default_factory=lambda: os.environ.get("PPOCRV6_CLS_MODEL_PATH") or None)
+
+    rapidocr_params: dict = Field(default_factory=dict)
+
+    model_config = ConfigDict(extra="forbid")

docling_pp_ocrv6/plugin.py

@@ -0,0 +1,8 @@
+"""Docling plugin entry point registering the PP-OCRv6 OCR engine."""
+
+from docling_pp_ocrv6.model import PPOCRv6Model
+
+
+def ocr_engines() -> dict[str, list[type[PPOCRv6Model]]]:
+    """Return the OCR engine classes provided by this plugin."""
+    return {"ocr_engines": [PPOCRv6Model]}

docling_pp_ocrv6-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: docling-pp-ocrv6
+Version: 0.1.0
+Summary: A docling OCR plugin for PaddlePaddle PP-OCRv6 (ONNX via RapidOCR)
+Project-URL: Homepage, https://github.com/DCC-BS/docling-pp-ocrv6
+Project-URL: Repository, https://github.com/DCC-BS/docling-pp-ocrv6
+Project-URL: Issues, https://github.com/DCC-BS/docling-pp-ocrv6/issues
+Project-URL: Changelog, https://github.com/DCC-BS/docling-pp-ocrv6/releases
+Author-email: Yanick Schraner <yanick.schraner@bs.ch>, Tobias Bollinger <tobias.bollinger@bs.ch>
+License: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: docling>=2.73
+Requires-Dist: huggingface-hub>=1.3.0
+Requires-Dist: numpy
+Requires-Dist: pillow>=10.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rapidocr>=3.0
+Provides-Extra: cpu
+Requires-Dist: onnxruntime>=1.17; extra == 'cpu'
+Provides-Extra: gpu
+Requires-Dist: onnxruntime-gpu>=1.17; extra == 'gpu'
+Description-Content-Type: text/markdown
+
+# docling-pp-ocrv6
+
+A [Docling](https://github.com/docling-project/docling) OCR plugin for
+PaddlePaddle's **PP-OCRv6** models. It runs the PP-OCRv6 detection and
+recognition **ONNX** checkpoints locally through
+[RapidOCR](https://github.com/RapidAI/RapidOCR) (onnxruntime), so OCR happens
+inside the docling worker — no external service required.
+
+GPU acceleration is automatic when the docling accelerator device resolves to
+CUDA and `onnxruntime-gpu` is installed.
+
+## Installation
+
+Pick exactly one onnxruntime extra — installing both the CPU and GPU wheels at
+once is unsupported and prevents the CUDA provider from registering:
+
+```bash
+pip install "docling-pp-ocrv6[cpu]"     # CPU (onnxruntime)
+pip install "docling-pp-ocrv6[gpu]"     # CUDA (onnxruntime-gpu)
+```
+
+The detection and recognition ONNX models are downloaded from HuggingFace on
+first use and cached under docling's model cache. To pre-fetch them (e.g. at
+container build time):
+
+```python
+from docling_pp_ocrv6 import PPOCRv6Model
+PPOCRv6Model.download_models()
+```
+
+## Usage
+
+```python
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.datamodel.base_models import InputFormat
+from docling.datamodel.pipeline_options import PdfPipelineOptions
+from docling_pp_ocrv6 import PPOCRv6Options
+
+pipeline_options = PdfPipelineOptions(do_ocr=True)
+pipeline_options.ocr_options = PPOCRv6Options()
+
+converter = DocumentConverter(
+    format_options={InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options)}
+)
+result = converter.convert("scanned.pdf")
+print(result.document.export_to_markdown())
+```
+
+With **docling-serve**, request the engine by its `kind`:
+
+```json
+{ "options": { "ocr": true, "ocr_engine": "pp-ocrv6" } }
+```
+
+(`DOCLING_SERVE_ALLOW_EXTERNAL_PLUGINS=true` must be set for the plugin to load.)
+
+## Configuration
+
+All options are settable via `PPOCRv6Options(...)` or environment variables:
+
+| Option | Env var | Default |
+| --- | --- | --- |
+| `lang` | `PPOCRV6_LANG` | `de,en,fr,it,es,nl,pt,...` (German-led European set) |
+| `text_score` | `PPOCRV6_TEXT_SCORE` | `0.5` |
+| `use_det` / `use_cls` / `use_rec` | `PPOCRV6_USE_DET` / `_CLS` / `_REC` | `true` |
+| `det_repo` | `PPOCRV6_DET_REPO` | `PaddlePaddle/PP-OCRv6_medium_det_onnx` |
+| `rec_repo` | `PPOCRV6_REC_REPO` | `PaddlePaddle/PP-OCRv6_medium_rec_onnx` |
+| `det_model_path` / `rec_model_path` / `rec_keys_path` / `cls_model_path` | `PPOCRV6_*_MODEL_PATH` / `_KEYS_PATH` | auto |
+
+The recognition character dictionary is extracted automatically from the
+recognition model's `inference.yml`. Angle classification uses RapidOCR's
+bundled cls model unless `cls_model_path` is set.
+
+## Development
+
+```bash
+make install   # uv sync + pre-commit
+make check     # ruff lint + format check + ty type check
+make test      # pytest with coverage
+```
+
+## License
+
+MIT

docling_pp_ocrv6-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+docling_pp_ocrv6/__init__.py,sha256=o_T8rpqV13O-qtFZussbl34WXDt1tgCbQONMtzeH7is,224
+docling_pp_ocrv6/model.py,sha256=Ra4s-FucBduaChpOaeH86--Vf9BmUqIyedwr2e1bPj8,11418
+docling_pp_ocrv6/options.py,sha256=ZKLXIxIxz-GjzsvHaS8H9DGY_s2V00fUY4oK2RMIkkI,4767
+docling_pp_ocrv6/plugin.py,sha256=x0u-TlioVNeAg6GRy13vajLyHbfCN8ltc21rBDpRrTQ,287
+docling_pp_ocrv6/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docling_pp_ocrv6-0.1.0.dist-info/METADATA,sha256=RvAj8fCMzXk8Ulo9CkXl5btDPY8ufn-7o2OkTsB3iLE,4049
+docling_pp_ocrv6-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+docling_pp_ocrv6-0.1.0.dist-info/entry_points.txt,sha256=my-zYx4Xr5Z68incYws4EyF9zMXDnC5wbnnFiUHuweU,53
+docling_pp_ocrv6-0.1.0.dist-info/licenses/LICENSE,sha256=APpdFXym3_5C78pFAfnlLvmP7umPBWYpQ2MKidnoRuw,1091
+docling_pp_ocrv6-0.1.0.dist-info/RECORD,,

docling_pp_ocrv6-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

docling_pp_ocrv6-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[docling]
+docling_pp_ocrv6 = docling_pp_ocrv6.plugin

docling_pp_ocrv6-0.1.0.dist-info/licenses/LICENSE

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