def test_path_hook_installed(self): # PathFinder can only use it with sys.executable on sys.path with patch('sys.path', sys.path): sys.path = [p for p in sys.path if p != sys.executable] PathFinder.invalidate_caches() self.assertIsNone(PathFinder.find_spec("pwd")) sys.path.append(sys.executable) spec = PathFinder.find_spec("pwd") self.assert_spec(spec, "pwd", is_pkg=False, Loader=sys.__spec__.loader, origin="built-in")
def _find_import_match(parent_path, parent_module): """Attempts to find an importable module.""" modules_paths = [parent_path] + sys.path found_spec = PathFinder.find_spec(parent_module, modules_paths) if found_spec is None: raise ClassNotSuitable return found_spec
def find_spec( self, fullname: str, path: Optional[Sequence[Union[bytes, str]]], target: Optional[ModuleType] = None, ): if _managers: index = -1 module_spec = PathFinder.find_spec(fullname, path, target) if not module_spec: return module_origin = module_spec.origin if not module_origin: return module_path = Path(module_origin).resolve() while -index <= len(_managers): manager = _managers[index] if ( fullname in manager.plugins or module_path in manager.searched_plugins.values() ): module_spec.loader = PluginLoader(manager, fullname, module_origin) return module_spec index -= 1 return
def get_importable_spec(self, symbol_is_module=False): """Returns the specification of an actual importable module. This is a check based on the limitations that we do not actually perform an import, and assumes a directory structure with modules. :param symbol_is_module: if it's known that the symbol is also a module, include it in the search for an importable spec :type symbol_is_module: bool """ modules_paths = sys.path modules_paths.insert(0, self.get_relative_module_fs_path()) spec = None for component, previous in self._walk_importable_components( symbol_is_module): if previous: modules_paths = [ os.path.join(mod, previous) for mod in modules_paths[:] ] spec = PathFinder.find_spec(component, modules_paths) if spec is None: break return spec
def find_spec(cls, fullname, path=None, target=None): parts = fullname.split('.') if len(parts) > 2 and parts[:2] == ['eddy', 'plugins']: from importlib.machinery import PathFinder return PathFinder.find_spec( fullname, [os.path.join(os.path.dirname(__file__), os.pardir)], target)
def find_spec(cls, fullname, path, target=None): if any(fullname.startswith(rdir) for rdir in (RECIPE_DIR, CONFIG_DIR)): if path is None: path = [os.path.abspath('.')] elif isinstance(path, str): path = [os.path.abspath(os.path.join('.', path))] spec = PathFinder.find_spec(fullname, path, target) return spec
def find_spec(cls, fullname, path, target=None): for rprefix, rdir in ((gs.RECIPE_PREFIX, gs.RECIPE_PATH), (gs.CONFIG_PREFIX, gs.CONFIG_PATH)): if fullname.startswith(rprefix): if path is None: path = [os.path.abspath(rdir)] elif isinstance(path, str): path = [os.path.abspath(os.path.join(rdir, path))] spec = PathFinder.find_spec(fullname, path, target) return spec
def find_spec(cls, fullname, path=None, target=None): spec = PathFinder.find_spec(fullname, path=path, target=target) if spec is None: return if spec.loader is not None: if hasattr(spec.loader, 'exec_module'): spec.loader = CustomLoader(spec.loader) else: spec.loader = LegacyCustomLoader(spec.loader) return spec
def find_spec( self, fullname: str, path: Optional[Sequence[Union[bytes, str]]] = None, target: Optional[types.ModuleType] = None, ) -> Optional[ModuleSpec]: if fullname != "pip": return None spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target) assert spec, (PIP_SOURCES_ROOT, fullname) return spec
def find_spec(cls, fullname: str, path=None, target=None): """Try to find a spec for 'fullname' on sys.path or 'path'. Search only for modules starting with 'labs.ext.' and use PathFinder to first search for submodule in the current build, then module starting with labs_. """ if not fullname.startswith(_prefix): return None # Not a labs extension _name = fullname[_offset:] if '.' in _name: return None # Extension already imported, this is a submodule. # Try importing non packaged version paths_1, paths_2 = _get_ctx_path() if paths_1: spec = PathFinder.find_spec(fullname, paths_1, target) if spec is not None: return _patch_spec(fullname, spec) # Correct the module's name. # Try importing a packaged version installed_name = f'labs_{_name}' if paths_2: spec = PathFinder.find_spec(installed_name, paths_2, target) if spec is not None: return _patch_spec(fullname, spec) # Correct the module's name. # Try importing an installed version spec = PathFinder.find_spec(installed_name, None, target) if spec is not None: return _patch_spec(fullname, spec) # Correct the module's name. return None
def find_spec(self, fullname: str, path, target): if _manager_stack: index = -1 while -index <= len(_manager_stack): manager = _manager_stack[index] newname = manager._rewrite_module_name(fullname) if newname: spec = PathFinder.find_spec(newname, list(manager.search_path), target) if spec: return spec index -= 1 return None
def find_spec(self, fullname: str, path, target): if _manager_stack: index = -1 origin_spec = PathFinder.find_spec(fullname, path, target) while -index <= len(_manager_stack): manager = _manager_stack[index] rel_name = None if origin_spec and origin_spec.origin: rel_name = manager._check_absolute_import( origin_spec.origin) newname = manager._rewrite_module_name(rel_name or fullname) if newname: spec = PathFinder.find_spec( newname, path or [*manager.search_path, *sys.path], target) if spec: spec.loader = PluginLoader( # type: ignore manager, newname, spec.origin) return spec index -= 1 return None
def get_package_directory(module_name): """Return Path of the package directory that the given module is in.""" base_module = module_name.split('.', 1)[0] # Find the import path of the package, excluding the `''` entry in `sys.path` so as # to avoid the false positive of returning the CWD if the user is in the development # directory (which may also be in the path for the case of an editable install, # which is why we skip `''` specifically, and not anything that expands to CWD). spec = PathFinder.find_spec(base_module, path=[p for p in sys.path if p]) if spec is None or spec.origin is None: raise ModuleNotFoundError(base_module) if not spec.parent: msg = f'{base_module} is not a package' raise ValueError(msg) return Path(spec.origin).parent
def find_spec(self, fullname, path=None, target=None): if world.rank == 0: spec = PathFinder.find_spec(fullname, path, target) if spec is None: return None code = spec.loader.get_code(fullname) if code is None: # C extensions return None loader = BroadcastLoader(spec, self.module_cache) assert fullname == spec.name searchloc = spec.submodule_search_locations spec = ModuleSpec(fullname, loader, origin=spec.origin, is_package=searchloc is not None) if searchloc is not None: spec.submodule_search_locations += searchloc return spec else: if fullname not in self.module_cache: # Could this in principle interfere with builtin imports? return PathFinder.find_spec(fullname, path, target) searchloc, origin = self.module_cache[fullname][0] loader = BroadcastLoader(None, self.module_cache) spec = ModuleSpec(fullname, loader, origin=origin, is_package=searchloc is not None) if searchloc is not None: spec.submodule_search_locations += searchloc loader.spec = spec # XXX loader.loader is still None return spec
def find_spec(self, fullname, path, target=None): spec = None if fullname in self._soft_patches or fullname in self._hard_patches: spec = PathFinder.find_spec(fullname, path, target=target) if spec is None: raise Exception("Could not patch %s" % fullname) if fullname in self._soft_patches: self._wrap_soft_patches(spec.loader, self._soft_patches[fullname]) elif fullname in self._hard_patches: self._wrap_hard_patch(spec.loader, self._hard_patches[fullname]) return spec
def find_spec(self, fullname: str, path, target): if _manager_stack: index = -1 while -index <= len(_manager_stack): manager = _manager_stack[index] newname = manager._rewrite_module_name(fullname) if newname: spec = PathFinder.find_spec( newname, [*manager.search_path, *(path or sys.path)], target) if spec: spec.loader = PluginLoader(manager, newname, spec.origin) return spec index -= 1 return None
def import_plugin(self, name, additional_paths=[]): """ Mimics Python's import mechanism to import plugins found in the specified plugin directories; returns the imported plugin module Args: name (str): The name of the plugin's module to be imported additional_paths (:obj:`list`, optional): Additional paths to search for the plugin in Returns: ModuleType: The imported plugin's module Raises: ImportError: If the name cannot be resolved without a package (e.g. a relative import) ModuleNotFoundError: If the name cannot be found in any of the searched directories. """ try: abs_name = importlib.util.resolve_name(name, None) except ImportError: raise ImportError(f'Invalid plugin name {name!r}') try: # if the plugin is already loaded, return it return self.plugins[abs_name] except KeyError: pass try: # if the plugin is already imported, return it return sys.modules[abs_name] except KeyError: pass search_paths = list(set(self.plugin_dirs + additional_paths)) spec = PathFinder.find_spec(abs_name, search_paths) if not spec: raise ModuleNotFoundError(f'No plugin named {abs_name!r}', name=abs_name) module = importlib.util.module_from_spec(spec) sys.modules[abs_name] = module spec.loader.exec_module(module) self.logger.debug("Imported plugin: %s", abs_name) return module
def findModules(module, submoduleName, pattern="*"): """Find the direct submodules from one or more DIRAC extension(s) that match a pattern :param list/str/module module: One or more Python modules or Python module names :param str submoduleName: The submodule under ``module`` in which to look :param str pattern: A ``fnmatch``-style pattern that the submodule must match :returns: list of tuples of the form (SystemName, ServiceName) """ for system in _findSystems(module): agentModule = PathFinder.find_spec( submoduleName, path=system.submodule_search_locations) if not agentModule: continue for _, name, _ in pkgutil.iter_modules( agentModule.submodule_search_locations): if fnmatch.fnmatch(name, pattern): yield system.name, name
def find_spec(cls, fullname, path=None, target=None): """ From the official documentation: - path is the list of paths where to look for the module, if set to 'None', then search for sys.path. - target is set only in case this is a module reload request, otherwise it will always be 'None'. """ splitname = fullname.split('.') # CHECK IF NAME MATCHES THE PLUGIN PACKAGE PATH if splitname[:2] == ['eddy', 'plugins'] and len(splitname) >= 3: if splitname[2] in PluginManager.info: plugin_spec, plugin_path, plugin_class = PluginManager.info.get(splitname[2]) plugin_path = expandPath(plugin_path) return PathFinder.find_spec(fullname, [plugin_path]) return None
def find_spec( self, fullname: str, path: Optional[Sequence[Union[bytes, str]]], target: Optional[ModuleType] = None, ): if _managers: module_spec = PathFinder.find_spec(fullname, path, target) if not module_spec: return module_origin = module_spec.origin if not module_origin: return module_path = Path(module_origin).resolve() for manager in reversed(_managers): # use path instead of name in case of submodule name conflict if (fullname in manager.plugins or module_path in manager._searched_plugin_names.values()): module_spec.loader = PluginLoader(manager, fullname, module_origin) return module_spec return
def find_spec(cls, fullname, path, target=None): for load_path in gs.IMPORT_PATHS: if load_path.endswith(os.path.sep): module_dir = load_path[:-1] module_prefix = '' else: module_dir = os.path.dirname(load_path) if not module_dir: module_dir = '.' module_prefix = os.path.basename(load_path) if not module_prefix or fullname == module_prefix or fullname.startswith( module_prefix + '.'): if path is None: search_path = [os.path.abspath(module_dir)] elif isinstance(path, str): search_path = [ os.path.abspath(os.path.join(module_dir, path)) ] else: search_path = path spec = PathFinder.find_spec(fullname, search_path, target) if spec: return spec
def find_python_tests(module_name, class_name, determine_match, path): """ Attempts to find Python tests from source files A Python test in this context is a method within a specific type of class (or that inherits from a specific class). :param module_name: the name of the module from which a class should have come from :type module_name: str :param class_name: the name of the class that is considered to contain test methods :type class_name: str :type determine_match: a callable that will determine if a given module and class is contains valid Python tests :type determine_match: function :param path: path to a Python source code file :type path: str :returns: tuple where first item is dict with class name and additional info such as method names and tags; the second item is set of class names which look like Python tests but have been forcefully disabled. :rtype: tuple """ module = PythonModule(path, module_name, class_name) # The resulting test classes result = collections.OrderedDict() disabled = set() for klass in module.iter_classes(): docstring = ast.get_docstring(klass) # Looking for a class that has in the docstring either # ":avocado: enable" or ":avocado: disable if check_docstring_directive(docstring, 'disable'): disabled.add(klass.name) continue if check_docstring_directive(docstring, 'enable'): info = get_methods_info(klass.body, get_docstring_directives_tags(docstring), get_docstring_directives_requirements( docstring)) result[klass.name] = info continue # From this point onwards we want to do recursive discovery, but # for now we don't know whether it is avocado.Test inherited # (Ifs are optimized for readability, not speed) # If "recursive" tag is specified, it is forced as test if check_docstring_directive(docstring, 'recursive'): is_valid_test = True else: is_valid_test = module.is_matching_klass(klass) info = get_methods_info(klass.body, get_docstring_directives_tags(docstring), get_docstring_directives_requirements( docstring)) _disabled = set() # Getting the list of parents of the current class parents = klass.bases # Searching the parents in the same module for parent in parents[:]: # Looking for a 'class FooTest(Parent)' if not isinstance(parent, ast.Name): # 'class FooTest(bar.Bar)' not supported withing # a module continue parent_class = parent.id _info, _dis, _python_test = _examine_class(module.path, parent_class, is_valid_test, module_name, class_name, determine_match) if _info: parents.remove(parent) _extend_test_list(info, _info) _disabled.update(_dis) if _python_test is not is_valid_test: is_valid_test = _python_test # If there are parents left to be discovered, they # might be in a different module. for parent in parents: if hasattr(parent, 'value'): if hasattr(parent.value, 'id'): # We know 'parent.Class' or 'asparent.Class' and need # to get path and original_module_name. Class is given # by parent definition. _parent = module.imported_objects.get(parent.value.id) if _parent is None: # We can't examine this parent (probably broken # module) continue parent_path = os.path.dirname(_parent) parent_module = os.path.basename(_parent) parent_class = parent.attr else: # We don't support multi-level 'parent.parent.Class' continue else: # We only know 'Class' or 'AsClass' and need to get # path, module and original class_name _parent = module.imported_objects.get(parent.id) if _parent is None: # We can't examine this parent (probably broken # module) continue parent_path, parent_module, parent_class = ( _parent.rsplit(os.path.sep, 2)) modules_paths = [parent_path, os.path.dirname(module.path)] + sys.path found_spec = PathFinder.find_spec(parent_module, modules_paths) if found_spec is None: continue _info, _dis, _python_test = _examine_class(found_spec.origin, parent_class, is_valid_test, module_name, class_name, determine_match) if _info: info.extend(_info) _disabled.update(_dis) if _python_test is not is_valid_test: is_valid_test = _python_test # Only update the results if this was detected as 'avocado.Test' if is_valid_test: result[klass.name] = info disabled.update(_disabled) return result, disabled
class CometModuleFinder(object): def __init__(self): self.patcher_functions = {} if sys.version_info[0] >= 3: from importlib.machinery import PathFinder self.pathfinder = PathFinder() def register(self, module_name, object_name, patcher_function): module_patchers = self.patcher_functions.setdefault(module_name, {}) module_patchers[object_name] = patcher_function def start(self): if self not in sys.meta_path and not in_notebook_environment(): sys.meta_path.insert(0, self) def find_module(self, fullname, path=None): """ Python 2 import hook """ if fullname not in self.patcher_functions: return return self def load_module(self, fullname): """ Python 2 import hook """ module = self._get_module(fullname) return self._patch(module, fullname) def find_spec(self, fullname, path=None, target=None): """ Python 3 import hook """ if fullname not in self.patcher_functions: return from importlib.machinery import ModuleSpec, SourceFileLoader spec = self.pathfinder.find_spec(fullname, path, target) loader = SourceFileLoader(fullname, spec.origin) return ModuleSpec(fullname, CustomFileLoader(loader, fullname, self)) def _get_module(self, fullname): splitted_name = fullname.split('.') parent = '.'.join(splitted_name[:-1]) if fullname in sys.modules: return sys.modules[fullname] elif parent in sys.modules: parent = sys.modules[parent] module_path = imp.find_module(splitted_name[-1], parent.__path__) return imp.load_module(fullname, *module_path) else: module_path = imp.find_module(fullname) return imp.load_module(fullname, *module_path) def _patch(self, module, fullname): objects_to_patch = self.patcher_functions.get(fullname, {}) for object_name, patcher_function in objects_to_patch.items(): object_path = object_name.split('.') original = self._get_object(module, object_path) if original is None: # TODO: Send back the error? continue new_object = patcher_function(original) self._set_object(module, object_path, new_object) return module def _get_object(self, module, object_path): current_object = module for part in object_path: try: current_object = getattr(current_object, part) except AttributeError: return None return current_object def _set_object(self, module, object_path, new_object): object_to_patch = self._get_object(module, object_path[:-1]) setattr(object_to_patch, object_path[-1], new_object)
def find_spec(self, name, path, target=None): ms = PathFinder.find_spec(name, path, target) if self.is_xhpy_module(name): ms.loader = XHPyLoader(ms.origin) return ms
log_message("boot_directory = %r", boot_directory) path = list(sys.path) if boot_directory in path: del path[path.index(boot_directory)] try: if PY2: import imp module_spec = imp.find_module("sitecustomize", path) else: from importlib.machinery import PathFinder module_spec = PathFinder.find_spec("sitecustomize", path=path) except ImportError: pass else: if module_spec is not None: # Import error not raised in importlib log_message("sitecustomize = %r", module_spec) if PY2: imp.load_module("sitecustomize", *module_spec) else: module_spec.loader.load_module("sitecustomize") # Because the PYTHONPATH environment variable has been amended and the # bootstrap directory added, if a Python application creates a sub # process which runs a different Python interpreter, then it will still
def _findSystems(module): """Implementation of _findSystems that returns a generator of system names""" for _, name, _ in pkgutil.iter_modules(module.__path__): if name.endswith("System"): yield PathFinder.find_spec(name, path=module.__path__)
class CometModuleFinder(object): def __init__(self): self.patcher_functions = {} if sys.version_info[0] >= 3: from importlib.machinery import PathFinder self.pathfinder = PathFinder() def register_before(self, module_name, object_name, patcher_function, allow_empty_experiment=False): self._register("before", module_name, object_name, patcher_function, allow_empty_experiment) def register_after(self, module_name, object_name, patcher_function, allow_empty_experiment=False): self._register("after", module_name, object_name, patcher_function, allow_empty_experiment) def _register( self, lifecycle, module_name, object_name, patcher_function, allow_empty_experiment, ): module_patchers = self.patcher_functions.setdefault(module_name, {}) object_patchers = module_patchers.setdefault( object_name, { "before": [], "after": [], "allow_empty_experiment": allow_empty_experiment, }, ) object_patchers[lifecycle].append(patcher_function) def start(self): if self not in sys.meta_path: sys.meta_path.insert(0, self) def find_module(self, fullname, path=None): """ Python 2 import hook """ if fullname not in self.patcher_functions: return return self def load_module(self, fullname): """ Python 2 import hook """ module = self._get_module(fullname) return self._patch(module, fullname) def find_spec(self, fullname, path=None, target=None): """ Python 3 import hook """ if fullname not in self.patcher_functions: return spec = self.pathfinder.find_spec(fullname, path, target) if not spec: return new_loader = CustomFileLoader(spec.loader, fullname, self) spec.loader = new_loader return spec def _get_module(self, fullname): splitted_name = fullname.split(".") parent = ".".join(splitted_name[:-1]) if fullname in sys.modules: return sys.modules[fullname] elif parent in sys.modules: parent = sys.modules[parent] module_path = imp.find_module(splitted_name[-1], parent.__path__) return imp.load_module(fullname, *module_path) else: try: module_path = imp.find_module(fullname) return imp.load_module(fullname, *module_path) except ImportError: for p in sys.path: importer = get_pep_302_importer(p) # Ignore invalid paths if importer is None: continue module_path = importer.find_module(fullname) if module_path: return importer.load_module(fullname) def _patch(self, module, fullname): objects_to_patch = self.patcher_functions.get(fullname, {}) for object_name, patcher_callbacks in objects_to_patch.items(): object_path = object_name.split(".") original = self._get_object(module, object_path) if original is None: # TODO: Send back the error? continue new_object = Entrypoint(original, **patcher_callbacks) self._set_object(module, object_path, original, new_object) return module def _get_object(self, module, object_path): current_object = module for part in object_path: try: current_object = getattr(current_object, part) except AttributeError: return None return current_object def _set_object(self, module, object_path, original, new_object): object_to_patch = self._get_object(module, object_path[:-1]) original_self = getattr(original, "__self__", None) # Support classmethod if original_self and inspect.isclass(original_self): new_object = classmethod(new_object) # Support staticmethod elif (six.PY2 and inspect.isclass(object_to_patch) and isinstance(original, types.FunctionType)): new_object = staticmethod(new_object) setattr(object_to_patch, object_path[-1], new_object)
print('ERROR:', req, repr(e)) ret = 1 continue # Try to load top level modules. This should not have any side-effects. try: metalines = dist.get_metadata_lines('top_level.txt') except (KeyError, EnvironmentError): # distutils (i.e. #:use-setuptools? #f) will not install any metadata. # This file is also missing for packages built using a PEP 517 builder # such as poetry. print('WARNING: cannot determine top-level modules') continue for name in metalines: # Only available on Python 3. if PathFinder and PathFinder.find_spec(name) is None: # Ignore unavailable modules, often C modules, which were not # installed at the top-level. Cannot use ModuleNotFoundError, # because it is raised by failed imports too. continue try: print('...trying to load module', name, end=': ') importlib.import_module(name) print('OK') except Exception: print('ERROR:') traceback.print_exc(file=sys.stdout) ret = 1 # Try to load entry points of console scripts too, making sure they # work. They should be removed if they don't. Other groups may not be
def find_spec(fullname, path=None, target=None): "Method for Python 3.4+." return PathFinder.find_spec(fullname, path or _get_paths(), target)
def find_spec(cls, fullname, path, target=None): if fullname.startswith('fife'): return ModuleSpec(fullname, DummyLoader()) return PathFinder.find_spec(fullname, path, target)
def _examine_class(path, class_name, match, target_module, target_class, determine_match): """ Examine a class from a given path :param path: path to a Python source code file :type path: str :param class_name: the specific class to be found :type path: str :param match: whether the inheritance from <target_module.target_class> has been determined or not :type match: bool :param target_module: the module name under which the target_class lives :type target_module: str :param target_class: the name of the class that class_name should ultimately inherit from :type target_class: str :param determine_match: a callable that will determine if a match has occurred or not :type determine_match: function :returns: tuple where first item is a list of test methods detected for given class; second item is set of class names which look like avocado tests but are force-disabled. :rtype: tuple """ module = PythonModule(path, target_module, target_class) info = [] disabled = set() for klass in module.iter_classes(): if class_name != klass.name: continue docstring = ast.get_docstring(klass) if match is False: match = determine_match(module, klass, docstring) info = get_methods_info(klass.body, get_docstring_directives_tags(docstring), get_docstring_directives_requirements( docstring)) # Getting the list of parents of the current class parents = klass.bases # From this point we use `_$variable` to name temporary returns # from method calls that are to-be-assigned/combined with the # existing `$variable`. # Searching the parents in the same module for parent in parents[:]: # Looking for a 'class FooTest(Parent)' if not isinstance(parent, ast.Name): # 'class FooTest(bar.Bar)' not supported withing # a module continue parent_class = parent.id _info, _disabled, _match = _examine_class(module.path, parent_class, match, target_module, target_class, determine_match) if _info: parents.remove(parent) _extend_test_list(info, _info) disabled.update(_disabled) if _match is not match: match = _match # If there are parents left to be discovered, they # might be in a different module. for parent in parents: if hasattr(parent, 'value'): if hasattr(parent.value, 'id'): # We know 'parent.Class' or 'asparent.Class' and need # to get path and original_module_name. Class is given # by parent definition. _parent = module.imported_objects.get(parent.value.id) if _parent is None: # We can't examine this parent (probably broken # module) continue parent_path = os.path.dirname(_parent) parent_module = os.path.basename(_parent) parent_class = parent.attr else: # We don't support multi-level 'parent.parent.Class' continue else: # We only know 'Class' or 'AsClass' and need to get # path, module and original class_name _parent = module.imported_objects.get(parent.id) if _parent is None: # We can't examine this parent (probably broken # module) continue parent_path, parent_module, parent_class = ( _parent.rsplit(os.path.sep, 2)) modules_paths = [parent_path, os.path.dirname(module.path)] + sys.path found_spec = PathFinder.find_spec(parent_module, modules_paths) if found_spec is not None: _info, _disabled, _match = _examine_class(found_spec.origin, parent_class, match, target_module, target_class, _determine_match_avocado) if _info: _extend_test_list(info, _info) disabled.update(_disabled) if _match is not match: match = _match return info, disabled, match
def getPath(self, fullname): """ Return the proper path to the module specified in fullname """ actualName = self.getActualModuleName(fullname) return PathFinder.find_spec(actualName).origin
def find_spec(self, fullname, path, target=None): module_spec = PathFinder.find_spec(fullname, path, target) if module_spec and module_spec.has_location and self._is_in_directory(module_spec.origin): loader = Loader(fullname, module_spec.origin, self._transformer) is_package = os.path.basename(module_spec.origin).lower() == "__init__.py" return spec_from_loader(fullname, loader, origin=module_spec.origin, is_package=is_package)