def find_spec(cls, name, path, target=None): # pragma: no cover match = cls.expr.match(name) try: # Construct the name for the actual module to load new_name = f"message_data.{match.group('name')}" except AttributeError: # `match` was None; unsupported. Let the importlib defaults take over. return None # Get an import spec for the message_data submodule spec = util.find_spec(new_name) if not spec: return None # Create a new spec that loads message_data.model.foo as if it were # message_ix_models.model.foo new_spec = ModuleSpec( name=name, # Create a new loader that loads from the actual file with the desired name loader=SourceFileLoader(fullname=name, path=spec.origin), origin=spec.origin, ) # These can't be passed through the constructor new_spec.submodule_search_locations = spec.submodule_search_locations return new_spec
def find_spec(self, fullname, path, target=None): # print('------分割---------') # print("fullname:", fullname) # print("path:", path) # 如果 fullname 是 pack 那么 last_mile 就是 'pack' # 如果 fullname 是 pack.music 那么 last_mile 就是 'music' last_mile = fullname.split('.')[-1] if path == None: # 导入的是 顶级包,例如:import pack serach_path = sys.path else: # 如果导入的是模块或者子包 serach_path = path for path_temp in serach_path: full_path = os.path.join(path_temp, last_mile) init_full_path = os.path.join(full_path, '__init__.py') module_full_path = full_path + '.py' if os.path.exists(full_path) and os.path.isfile(init_full_path): # 导入 包 return ModuleSpec(fullname, loader=loader, origin=init_full_path, is_package=True) if os.path.isfile(module_full_path): # 导入 模块 return ModuleSpec(fullname, loader=loader, origin=module_full_path, is_package=False)
def find_spec(self, fullname, path=None, target=None): if not fullname.startswith('calibre_extensions'): return parts = fullname.split('.') if parts[0] != 'calibre_extensions': return if len(parts) > 2: return is_package = len(parts) == 1 extension_name = None if is_package else parts[1] path = os.path.join(plugins_loc, '__init__.py') if extension_name: if extension_name not in self.calibre_extensions: return for suffix in EXTENSION_SUFFIXES: path = os.path.join(plugins_loc, extension_name + suffix) if os.path.exists(path): break else: return return ModuleSpec(fullname, ExtensionFileLoader(fullname, path), is_package=is_package, origin=path) return ModuleSpec(fullname, ExtensionsPackageLoader(self.calibre_extensions), is_package=is_package, origin=path)
def find_spec(self, module_name: str, path: list[str], target: str = None): if path is None: paths = [ path for path in map(Path, sys.path) if path.exists() and path.is_dir() ] else: paths = list(map(Path, path)) for try_path in paths: log.debug(f"Finding module {module_name} in {try_path}") last_module_name = module_name.rpartition(".")[2] fullpath = try_path / (last_module_name + self.suffix) if fullpath.exists(): log.debug(f"Found module '{module_name}' in {fullpath}") loader = ExtensionModuleLoader(fullpath) return ModuleSpec(module_name, loader, origin=fullpath) fullpath = try_path / last_module_name if fullpath.is_dir() and (fullpath / f"__init__{self.suffix}").exists(): log.debug(f"Found package '{module_name}' in {fullpath}") loader = ExtensionPackageLoader(fullpath) return ModuleSpec(module_name, loader, origin=fullpath, is_package=True)
def find_spec(self, fullname, paths=None, target=None): if self._paths is None: self._paths = [] self._paths = self._zip.namelist() spec = None if fullname.replace(".", "/") + '/__init__.py' in self._paths: full_uri = self._zip_path + '/' + fullname.replace(".", "/") try: loader = PackageLoader(self._zip, full_uri) loader.load_module(fullname) spec = ModuleSpec(fullname, loader, origin=paths) except ImportError as ie: spec = None except Exception as e: spec = None elif fullname.replace(".", "/") + '.py' in self._paths: full_uri = self._zip_path + '/' + fullname.replace(".", "/") try: loader = ModuleLoader(self._zip, full_uri) spec = ModuleSpec(fullname, loader, origin=paths) except ImportError as ie: spec = None except Exception as e: spec = None else: pass return spec
def find_spec(self, fullname, path, target=None): if path is None: path = sys.path import_path = fullname else: import_path = fullname.split('.')[-1] split_path = import_path.split('.') file_name = "{}.hivemap".format(split_path[-1]) # Search all paths to find hivemap for root in path: directory = join(root, *split_path[:-1]) if not isdir(directory): continue if file_name in listdir(directory): file_path = join(directory, file_name) break else: return None loader = HivemapModuleLoader(fullname, file_path) self._loaders.append(loader) spec = ModuleSpec(fullname, loader, origin=file_path, loader_state=None, is_package=False) spec.has_location = True return spec
def find_spec(self, fullname, _path=None, _target=None): if not self._in_capsule(fullname): # If the capsule directory name is not in the fullname, it's # not our job to import it return None if fullname == self._capsule_dir_name: # If the capsule root directory is being loaded, return a # modulespec return ModuleSpec(name=fullname, loader=None, is_package=True) # Get rid of the capsule name prefix pruned_fullname = _remove_capsule_name(self._capsule_dir_name, fullname) package_path = _package_fullname_to_path(pruned_fullname) module_path = _module_fullname_to_path(pruned_fullname) if package_path in self._zip_file.namelist(): # If a directory exists with a name that matches the import, we # assume it is a package import. return ModuleSpec(name=fullname, loader=None, is_package=True) elif module_path in self._zip_file.namelist(): # If a .py file exists with a name that matches the import, we # assume it is a module import module_file_path = self._capsule_dir_path / module_path loader = ZipModuleLoader(zip_file=self._zip_file, module_file_path=module_file_path, capsule_dir_name=self._capsule_dir_name) return ModuleSpec(name=fullname, loader=loader) raise ImportError(f"Problem while importing {fullname}")
def find_spec(cls, fullname, paths=None, target=None): """Try to find a spec for the specified module. :param fullname: module full name :param paths: the search paths :param target: the target :return: a module spec """ from importlib.machinery import ModuleSpec # TODO: read PEP 420 last_module = fullname.split('.')[-1] if paths is None: paths = [cls.__path__] for path in paths: full_path = os.path.join(path, last_module) init_path = os.path.join(full_path, '__init__.py') module_path = full_path + '.py' if os.path.exists(init_path) and not os.path.exists(module_path): return ModuleSpec(fullname, _loader, origin=init_path) elif os.path.exists(module_path): return ModuleSpec(fullname, _loader, origin=module_path) return None
def _patch_spec( fullname, spec: ModuleSpec): #loader_class, fullname, path, smsl, target): spec.name = fullname if isinstance(spec.loader, abc_FileLoader): spec.loader = spec.loader.__class__(fullname, spec.loader.path) return spec
def find_spec(self, fullname, paths=None, target=None): relative_path = fullname.replace(".", "/") base_path = None full_path = None for path in sys.path: path_dir = Path(path) base_path = path_dir.resolve() abs_path = base_path.joinpath(relative_path) # 如果已经编译,那么跳过 if path_dir.is_dir(): find_files = [ i for i in path_dir.iterdir() if i.match(f"{relative_path}_pb2.py") ] if len(find_files) > 0: full_path = str(find_files[0]) loader = PyProtoBufferImportLoader(full_path) spec = ModuleSpec(fullname, loader, origin=paths) return spec # 判断是否是proto模块 if abs_path.with_suffix(".proto").exists(): full_path = abs_path.with_suffix(".proto") loader = ProtoBufferImportLoader(full_path) spec = ModuleSpec(fullname, loader, origin=paths) return spec else: # 都不是就跳过 return None
def from_path(cls, path: str, compiler: Compiler) -> FileSource: """create an instance with a spec inferred from a path""" spec = ModuleSpec("__main__", SourceFileLoader("__main__", path), origin=path, is_package=False) spec.has_location = True return cls(io.FileIO(path, "r"), spec, compiler)
def find_spec( self, fullname: str, path, # Optional[List[str]] # MyPy complains this is incompatible with supertype target: types.ModuleType = None, ) -> Optional[ModuleSpec]: """Find the ModuleSpec for the specified Basilisp module. Returns None if the module is not a Basilisp module to allow import processing to continue.""" package_components = fullname.split(".") if not path: path = sys.path module_name = package_components else: module_name = [package_components[-1]] for entry in path: root_path = os.path.join(entry, *module_name) filenames = [ f"{os.path.join(root_path, '__init__')}.lpy", f"{root_path}.lpy", ] for filename in filenames: if os.path.isfile(filename): state = { "fullname": fullname, "filename": filename, "path": entry, "target": target, "cache_filename": _cache_from_source(filename), } logger.debug( f"Found potential Basilisp module '{fullname}' in file '{filename}'" ) is_package = filename.endswith( "__init__.lpy") or _is_package(root_path) spec = ModuleSpec( fullname, self, origin=filename, loader_state=state, is_package=is_package, ) # The Basilisp loader can find packages regardless of # submodule_search_locations, but the Python loader cannot. # Set this to the root path to allow the Python loader to # load submodules of Basilisp "packages". if is_package: assert ( spec.submodule_search_locations is not None ), "Package module spec must have submodule_search_locations list" spec.submodule_search_locations.append(root_path) return spec if os.path.isdir(root_path): if _is_namespace_package(root_path): return ModuleSpec(fullname, None, is_package=True) return None
def find_spec(self, fullname, path, target=None): key = fullname.replace('.', '/') + '.py' if self.db.exists(key): return ModuleSpec(fullname, self, origin=key) key = fullname.replace('.', '/') + '/__init__.py' if self.db.exists(key): return ModuleSpec(fullname, self, origin=key)
def spec(self, fullname, node, origin=None, pkg=True): spec = ModuleSpec(fullname, self, origin=str(origin), is_package=pkg) spec._node = node if pkg: if hasattr(node, 'path'): spec.submodule_search_locations = [str(node.path)] else: spec.submodule_search_locations = [] return spec
def find_spec(self, fullname, path=None, target=None): code = self.code_map.get(fullname) if code is None: return None loader = self spec = ModuleSpec(fullname, loader) if not code: spec.submodule_search_locations = [ str(pathlib.Path(__file__).parent) ] return spec
def find_spec(self, name, path=None, module=None): # if name space matches, create a namespace module which searches the desired directories. if name == self.namespace: spec = ModuleSpec(name, None, is_package=True) spec.submodule_search_locations = self.dirs else: spec = None # print(f"NamespaceCreator.find_spec: name={name} path={path} spec={spec}") return spec
def test_file_shebang(self) -> None: """test the handling of shebangs in files""" path = "./tests/embedding/shebang.pyhp" with open(path, "r") as file: code = self.compiler.compile_file(file) builder = self.compiler.builder() spec = ModuleSpec("__main__", None, origin=path, is_package=False) spec.has_location = True with open(path, "r") as file: file.readline() # discard shebang self.compiler.parser.build(file.read(), builder, 1) self.assertEqual(code, builder.code(spec))
def test_file(self) -> None: """test the compilation of files""" path = "./tests/embedding/syntax.pyhp" with open(path, "r") as file: code = self.compiler.compile_file(file) builder = self.compiler.builder() spec = ModuleSpec("__main__", None, origin=path, is_package=False) spec.has_location = True with open(path, "r") as file: self.compiler.parser.build(file.read(), builder) self.assertEqual(code, builder.code(spec))
def find_spec(self, fullname: str, path: Optional[Sequence[Union[bytes, str]]], target: Optional[ModuleType] = None) -> Optional[ModuleSpec]: if fullname not in self.sources: return None is_package, _ = self.sources[fullname] spec = ModuleSpec(name=fullname, loader=self, origin=self.origin, is_package=is_package) spec.has_location = False return spec
def get_yapypy_module_spec_from_path(names, module_path): with Path(module_path).open('r') as fr: spec = ModuleSpec(names, YAPyPyLoader(names, module_path)) __source__ = fr.read() result = parse(__source__, module_path) # pprint(result.result) check_parsing_complete(__source__, result.tokens, result.state) __bytecode__ = py_compile(result.result, filename=module_path, is_entrypoint=False) spec.__source__ = __source__ spec.__bytecode__ = __bytecode__ return spec
def find_spec(self, fullname, path, target=None): try: if not fullname.startswith( self.message_root) and not fullname.startswith( self.enum_root): return None name_path = fullname.split('.') if len(name_path) == 2: # olympe.messages origin = os.path.join(self.olympe_root, fullname.replace('.', '/')) spec = ModuleSpec(fullname, self, origin=origin, is_package=False) # olympe.enums return spec elif len(name_path) == 3: # olympe.messages.<feature_name> # olympe.enums.<feature_name> type_, feature_name, class_name = name_path[1], name_path[ 2], None elif len(name_path) == 4: # olympe.messages.<feature_name>.<class_or_message> # olympe.enums.<feature_name>.<class_or_enum> type_, feature_name, class_name = name_path[1:] else: return None if feature_name not in self.messages.by_feature: # feature name does not exists return None if (class_name is not None and class_name not in self.messages.by_feature[feature_name]): # class name, message or enum does not exist return None is_package = class_name is None origin = os.path.join(self.olympe_root, fullname.replace('.', '/')) spec = ModuleSpec(fullname, self, origin=origin, is_package=is_package) return spec except Exception: traceback.print_exc() return None
def test_wrap_module(): my_module = types.ModuleType('my_module', 'my doc string') my_module.foo = 'foo' my_module.bar = 'bar' my_module.__spec__ = ModuleSpec('my_module', loader=None) assert 'foo' in my_module.__dict__ assert 'bar' in my_module.__dict__ assert 'zoo' not in my_module.__dict__ with pytest.raises(AssertionError, match='deadline should match vX.Y'): deprecate_attributes(my_module, {'foo': ('invalid', 'use bar instead')}) # temporarily update sys.modules so deprecate_attributes can find my_module sys.modules['my_module'] = my_module wrapped = deprecate_attributes('my_module', {'foo': ('v0.6', 'use bar instead')}) assert wrapped is sys.modules.pop('my_module') # Dunder methods assert wrapped.__doc__ == 'my doc string' assert wrapped.__name__ == 'my_module' assert wrapped.__spec__ is my_module.__spec__ # Verify __spec__ setter in the wrapped module wrapped.__spec__ = ModuleSpec('my_module', loader=None) assert my_module.__spec__ is wrapped.__spec__ # Test dict is correct. assert 'foo' in wrapped.__dict__ assert 'bar' in wrapped.__dict__ assert 'zoo' not in wrapped.__dict__ # Deprecation capability. with cirq.testing.assert_deprecated( '_compat_test.py:', 'foo was used but is deprecated.', 'will be removed in cirq v0.6', 'use bar instead', deadline='v0.6', ): _ = wrapped.foo with pytest.raises( ValueError, match= 'During testing using Cirq deprecated functionality is not allowed' ): _ = wrapped.foo with cirq.testing.assert_logs(count=0): _ = wrapped.bar
def with_inferred_spec(cls, fd: io.FileIO, compiler: Compiler) -> FileSource: """create an instance with a spec inferred from the file""" if isinstance(fd.name, str): spec = ModuleSpec("__main__", SourceFileLoader("__main__", fd.name), origin=fd.name, is_package=False) spec.has_location = True else: spec = ModuleSpec("__main__", None, origin=f"<fd {fd.name}>", is_package=False) return cls(fd, spec, compiler)
def test_equal(self) -> None: """test if equality between generic code objetcs works""" builder = bytecode.ByteCodeBuilder(-1) builder.add_code("print(1)", 0) builder.add_text("X", 0) spec = ModuleSpec("test", None, origin="this test", is_package=False) code = builder.code(spec) code2 = builder.code(spec) code3 = builder.code( ModuleSpec("X", None, origin="this test", is_package=False)) builder.add_text("Y", 0) code4 = builder.code(spec) self.assertEqual(code, code2) self.assertNotEqual(code, code3) self.assertNotEqual(code, code4)
def find_spec(self, fullname, path, target=None): spec = super(TracedModuleImporter, self).find_spec(fullname, path, target) if spec is not None: if spec.origin == self.traced_file: self.record_module(fullname) return ModuleSpec(fullname, self, origin=self.traced_file) if self.traced_file is None and self.traced.startswith(fullname): self.original_loaders[fullname] = spec.loader spec.loader = self return spec if fullname == self.traced: return ModuleSpec(fullname, self, origin=self.traced_file) return None
def find_spec(klass, full_name, paths=None, target=None): if full_name.startswith("dbmodule"): x = full_name.split(".") if len(x) < 5: full_path = os.path.join(full_name, "__init__.dbpy") return ModuleSpec(full_name, DBPackageLoader(), origin=full_path) else: full_path = full_name.replace(".", os.sep) + ".dbpy" return ModuleSpec(full_name, DBModuleLoader(), origin=full_path) else: return None
def load_module(self, fullname): """ Loads and returns the Python module for the given enaml path. If a module already exisist in sys.path, the existing module is reused, otherwise a new one is created. Only used in Python 2. """ if fullname in sys.modules: pre_exists = True else: pre_exists = False mod = self.create_module( ModuleSpec(fullname, self, origin=self.file_info.src_path)) code, _ = self.get_code() try: self.exec_module(mod, code) except Exception: if not pre_exists: del sys.modules[fullname] raise return mod
def find_spec(self, fullname, path=None, target=None): # ModuleSpecを返す。 if path is None: baseurl = self._baseurl else: if not path[0].startswith(self._baseurl): return None baseurl = path[0] parts = fullname.split('.') basename = parts[-1] if basename not in self._links: # Check link cache self._links[baseurl] = _get_links(self._simplefileaccess, baseurl) if basename in self._links[ baseurl]: # Check if it's a package。パッケージの時。 fullurl = "/".join((self._baseurl, basename)) loader = UrlPackageLoader(self._simplefileaccess, fullurl) try: # Attempt to load the package (which accesses __init__.py) loader.load_module(fullname) self._links[fullurl] = _get_links(self._simplefileaccess, fullurl) self._loaders[fullurl] = UrlModuleLoader( self._simplefileaccess, fullurl) except ImportError: loader = None return loader filename = "".join((basename, '.py')) if filename in self._links[baseurl]: # A normal module return ModuleSpec(fullname, self._loaders[baseurl], origin=path) else: return None
def find_spec(cls, fullname, path=None, target=None): soname = 'libpy.' + fullname + '.so' path = os.path.join(sys._native_library_dir, soname) if os.path.exists(path): loader = _bootstrap_external.ExtensionFileLoader(fullname, path) return ModuleSpec(fullname, loader, origin=path)
def create_module(self, spec: ModuleSpec): state = spec.loader_state cmake = tool.CMake(spec, state) cmake.configure() cmake.build() spec = ModuleSpec(spec.name, loader=self, origin=cmake.output) return super().create_module(spec)
def find_spec(self, modulename, target): tail_modulename = modulename.rpartition('.')[2] try: path = tail_modulename + PACKAGE_SUFFIX tree_entry = self.get_tree_entry(path) if tree_entry.type == 'blob': spec = ModuleSpec(modulename, GitLoader(tree_entry, self.repo, self.commit_sha), is_package=True, origin=path) spec.submodule_search_locations = [os.path.join(self.repopath, tail_modulename)] return spec except KeyError: pass try: path = tail_modulename + SOURCE_SUFFIX tree_entry = self.get_tree_entry(path) if tree_entry.type == 'blob': return ModuleSpec(modulename, GitLoader(tree_entry, self.repo, self.commit_sha), origin=path) except KeyError: pass