cells2table 0.2.0__tar.gz → 0.2.2__tar.gz

{cells2table-0.2.0 → cells2table-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cells2table
-Version: 0.2.0
+Version: 0.2.2
 Summary: Table image parsing with cell detection models
 Keywords: docling,plugin
 Author: jspast
@@ -9,20 +9,21 @@ License-Expression: MIT
 License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Dist: huggingface-hub>=0.36.0
-Requires-Dist: numpy>=2.2.0
-Requires-Dist: opencv-python>=4.11.0.86
-Requires-Dist: onnxruntime>=1.23.2 ; extra == 'cpu'
-Requires-Dist: onnxruntime-gpu>=1.23.2 ; extra == 'cuda'
-Requires-Dist: docling>=2.66.0 ; extra == 'docling'
-Requires-Dist: onnxruntime-openvino>=1.23.0 ; extra == 'openvino'
-Requires-Python: >=3.12
+Requires-Dist: numpy>=2.2.0,<3.0.0
+Requires-Dist: opencv-python>=4.11.0.86,<5.0.0.0
+Requires-Dist: docling>=2.66.0,<3.0.0 ; extra == 'docling'
+Requires-Dist: huggingface-hub>=0.36.0,<1.0.0 ; extra == 'huggingface'
+Requires-Dist: onnxruntime>=1.23.2,<2.0.0 ; extra == 'onnx-cpu'
+Requires-Dist: onnxruntime-gpu>=1.23.2,<2.0.0 ; extra == 'onnx-cuda'
+Requires-Dist: onnxruntime-openvino>=1.23.0,<2.0.0 ; extra == 'onnx-openvino'
+Requires-Python: >=3.12, <4.0
 Project-URL: Homepage, https://github.com/jspast/cells2table
 Project-URL: Issues, https://github.com/jspast/cells2table/issues
-Provides-Extra: cpu
-Provides-Extra: cuda
 Provides-Extra: docling
-Provides-Extra: openvino
+Provides-Extra: huggingface
+Provides-Extra: onnx-cpu
+Provides-Extra: onnx-cuda
+Provides-Extra: onnx-openvino
 Description-Content-Type: text/markdown
 
 # cells2table
@@ -31,29 +32,30 @@ Parsing tables in document images with cell detection models
 
 ## Implemented pipelines
 
-### PaddlePaddle models
+### PaddlePaddle
 
 - Classification model (wired / wireless)
 - Cell detection model with different weights for each class
 
-Using [ONNX weights](https://huggingface.co/jspast/paddlepaddle-table-models-onnx) (downloaded automatically on first use with `huggingface_hub`)
+Uses ONNX weights downloaded automatically from [Hugging Face](https://huggingface.co/jspast/paddlepaddle-table-models-onnx) on first use.
 
 ## Instalation
 
 With [uv](https://docs.astral.sh/uv/), add to your project with:
 
 ```sh
-uv add git+https://github.com/jspast/cells2table
+uv add cells2table
 ```
 
 ONNX models need a [ONNX Runtime](https://onnxruntime.ai/getting-started) installed to run. You can install one on your own or use one of the optionals already configured.
 
-| Optional   | Description             |
-| ---------- | ----------------------- |
-| `cuda`     | For NVIDIA GPUs         |
-| `openvino` | For Intel GPUs and CPUs |
-| `cpu`      | Default CPU runtime     |
-| `docling`  | For docling usage       |
+| Optional        | Description             |
+| --------------- | ----------------------- |
+| `docling`       | For docling usage       |
+| `huggingface`   | For downloading models  |
+| `onnx_cuda`     | For NVIDIA GPUs         |
+| `onnx_openvino` | For Intel GPUs and CPUs |
+| `onnx_cpu`      | Default CPU runtime     |
 
 ## Usage
 

{cells2table-0.2.0 → cells2table-0.2.2}/README.md

@@ -4,29 +4,30 @@ Parsing tables in document images with cell detection models
 
 ## Implemented pipelines
 
-### PaddlePaddle models
+### PaddlePaddle
 
 - Classification model (wired / wireless)
 - Cell detection model with different weights for each class
 
-Using [ONNX weights](https://huggingface.co/jspast/paddlepaddle-table-models-onnx) (downloaded automatically on first use with `huggingface_hub`)
+Uses ONNX weights downloaded automatically from [Hugging Face](https://huggingface.co/jspast/paddlepaddle-table-models-onnx) on first use.
 
 ## Instalation
 
 With [uv](https://docs.astral.sh/uv/), add to your project with:
 
 ```sh
-uv add git+https://github.com/jspast/cells2table
+uv add cells2table
 ```
 
 ONNX models need a [ONNX Runtime](https://onnxruntime.ai/getting-started) installed to run. You can install one on your own or use one of the optionals already configured.
 
-| Optional   | Description             |
-| ---------- | ----------------------- |
-| `cuda`     | For NVIDIA GPUs         |
-| `openvino` | For Intel GPUs and CPUs |
-| `cpu`      | Default CPU runtime     |
-| `docling`  | For docling usage       |
+| Optional        | Description             |
+| --------------- | ----------------------- |
+| `docling`       | For docling usage       |
+| `huggingface`   | For downloading models  |
+| `onnx_cuda`     | For NVIDIA GPUs         |
+| `onnx_openvino` | For Intel GPUs and CPUs |
+| `onnx_cpu`      | Default CPU runtime     |
 
 ## Usage
 

{cells2table-0.2.0 → cells2table-0.2.2}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "cells2table"
-version = "0.2.0"
+version = "0.2.2"
 description = "Table image parsing with cell detection models"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.12,<4.0"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
@@ -15,9 +15,8 @@ classifiers = [
   "Programming Language :: Python :: 3",
 ]
 dependencies = [
-  "huggingface-hub>=0.36.0",
-  "numpy>=2.2.0",
-  "opencv-python>=4.11.0.86",
+  "numpy (>=2.2.0,<3.0.0)",
+  "opencv-python (>=4.11.0.86,<5.0.0.0)",
 ]
 
 [project.urls]
@@ -25,23 +24,33 @@ Homepage = "https://github.com/jspast/cells2table"
 Issues = "https://github.com/jspast/cells2table/issues"
 
 [project.scripts]
-cells2table = "cells2table.cli:main"
+cells2table = "cli:main"
 
 [project.entry-points.docling]
 cells2table = "cells2table.docling"
 
 [project.optional-dependencies]
-cpu = [
-  "onnxruntime>=1.23.2",
+docling = [
+  "docling (>=2.66.0,<3.0.0)",
 ]
-cuda = [
-  "onnxruntime-gpu>=1.23.2",
+huggingface = [
+  "huggingface-hub (>=0.36.0,<1.0.0)",
 ]
-docling = [
-  "docling>=2.66.0",
+onnx_cpu = [
+  "onnxruntime (>=1.23.2,<2.0.0)",
+]
+onnx_cuda = [
+  "onnxruntime-gpu (>=1.23.2,<2.0.0)",
 ]
-openvino = [
-  "onnxruntime-openvino>=1.23.0",
+onnx_openvino = [
+  "onnxruntime-openvino (>=1.23.0,<2.0.0)",
+]
+
+[dependency-groups]
+dev = [
+  "cells2table",
+  "pytest (>=7.0,<8.0)",
+  "ruff (>=0.5.0,<1.0.0)",
 ]
 
 [build-system]
@@ -53,4 +62,10 @@ line-length = 100
 
 [tool.uv]
 package = true
-conflicts = [[{ extra = "cpu" }, { extra = "cuda" }, { extra = "openvino" }]]
+conflicts = [
+  [
+    { extra = "onnx_cpu" },
+    { extra = "onnx_cuda" },
+    { extra = "onnx_openvino" }
+  ]
+]

cells2table-0.2.2/src/cells2table/__init__.py

@@ -0,0 +1,3 @@
+from .pipelines import PaddlePaddleTablePipeline as DefaultPipeline
+
+__all__ = [DefaultPipeline]

cells2table-0.2.2/src/cells2table/datamodels/__init__.py

@@ -0,0 +1,4 @@
+from .bbox import BoundingBox
+from .table import Cell, Table
+
+__all__ = [BoundingBox, Cell, Table]

cells2table-0.2.2/src/cells2table/datamodels/bbox.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+
+@dataclass
+class BoundingBox:
+    l: float  # noqa: E741
+    t: float
+    r: float
+    b: float
+
+    @staticmethod
+    def from_array(bbox: ArrayLike[float]) -> BoundingBox:
+        return BoundingBox(l=bbox[0], t=bbox[1], r=bbox[2], b=bbox[3])
+
+    def as_array(self) -> NDArray[np.float32]:
+        return np.array([self.l, self.t, self.r, self.b], dtype=np.float32)

{cells2table-0.2.0/src/cells2table/utils → cells2table-0.2.2/src/cells2table/datamodels}/table.py

@@ -3,25 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Iterable, Optional
 
-import numpy as np
-from numpy.typing import ArrayLike
-
-from ..models.utils.tasks import DetectionResult
-
-
-@dataclass
-class BoundingBox:
-    l: float  # noqa: E741
-    t: float
-    r: float
-    b: float
-
-    @staticmethod
-    def from_array(bbox: ArrayLike[float]) -> BoundingBox:
-        return BoundingBox(l=bbox[0], t=bbox[1], r=bbox[2], b=bbox[3])
-
-    def as_array(self) -> ArrayLike[float]:
-        return np.array([self.l, self.t, self.r, self.b])
+from ..models.tasks import DetectionResult
+from .bbox import BoundingBox
 
 
 @dataclass

{cells2table-0.2.0 → cells2table-0.2.2}/src/cells2table/docling.py

@@ -1,32 +1,30 @@
 import copy
-import logging
 from collections.abc import Iterable
 from pathlib import Path
 from typing import ClassVar, Literal, Optional, Sequence, Type
 
 import numpy
-from docling.datamodel.accelerator_options import AcceleratorOptions
-from docling.datamodel.base_models import Cluster, Page, Table, TableStructurePrediction
-from docling.datamodel.document import ConversionResult
-from docling.datamodel.pipeline_options import BaseTableStructureOptions
-from docling.datamodel.settings import settings
-from docling.models.base_table_model import BaseTableStructureModel
-from docling.utils.profiling import TimeRecorder
-from docling_core.types.doc.base import BoundingBox
-from docling_core.types.doc.document import TableCell
-from docling_core.types.doc.labels import DocItemLabel
-from docling_core.types.doc.page import BoundingRectangle, TextCellUnit
-from PIL import ImageDraw
 
-# from docling.utils.accelerator_utils import decide_device
-from .models import DefaultPipeline
-
-logger = logging.getLogger(__name__)
+try:
+    from docling.datamodel.accelerator_options import AcceleratorOptions
+    from docling.datamodel.base_models import Cluster, Page, Table, TableStructurePrediction
+    from docling.datamodel.document import ConversionResult
+    from docling.datamodel.pipeline_options import BaseTableStructureOptions
+    from docling.datamodel.settings import settings
+    from docling.models.base_table_model import BaseTableStructureModel
+    from docling.utils.profiling import TimeRecorder
+    from docling_core.types.doc.base import BoundingBox
+    from docling_core.types.doc.document import TableCell
+    from docling_core.types.doc.labels import DocItemLabel
+    from docling_core.types.doc.page import BoundingRectangle, TextCellUnit
+    from PIL import ImageDraw
+except ImportError:
+    raise ImportError("docling is not installed. Unable to initialize plugin.")
+
+from . import DefaultPipeline
 
 
 def get_tokens(page: Page, table_cluster: Cluster, scale: float) -> list[str]:
-    """Docling logic for token extraction."""
-
     # Check if word-level cells are available from backend:
     sp = page._backend.get_segmented_page() if page._backend else None
     if sp is not None:
@@ -70,6 +68,7 @@ class CustomDoclingTableStructureModel(BaseTableStructureModel):
         artifacts_path: Optional[Path],
         options: CustomDoclingTableStructureOptions,
         accelerator_options: AcceleratorOptions,
+        **kwargs,
     ):
         self.enabled = enabled
 

cells2table-0.2.2/src/cells2table/models/PaddlePaddle/__init__.py

@@ -0,0 +1,13 @@
+from .cell_detection import (
+    PaddlePaddleCellDetectionModel,
+    PaddlePaddleWiredCellDetectionModel,
+    PaddlePaddleWirelessCellDetectionModel,
+)
+from .table_classification import PaddlePaddleTableClassificationModel
+
+__all__ = [
+    PaddlePaddleCellDetectionModel,
+    PaddlePaddleWiredCellDetectionModel,
+    PaddlePaddleWirelessCellDetectionModel,
+    PaddlePaddleTableClassificationModel,
+]

{cells2table-0.2.0 → cells2table-0.2.2}/src/cells2table/models/PaddlePaddle/cell_detection.py

@@ -4,9 +4,9 @@ from typing import Iterable, Iterator, Sequence
 import numpy as np
 from numpy.typing import NDArray
 
-from ..utils.download import DownloadOptions, DownloadPlatform
-from ..utils.runtimes import OnnxModel
-from ..utils.tasks import DetectionModel, DetectionResult
+from ..download import DownloadOptions, DownloadPlatform
+from ..runtimes.onnx import OnnxModel
+from ..tasks import DetectionModel, DetectionResult
 
 HF_REPO_ID = "jspast/paddlepaddle-table-models-onnx"
 CONFIDENCE_THRESHOLD = 0.5
@@ -14,7 +14,7 @@ CONFIDENCE_THRESHOLD = 0.5
 logger = logging.getLogger(__name__)
 
 
-class PaddlePaddleCellDetection(DetectionModel, OnnxModel):
+class PaddlePaddleCellDetectionModel(DetectionModel, OnnxModel):
     """Table cell detection model from PaddlePaddle."""
 
     @property
@@ -51,8 +51,9 @@ class PaddlePaddleCellDetection(DetectionModel, OnnxModel):
 
         return result
 
+    @classmethod
     def postprocess(
-        self,
+        cls,
         pred: NDArray,
         scale_factors: Sequence[tuple[int, int]],
     ) -> list[Iterator[DetectionResult]]:
@@ -79,13 +80,15 @@ class PaddlePaddleCellDetection(DetectionModel, OnnxModel):
         return generators
 
 
-class PaddlePaddleWiredCellDetection(PaddlePaddleCellDetection):
+class PaddlePaddleWiredCellDetectionModel(PaddlePaddleCellDetectionModel):
+    classes = ["wired"]
     download_options = DownloadOptions(
         DownloadPlatform.HUGGINGFACE, HF_REPO_ID, "wired_table_cell_det.onnx"
     )
 
 
-class PaddlePaddleWirelessCellDetection(PaddlePaddleCellDetection):
+class PaddlePaddleWirelessCellDetectionModel(PaddlePaddleCellDetectionModel):
+    classes = ["wireless"]
     download_options = DownloadOptions(
         DownloadPlatform.HUGGINGFACE, HF_REPO_ID, "wireless_table_cell_det.onnx"
     )

{cells2table-0.2.0 → cells2table-0.2.2}/src/cells2table/models/PaddlePaddle/table_classification.py

@@ -4,16 +4,17 @@ from typing import Iterable, Sequence
 import numpy as np
 from numpy.typing import NDArray
 
-from ..utils.download import DownloadOptions, DownloadPlatform
-from ..utils.runtimes import OnnxModel
-from ..utils.tasks import ClassificationModel, ClassificationResult
+from ..download import DownloadOptions, DownloadPlatform
+from ..runtimes.onnx import OnnxModel
+from ..tasks import ClassificationModel, ClassificationResult
 
 HF_REPO_ID = "jspast/paddlepaddle-table-models-onnx"
 
 logger = logging.getLogger(__name__)
 
 
-class PaddlePaddleTableClassification(ClassificationModel, OnnxModel):
+class PaddlePaddleTableClassificationModel(ClassificationModel, OnnxModel):
+    classes = ["wired", "wireless"]
     download_options = DownloadOptions(DownloadPlatform.HUGGINGFACE, HF_REPO_ID, "table_cls.onnx")
 
     def __call__(self, input: Iterable[NDArray[np.uint8]]) -> list[ClassificationResult]:
@@ -36,8 +37,6 @@ class PaddlePaddleTableClassification(ClassificationModel, OnnxModel):
 
         return result
 
-    @staticmethod
-    def postprocess(pred: Sequence[Sequence[float]]) -> list[ClassificationResult]:
-        return [
-            ClassificationResult({0: "wired", 1: "wireless"}[np.argmax(p)], max(p)) for p in pred
-        ]
+    @classmethod
+    def postprocess(cls, pred: Sequence[Sequence[float]]) -> list[ClassificationResult]:
+        return [ClassificationResult(cls.classes[np.argmax(p)], max(p)) for p in pred]

{cells2table-0.2.0/src/cells2table/models/utils → cells2table-0.2.2/src/cells2table/models}/runtimes/onnx.py

@@ -13,9 +13,12 @@ from ..tasks.base import BaseModel
 class OnnxModel(BaseModel, ABC):
     """Base interface for ONNX models."""
 
+    scale = 1 / 255.0
+    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+    std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+
     def __init__(self, model_path: Optional[Path | str] = None) -> None:
-        if model_path is None:
-           model_path = self.download()
+        self.model_path = self.download() if model_path is None else Path(model_path)
 
         providers_priority = [
             "CUDAExecutionProvider",
@@ -26,14 +29,10 @@ class OnnxModel(BaseModel, ABC):
         available_providers = ort.get_available_providers()  # type: ignore
 
         self.session = ort.InferenceSession(
-            model_path,
+            self.model_path,
             providers=[p for p in providers_priority if p in available_providers],
         )
 
-        self.scale = 1 / 255.0
-        self.mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
-        self.std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
-
     @property
     def input_shape(self):
         return self.session.get_inputs()[0].shape[2:]  # assuming NCHW

{cells2table-0.2.0/src/cells2table/models/utils → cells2table-0.2.2/src/cells2table/models}/tasks/base.py

@@ -8,6 +8,7 @@ from ..download import DownloadOptions, download
 class BaseModel(ABC):
     """Base interface for models of any type."""
 
+    model_path: Path
     download_options: Optional[DownloadOptions] = None
 
     @abstractmethod

{cells2table-0.2.0/src/cells2table/models/utils → cells2table-0.2.2/src/cells2table/models}/tasks/classification.py

@@ -14,6 +14,8 @@ class ClassificationResult(NamedTuple):
 class ClassificationModel(BaseModel, ABC):
     """Base interface for table classification models."""
 
+    classes: list[str]
+
     @abstractmethod
     def __call__(self, input: Any) -> list[ClassificationResult]:
         pass

{cells2table-0.2.0/src/cells2table/models/utils → cells2table-0.2.2/src/cells2table/models}/tasks/detection.py

@@ -16,6 +16,8 @@ class DetectionResult(NamedTuple):
 class DetectionModel(BaseModel, ABC):
     """Base interface for detection models."""
 
+    classes: list[str] = []
+
     @abstractmethod
     def __call__(self, input: Any) -> list[Iterator[DetectionResult]]:
         pass

cells2table-0.2.2/src/cells2table/pipelines/__init__.py

@@ -0,0 +1,3 @@
+from .paddlepaddle import PaddlePaddleTablePipeline
+
+__all__ = [PaddlePaddleTablePipeline]

cells2table-0.2.2/src/cells2table/pipelines/base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Optional
+
+
+class BasePipeline(ABC):
+    """Base interface for pipelines of any type."""
+
+    @abstractmethod
+    def __init__(self, models_path: Optional[Path | str] = None) -> None:
+        pass
+
+    @abstractmethod
+    def __call__(self, input: Any):
+        pass

cells2table-0.2.2/src/cells2table/pipelines/classification_detection.py

@@ -0,0 +1,62 @@
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Iterable, Optional
+
+from ..datamodels import Table
+from ..models.tasks import ClassificationModel, DetectionModel
+from .base import BasePipeline
+
+logger = logging.getLogger(__name__)
+
+
+class ClassificationDetectionPipeline(BasePipeline, ABC):
+    """Base class for standard classification and detection pipelines."""
+
+    classification_model: ClassificationModel
+    detection_models: list[DetectionModel]
+
+    @abstractmethod
+    def __init__(self, models_path: Optional[Path | str] = None) -> None:
+        """Initialize the models."""
+
+        pass
+
+    def __call__(self, input: Iterable[Any]) -> list[Table]:
+        """Run the pipeline."""
+
+        cls_images = [[] for c in self.classification_model.classes]
+        cls_detections = [[] for c in self.classification_model.classes]
+        cls_current_idx = [0 for c in self.classification_model.classes]
+        output = []
+
+        cls_result = self.classification_model(input)
+
+        # Run the classification model for each image
+        for i, (img, p) in enumerate(zip(input, cls_result)):
+            cls_images[self.assigned_model_idx(p.cls, self.detection_models)].append(img)
+            logger.info("Image %d classified as %s with %.4f confidence", i, p.cls, p.confidence)
+
+        # Run the detection model for each image
+        for i in range(len(self.classification_model.classes)):
+            if len(cls_images[i]):
+                cls_detections[i] = self.detection_models[i](cls_images[i])
+
+        # Combine results
+        for i in range(len(cls_result)):
+            model_idx = self.assigned_model_idx(cls_result[i].cls, self.detection_models)
+            cells_det = cls_detections[model_idx][cls_current_idx[model_idx]]
+            cls_current_idx[model_idx] += 1
+            output.append(Table.from_detections(cells_det))
+
+        return output
+
+    @staticmethod
+    def assigned_model_idx(pred_cls: str, models: list[DetectionModel]) -> int:
+        """Return the index of the first model appropriate for the class."""
+
+        for idx, model in enumerate(models):
+            if pred_cls in model.classes:
+                return idx
+
+        raise ValueError(f"No model can be assigned for class {pred_cls}")

cells2table-0.2.2/src/cells2table/pipelines/paddlepaddle.py

@@ -0,0 +1,45 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+from ..models.PaddlePaddle import (
+    PaddlePaddleTableClassificationModel,
+    PaddlePaddleWiredCellDetectionModel,
+    PaddlePaddleWirelessCellDetectionModel,
+)
+from .classification_detection import ClassificationDetectionPipeline
+
+logger = logging.getLogger(__name__)
+
+
+class PaddlePaddleTablePipeline(ClassificationDetectionPipeline):
+    """A table pipeline combining PaddlePaddle classification and detection models."""
+
+    def __init__(self, models_path: Optional[Path | str] = None) -> None:
+        """Initialize models from the provided path or download them.
+
+        As the models are all in the same repository, do the download only once.
+        """
+
+        self.detection_models = []
+        cls_path, wired_path, wireless_path = None, None, None
+
+        if models_path is not None:
+            models_path = Path(models_path)
+            cls_path = (
+                models_path / PaddlePaddleTableClassificationModel.download_options.model_path
+            )
+
+        self.classification_model = PaddlePaddleTableClassificationModel(cls_path)
+
+        wired_path = (
+            self.classification_model.model_path.parent
+            / PaddlePaddleWiredCellDetectionModel.download_options.model_path
+        )
+        wireless_path = (
+            self.classification_model.model_path.parent
+            / PaddlePaddleWirelessCellDetectionModel.download_options.model_path
+        )
+
+        self.detection_models.append(PaddlePaddleWiredCellDetectionModel(wired_path))
+        self.detection_models.append(PaddlePaddleWirelessCellDetectionModel(wireless_path))

{cells2table-0.2.0 → cells2table-0.2.2}/src/cells2table/utils/visualize.py

@@ -2,7 +2,7 @@ import cv2
 import numpy as np
 from numpy.typing import NDArray
 
-from .table import Table
+from ..datamodels import Table
 
 
 def visualize_table(

cells2table-0.2.0/src/cells2table/__init__.py

@@ -1,3 +0,0 @@
-from .models import DefaultPipeline
-
-__all__ = [DefaultPipeline]

cells2table-0.2.0/src/cells2table/models/PaddlePaddle/__init__.py

@@ -1,15 +0,0 @@
-from .cell_detection import (
-    PaddlePaddleCellDetection,
-    PaddlePaddleWiredCellDetection,
-    PaddlePaddleWirelessCellDetection,
-)
-from .pipeline import PaddlePaddleTablePipeline
-from .table_classification import PaddlePaddleTableClassification
-
-__all__ = [
-    PaddlePaddleCellDetection,
-    PaddlePaddleWiredCellDetection,
-    PaddlePaddleWirelessCellDetection,
-    PaddlePaddleTablePipeline,
-    PaddlePaddleTableClassification,
-]

cells2table-0.2.0/src/cells2table/models/PaddlePaddle/pipeline.py

@@ -1,59 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Iterable, Optional
-
-import numpy as np
-from numpy.typing import NDArray
-
-from ...utils.table import Table
-from .cell_detection import PaddlePaddleWiredCellDetection, PaddlePaddleWirelessCellDetection
-from .table_classification import PaddlePaddleTableClassification
-
-logger = logging.getLogger(__name__)
-
-
-class PaddlePaddleTablePipeline:
-    """A table pipeline combining PaddlePaddle classification and detection models."""
-
-    def __init__(self, models_path: Optional[Path | str] = None):
-        cls_path, wired_path, wireless_path = None, None, None
-
-        if models_path is not None:
-            models_path = Path(models_path)
-            cls_path = models_path / PaddlePaddleTableClassification.download_options.model_path
-            wired_path = models_path / PaddlePaddleWiredCellDetection.download_options.model_path
-            wireless_path = models_path / PaddlePaddleWiredCellDetection.download_options.model_path
-
-        self.cls_predictor = PaddlePaddleTableClassification(cls_path)
-        self.wired_predictor = PaddlePaddleWiredCellDetection(wired_path)
-        self.wireless_predictor = PaddlePaddleWirelessCellDetection(wireless_path)
-
-    def __call__(self, input: Iterable[NDArray[np.uint8]]) -> list[Table]:
-        wired_images, wireless_images, output = [], [], []
-
-        cls_result = self.cls_predictor(input)
-
-        for i, (img, p) in enumerate(zip(input, cls_result)):
-            (wired_images if p.cls == "wired" else wireless_images).append(img)
-            logger.info("Image %d classified as %s", i, p.cls)
-
-        if len(wired_images):
-            wired_cells = self.wired_predictor(wired_images)
-
-        if len(wireless_images):
-            wireless_cells = self.wireless_predictor(wireless_images)
-
-        wired_idx = 0
-        wireless_idx = 0
-
-        for i in range(len(cls_result)):
-            if cls_result[i].cls == "wired":
-                cells_det = wired_cells[wired_idx]
-                wired_idx += 1
-            else:
-                cells_det = wireless_cells[wireless_idx]
-                wireless_idx += 1
-
-            output.append(Table.from_detections(cells_det))
-
-        return output

cells2table-0.2.0/src/cells2table/models/__init__.py

@@ -1,3 +0,0 @@
-from .PaddlePaddle import PaddlePaddleTablePipeline as DefaultPipeline
-
-__all__ = [DefaultPipeline]

cells2table-0.2.0/src/cells2table/models/utils/runtimes/__init__.py

@@ -1,3 +0,0 @@
-from .onnx import OnnxModel
-
-__all__ = [OnnxModel]