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 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 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 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 find_spec(cls, fullname, path=None, target=None): """ Finds the given Enaml module and returns an importer, or None if the module is not found. """ loader = cls.locate_module(fullname, path) if loader is not None: if not isinstance(loader, AbstractEnamlImporter): msg = 'Enaml imports received invalid loader object %s' raise ImportError(msg % loader) spec = ModuleSpec(fullname, loader, origin=loader.file_info.src_path) spec.cached = loader.file_info.cache_path spec.has_location = True return spec
def test_code(self) -> None: """test ZIPSource.code""" with open("tests/embedding/syntax.pyhp", "r") as fd, \ zipfile.ZipFile("tests/embedding.zip") as file, \ zipfiles.ZIPSource(file, file.getinfo("syntax.pyhp"), compiler) as source: code1 = source.code() spec = ModuleSpec("__main__", zipfiles.ZIPLoader("__main__", file, file.getinfo("syntax.pyhp")), origin=os.path.join("tests/embedding.zip", "syntax.pyhp"), is_package=False) spec.has_location = True code2 = compiler.compile_raw(fd.read(), spec) code3 = source.code( ) # check if the source can be read multiple times self.assertEqual(code1, code2) self.assertEqual(code1, code3)
def find_spec(cls, fullname, path=None, target=None): """Find a spec for a given module. Because we only deal with our inlined module, we don't have to care about path or target. The import machinery also takes care of fully resolving all names, so we just have to deal with the fullnames. """ if fullname in cls.inlined_modules: # We have inlined this module, so return the spec ms = ModuleSpec(fullname, cls, origin=cls.get_filename(fullname), is_package=cls.is_package(fullname)) ms.has_location = True if cls.namespace_packages and ms.submodule_search_locations is not None: for p in _sys.path: ms.submodule_search_locations.append( _os.path.join(p, _os.path.dirname(ms.origin))) return ms return None
def compile_file(self, file: TextIO, loader: Optional[Loader] = None) -> Code: """compile a text stream into a code object""" builder = self.builder() spec = ModuleSpec("__main__", loader, origin=file.name, is_package=False) spec.has_location = True first_line = file.readline() try: if first_line.startswith("#!"): # shebang, remove first line # line offset of 1 to compensate for removed shebang self.parser.build(file.read(), builder, 1) else: self.parser.build(first_line + file.read(), builder) except SyntaxError as e: # change filename e.filename = spec.origin raise e return builder.code(spec)