onnxtr 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

onnxtr/models/predictor/base.py

@@ -3,7 +3,8 @@
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 
@@ -24,7 +25,6 @@ class _OCRPredictor:
     """Implements an object able to localize and identify text elements in a set of documents
 
     Args:
-    ----
         assume_straight_pages: if True, speeds up the inference by assuming you only pass straight pages
             without rotated textual elements.
         straighten_pages: if True, estimates the page general orientation based on the median line orientation.
@@ -39,8 +39,8 @@ class _OCRPredictor:
         **kwargs: keyword args of `DocumentBuilder`
     """
 
-    crop_orientation_predictor: Optional[OrientationPredictor]
-    page_orientation_predictor: Optional[OrientationPredictor]
+    crop_orientation_predictor: OrientationPredictor | None
+    page_orientation_predictor: OrientationPredictor | None
 
     def __init__(
         self,
@@ -50,7 +50,7 @@ class _OCRPredictor:
         symmetric_pad: bool = True,
         detect_orientation: bool = False,
         load_in_8_bit: bool = False,
-        clf_engine_cfg: Optional[EngineConfig] = None,
+        clf_engine_cfg: EngineConfig | None = None,
         **kwargs: Any,
     ) -> None:
         self.assume_straight_pages = assume_straight_pages
@@ -74,12 +74,12 @@ class _OCRPredictor:
         self.doc_builder = DocumentBuilder(**kwargs)
         self.preserve_aspect_ratio = preserve_aspect_ratio
         self.symmetric_pad = symmetric_pad
-        self.hooks: List[Callable] = []
+        self.hooks: list[Callable] = []
 
     def _general_page_orientations(
         self,
-        pages: List[np.ndarray],
-    ) -> List[Tuple[int, float]]:
+        pages: list[np.ndarray],
+    ) -> list[tuple[int, float]]:
         _, classes, probs = zip(self.page_orientation_predictor(pages))  # type: ignore[misc]
         # Flatten to list of tuples with (value, confidence)
         page_orientations = [
@@ -90,8 +90,8 @@ class _OCRPredictor:
         return page_orientations
 
     def _get_orientations(
-        self, pages: List[np.ndarray], seg_maps: List[np.ndarray]
-    ) -> Tuple[List[Tuple[int, float]], List[int]]:
+        self, pages: list[np.ndarray], seg_maps: list[np.ndarray]
+    ) -> tuple[list[tuple[int, float]], list[int]]:
         general_pages_orientations = self._general_page_orientations(pages)
         origin_page_orientations = [
             estimate_orientation(seq_map, general_orientation)
@@ -101,11 +101,11 @@ class _OCRPredictor:
 
     def _straighten_pages(
         self,
-        pages: List[np.ndarray],
-        seg_maps: List[np.ndarray],
-        general_pages_orientations: Optional[List[Tuple[int, float]]] = None,
-        origin_pages_orientations: Optional[List[int]] = None,
-    ) -> List[np.ndarray]:
+        pages: list[np.ndarray],
+        seg_maps: list[np.ndarray],
+        general_pages_orientations: list[tuple[int, float]] | None = None,
+        origin_pages_orientations: list[int] | None = None,
+    ) -> list[np.ndarray]:
         general_pages_orientations = (
             general_pages_orientations if general_pages_orientations else self._general_page_orientations(pages)
         )
@@ -125,12 +125,12 @@ class _OCRPredictor:
 
     @staticmethod
     def _generate_crops(
-        pages: List[np.ndarray],
-        loc_preds: List[np.ndarray],
+        pages: list[np.ndarray],
+        loc_preds: list[np.ndarray],
         channels_last: bool,
         assume_straight_pages: bool = False,
         assume_horizontal: bool = False,
-    ) -> List[List[np.ndarray]]:
+    ) -> list[list[np.ndarray]]:
         if assume_straight_pages:
             crops = [
                 extract_crops(page, _boxes[:, :4], channels_last=channels_last)
@@ -145,12 +145,12 @@ class _OCRPredictor:
 
     @staticmethod
     def _prepare_crops(
-        pages: List[np.ndarray],
-        loc_preds: List[np.ndarray],
+        pages: list[np.ndarray],
+        loc_preds: list[np.ndarray],
         channels_last: bool,
         assume_straight_pages: bool = False,
         assume_horizontal: bool = False,
-    ) -> Tuple[List[List[np.ndarray]], List[np.ndarray]]:
+    ) -> tuple[list[list[np.ndarray]], list[np.ndarray]]:
         crops = _OCRPredictor._generate_crops(pages, loc_preds, channels_last, assume_straight_pages, assume_horizontal)
 
         # Avoid sending zero-sized crops
@@ -165,9 +165,9 @@ class _OCRPredictor:
 
     def _rectify_crops(
         self,
-        crops: List[List[np.ndarray]],
-        loc_preds: List[np.ndarray],
-    ) -> Tuple[List[List[np.ndarray]], List[np.ndarray], List[Tuple[int, float]]]:
+        crops: list[list[np.ndarray]],
+        loc_preds: list[np.ndarray],
+    ) -> tuple[list[list[np.ndarray]], list[np.ndarray], list[tuple[int, float]]]:
         # Work at a page level
         orientations, classes, probs = zip(*[self.crop_orientation_predictor(page_crops) for page_crops in crops])  # type: ignore[misc]
         rect_crops = [rectify_crops(page_crops, orientation) for page_crops, orientation in zip(crops, orientations)]
@@ -185,10 +185,10 @@ class _OCRPredictor:
 
     @staticmethod
     def _process_predictions(
-        loc_preds: List[np.ndarray],
-        word_preds: List[Tuple[str, float]],
-        crop_orientations: List[Dict[str, Any]],
-    ) -> Tuple[List[np.ndarray], List[List[Tuple[str, float]]], List[List[Dict[str, Any]]]]:
+        loc_preds: list[np.ndarray],
+        word_preds: list[tuple[str, float]],
+        crop_orientations: list[dict[str, Any]],
+    ) -> tuple[list[np.ndarray], list[list[tuple[str, float]]], list[list[dict[str, Any]]]]:
         text_preds = []
         crop_orientation_preds = []
         if len(loc_preds) > 0:
@@ -205,10 +205,9 @@ class _OCRPredictor:
         """Add a hook to the predictor
 
         Args:
-        ----
             hook: a callable that takes as input the `loc_preds` and returns the modified `loc_preds`
         """
         self.hooks.append(hook)
 
-    def list_archs(self) -> Dict[str, List[str]]:
+    def list_archs(self) -> dict[str, list[str]]:
         return {"detection_archs": DETECTION_ARCHS, "recognition_archs": RECOGNITION_ARCHS}

onnxtr/models/predictor/predictor.py

@@ -3,7 +3,7 @@
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
-from typing import Any, List, Optional
+from typing import Any
 
 import numpy as np
 
@@ -24,7 +24,6 @@ class OCRPredictor(NestedObject, _OCRPredictor):
     """Implements an object able to localize and identify text elements in a set of documents
 
     Args:
-    ----
         det_predictor: detection module
         reco_predictor: recognition module
         assume_straight_pages: if True, speeds up the inference by assuming you only pass straight pages
@@ -52,7 +51,7 @@ class OCRPredictor(NestedObject, _OCRPredictor):
         symmetric_pad: bool = True,
         detect_orientation: bool = False,
         detect_language: bool = False,
-        clf_engine_cfg: Optional[EngineConfig] = None,
+        clf_engine_cfg: EngineConfig | None = None,
         **kwargs: Any,
     ) -> None:
         self.det_predictor = det_predictor
@@ -72,7 +71,7 @@ class OCRPredictor(NestedObject, _OCRPredictor):
 
     def __call__(
         self,
-        pages: List[np.ndarray],
+        pages: list[np.ndarray],
         **kwargs: Any,
     ) -> Document:
         # Dimension check
@@ -147,7 +146,7 @@ class OCRPredictor(NestedObject, _OCRPredictor):
             boxes,
             objectness_scores,
             text_preds,
-            origin_page_shapes,  # type: ignore[arg-type]
+            origin_page_shapes,
             crop_orientations,
             orientations,
             languages_dict,

onnxtr/models/preprocessor/base.py

@@ -4,7 +4,7 @@
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 import math
-from typing import Any, List, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -20,36 +20,34 @@ class PreProcessor(NestedObject):
     """Implements an abstract preprocessor object which performs casting, resizing, batching and normalization.
 
     Args:
-    ----
         output_size: expected size of each page in format (H, W)
         batch_size: the size of page batches
         mean: mean value of the training distribution by channel
         std: standard deviation of the training distribution by channel
+        **kwargs: additional arguments for the resizing operation
     """
 
-    _children_names: List[str] = ["resize", "normalize"]
+    _children_names: list[str] = ["resize", "normalize"]
 
     def __init__(
         self,
-        output_size: Tuple[int, int],
+        output_size: tuple[int, int],
         batch_size: int,
-        mean: Tuple[float, float, float] = (0.5, 0.5, 0.5),
-        std: Tuple[float, float, float] = (1.0, 1.0, 1.0),
+        mean: tuple[float, float, float] = (0.5, 0.5, 0.5),
+        std: tuple[float, float, float] = (1.0, 1.0, 1.0),
         **kwargs: Any,
     ) -> None:
         self.batch_size = batch_size
         self.resize = Resize(output_size, **kwargs)
         self.normalize = Normalize(mean, std)
 
-    def batch_inputs(self, samples: List[np.ndarray]) -> List[np.ndarray]:
+    def batch_inputs(self, samples: list[np.ndarray]) -> list[np.ndarray]:
         """Gather samples into batches for inference purposes
 
         Args:
-        ----
             samples: list of samples (tf.Tensor)
 
         Returns:
-        -------
             list of batched samples
         """
         num_batches = int(math.ceil(len(samples) / self.batch_size))
@@ -76,15 +74,13 @@ class PreProcessor(NestedObject):
 
         return x
 
-    def __call__(self, x: Union[np.ndarray, List[np.ndarray]]) -> List[np.ndarray]:
+    def __call__(self, x: np.ndarray | list[np.ndarray]) -> list[np.ndarray]:
         """Prepare document data for model forwarding
 
         Args:
-        ----
             x: list of images (np.array) or tensors (already resized and batched)
 
         Returns:
-        -------
             list of page batches
         """
         # Input type check

onnxtr/models/recognition/core.py

@@ -13,7 +13,6 @@ class RecognitionPostProcessor(NestedObject):
     """Abstract class to postprocess the raw output of the model
 
     Args:
-    ----
         vocab: string containing the ordered sequence of supported characters
     """
 

onnxtr/models/recognition/models/crnn.py

@@ -5,7 +5,7 @@
 
 from copy import deepcopy
 from itertools import groupby
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import numpy as np
 from scipy.special import softmax
@@ -17,7 +17,7 @@ from ..core import RecognitionPostProcessor
 
 __all__ = ["CRNN", "crnn_vgg16_bn", "crnn_mobilenet_v3_small", "crnn_mobilenet_v3_large"]
 
-default_cfgs: Dict[str, Dict[str, Any]] = {
+default_cfgs: dict[str, dict[str, Any]] = {
     "crnn_vgg16_bn": {
         "mean": (0.694, 0.695, 0.693),
         "std": (0.299, 0.296, 0.301),
@@ -49,7 +49,6 @@ class CRNNPostProcessor(RecognitionPostProcessor):
     """Postprocess raw prediction of the model (logits) to a list of words using CTC decoding
 
     Args:
-    ----
         vocab: string containing the ordered sequence of supported characters
     """
 
@@ -69,13 +68,11 @@ class CRNNPostProcessor(RecognitionPostProcessor):
         <https://github.com/githubharald/CTCDecoder>`_.
 
         Args:
-        ----
             logits: model output, shape: N x T x C
             vocab: vocabulary to use
             blank: index of blank label
 
         Returns:
-        -------
             A list of tuples: (word, confidence)
         """
         # Gather the most confident characters, and assign the smallest conf among those to the sequence prob
@@ -94,11 +91,9 @@ class CRNNPostProcessor(RecognitionPostProcessor):
         with label_to_idx mapping dictionnary
 
         Args:
-        ----
             logits: raw output of the model, shape (N, C + 1, seq_len)
 
         Returns:
-        -------
             A tuple of 2 lists: a list of str (words) and a list of float (probs)
 
         """
@@ -110,7 +105,6 @@ class CRNN(Engine):
     """CRNN Onnx loader
 
     Args:
-    ----
         model_path: path or url to onnx model file
         vocab: vocabulary used for encoding
         engine_cfg: configuration for the inference engine
@@ -118,14 +112,14 @@ class CRNN(Engine):
         **kwargs: additional arguments to be passed to `Engine`
     """
 
-    _children_names: List[str] = ["postprocessor"]
+    _children_names: list[str] = ["postprocessor"]
 
     def __init__(
         self,
         model_path: str,
         vocab: str,
-        engine_cfg: Optional[EngineConfig] = None,
-        cfg: Optional[Dict[str, Any]] = None,
+        engine_cfg: EngineConfig | None = None,
+        cfg: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(url=model_path, engine_cfg=engine_cfg, **kwargs)
@@ -139,10 +133,10 @@ class CRNN(Engine):
         self,
         x: np.ndarray,
         return_model_output: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         logits = self.run(x)
 
-        out: Dict[str, Any] = {}
+        out: dict[str, Any] = {}
         if return_model_output:
             out["out_map"] = logits
 
@@ -156,7 +150,7 @@ def _crnn(
     arch: str,
     model_path: str,
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> CRNN:
     kwargs["vocab"] = kwargs.get("vocab", default_cfgs[arch]["vocab"])
@@ -174,7 +168,7 @@ def _crnn(
 def crnn_vgg16_bn(
     model_path: str = default_cfgs["crnn_vgg16_bn"]["url"],
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> CRNN:
     """CRNN with a VGG-16 backbone as described in `"An End-to-End Trainable Neural Network for Image-based
@@ -187,14 +181,12 @@ def crnn_vgg16_bn(
     >>> out = model(input_tensor)
 
     Args:
-    ----
         model_path: path to onnx model file, defaults to url in default_cfgs
         load_in_8_bit: whether to load the the 8-bit quantized model, defaults to False
         engine_cfg: configuration for the inference engine
         **kwargs: keyword arguments of the CRNN architecture
 
     Returns:
-    -------
         text recognition architecture
     """
     return _crnn("crnn_vgg16_bn", model_path, load_in_8_bit, engine_cfg, **kwargs)
@@ -203,7 +195,7 @@ def crnn_vgg16_bn(
 def crnn_mobilenet_v3_small(
     model_path: str = default_cfgs["crnn_mobilenet_v3_small"]["url"],
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> CRNN:
     """CRNN with a MobileNet V3 Small backbone as described in `"An End-to-End Trainable Neural Network for Image-based
@@ -216,14 +208,12 @@ def crnn_mobilenet_v3_small(
     >>> out = model(input_tensor)
 
     Args:
-    ----
         model_path: path to onnx model file, defaults to url in default_cfgs
         load_in_8_bit: whether to load the the 8-bit quantized model, defaults to False
         engine_cfg: configuration for the inference engine
         **kwargs: keyword arguments of the CRNN architecture
 
     Returns:
-    -------
         text recognition architecture
     """
     return _crnn("crnn_mobilenet_v3_small", model_path, load_in_8_bit, engine_cfg, **kwargs)
@@ -232,7 +222,7 @@ def crnn_mobilenet_v3_small(
 def crnn_mobilenet_v3_large(
     model_path: str = default_cfgs["crnn_mobilenet_v3_large"]["url"],
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> CRNN:
     """CRNN with a MobileNet V3 Large backbone as described in `"An End-to-End Trainable Neural Network for Image-based
@@ -245,14 +235,12 @@ def crnn_mobilenet_v3_large(
     >>> out = model(input_tensor)
 
     Args:
-    ----
         model_path: path to onnx model file, defaults to url in default_cfgs
         load_in_8_bit: whether to load the the 8-bit quantized model, defaults to False
         engine_cfg: configuration for the inference engine
         **kwargs: keyword arguments of the CRNN architecture
 
     Returns:
-    -------
         text recognition architecture
     """
     return _crnn("crnn_mobilenet_v3_large", model_path, load_in_8_bit, engine_cfg, **kwargs)

onnxtr/models/recognition/models/master.py

@@ -4,7 +4,7 @@
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 import numpy as np
 from scipy.special import softmax
@@ -17,7 +17,7 @@ from ..core import RecognitionPostProcessor
 __all__ = ["MASTER", "master"]
 
 
-default_cfgs: Dict[str, Dict[str, Any]] = {
+default_cfgs: dict[str, dict[str, Any]] = {
     "master": {
         "mean": (0.694, 0.695, 0.693),
         "std": (0.299, 0.296, 0.301),
@@ -33,7 +33,6 @@ class MASTER(Engine):
     """MASTER Onnx loader
 
     Args:
-    ----
         model_path: path or url to onnx model file
         vocab: vocabulary, (without EOS, SOS, PAD)
         engine_cfg: configuration for the inference engine
@@ -45,8 +44,8 @@ class MASTER(Engine):
         self,
         model_path: str,
         vocab: str,
-        engine_cfg: Optional[EngineConfig] = None,
-        cfg: Optional[Dict[str, Any]] = None,
+        engine_cfg: EngineConfig | None = None,
+        cfg: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(url=model_path, engine_cfg=engine_cfg, **kwargs)
@@ -60,20 +59,18 @@ class MASTER(Engine):
         self,
         x: np.ndarray,
         return_model_output: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Call function
 
         Args:
-        ----
             x: images
             return_model_output: if True, return logits
 
         Returns:
-        -------
             A dictionnary containing eventually logits and predictions.
         """
         logits = self.run(x)
-        out: Dict[str, Any] = {}
+        out: dict[str, Any] = {}
 
         if return_model_output:
             out["out_map"] = logits
@@ -87,7 +84,6 @@ class MASTERPostProcessor(RecognitionPostProcessor):
     """Post-processor for the MASTER model
 
     Args:
-    ----
         vocab: string containing the ordered sequence of supported characters
     """
 
@@ -98,7 +94,7 @@ class MASTERPostProcessor(RecognitionPostProcessor):
         super().__init__(vocab)
         self._embedding = list(vocab) + ["<eos>"] + ["<sos>"] + ["<pad>"]
 
-    def __call__(self, logits: np.ndarray) -> List[Tuple[str, float]]:
+    def __call__(self, logits: np.ndarray) -> list[tuple[str, float]]:
         # compute pred with argmax for attention models
         out_idxs = np.argmax(logits, axis=-1)
         # N x L
@@ -117,7 +113,7 @@ def _master(
     arch: str,
     model_path: str,
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> MASTER:
     # Patch the config
@@ -135,7 +131,7 @@ def _master(
 def master(
     model_path: str = default_cfgs["master"]["url"],
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> MASTER:
     """MASTER as described in paper: <https://arxiv.org/pdf/1910.02562.pdf>`_.
@@ -147,14 +143,12 @@ def master(
     >>> out = model(input_tensor)
 
     Args:
-    ----
         model_path: path to onnx model file, defaults to url in default_cfgs
         load_in_8_bit: whether to load the the 8-bit quantized model, defaults to False
         engine_cfg: configuration for the inference engine
         **kwargs: keywoard arguments passed to the MASTER architecture
 
     Returns:
-    -------
         text recognition architecture
     """
     return _master("master", model_path, load_in_8_bit, engine_cfg, **kwargs)

onnxtr/models/recognition/models/parseq.py

@@ -4,7 +4,7 @@
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 from copy import deepcopy
-from typing import Any, Dict, Optional
+from typing import Any
 
 import numpy as np
 from scipy.special import softmax
@@ -16,7 +16,7 @@ from ..core import RecognitionPostProcessor
 
 __all__ = ["PARSeq", "parseq"]
 
-default_cfgs: Dict[str, Dict[str, Any]] = {
+default_cfgs: dict[str, dict[str, Any]] = {
     "parseq": {
         "mean": (0.694, 0.695, 0.693),
         "std": (0.299, 0.296, 0.301),
@@ -32,7 +32,6 @@ class PARSeq(Engine):
     """PARSeq Onnx loader
 
     Args:
-    ----
         model_path: path to onnx model file
         vocab: vocabulary used for encoding
         engine_cfg: configuration for the inference engine
@@ -44,8 +43,8 @@ class PARSeq(Engine):
         self,
         model_path: str,
         vocab: str,
-        engine_cfg: Optional[EngineConfig] = None,
-        cfg: Optional[Dict[str, Any]] = None,
+        engine_cfg: EngineConfig | None = None,
+        cfg: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(url=model_path, engine_cfg=engine_cfg, **kwargs)
@@ -59,9 +58,9 @@ class PARSeq(Engine):
         self,
         x: np.ndarray,
         return_model_output: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         logits = self.run(x)
-        out: Dict[str, Any] = {}
+        out: dict[str, Any] = {}
 
         if return_model_output:
             out["out_map"] = logits
@@ -74,7 +73,6 @@ class PARSeqPostProcessor(RecognitionPostProcessor):
     """Post processor for PARSeq architecture
 
     Args:
-    ----
         vocab: string containing the ordered sequence of supported characters
     """
 
@@ -106,7 +104,7 @@ def _parseq(
     arch: str,
     model_path: str,
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> PARSeq:
     # Patch the config
@@ -125,7 +123,7 @@ def _parseq(
 def parseq(
     model_path: str = default_cfgs["parseq"]["url"],
     load_in_8_bit: bool = False,
-    engine_cfg: Optional[EngineConfig] = None,
+    engine_cfg: EngineConfig | None = None,
     **kwargs: Any,
 ) -> PARSeq:
     """PARSeq architecture from
@@ -138,14 +136,12 @@ def parseq(
     >>> out = model(input_tensor)
 
     Args:
-    ----
         model_path: path to onnx model file, defaults to url in default_cfgs
         load_in_8_bit: whether to load the the 8-bit quantized model, defaults to False
         engine_cfg: configuration for the inference engine
         **kwargs: keyword arguments of the PARSeq architecture
 
     Returns:
-    -------
         text recognition architecture
     """
     return _parseq("parseq", model_path, load_in_8_bit, engine_cfg, **kwargs)