Skip to content

Package Management

fusion_bench.utils.packages

compare_versions(v1, v2)

Compare two version strings. Returns -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2

Source code in fusion_bench/utils/packages.py 
87
88
89
90
91
92
93
94
95
96
97
98
def compare_versions(v1, v2):
    """Compare two version strings.
    Returns -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2"""

    v1 = version.parse(v1)
    v2 = version.parse(v2)
    if v1 < v2:
        return -1
    elif v1 > v2:
        return 1
    else:
        return 0

import_object(abs_obj_name)

Imports a class from a module given the absolute class name.

Parameters:

  • abs_obj_name (str) –

    The absolute name of the object to import.

Returns:

  • –

    The imported class.

Source code in fusion_bench/utils/packages.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
def import_object(abs_obj_name: str):
    """
    Imports a class from a module given the absolute class name.

    Args:
        abs_obj_name (str): The absolute name of the object to import.

    Returns:
        The imported class.
    """
    module_name, obj_name = abs_obj_name.rsplit(".", 1)
    module = importlib.import_module(module_name)
    return getattr(module, obj_name)

fusion_bench.utils.lazy_imports

Lazy-Imports module.

This is code taken from the HuggingFace team <https://huggingface.co/>. Many thanks to HuggingFace for your consent <https://github.com/huggingface/transformers/issues/12861#issuecomment-886712209> to publish it as a standalone package.

LazyImporter

Bases: ModuleType

Do lazy imports.

Source code in fusion_bench/utils/lazy_imports.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
class LazyImporter(ModuleType):
    """Do lazy imports."""

    # Very heavily inspired by optuna.integration._IntegrationModule
    # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py
    def __init__(self, name, module_file, import_structure, extra_objects=None):
        super().__init__(name)
        self._modules = set(import_structure.keys())
        self._class_to_module = {}
        for key, values in import_structure.items():
            for value in values:
                self._class_to_module[value] = key
        # Needed for autocompletion in an IDE
        self.__all__ = list(import_structure.keys()) + sum(
            import_structure.values(), []
        )
        self.__file__ = module_file
        self.__path__ = [os.path.dirname(module_file)]
        self._objects = {} if extra_objects is None else extra_objects
        self._name = name
        self._import_structure = import_structure

    # Needed for autocompletion in an IDE
    def __dir__(self):
        return super().__dir__() + self.__all__

    def __getattr__(self, name: str) -> Any:
        if name in self._objects:
            return self._objects[name]
        if name in self._modules:
            value = self._get_module(name)
        elif name in self._class_to_module:
            module = self._get_module(self._class_to_module[name])
            value = getattr(module, name)
        else:
            raise AttributeError(f"module {self.__name__} has no attribute {name}")

        setattr(self, name, value)
        return value

    def _get_module(self, module_name: str):
        return importlib.import_module("." + module_name, self.__name__)

    def __reduce__(self):
        return (self.__class__, (self._name, self.__file__, self._import_structure))