Spaces:
Running
on
Zero
Running
on
Zero
File size: 8,882 Bytes
28c256d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 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 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 |
# Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
import importlib
from typing import Any, Optional, Union
from mmengine.utils import is_seq_of
class LazyObject:
"""LazyObject is used to lazily initialize the imported module during
parsing the configuration file.
During parsing process, the syntax like:
Examples:
>>> import torch.nn as nn
>>> from mmdet.models import RetinaNet
>>> import mmcls.models
>>> import mmcls.datasets
>>> import mmcls
Will be parsed as:
Examples:
>>> # import torch.nn as nn
>>> nn = lazyObject('torch.nn')
>>> # from mmdet.models import RetinaNet
>>> RetinaNet = lazyObject('mmdet.models', 'RetinaNet')
>>> # import mmcls.models; import mmcls.datasets; import mmcls
>>> mmcls = lazyObject(['mmcls', 'mmcls.datasets', 'mmcls.models'])
``LazyObject`` records all module information and will be further
referenced by the configuration file.
Args:
module (str or list or tuple): The module name to be imported.
imported (str, optional): The imported module name. Defaults to None.
location (str, optional): The filename and line number of the imported
module statement happened.
"""
def __init__(self,
module: Union[str, list, tuple],
imported: Optional[str] = None,
location: Optional[str] = None):
if not isinstance(module, str) and not is_seq_of(module, str):
raise TypeError('module should be `str`, `list`, or `tuple`'
f'but got {type(module)}, this might be '
'a bug of MMEngine, please report it to '
'https://github.com/open-mmlab/mmengine/issues')
self._module: Union[str, list, tuple] = module
if not isinstance(imported, str) and imported is not None:
raise TypeError('imported should be `str` or None, but got '
f'{type(imported)}, this might be '
'a bug of MMEngine, please report it to '
'https://github.com/open-mmlab/mmengine/issues')
self._imported = imported
self.location = location
def build(self) -> Any:
"""Return imported object.
Returns:
Any: Imported object
"""
if isinstance(self._module, str):
try:
module = importlib.import_module(self._module)
except Exception as e:
raise type(e)(f'Failed to import {self._module} '
f'in {self.location} for {e}')
if self._imported is not None:
if hasattr(module, self._imported):
module = getattr(module, self._imported)
else:
raise ImportError(
f'Failed to import {self._imported} '
f'from {self._module} in {self.location}')
return module
else:
# import xxx.xxx
# import xxx.yyy
# import xxx.zzz
# return imported xxx
try:
for module in self._module:
importlib.import_module(module) # type: ignore
module_name = self._module[0].split('.')[0]
return importlib.import_module(module_name)
except Exception as e:
raise type(e)(f'Failed to import {self.module} '
f'in {self.location} for {e}')
@property
def module(self):
if isinstance(self._module, str):
return self._module
return self._module[0].split('.')[0]
def __call__(self, *args, **kwargs):
raise RuntimeError()
def __deepcopy__(self, memo):
return LazyObject(self._module, self._imported, self.location)
def __getattr__(self, name):
# Cannot locate the line number of the getting attribute.
# Therefore only record the filename.
if self.location is not None:
location = self.location.split(', line')[0]
else:
location = self.location
return LazyAttr(name, self, location)
def __str__(self) -> str:
if self._imported is not None:
return self._imported
return self.module
__repr__ = __str__
# `pickle.dump` will try to get the `__getstate__` and `__setstate__`
# methods of the dumped object. If these two methods are not defined,
# LazyObject will return a `__getstate__` LazyObject` or `__setstate__`
# LazyObject.
def __getstate__(self):
return self.__dict__
def __setstate__(self, state):
self.__dict__ = state
class LazyAttr:
"""The attribute of the LazyObject.
When parsing the configuration file, the imported syntax will be
parsed as the assignment ``LazyObject``. During the subsequent parsing
process, users may reference the attributes of the LazyObject.
To ensure that these attributes also contain information needed to
reconstruct the attribute itself, LazyAttr was introduced.
Examples:
>>> models = LazyObject(['mmdet.models'])
>>> model = dict(type=models.RetinaNet)
>>> print(type(model['type'])) # <class 'mmengine.config.lazy.LazyAttr'>
>>> print(model['type'].build()) # <class 'mmdet.models.detectors.retinanet.RetinaNet'>
""" # noqa: E501
def __init__(self,
name: str,
source: Union['LazyObject', 'LazyAttr'],
location=None):
self.name = name
self.source: Union[LazyAttr, LazyObject] = source
if isinstance(self.source, LazyObject):
if isinstance(self.source._module, str):
if self.source._imported is None:
# source code:
# from xxx.yyy import zzz
# equivalent code:
# zzz = LazyObject('xxx.yyy', 'zzz')
# The source code of get attribute:
# eee = zzz.eee
# Then, `eee._module` should be "xxx.yyy.zzz"
self._module = self.source._module
else:
# source code:
# import xxx.yyy as zzz
# equivalent code:
# zzz = LazyObject('xxx.yyy')
# The source code of get attribute:
# eee = zzz.eee
# Then, `eee._module` should be "xxx.yyy"
self._module = f'{self.source._module}.{self.source}'
else:
# The source code of LazyObject should be
# 1. import xxx.yyy
# 2. import xxx.zzz
# Equivalent to
# xxx = LazyObject(['xxx.yyy', 'xxx.zzz'])
# The source code of LazyAttr should be
# eee = xxx.eee
# Then, eee._module = xxx
self._module = str(self.source)
elif isinstance(self.source, LazyAttr):
# 1. import xxx
# 2. zzz = xxx.yyy.zzz
# Equivalent to:
# xxx = LazyObject('xxx')
# zzz = xxx.yyy.zzz
# zzz._module = xxx.yyy._module + zzz.name
self._module = f'{self.source._module}.{self.source.name}'
self.location = location
@property
def module(self):
return self._module
def __call__(self, *args, **kwargs: Any) -> Any:
raise RuntimeError()
def __getattr__(self, name: str) -> 'LazyAttr':
return LazyAttr(name, self)
def __deepcopy__(self, memo):
return LazyAttr(self.name, self.source)
def build(self) -> Any:
"""Return the attribute of the imported object.
Returns:
Any: attribute of the imported object.
"""
obj = self.source.build()
try:
return getattr(obj, self.name)
except AttributeError:
raise ImportError(f'Failed to import {self.module}.{self.name} in '
f'{self.location}')
except ImportError as e:
raise e
def __str__(self) -> str:
return self.name
__repr__ = __str__
# `pickle.dump` will try to get the `__getstate__` and `__setstate__`
# methods of the dumped object. If these two methods are not defined,
# LazyAttr will return a `__getstate__` LazyAttr` or `__setstate__`
# LazyAttr.
def __getstate__(self):
return self.__dict__
def __setstate__(self, state):
self.__dict__ = state
|