.. c:function:: PyObject* PyImport_GetImporter(PyObject *path)
- Return an importer object for a :data:`sys.path`/:attr:`pkg.__path__` item
+ Return a finder object for a :data:`sys.path`/:attr:`pkg.__path__` item
*path*, possibly by fetching it from the :data:`sys.path_importer_cache`
dict. If it wasn't yet cached, traverse :data:`sys.path_hooks` until a hook
is found that can handle the path item. Return ``None`` if no hook could;
- this tells our caller it should fall back to the built-in import mechanism.
- Cache the result in :data:`sys.path_importer_cache`. Return a new reference
- to the importer object.
+ this tells our caller that the :term:`path based finder` could not find a
+ finder for this path item. Cache the result in :data:`sys.path_importer_cache`.
+ Return a new reference to the finder object.
.. c:function:: void _PyImport_Init()
def walk_packages(path=None, prefix='', onerror=None):
- """Yields (module_loader, name, ispkg) for all modules recursively
+ """Yields (module_finder, name, ispkg) for all modules recursively
on path, or, if path is None, all accessible modules.
'path' should be either None or a list of paths to look for
def iter_modules(path=None, prefix=''):
- """Yields (module_loader, name, ispkg) for all submodules on path,
+ """Yields (module_finder, name, ispkg) for all submodules on path,
or, if path is None, all top-level modules on sys.path.
'path' should be either None or a list of paths to look for
imp = importlib.import_module('imp')
class ImpImporter:
- """PEP 302 Importer that wraps Python's "classic" import algorithm
+ """PEP 302 Finder that wraps Python's "classic" import algorithm
- ImpImporter(dirname) produces a PEP 302 importer that searches that
- directory. ImpImporter(None) produces a PEP 302 importer that searches
+ ImpImporter(dirname) produces a PEP 302 finder that searches that
+ directory. ImpImporter(None) produces a PEP 302 finder that searches
the current sys.path, plus any modules that are frozen or built-in.
Note that ImpImporter does not currently support being used by placement
def get_importer(path_item):
"""Retrieve a finder for the given path item
- The returned importer is cached in sys.path_importer_cache
+ The returned finder is cached in sys.path_importer_cache
if it was newly created by a path hook.
The cache (or part of it) can be cleared manually if a
def iter_importers(fullname=""):
"""Yield finders for the given module name
- If fullname contains a '.', the importers will be for the package
+ If fullname contains a '.', the finders will be for the package
containing fullname, otherwise they will be all registered top level
- importers (i.e. those on both sys.meta_path and sys.path_hooks).
+ finders (i.e. those on both sys.meta_path and sys.path_hooks).
If the named module is in a package, that package is imported as a side
effect of invoking this function.
- If no module name is specified, all top level importers are produced.
+ If no module name is specified, all top level finders are produced.
"""
if fullname.startswith('.'):
msg = "Relative module name {!r} not supported".format(fullname)
# may be cleared when the temporary module goes away
return mod_globals.copy()
-# Helper to get the loader, code and filename for a module
+# Helper to get the full name, spec and code for a module
def _get_module_details(mod_name, error=ImportError):
if mod_name.startswith("."):
raise error("Relative module names not supported")
return _run_module_code(code, init_globals, run_name,
pkg_name=pkg_name, script_name=fname)
else:
- # Importer is defined for path, so add it to
+ # Finder is defined for path, so add it to
# the start of sys.path
sys.path.insert(0, path_name)
try:
self.__import__(mod_name)
assert len(log) == 1
args = log[0][0]
- kwargs = log[0][1]
# Assuming all arguments are positional.
self.assertEqual(args[0], mod_name)
self.assertIsNone(args[1])
module = self.modules[fullname]
except KeyError:
return None
- is_package = hasattr(module, '__path__')
spec = util.spec_from_file_location(
fullname, module.__file__, loader=self,
submodule_search_locations=getattr(module, '__path__', None))
del sys.meta_path[0]
def test_getdata_pep302(self):
- # Use a dummy importer/loader
+ # Use a dummy finder/loader
self.assertEqual(pkgutil.get_data('foo', 'dummy'), "Hello, world!")
del sys.modules['foo']
Jason V. Miller
Jay T. Miller
Katie Miller
+Oren Milman
Roman Milner
Julien Miotte
Andrii V. Mishkovskyi
}
-/* Return an importer object for a sys.path/pkg.__path__ item 'p',
+/* Return a finder object for a sys.path/pkg.__path__ item 'p',
possibly by fetching it from the path_importer_cache dict. If it
wasn't yet cached, traverse path_hooks until a hook is found
that can handle the path item. Return None if no hook could;
- this tells our caller it should fall back to the builtin
- import mechanism. Cache the result in path_importer_cache.
+ this tells our caller that the path based finder could not find
+ a finder for this path item. Cache the result in
+ path_importer_cache.
Returns a borrowed reference. */
static PyObject *
projects / python / commitdiff