custom-layoutparser 0.1.0__py3-none-any.whl

layoutparser/models/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .detectron2.layoutmodel import Detectron2LayoutModel
+from .paddledetection.layoutmodel import PaddleDetectionLayoutModel
+from .effdet.layoutmodel import EfficientDetLayoutModel
+from .auto_layoutmodel import AutoLayoutModel

layoutparser/models/auto_layoutmodel.py

@@ -0,0 +1,70 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Dict, Union, List
+from .detectron2.layoutmodel import Detectron2LayoutModel
+from .paddledetection.layoutmodel import PaddleDetectionLayoutModel
+from .effdet.layoutmodel import EfficientDetLayoutModel
+from .model_config import (
+    is_lp_layout_model_config_any_format,
+)
+
+ALL_AVAILABLE_BACKENDS = {
+    Detectron2LayoutModel.DETECTOR_NAME: Detectron2LayoutModel,
+    PaddleDetectionLayoutModel.DETECTOR_NAME: PaddleDetectionLayoutModel,
+    EfficientDetLayoutModel.DETECTOR_NAME: EfficientDetLayoutModel,
+}
+
+
+def AutoLayoutModel(
+    config_path: str,
+    model_path: Optional[str] = None,
+    label_map: Optional[Dict]=None,
+    device: Optional[str]=None,
+    extra_config: Optional[Union[Dict, List]]=None,
+) -> "BaseLayoutModel":
+    """[summary]
+
+    Args:
+        config_path (:obj:`str`):
+            The path to the configuration file.
+        model_path (:obj:`str`, None):
+            The path to the saved weights of the model.
+            If set, overwrite the weights in the configuration file.
+            Defaults to `None`.
+        label_map (:obj:`dict`, optional):
+            The map from the model prediction (ids) to real
+            word labels (strings). If the config is from one of the supported
+            datasets, Layout Parser will automatically initialize the label_map.
+            Defaults to `None`.
+        device(:obj:`str`, optional):
+            Whether to use cuda or cpu devices. If not set, LayoutParser will
+            automatically determine the device to initialize the models on. 
+        extra_config (:obj:`dict`, optional):
+            Extra configuration passed used for initializing the layout model.
+
+    Returns:
+        # BaseLayoutModel: the create LayoutModel instance
+    """
+    if not is_lp_layout_model_config_any_format(config_path):
+        raise ValueError(f"Invalid model config_path {config_path}")
+    for backend_name in ALL_AVAILABLE_BACKENDS:
+        if backend_name in config_path:
+            return ALL_AVAILABLE_BACKENDS[backend_name](
+                config_path,
+                model_path=model_path,
+                label_map=label_map,
+                extra_config=extra_config,
+                device=device,
+            )

layoutparser/models/base_catalog.py

@@ -0,0 +1,34 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from iopath.common.file_io import HTTPURLHandler
+from iopath.common.file_io import PathManager as PathManagerBase
+
+# A trick learned from https://github.com/facebookresearch/detectron2/blob/65faeb4779e4c142484deeece18dc958c5c9ad18/detectron2/utils/file_io.py#L3
+
+
+class DropboxHandler(HTTPURLHandler):
+    """
+    Supports download and file check for dropbox links
+    """
+
+    def _get_supported_prefixes(self):
+        return ["https://www.dropbox.com"]
+
+    def _isfile(self, path):
+        return path in self.cache_map
+
+
+PathManager = PathManagerBase()
+PathManager.register_handler(DropboxHandler())

layoutparser/models/base_layoutmodel.py

@@ -0,0 +1,88 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Tuple, Union, Dict
+from abc import ABC, abstractmethod
+
+from .model_config import LayoutModelConfig, add_identifier_for_config, layout_model_config_parser, is_lp_layout_model_config_any_format
+from ..file_utils import requires_backends
+
+class BaseLayoutModel(ABC):
+
+    # TODO: Build a metaclass for lazy module loader
+    @property
+    @abstractmethod
+    def DEPENDENCIES(self):
+        """DEPENDENCIES lists all necessary dependencies for the class."""
+        pass
+
+    @property
+    @abstractmethod
+    def DETECTOR_NAME(self):
+        pass
+
+    @property
+    @abstractmethod
+    def MODEL_CATALOG(self) -> Dict[str, Dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def detect(self, image: Union["np.ndarray", "Image.Image"]):
+        pass
+
+
+    @abstractmethod
+    def image_loader(self, image: Union["np.ndarray", "Image.Image"]):
+        """It will process the input images appropriately to the target format."""
+        pass
+    
+    def _parse_config(self, config_path:str, identifier:str) -> Union[LayoutModelConfig, str]:
+        
+        if is_lp_layout_model_config_any_format(config_path):
+            config_path = add_identifier_for_config(config_path, identifier)
+            for dataset_name in self.MODEL_CATALOG:
+                if dataset_name in config_path:
+                    default_model_arch = list(self.MODEL_CATALOG[dataset_name].keys())[0]
+                    # Use the first model_name for the dataset as the default_model_arch
+                    return layout_model_config_parser(config_path, self.DETECTOR_NAME, default_model_arch)
+            raise ValueError(f"The config {config_path} is not a valid config for {self.__class__}, "
+                             f"possibly because there aren't models trained for the specified dataset.")
+        else:
+            return config_path
+
+    def config_parser(self, config_path:str, model_path: Optional[str], allow_empty_path=False) -> Tuple[str, str]:
+
+        config_path = self._parse_config(config_path, "config")
+        
+        if isinstance(config_path, str) and model_path is None:
+            if not allow_empty_path:
+                raise ValueError(
+                    f"Invalid config and model path pairs ({(config_path, model_path)}):"
+                    f"When config_path is a regular URL, the model_path should not be empty"
+                )
+            else:
+                return config_path, model_path
+        elif isinstance(config_path, LayoutModelConfig) and model_path is None:
+            model_path = config_path.dual()
+        else:
+            model_path = self._parse_config(model_path, "weight")
+
+        config_path = config_path if isinstance(config_path, str) else config_path.full
+        model_path = model_path if isinstance(model_path, str) else model_path.full
+        return config_path, model_path
+
+    def __new__(cls, *args, **kwargs):
+
+        requires_backends(cls, cls.DEPENDENCIES)
+        return super().__new__(cls)

layoutparser/models/detectron2/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import catalog as _UNUSED
+# A trick learned from
+# https://github.com/facebookresearch/detectron2/blob/62cf3a2b6840734d2717abdf96e2dd57ed6612a6/detectron2/checkpoint/__init__.py#L6
+from .layoutmodel import Detectron2LayoutModel

layoutparser/models/detectron2/catalog.py

@@ -0,0 +1,142 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from iopath.common.file_io import PathHandler
+
+from ..base_catalog import PathManager
+
+MODEL_CATALOG = {
+    "HJDataset": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/6icw6at8m28a2ho/model_final.pth?dl=1",
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/893paxpy5suvlx9/model_final.pth?dl=1",
+        "retinanet_R_50_FPN_3x": "https://www.dropbox.com/s/yxsloxu3djt456i/model_final.pth?dl=1",
+    },
+    "PubLayNet": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/dgy9c10wykk4lq4/model_final.pth?dl=1",
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/d9fc9tahfzyl6df/model_final.pth?dl=1",
+        "mask_rcnn_X_101_32x8d_FPN_3x": "https://www.dropbox.com/s/57zjbwv6gh3srry/model_final.pth?dl=1",
+    },
+    "PrimaLayout": {
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/h7th27jfv19rxiy/model_final.pth?dl=1"
+    },
+    "NewspaperNavigator": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/6ewh6g8rqt2ev3a/model_final.pth?dl=1",
+    },
+    "TableBank": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/8v4uqmz1at9v72a/model_final.pth?dl=1",
+        "faster_rcnn_R_101_FPN_3x": "https://www.dropbox.com/s/6vzfk8lk9xvyitg/model_final.pth?dl=1",
+    },
+    "MFD": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/7xel0i3iqpm2p8y/model_final.pth?dl=1",
+    },
+}
+
+CONFIG_CATALOG = {
+    "HJDataset": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/j4yseny2u0hn22r/config.yml?dl=1",
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/4jmr3xanmxmjcf8/config.yml?dl=1",
+        "retinanet_R_50_FPN_3x": "https://www.dropbox.com/s/z8a8ywozuyc5c2x/config.yml?dl=1",
+    },
+    "PubLayNet": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/f3b12qc4hc0yh4m/config.yml?dl=1",
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/u9wbsfwz4y0ziki/config.yml?dl=1",
+        "mask_rcnn_X_101_32x8d_FPN_3x": "https://www.dropbox.com/s/nau5ut6zgthunil/config.yaml?dl=1",
+    },
+    "PrimaLayout": {
+        "mask_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/yc92x97k50abynt/config.yaml?dl=1"
+    },
+    "NewspaperNavigator": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/wnido8pk4oubyzr/config.yml?dl=1",
+    },
+    "TableBank": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/7cqle02do7ah7k4/config.yaml?dl=1",
+        "faster_rcnn_R_101_FPN_3x": "https://www.dropbox.com/s/h63n6nv51kfl923/config.yaml?dl=1",
+    },
+    "MFD": {
+        "faster_rcnn_R_50_FPN_3x": "https://www.dropbox.com/s/ld9izb95f19369w/config.yaml?dl=1",
+    },
+}
+
+# fmt: off
+LABEL_MAP_CATALOG = {
+    "HJDataset": {
+        1: "Page Frame",
+        2: "Row",
+        3: "Title Region",
+        4: "Text Region",
+        5: "Title",
+        6: "Subtitle",
+        7: "Other",
+    },
+    "PubLayNet": {
+        0: "Text", 
+        1: "Title", 
+        2: "List", 
+        3: "Table", 
+        4: "Figure"},
+    "PrimaLayout": {
+        1: "TextRegion",
+        2: "ImageRegion",
+        3: "TableRegion",
+        4: "MathsRegion",
+        5: "SeparatorRegion",
+        6: "OtherRegion",
+    },
+    "NewspaperNavigator": {
+        0: "Photograph",
+        1: "Illustration",
+        2: "Map",
+        3: "Comics/Cartoon",
+        4: "Editorial Cartoon",
+        5: "Headline",
+        6: "Advertisement",
+    },
+    "TableBank": {
+        0: "Table"
+    },
+    "MFD": {
+        1: "Equation"
+    },
+}
+# fmt: on
+
+
+class LayoutParserDetectron2ModelHandler(PathHandler):
+    """
+    Resolve anything that's in LayoutParser model zoo.
+    """
+
+    PREFIX = "lp://detectron2/"
+
+    def _get_supported_prefixes(self):
+        return [self.PREFIX]
+
+    def _get_local_path(self, path, **kwargs):
+        model_name = path[len(self.PREFIX) :]
+
+        dataset_name, *model_name, data_type = model_name.split("/")
+
+        if data_type == "weight":
+            model_url = MODEL_CATALOG[dataset_name]["/".join(model_name)]
+        elif data_type == "config":
+            model_url = CONFIG_CATALOG[dataset_name]["/".join(model_name)]
+        else:
+            raise ValueError(f"Unknown data_type {data_type}")
+        return PathManager.get_local_path(model_url, **kwargs)
+
+    def _open(self, path, mode="r", **kwargs):
+        return PathManager.open(self._get_local_path(path), mode, **kwargs)
+
+
+PathManager.register_handler(LayoutParserDetectron2ModelHandler())

layoutparser/models/detectron2/layoutmodel.py

@@ -0,0 +1,168 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Union
+from PIL import Image
+import numpy as np
+import warnings
+
+from .catalog import MODEL_CATALOG, PathManager, LABEL_MAP_CATALOG
+from ..base_layoutmodel import BaseLayoutModel
+from ...elements import Rectangle, TextBlock, Layout
+from ...file_utils import is_torch_cuda_available, is_detectron2_available
+
+if is_detectron2_available():
+    import detectron2.engine
+    import detectron2.config
+
+
+__all__ = ["Detectron2LayoutModel"]
+
+
+class Detectron2LayoutModel(BaseLayoutModel):
+    """Create a Detectron2-based Layout Detection Model
+
+    Args:
+        config_path (:obj:`str`):
+            The path to the configuration file.
+        model_path (:obj:`str`, None):
+            The path to the saved weights of the model.
+            If set, overwrite the weights in the configuration file.
+            Defaults to `None`.
+        label_map (:obj:`dict`, optional):
+            The map from the model prediction (ids) to real
+            word labels (strings). If the config is from one of the supported
+            datasets, Layout Parser will automatically initialize the label_map.
+            Defaults to `None`.
+        device(:obj:`str`, optional):
+            Whether to use cuda or cpu devices. If not set, LayoutParser will
+            automatically determine the device to initialize the models on.
+        extra_config (:obj:`list`, optional):
+            Extra configuration passed to the Detectron2 model
+            configuration. The argument will be used in the `merge_from_list
+            <https://detectron2.readthedocs.io/modules/config.html
+            #detectron2.config.CfgNode.merge_from_list>`_ function.
+            Defaults to `[]`.
+
+    Examples::
+        >>> import layoutparser as lp
+        >>> model = lp.Detectron2LayoutModel('lp://HJDataset/faster_rcnn_R_50_FPN_3x/config')
+        >>> model.detect(image)
+
+    """
+
+    DEPENDENCIES = ["detectron2"]
+    DETECTOR_NAME = "detectron2"
+    MODEL_CATALOG = MODEL_CATALOG
+
+    def __init__(
+        self,
+        config_path,
+        model_path=None,
+        label_map=None,
+        extra_config=None,
+        enforce_cpu=None,
+        device=None,
+    ):
+
+        if enforce_cpu is not None:
+            warnings.warn(
+                "Setting enforce_cpu is deprecated. Please set `device` instead.",
+                DeprecationWarning,
+            )
+
+        if extra_config is None:
+            extra_config = []
+
+        config_path, model_path = self.config_parser(
+            config_path, model_path, allow_empty_path=True
+        )
+        config_path = PathManager.get_local_path(config_path)
+
+        if label_map is None:
+            if config_path.startswith("lp://"):
+                dataset_name = config_path.lstrip("lp://").split("/")[1]
+                label_map = LABEL_MAP_CATALOG[dataset_name]
+            else:
+                label_map = {}
+
+        cfg = detectron2.config.get_cfg()
+        cfg.merge_from_file(config_path)
+        cfg.merge_from_list(extra_config)
+
+        if model_path is not None:
+            model_path = PathManager.get_local_path(model_path)
+            # Because it will be forwarded to the detectron2 paths
+            cfg.MODEL.WEIGHTS = model_path
+
+        if is_torch_cuda_available():
+            if device is None:
+                device = "cuda"
+        else:
+            device = "cpu"
+        cfg.MODEL.DEVICE = device
+
+        self.cfg = cfg
+
+        self.label_map = label_map
+        self._create_model()
+
+    def _create_model(self):
+        self.model = detectron2.engine.DefaultPredictor(self.cfg)
+
+    def gather_output(self, outputs):
+
+        instance_pred = outputs["instances"].to("cpu")
+
+        layout = Layout()
+        scores = instance_pred.scores.tolist()
+        boxes = instance_pred.pred_boxes.tensor.tolist()
+        labels = instance_pred.pred_classes.tolist()
+
+        for score, box, label in zip(scores, boxes, labels):
+            x_1, y_1, x_2, y_2 = box
+
+
+            label = self.label_map.get(label, label)
+
+            cur_block = TextBlock(
+                Rectangle(x_1, y_1, x_2, y_2), type=label, score=score
+            )
+            layout.append(cur_block)
+
+        return layout
+
+    def detect(self, image):
+        """Detect the layout of a given image.
+
+        Args:
+            image (:obj:`np.ndarray` or `PIL.Image`): The input image to detect.
+
+        Returns:
+            :obj:`~layoutparser.Layout`: The detected layout of the input image
+        """
+
+        image = self.image_loader(image)
+        outputs = self.model(image)
+        layout = self.gather_output(outputs)
+        return layout
+
+    def image_loader(self, image: Union["np.ndarray", "Image.Image"]):
+        # Convert PIL Image Input
+        if isinstance(image, Image.Image):
+            if image.mode != "RGB":
+                image = image.convert("RGB")
+            image = np.array(image)
+
+        return image

layoutparser/models/effdet/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import catalog as _UNUSED
+from .layoutmodel import EfficientDetLayoutModel

layoutparser/models/effdet/catalog.py

@@ -0,0 +1,88 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from iopath.common.file_io import PathHandler
+
+from ..base_catalog import PathManager
+
+MODEL_CATALOG = {
+    "PubLayNet": {
+        "tf_efficientdet_d0": "https://huggingface.co/ClosedUni/publaynet-tf_efficientdet/blob/main/publaynet-tf_efficientdet_d0.pth.tar",
+        "tf_efficientdet_d1": "https://huggingface.co/ClosedUni/publaynet-tf_efficientdet/blob/main/publaynet-tf_efficientdet_d1.pth.tar"
+    },
+    "MFD": {
+        "tf_efficientdet_d0": "https://huggingface.co/ClosedUni/mfd-tf_efficientdet/blob/main/mfd-tf_efficientdet_d0.pth.tar",
+        "tf_efficientdet_d1": "https://huggingface.co/ClosedUni/mfd-tf_efficientdet/blob/main/mfd-tf_efficientdet_d1.pth.tar"
+    }
+}
+
+# In effdet training scripts, it requires the label_map starting
+# from 1 instead of 0
+LABEL_MAP_CATALOG = {
+    "PubLayNet": {
+        1: "Text", 
+        2: "Title", 
+        3: "List", 
+        4: "Table", 
+        5: "Figure"
+    },
+    "MFD": {
+        1: "Equation",
+    }
+}
+
+class LayoutParserEfficientDetModelHandler(PathHandler):
+    """
+    Resolve anything that's in LayoutParser model zoo.
+    """
+
+    PREFIX = "lp://efficientdet/"
+
+    def _get_supported_prefixes(self):
+        return [self.PREFIX]
+
+    def _get_local_path(self, path, **kwargs):
+        model_name = path[len(self.PREFIX) :]
+        dataset_name, *model_name, data_type = model_name.split("/")
+
+        if data_type == "weight":
+            # Safely check and import huggingface_hub inside the function execution
+            try:
+                from huggingface_hub import hf_hub_download
+            except ImportError:
+                raise ImportError(
+                    "The 'huggingface_hub' package is required to download custom weights. "
+                    "Please install it via 'pip install huggingface_hub'."
+                )
+            
+            # Dynamically map the filename format (e.g., 'publaynet-tf_efficientdet_d0.pth.tar' or 'mfd-tf_efficientdet_d0.pth.tar')
+            filename = f"{dataset_name.lower()}-{'/'.join(model_name)}.pth.tar"
+            
+            # Download weights through Hugging Face official API. 
+            # Features: Automated caching, handles high-traffic, and works seamlessly across environments (Docker, Colab, etc.)
+            local_registry_path = hf_hub_download(
+                repo_id="ClosedUni/publaynet-tf_efficientdet", 
+                filename=filename
+            )
+            return local_registry_path
+            
+        else:
+            raise ValueError(f"Unknown data_type {data_type}")
+
+    def _open(self, path, mode="r", **kwargs):
+        return PathManager.open(self._get_local_path(path), mode, **kwargs)
+
+
+# Register the handler into layoutparser's path management system
+PathManager.register_handler(LayoutParserEfficientDetModelHandler())