# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-02-12 21:25+0100\n" "PO-Revision-Date: 2018-07-04 11:26+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.8.11\n" #: library/importlib.rst:2 msgid ":mod:`!importlib` --- The implementation of :keyword:`!import`" msgstr "" #: library/importlib.rst:12 #, fuzzy msgid "**Source code:** :source:`Lib/importlib/__init__.py`" msgstr "**Source code:** :source:`Lib/html/__init__.py`" #: library/importlib.rst:18 msgid "Introduction" msgstr "Introduction" #: library/importlib.rst:20 msgid "The purpose of the :mod:`importlib` package is three-fold." msgstr "" #: library/importlib.rst:22 msgid "" "One is to provide the implementation of the :keyword:`import` statement (and " "thus, by extension, the :func:`__import__` function) in Python source code. " "This provides an implementation of :keyword:`!import` which is portable to " "any Python interpreter. This also provides an implementation which is easier " "to comprehend than one implemented in a programming language other than " "Python." msgstr "" #: library/importlib.rst:29 msgid "" "Two, the components to implement :keyword:`import` are exposed in this " "package, making it easier for users to create their own custom objects " "(known generically as an :term:`importer`) to participate in the import " "process." msgstr "" #: library/importlib.rst:33 msgid "" "Three, the package contains modules exposing additional functionality for " "managing aspects of Python packages:" msgstr "" #: library/importlib.rst:36 msgid "" ":mod:`importlib.metadata` presents access to metadata from third-party " "distributions." msgstr "" #: library/importlib.rst:38 msgid "" ":mod:`importlib.resources` provides routines for accessing non-code " "\"resources\" from Python packages." msgstr "" #: library/importlib.rst:44 msgid ":ref:`import`" msgstr ":ref:`import`" #: library/importlib.rst:44 msgid "The language reference for the :keyword:`import` statement." msgstr "" #: library/importlib.rst:49 msgid "" "`Packages specification `__" msgstr "" #: library/importlib.rst:47 msgid "" "Original specification of packages. Some semantics have changed since the " "writing of this document (e.g. redirecting based on ``None`` in :data:`sys." "modules`)." msgstr "" #: library/importlib.rst:52 msgid "The :func:`.__import__` function" msgstr "La fonction :func:`.__import__`" #: library/importlib.rst:52 msgid "The :keyword:`import` statement is syntactic sugar for this function." msgstr "" #: library/importlib.rst:55 msgid ":ref:`sys-path-init`" msgstr "" #: library/importlib.rst:55 msgid "The initialization of :data:`sys.path`." msgstr "" #: library/importlib.rst:58 msgid ":pep:`235`" msgstr ":pep:`235`" #: library/importlib.rst:58 msgid "Import on Case-Insensitive Platforms" msgstr "" #: library/importlib.rst:61 msgid ":pep:`263`" msgstr ":pep:`263`" #: library/importlib.rst:61 msgid "Defining Python Source Code Encodings" msgstr "" #: library/importlib.rst:64 msgid ":pep:`302`" msgstr ":pep:`302`" #: library/importlib.rst:64 msgid "New Import Hooks" msgstr "" #: library/importlib.rst:67 msgid ":pep:`328`" msgstr ":pep:`328`" #: library/importlib.rst:67 msgid "Imports: Multi-Line and Absolute/Relative" msgstr "" #: library/importlib.rst:70 msgid ":pep:`366`" msgstr ":pep:`366`" #: library/importlib.rst:70 msgid "Main module explicit relative imports" msgstr "" #: library/importlib.rst:73 msgid ":pep:`420`" msgstr ":pep:`420`" #: library/importlib.rst:73 msgid "Implicit namespace packages" msgstr "" #: library/importlib.rst:76 msgid ":pep:`451`" msgstr ":pep:`451`" #: library/importlib.rst:76 msgid "A ModuleSpec Type for the Import System" msgstr "" #: library/importlib.rst:79 msgid ":pep:`488`" msgstr ":pep:`488`" #: library/importlib.rst:79 msgid "Elimination of PYO files" msgstr "" #: library/importlib.rst:82 msgid ":pep:`489`" msgstr ":pep:`489`" #: library/importlib.rst:82 msgid "Multi-phase extension module initialization" msgstr "" #: library/importlib.rst:85 msgid ":pep:`552`" msgstr ":pep:`552`" #: library/importlib.rst:85 msgid "Deterministic pycs" msgstr "" #: library/importlib.rst:88 msgid ":pep:`3120`" msgstr ":pep:`3120`" #: library/importlib.rst:88 msgid "Using UTF-8 as the Default Source Encoding" msgstr "" #: library/importlib.rst:90 msgid ":pep:`3147`" msgstr ":pep:`3147`" #: library/importlib.rst:91 msgid "PYC Repository Directories" msgstr "" #: library/importlib.rst:95 msgid "Functions" msgstr "Fonctions" #: library/importlib.rst:99 msgid "An implementation of the built-in :func:`__import__` function." msgstr "" #: library/importlib.rst:102 msgid "" "Programmatic importing of modules should use :func:`import_module` instead " "of this function." msgstr "" #: library/importlib.rst:107 msgid "" "Import a module. The *name* argument specifies what module to import in " "absolute or relative terms (e.g. either ``pkg.mod`` or ``..mod``). If the " "name is specified in relative terms, then the *package* argument must be set " "to the name of the package which is to act as the anchor for resolving the " "package name (e.g. ``import_module('..mod', 'pkg.subpkg')`` will import " "``pkg.mod``)." msgstr "" #: library/importlib.rst:115 msgid "" "The :func:`import_module` function acts as a simplifying wrapper around :" "func:`importlib.__import__`. This means all semantics of the function are " "derived from :func:`importlib.__import__`. The most important difference " "between these two functions is that :func:`import_module` returns the " "specified package or module (e.g. ``pkg.mod``), while :func:`__import__` " "returns the top-level package or module (e.g. ``pkg``)." msgstr "" #: library/importlib.rst:122 msgid "" "If you are dynamically importing a module that was created since the " "interpreter began execution (e.g., created a Python source file), you may " "need to call :func:`invalidate_caches` in order for the new module to be " "noticed by the import system." msgstr "" #: library/importlib.rst:127 msgid "Parent packages are automatically imported." msgstr "" #: library/importlib.rst:132 msgid "" "Find the loader for a module, optionally within the specified *path*. If the " "module is in :attr:`sys.modules`, then ``sys.modules[name].__loader__`` is " "returned (unless the loader would be ``None`` or is not set, in which case :" "exc:`ValueError` is raised). Otherwise a search using :attr:`sys.meta_path` " "is done. ``None`` is returned if no loader is found." msgstr "" #: library/importlib.rst:138 msgid "" "A dotted name does not have its parents implicitly imported as that requires " "loading them and that may not be desired. To properly import a submodule you " "will need to import all parent packages of the submodule and use the correct " "argument to *path*." msgstr "" #: library/importlib.rst:145 msgid "" "If ``__loader__`` is not set, raise :exc:`ValueError`, just like when the " "attribute is set to ``None``." msgstr "" #: library/importlib.rst:149 msgid "Use :func:`importlib.util.find_spec` instead." msgstr "" #: library/importlib.rst:154 msgid "" "Invalidate the internal caches of finders stored at :data:`sys.meta_path`. " "If a finder implements ``invalidate_caches()`` then it will be called to " "perform the invalidation. This function should be called if any modules are " "created/installed while your program is running to guarantee all finders " "will notice the new module's existence." msgstr "" #: library/importlib.rst:162 msgid "" "Namespace packages created/installed in a different :data:`sys.path` " "location after the same namespace was already imported are noticed." msgstr "" #: library/importlib.rst:168 msgid "" "Reload a previously imported *module*. The argument must be a module " "object, so it must have been successfully imported before. This is useful " "if you have edited the module source file using an external editor and want " "to try out the new version without leaving the Python interpreter. The " "return value is the module object (which can be different if re-importing " "causes a different object to be placed in :data:`sys.modules`)." msgstr "" #: library/importlib.rst:175 msgid "When :func:`reload` is executed:" msgstr "" #: library/importlib.rst:177 msgid "" "Python module's code is recompiled and the module-level code re-executed, " "defining a new set of objects which are bound to names in the module's " "dictionary by reusing the :term:`loader` which originally loaded the " "module. The ``init`` function of extension modules is not called a second " "time." msgstr "" #: library/importlib.rst:183 msgid "" "As with all other objects in Python the old objects are only reclaimed after " "their reference counts drop to zero." msgstr "" #: library/importlib.rst:186 msgid "" "The names in the module namespace are updated to point to any new or changed " "objects." msgstr "" #: library/importlib.rst:189 msgid "" "Other references to the old objects (such as names external to the module) " "are not rebound to refer to the new objects and must be updated in each " "namespace where they occur if that is desired." msgstr "" #: library/importlib.rst:193 msgid "There are a number of other caveats:" msgstr "" #: library/importlib.rst:195 msgid "" "When a module is reloaded, its dictionary (containing the module's global " "variables) is retained. Redefinitions of names will override the old " "definitions, so this is generally not a problem. If the new version of a " "module does not define a name that was defined by the old version, the old " "definition remains. This feature can be used to the module's advantage if " "it maintains a global table or cache of objects --- with a :keyword:`try` " "statement it can test for the table's presence and skip its initialization " "if desired::" msgstr "" #: library/importlib.rst:209 msgid "" "It is generally not very useful to reload built-in or dynamically loaded " "modules. Reloading :mod:`sys`, :mod:`__main__`, :mod:`builtins` and other " "key modules is not recommended. In many cases extension modules are not " "designed to be initialized more than once, and may fail in arbitrary ways " "when reloaded." msgstr "" #: library/importlib.rst:215 msgid "" "If a module imports objects from another module using :keyword:`from` ... :" "keyword:`import` ..., calling :func:`reload` for the other module does not " "redefine the objects imported from it --- one way around this is to re-" "execute the :keyword:`!from` statement, another is to use :keyword:`!import` " "and qualified names (*module.name*) instead." msgstr "" #: library/importlib.rst:221 msgid "" "If a module instantiates instances of a class, reloading the module that " "defines the class does not affect the method definitions of the instances " "--- they continue to use the old class definition. The same is true for " "derived classes." msgstr "" #: library/importlib.rst:227 msgid "" ":exc:`ModuleNotFoundError` is raised when the module being reloaded lacks a :" "class:`~importlib.machinery.ModuleSpec`." msgstr "" #: library/importlib.rst:233 msgid ":mod:`importlib.abc` -- Abstract base classes related to import" msgstr "" #: library/importlib.rst:238 #, fuzzy msgid "**Source code:** :source:`Lib/importlib/abc.py`" msgstr "**Code source :** :source:`Lib/imaplib.py`" #: library/importlib.rst:243 msgid "" "The :mod:`importlib.abc` module contains all of the core abstract base " "classes used by :keyword:`import`. Some subclasses of the core abstract base " "classes are also provided to help in implementing the core ABCs." msgstr "" #: library/importlib.rst:247 msgid "ABC hierarchy::" msgstr "" #: library/importlib.rst:263 msgid "An abstract base class representing a :term:`finder`." msgstr "" #: library/importlib.rst:265 msgid "Use :class:`MetaPathFinder` or :class:`PathEntryFinder` instead." msgstr "" #: library/importlib.rst:270 msgid "" "An abstract method for finding a :term:`loader` for the specified module. " "Originally specified in :pep:`302`, this method was meant for use in :data:" "`sys.meta_path` and in the path-based import subsystem." msgstr "" #: library/importlib.rst:274 msgid "" "Returns ``None`` when called instead of raising :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:278 msgid "" "Implement :meth:`MetaPathFinder.find_spec` or :meth:`PathEntryFinder." "find_spec` instead." msgstr "" #: library/importlib.rst:285 msgid "An abstract base class representing a :term:`meta path finder`." msgstr "" #: library/importlib.rst:344 msgid "No longer a subclass of :class:`Finder`." msgstr "" #: library/importlib.rst:294 msgid "" "An abstract method for finding a :term:`spec ` for the " "specified module. If this is a top-level import, *path* will be ``None``. " "Otherwise, this is a search for a subpackage or module and *path* will be " "the value of :attr:`__path__` from the parent package. If a spec cannot be " "found, ``None`` is returned. When passed in, ``target`` is a module object " "that the finder may use to make a more educated guess about what spec to " "return. :func:`importlib.util.spec_from_loader` may be useful for " "implementing concrete ``MetaPathFinders``." msgstr "" #: library/importlib.rst:308 msgid "" "A legacy method for finding a :term:`loader` for the specified module. If " "this is a top-level import, *path* will be ``None``. Otherwise, this is a " "search for a subpackage or module and *path* will be the value of :attr:" "`__path__` from the parent package. If a loader cannot be found, ``None`` is " "returned." msgstr "" #: library/importlib.rst:314 msgid "" "If :meth:`find_spec` is defined, backwards-compatible functionality is " "provided." msgstr "" #: library/importlib.rst:317 msgid "" "Returns ``None`` when called instead of raising :exc:`NotImplementedError`. " "Can use :meth:`find_spec` to provide functionality." msgstr "" #: library/importlib.rst:378 library/importlib.rst:902 #: library/importlib.rst:959 msgid "Use :meth:`find_spec` instead." msgstr "" #: library/importlib.rst:327 msgid "" "An optional method which, when called, should invalidate any internal cache " "used by the finder. Used by :func:`importlib.invalidate_caches` when " "invalidating the caches of all finders on :data:`sys.meta_path`." msgstr "" #: library/importlib.rst:331 msgid "Returns ``None`` when called instead of ``NotImplemented``." msgstr "" #: library/importlib.rst:337 msgid "" "An abstract base class representing a :term:`path entry finder`. Though it " "bears some similarities to :class:`MetaPathFinder`, ``PathEntryFinder`` is " "meant for use only within the path-based import subsystem provided by :class:" "`importlib.machinery.PathFinder`." msgstr "" #: library/importlib.rst:349 msgid "" "An abstract method for finding a :term:`spec ` for the " "specified module. The finder will search for the module only within the :" "term:`path entry` to which it is assigned. If a spec cannot be found, " "``None`` is returned. When passed in, ``target`` is a module object that " "the finder may use to make a more educated guess about what spec to return. :" "func:`importlib.util.spec_from_loader` may be useful for implementing " "concrete ``PathEntryFinders``." msgstr "" #: library/importlib.rst:361 msgid "" "A legacy method for finding a :term:`loader` for the specified module. " "Returns a 2-tuple of ``(loader, portion)`` where ``portion`` is a sequence " "of file system locations contributing to part of a namespace package. The " "loader may be ``None`` while specifying ``portion`` to signify the " "contribution of the file system locations to a namespace package. An empty " "list can be used for ``portion`` to signify the loader is not part of a " "namespace package. If ``loader`` is ``None`` and ``portion`` is the empty " "list then no loader or location for a namespace package were found (i.e. " "failure to find anything for the module)." msgstr "" #: library/importlib.rst:371 msgid "" "If :meth:`find_spec` is defined then backwards-compatible functionality is " "provided." msgstr "" #: library/importlib.rst:374 msgid "" "Returns ``(None, [])`` instead of raising :exc:`NotImplementedError`. Uses :" "meth:`find_spec` when available to provide functionality." msgstr "" #: library/importlib.rst:383 msgid "" "A concrete implementation of :meth:`Finder.find_module` which is equivalent " "to ``self.find_loader(fullname)[0]``." msgstr "" #: library/importlib.rst:391 msgid "" "An optional method which, when called, should invalidate any internal cache " "used by the finder. Used by :meth:`importlib.machinery.PathFinder." "invalidate_caches` when invalidating the caches of all cached finders." msgstr "" #: library/importlib.rst:399 msgid "" "An abstract base class for a :term:`loader`. See :pep:`302` for the exact " "definition for a loader." msgstr "" #: library/importlib.rst:402 msgid "" "Loaders that wish to support resource reading should implement a :meth:" "`get_resource_reader` method as specified by :class:`importlib.resources.abc." "ResourceReader`." msgstr "" #: library/importlib.rst:406 msgid "Introduced the optional :meth:`get_resource_reader` method." msgstr "" #: library/importlib.rst:411 msgid "" "A method that returns the module object to use when importing a module. " "This method may return ``None``, indicating that default module creation " "semantics should take place." msgstr "" #: library/importlib.rst:417 msgid "This method is no longer optional when :meth:`exec_module` is defined." msgstr "" #: library/importlib.rst:423 msgid "" "An abstract method that executes the module in its own namespace when a " "module is imported or reloaded. The module should already be initialized " "when :meth:`exec_module` is called. When this method exists, :meth:" "`create_module` must be defined." msgstr "" #: library/importlib.rst:430 msgid ":meth:`create_module` must also be defined." msgstr "" #: library/importlib.rst:435 msgid "" "A legacy method for loading a module. If the module cannot be loaded, :exc:" "`ImportError` is raised, otherwise the loaded module is returned." msgstr "" #: library/importlib.rst:439 msgid "" "If the requested module already exists in :data:`sys.modules`, that module " "should be used and reloaded. Otherwise the loader should create a new module " "and insert it into :data:`sys.modules` before any loading begins, to prevent " "recursion from the import. If the loader inserted a module and the load " "fails, it must be removed by the loader from :data:`sys.modules`; modules " "already in :data:`sys.modules` before the loader began execution should be " "left alone (see :func:`importlib.util.module_for_loader`)." msgstr "" #: library/importlib.rst:448 msgid "" "The loader should set several attributes on the module (note that some of " "these attributes can change when a module is reloaded):" msgstr "" #: library/importlib.rst:454 msgid ":attr:`__name__`" msgstr ":attr:`__name__`" #: library/importlib.rst:453 msgid "" "The module's fully qualified name. It is ``'__main__'`` for an executed " "module." msgstr "" #: library/importlib.rst:459 msgid ":attr:`__file__`" msgstr ":attr:`__file__`" #: library/importlib.rst:457 msgid "" "The location the :term:`loader` used to load the module. For example, for " "modules loaded from a .py file this is the filename. It is not set on all " "modules (e.g. built-in modules)." msgstr "" #: library/importlib.rst:463 msgid ":attr:`__cached__`" msgstr ":attr:`__cached__`" #: library/importlib.rst:462 msgid "" "The filename of a compiled version of the module's code. It is not set on " "all modules (e.g. built-in modules)." msgstr "" #: library/importlib.rst:471 msgid ":attr:`__path__`" msgstr ":attr:`__path__`" #: library/importlib.rst:466 msgid "" "The list of locations where the package's submodules will be found. Most of " "the time this is a single directory. The import system passes this attribute " "to ``__import__()`` and to finders in the same way as :attr:`sys.path` but " "just for the package. It is not set on non-package modules so it can be used " "as an indicator that the module is a package." msgstr "" #: library/importlib.rst:476 msgid ":attr:`__package__`" msgstr ":attr:`__package__`" #: library/importlib.rst:474 msgid "" "The fully qualified name of the package the module is in (or the empty " "string for a top-level module). If the module is a package then this is the " "same as :attr:`__name__`." msgstr "" #: library/importlib.rst:479 msgid ":attr:`__loader__`" msgstr ":attr:`__loader__`" #: library/importlib.rst:479 msgid "The :term:`loader` used to load the module." msgstr "" #: library/importlib.rst:481 msgid "" "When :meth:`exec_module` is available then backwards-compatible " "functionality is provided." msgstr "" #: library/importlib.rst:484 msgid "" "Raise :exc:`ImportError` when called instead of :exc:`NotImplementedError`. " "Functionality provided when :meth:`exec_module` is available." msgstr "" #: library/importlib.rst:489 msgid "" "The recommended API for loading a module is :meth:`exec_module` (and :meth:" "`create_module`). Loaders should implement it instead of :meth:" "`load_module`. The import machinery takes care of all the other " "responsibilities of :meth:`load_module` when :meth:`exec_module` is " "implemented." msgstr "" #: library/importlib.rst:498 msgid "" "A legacy method which when implemented calculates and returns the given " "module's representation, as a string. The module type's default :meth:" "`__repr__` will use the result of this method as appropriate." msgstr "" #: library/importlib.rst:504 msgid "Made optional instead of an abstractmethod." msgstr "" #: library/importlib.rst:507 msgid "The import machinery now takes care of this automatically." msgstr "" #: library/importlib.rst:513 msgid "" "An abstract base class for a :term:`loader` which implements the optional :" "pep:`302` protocol for loading arbitrary resources from the storage back-end." msgstr "" #: library/importlib.rst:517 msgid "" "This ABC is deprecated in favour of supporting resource loading through :" "class:`importlib.resources.abc.ResourceReader`." msgstr "" #: library/importlib.rst:523 msgid "" "An abstract method to return the bytes for the data located at *path*. " "Loaders that have a file-like storage back-end that allows storing arbitrary " "data can implement this abstract method to give direct access to the data " "stored. :exc:`OSError` is to be raised if the *path* cannot be found. The " "*path* is expected to be constructed using a module's :attr:`__file__` " "attribute or an item from a package's :attr:`__path__`." msgstr "" #: library/importlib.rst:531 msgid "Raises :exc:`OSError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:537 msgid "" "An abstract base class for a :term:`loader` which implements the optional :" "pep:`302` protocol for loaders that inspect modules." msgstr "" #: library/importlib.rst:542 msgid "" "Return the code object for a module, or ``None`` if the module does not have " "a code object (as would be the case, for example, for a built-in module). " "Raise an :exc:`ImportError` if loader cannot find the requested module." msgstr "" #: library/importlib.rst:548 msgid "" "While the method has a default implementation, it is suggested that it be " "overridden if possible for performance." msgstr "" #: library/importlib.rst:554 msgid "No longer abstract and a concrete implementation is provided." msgstr "" #: library/importlib.rst:559 msgid "" "An abstract method to return the source of a module. It is returned as a " "text string using :term:`universal newlines`, translating all recognized " "line separators into ``'\\n'`` characters. Returns ``None`` if no source is " "available (e.g. a built-in module). Raises :exc:`ImportError` if the loader " "cannot find the module specified." msgstr "" #: library/importlib.rst:574 library/importlib.rst:624 msgid "Raises :exc:`ImportError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:570 msgid "" "An optional method to return a true value if the module is a package, a " "false value otherwise. :exc:`ImportError` is raised if the :term:`loader` " "cannot find the module." msgstr "" #: library/importlib.rst:579 msgid "Create a code object from Python source." msgstr "" #: library/importlib.rst:581 msgid "" "The *data* argument can be whatever the :func:`compile` function supports (i." "e. string or bytes). The *path* argument should be the \"path\" to where the " "source code originated from, which can be an abstract concept (e.g. location " "in a zip file)." msgstr "" #: library/importlib.rst:586 msgid "" "With the subsequent code object one can execute it in a module by running " "``exec(code, module.__dict__)``." msgstr "" #: library/importlib.rst:591 msgid "Made the method static." msgstr "" #: library/importlib.rst:596 msgid "Implementation of :meth:`Loader.exec_module`." msgstr "" #: library/importlib.rst:602 msgid "Implementation of :meth:`Loader.load_module`." msgstr "" #: library/importlib.rst:604 msgid "use :meth:`exec_module` instead." msgstr "" #: library/importlib.rst:610 msgid "" "An abstract base class which inherits from :class:`InspectLoader` that, when " "implemented, helps a module to be executed as a script. The ABC represents " "an optional :pep:`302` protocol." msgstr "" #: library/importlib.rst:616 msgid "" "An abstract method that is to return the value of :attr:`__file__` for the " "specified module. If no path is available, :exc:`ImportError` is raised." msgstr "" #: library/importlib.rst:620 msgid "" "If source code is available, then the method should return the path to the " "source file, regardless of whether a bytecode was used to load the module." msgstr "" #: library/importlib.rst:630 msgid "" "An abstract base class which inherits from :class:`ResourceLoader` and :" "class:`ExecutionLoader`, providing concrete implementations of :meth:" "`ResourceLoader.get_data` and :meth:`ExecutionLoader.get_filename`." msgstr "" #: library/importlib.rst:634 msgid "" "The *fullname* argument is a fully resolved name of the module the loader is " "to handle. The *path* argument is the path to the file for the module." msgstr "" #: library/importlib.rst:641 msgid "The name of the module the loader can handle." msgstr "" #: library/importlib.rst:645 msgid "Path to the file of the module." msgstr "" #: library/importlib.rst:649 msgid "Calls super's ``load_module()``." msgstr "" #: library/importlib.rst:651 msgid "Use :meth:`Loader.exec_module` instead." msgstr "" #: library/importlib.rst:1104 msgid "Returns :attr:`path`." msgstr "" #: library/importlib.rst:660 msgid "Reads *path* as a binary file and returns the bytes from it." msgstr "" #: library/importlib.rst:665 msgid "" "An abstract base class for implementing source (and optionally bytecode) " "file loading. The class inherits from both :class:`ResourceLoader` and :" "class:`ExecutionLoader`, requiring the implementation of:" msgstr "" #: library/importlib.rst:669 msgid ":meth:`ResourceLoader.get_data`" msgstr ":meth:`ResourceLoader.get_data`" #: library/importlib.rst:672 msgid ":meth:`ExecutionLoader.get_filename`" msgstr ":meth:`ExecutionLoader.get_filename`" #: library/importlib.rst:671 msgid "" "Should only return the path to the source file; sourceless loading is not " "supported." msgstr "" #: library/importlib.rst:674 msgid "" "The abstract methods defined by this class are to add optional bytecode file " "support. Not implementing these optional methods (or causing them to raise :" "exc:`NotImplementedError`) causes the loader to only work with source code. " "Implementing the methods allows the loader to work with source *and* " "bytecode files; it does not allow for *sourceless* loading where only " "bytecode is provided. Bytecode files are an optimization to speed up " "loading by removing the parsing step of Python's compiler, and so no " "bytecode-specific API is exposed." msgstr "" #: library/importlib.rst:685 msgid "" "Optional abstract method which returns a :class:`dict` containing metadata " "about the specified path. Supported dictionary keys are:" msgstr "" #: library/importlib.rst:688 msgid "" "``'mtime'`` (mandatory): an integer or floating-point number representing " "the modification time of the source code;" msgstr "" #: library/importlib.rst:690 msgid "``'size'`` (optional): the size in bytes of the source code." msgstr "" #: library/importlib.rst:692 msgid "" "Any other keys in the dictionary are ignored, to allow for future " "extensions. If the path cannot be handled, :exc:`OSError` is raised." msgstr "" #: library/importlib.rst:710 msgid "Raise :exc:`OSError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:702 msgid "" "Optional abstract method which returns the modification time for the " "specified path." msgstr "" #: library/importlib.rst:705 msgid "" "This method is deprecated in favour of :meth:`path_stats`. You don't have " "to implement it, but it is still available for compatibility purposes. " "Raise :exc:`OSError` if the path cannot be handled." msgstr "" #: library/importlib.rst:715 msgid "" "Optional abstract method which writes the specified bytes to a file path. " "Any intermediate directories which do not exist are to be created " "automatically." msgstr "" #: library/importlib.rst:719 msgid "" "When writing to the path fails because the path is read-only (:attr:`errno." "EACCES`/:exc:`PermissionError`), do not propagate the exception." msgstr "" #: library/importlib.rst:723 msgid "No longer raises :exc:`NotImplementedError` when called." msgstr "" #: library/importlib.rst:728 msgid "Concrete implementation of :meth:`InspectLoader.get_code`." msgstr "" #: library/importlib.rst:732 msgid "Concrete implementation of :meth:`Loader.exec_module`." msgstr "" #: library/importlib.rst:738 msgid "Concrete implementation of :meth:`Loader.load_module`." msgstr "" #: library/importlib.rst:740 msgid "Use :meth:`exec_module` instead." msgstr "" #: library/importlib.rst:745 msgid "Concrete implementation of :meth:`InspectLoader.get_source`." msgstr "" #: library/importlib.rst:749 msgid "" "Concrete implementation of :meth:`InspectLoader.is_package`. A module is " "determined to be a package if its file path (as provided by :meth:" "`ExecutionLoader.get_filename`) is a file named ``__init__`` when the file " "extension is removed **and** the module name itself does not end in " "``__init__``." msgstr "" #: library/importlib.rst:758 msgid ":mod:`importlib.machinery` -- Importers and path hooks" msgstr "" #: library/importlib.rst:763 msgid "**Source code:** :source:`Lib/importlib/machinery.py`" msgstr "" #: library/importlib.rst:767 msgid "" "This module contains the various objects that help :keyword:`import` find " "and load modules." msgstr "" #: library/importlib.rst:772 msgid "" "A list of strings representing the recognized file suffixes for source " "modules." msgstr "" #: library/importlib.rst:779 msgid "" "A list of strings representing the file suffixes for non-optimized bytecode " "modules." msgstr "" #: library/importlib.rst:794 msgid "Use :attr:`BYTECODE_SUFFIXES` instead." msgstr "" #: library/importlib.rst:789 msgid "" "A list of strings representing the file suffixes for optimized bytecode " "modules." msgstr "" #: library/importlib.rst:799 msgid "" "A list of strings representing the recognized file suffixes for bytecode " "modules (including the leading dot)." msgstr "" #: library/importlib.rst:804 msgid "The value is no longer dependent on ``__debug__``." msgstr "" #: library/importlib.rst:809 msgid "" "A list of strings representing the recognized file suffixes for extension " "modules." msgstr "" #: library/importlib.rst:816 msgid "" "Returns a combined list of strings representing all file suffixes for " "modules recognized by the standard import machinery. This is a helper for " "code which simply needs to know if a filesystem path potentially refers to a " "module without needing any details on the kind of module (for example, :func:" "`inspect.getmodulename`)." msgstr "" #: library/importlib.rst:827 msgid "" "An :term:`importer` for built-in modules. All known built-in modules are " "listed in :data:`sys.builtin_module_names`. This class implements the :class:" "`importlib.abc.MetaPathFinder` and :class:`importlib.abc.InspectLoader` ABCs." msgstr "" #: library/importlib.rst:846 library/importlib.rst:874 msgid "" "Only class methods are defined by this class to alleviate the need for " "instantiation." msgstr "" #: library/importlib.rst:835 msgid "" "As part of :pep:`489`, the builtin importer now implements :meth:`Loader." "create_module` and :meth:`Loader.exec_module`" msgstr "" #: library/importlib.rst:842 msgid "" "An :term:`importer` for frozen modules. This class implements the :class:" "`importlib.abc.MetaPathFinder` and :class:`importlib.abc.InspectLoader` ABCs." msgstr "" #: library/importlib.rst:849 msgid "" "Gained :meth:`~Loader.create_module` and :meth:`~Loader.exec_module` methods." msgstr "" #: library/importlib.rst:856 msgid "" ":term:`Finder ` for modules declared in the Windows registry. This " "class implements the :class:`importlib.abc.MetaPathFinder` ABC." msgstr "" #: library/importlib.rst:864 msgid "" "Use :mod:`site` configuration instead. Future versions of Python may not " "enable this finder by default." msgstr "" #: library/importlib.rst:871 msgid "" "A :term:`Finder ` for :data:`sys.path` and package ``__path__`` " "attributes. This class implements the :class:`importlib.abc.MetaPathFinder` " "ABC." msgstr "" #: library/importlib.rst:879 msgid "" "Class method that attempts to find a :term:`spec ` for the " "module specified by *fullname* on :data:`sys.path` or, if defined, on " "*path*. For each path entry that is searched, :data:`sys." "path_importer_cache` is checked. If a non-false object is found then it is " "used as the :term:`path entry finder` to look for the module being searched " "for. If no entry is found in :data:`sys.path_importer_cache`, then :data:" "`sys.path_hooks` is searched for a finder for the path entry and, if found, " "is stored in :data:`sys.path_importer_cache` along with being queried about " "the module. If no finder is ever found then ``None`` is both stored in the " "cache and returned." msgstr "" #: library/importlib.rst:893 msgid "" "If the current working directory -- represented by an empty string -- is no " "longer valid then ``None`` is returned but no value is cached in :data:`sys." "path_importer_cache`." msgstr "" #: library/importlib.rst:900 msgid "A legacy wrapper around :meth:`find_spec`." msgstr "" #: library/importlib.rst:907 msgid "" "Calls :meth:`importlib.abc.PathEntryFinder.invalidate_caches` on all finders " "stored in :data:`sys.path_importer_cache` that define the method. Otherwise " "entries in :data:`sys.path_importer_cache` set to ``None`` are deleted." msgstr "" #: library/importlib.rst:912 msgid "Entries of ``None`` in :data:`sys.path_importer_cache` are deleted." msgstr "" #: library/importlib.rst:915 msgid "" "Calls objects in :data:`sys.path_hooks` with the current working directory " "for ``''`` (i.e. the empty string)." msgstr "" #: library/importlib.rst:922 msgid "" "A concrete implementation of :class:`importlib.abc.PathEntryFinder` which " "caches results from the file system." msgstr "" #: library/importlib.rst:925 msgid "" "The *path* argument is the directory for which the finder is in charge of " "searching." msgstr "" #: library/importlib.rst:928 msgid "" "The *loader_details* argument is a variable number of 2-item tuples each " "containing a loader and a sequence of file suffixes the loader recognizes. " "The loaders are expected to be callables which accept two arguments of the " "module's name and the path to the file found." msgstr "" #: library/importlib.rst:933 msgid "" "The finder will cache the directory contents as necessary, making stat calls " "for each module search to verify the cache is not outdated. Because cache " "staleness relies upon the granularity of the operating system's state " "information of the file system, there is a potential race condition of " "searching for a module, creating a new file, and then searching for the " "module the new file represents. If the operations happen fast enough to fit " "within the granularity of stat calls, then the module search will fail. To " "prevent this from happening, when you create a module dynamically, make sure " "to call :func:`importlib.invalidate_caches`." msgstr "" #: library/importlib.rst:947 msgid "The path the finder will search in." msgstr "" #: library/importlib.rst:951 msgid "Attempt to find the spec to handle *fullname* within :attr:`path`." msgstr "" #: library/importlib.rst:957 msgid "Attempt to find the loader to handle *fullname* within :attr:`path`." msgstr "" #: library/importlib.rst:964 msgid "Clear out the internal cache." msgstr "" #: library/importlib.rst:968 msgid "" "A class method which returns a closure for use on :attr:`sys.path_hooks`. An " "instance of :class:`FileFinder` is returned by the closure using the path " "argument given to the closure directly and *loader_details* indirectly." msgstr "" #: library/importlib.rst:973 msgid "" "If the argument to the closure is not an existing directory, :exc:" "`ImportError` is raised." msgstr "" #: library/importlib.rst:979 msgid "" "A concrete implementation of :class:`importlib.abc.SourceLoader` by " "subclassing :class:`importlib.abc.FileLoader` and providing some concrete " "implementations of other methods." msgstr "" #: library/importlib.rst:987 msgid "The name of the module that this loader will handle." msgstr "" #: library/importlib.rst:991 msgid "The path to the source file." msgstr "" #: library/importlib.rst:995 msgid "Return ``True`` if :attr:`path` appears to be for a package." msgstr "" #: library/importlib.rst:999 msgid "" "Concrete implementation of :meth:`importlib.abc.SourceLoader.path_stats`." msgstr "" #: library/importlib.rst:1003 msgid "Concrete implementation of :meth:`importlib.abc.SourceLoader.set_data`." msgstr "" #: library/importlib.rst:1050 msgid "" "Concrete implementation of :meth:`importlib.abc.Loader.load_module` where " "specifying the name of the module to load is optional." msgstr "" #: library/importlib.rst:1055 msgid "Use :meth:`importlib.abc.Loader.exec_module` instead." msgstr "" #: library/importlib.rst:1017 msgid "" "A concrete implementation of :class:`importlib.abc.FileLoader` which can " "import bytecode files (i.e. no source code files exist)." msgstr "" #: library/importlib.rst:1020 msgid "" "Please note that direct use of bytecode files (and thus not source code " "files) inhibits your modules from being usable by all Python implementations " "or new versions of Python which change the bytecode format." msgstr "" #: library/importlib.rst:1029 msgid "The name of the module the loader will handle." msgstr "" #: library/importlib.rst:1033 msgid "The path to the bytecode file." msgstr "" #: library/importlib.rst:1037 msgid "Determines if the module is a package based on :attr:`path`." msgstr "" #: library/importlib.rst:1041 msgid "Returns the code object for :attr:`name` created from :attr:`path`." msgstr "" #: library/importlib.rst:1045 msgid "" "Returns ``None`` as bytecode files have no source when this loader is used." msgstr "" #: library/importlib.rst:1060 msgid "" "A concrete implementation of :class:`importlib.abc.ExecutionLoader` for " "extension modules." msgstr "" #: library/importlib.rst:1063 msgid "" "The *fullname* argument specifies the name of the module the loader is to " "support. The *path* argument is the path to the extension module's file." msgstr "" #: library/importlib.rst:1070 msgid "Name of the module the loader supports." msgstr "" #: library/importlib.rst:1074 msgid "Path to the extension module." msgstr "" #: library/importlib.rst:1078 msgid "" "Creates the module object from the given specification in accordance with :" "pep:`489`." msgstr "" #: library/importlib.rst:1085 msgid "Initializes the given module object in accordance with :pep:`489`." msgstr "" #: library/importlib.rst:1091 msgid "" "Returns ``True`` if the file path points to a package's ``__init__`` module " "based on :attr:`EXTENSION_SUFFIXES`." msgstr "" #: library/importlib.rst:1096 msgid "Returns ``None`` as extension modules lack a code object." msgstr "" #: library/importlib.rst:1100 msgid "Returns ``None`` as extension modules do not have source code." msgstr "" #: library/importlib.rst:1111 msgid "" "A concrete implementation of :class:`importlib.abc.InspectLoader` for " "namespace packages. This is an alias for a private class and is only made " "public for introspecting the ``__loader__`` attribute on namespace packages::" msgstr "" #: library/importlib.rst:1129 msgid "" "A specification for a module's import-system-related state. This is " "typically exposed as the module's :attr:`__spec__` attribute. In the " "descriptions below, the names in parentheses give the corresponding " "attribute available directly on the module object, e.g. ``module.__spec__." "origin == module.__file__``. Note, however, that while the *values* are " "usually equivalent, they can differ since there is no synchronization " "between the two objects. For example, it is possible to update the " "module's :attr:`__file__` at runtime and this will not be automatically " "reflected in the module's :attr:`__spec__.origin`, and vice versa." msgstr "" #: library/importlib.rst:1143 msgid "(:attr:`__name__`)" msgstr "" #: library/importlib.rst:1145 msgid "" "The module's fully qualified name. The :term:`finder` should always set this " "attribute to a non-empty string." msgstr "" #: library/importlib.rst:1150 msgid "(:attr:`__loader__`)" msgstr "" #: library/importlib.rst:1152 msgid "" "The :term:`loader` used to load the module. The :term:`finder` should always " "set this attribute." msgstr "" #: library/importlib.rst:1157 msgid "(:attr:`__file__`)" msgstr "" #: library/importlib.rst:1159 msgid "" "The location the :term:`loader` should use to load the module. For example, " "for modules loaded from a .py file this is the filename. The :term:`finder` " "should always set this attribute to a meaningful value for the :term:" "`loader` to use. In the uncommon case that there is not one (like for " "namespace packages), it should be set to ``None``." msgstr "" #: library/importlib.rst:1167 msgid "(:attr:`__path__`)" msgstr "" #: library/importlib.rst:1169 msgid "" "The list of locations where the package's submodules will be found. Most of " "the time this is a single directory. The :term:`finder` should set this " "attribute to a list, even an empty one, to indicate to the import system " "that the module is a package. It should be set to ``None`` for non-package " "modules. It is set automatically later to a special object for namespace " "packages." msgstr "" #: library/importlib.rst:1178 msgid "" "The :term:`finder` may set this attribute to an object containing " "additional, module-specific data to use when loading the module. Otherwise " "it should be set to ``None``." msgstr "" #: library/importlib.rst:1184 msgid "(:attr:`__cached__`)" msgstr "" #: library/importlib.rst:1186 msgid "" "The filename of a compiled version of the module's code. The :term:`finder` " "should always set this attribute but it may be ``None`` for modules that do " "not need compiled code stored." msgstr "" #: library/importlib.rst:1192 msgid "(:attr:`__package__`)" msgstr "" #: library/importlib.rst:1194 msgid "" "(Read-only) The fully qualified name of the package the module is in (or the " "empty string for a top-level module). If the module is a package then this " "is the same as :attr:`name`." msgstr "" #: library/importlib.rst:1201 msgid "``True`` if the spec's :attr:`origin` refers to a loadable location," msgstr "" #: library/importlib.rst:1201 msgid "" "``False`` otherwise. This value impacts how :attr:`origin` is interpreted " "and how the module's :attr:`__file__` is populated." msgstr "" #: library/importlib.rst:1206 msgid ":mod:`importlib.util` -- Utility code for importers" msgstr "" #: library/importlib.rst:1212 msgid "**Source code:** :source:`Lib/importlib/util.py`" msgstr "" #: library/importlib.rst:1216 msgid "" "This module contains the various objects that help in the construction of " "an :term:`importer`." msgstr "" #: library/importlib.rst:1221 msgid "" "The bytes which represent the bytecode version number. If you need help with " "loading/writing bytecode then consider :class:`importlib.abc.SourceLoader`." msgstr "" #: library/importlib.rst:1228 msgid "" "Return the :pep:`3147`/:pep:`488` path to the byte-compiled file associated " "with the source *path*. For example, if *path* is ``/foo/bar/baz.py`` the " "return value would be ``/foo/bar/__pycache__/baz.cpython-32.pyc`` for Python " "3.2. The ``cpython-32`` string comes from the current magic tag (see :func:" "`get_tag`; if :attr:`sys.implementation.cache_tag` is not defined then :exc:" "`NotImplementedError` will be raised)." msgstr "" #: library/importlib.rst:1235 msgid "" "The *optimization* parameter is used to specify the optimization level of " "the bytecode file. An empty string represents no optimization, so ``/foo/bar/" "baz.py`` with an *optimization* of ``''`` will result in a bytecode path of " "``/foo/bar/__pycache__/baz.cpython-32.pyc``. ``None`` causes the " "interpreter's optimization level to be used. Any other value's string " "representation is used, so ``/foo/bar/baz.py`` with an *optimization* of " "``2`` will lead to the bytecode path of ``/foo/bar/__pycache__/baz." "cpython-32.opt-2.pyc``. The string representation of *optimization* can only " "be alphanumeric, else :exc:`ValueError` is raised." msgstr "" #: library/importlib.rst:1245 msgid "" "The *debug_override* parameter is deprecated and can be used to override the " "system's value for ``__debug__``. A ``True`` value is the equivalent of " "setting *optimization* to the empty string. A ``False`` value is the same as " "setting *optimization* to ``1``. If both *debug_override* an *optimization* " "are not ``None`` then :exc:`TypeError` is raised." msgstr "" #: library/importlib.rst:1253 msgid "" "The *optimization* parameter was added and the *debug_override* parameter " "was deprecated." msgstr "" #: library/importlib.rst:1273 library/importlib.rst:1423 msgid "Accepts a :term:`path-like object`." msgstr "Accepte un :term:`path-like object`." #: library/importlib.rst:1263 msgid "" "Given the *path* to a :pep:`3147` file name, return the associated source " "code file path. For example, if *path* is ``/foo/bar/__pycache__/baz." "cpython-32.pyc`` the returned path would be ``/foo/bar/baz.py``. *path* " "need not exist, however if it does not conform to :pep:`3147` or :pep:`488` " "format, a :exc:`ValueError` is raised. If :attr:`sys.implementation." "cache_tag` is not defined, :exc:`NotImplementedError` is raised." msgstr "" #: library/importlib.rst:1278 msgid "" "Decode the given bytes representing source code and return it as a string " "with universal newlines (as required by :meth:`importlib.abc.InspectLoader." "get_source`)." msgstr "" #: library/importlib.rst:1286 msgid "Resolve a relative module name to an absolute one." msgstr "" #: library/importlib.rst:1288 msgid "" "If **name** has no leading dots, then **name** is simply returned. This " "allows for usage such as ``importlib.util.resolve_name('sys', __spec__." "parent)`` without doing a check to see if the **package** argument is needed." msgstr "" #: library/importlib.rst:1293 msgid "" ":exc:`ImportError` is raised if **name** is a relative module name but " "**package** is a false value (e.g. ``None`` or the empty string). :exc:" "`ImportError` is also raised if a relative name would escape its containing " "package (e.g. requesting ``..bacon`` from within the ``spam`` package)." msgstr "" #: library/importlib.rst:1301 msgid "" "To improve consistency with import statements, raise :exc:`ImportError` " "instead of :exc:`ValueError` for invalid relative import attempts." msgstr "" #: library/importlib.rst:1308 msgid "" "Find the :term:`spec ` for a module, optionally relative to the " "specified **package** name. If the module is in :attr:`sys.modules`, then " "``sys.modules[name].__spec__`` is returned (unless the spec would be " "``None`` or is not set, in which case :exc:`ValueError` is raised). " "Otherwise a search using :attr:`sys.meta_path` is done. ``None`` is returned " "if no spec is found." msgstr "" #: library/importlib.rst:1315 msgid "" "If **name** is for a submodule (contains a dot), the parent module is " "automatically imported." msgstr "" #: library/importlib.rst:1318 msgid "**name** and **package** work the same as for :func:`import_module`." msgstr "" #: library/importlib.rst:1322 msgid "" "Raises :exc:`ModuleNotFoundError` instead of :exc:`AttributeError` if " "**package** is in fact not a package (i.e. lacks a :attr:`__path__` " "attribute)." msgstr "" #: library/importlib.rst:1329 msgid "" "Create a new module based on **spec** and :meth:`spec.loader.create_module " "`." msgstr "" #: library/importlib.rst:1332 msgid "" "If :meth:`spec.loader.create_module ` " "does not return ``None``, then any pre-existing attributes will not be " "reset. Also, no :exc:`AttributeError` will be raised if triggered while " "accessing **spec** or setting an attribute on the module." msgstr "" #: library/importlib.rst:1337 msgid "" "This function is preferred over using :class:`types.ModuleType` to create a " "new module as **spec** is used to set as many import-controlled attributes " "on the module as possible." msgstr "" #: library/importlib.rst:1345 msgid "" "A :term:`decorator` for :meth:`importlib.abc.Loader.load_module` to handle " "selecting the proper module object to load with. The decorated method is " "expected to have a call signature taking two positional arguments (e.g. " "``load_module(self, module)``) for which the second argument will be the " "module **object** to be used by the loader. Note that the decorator will not " "work on static methods because of the assumption of two arguments." msgstr "" #: library/importlib.rst:1354 msgid "" "The decorated method will take in the **name** of the module to be loaded as " "expected for a :term:`loader`. If the module is not found in :data:`sys." "modules` then a new one is constructed. Regardless of where the module came " "from, :attr:`__loader__` set to **self** and :attr:`__package__` is set " "based on what :meth:`importlib.abc.InspectLoader.is_package` returns (if " "available). These attributes are set unconditionally to support reloading." msgstr "" #: library/importlib.rst:1362 msgid "" "If an exception is raised by the decorated method and a module was added to :" "data:`sys.modules`, then the module will be removed to prevent a partially " "initialized module from being in left in :data:`sys.modules`. If the module " "was already in :data:`sys.modules` then it is left alone." msgstr "" #: library/importlib.rst:1367 msgid "" ":attr:`__loader__` and :attr:`__package__` are automatically set (when " "possible)." msgstr "" #: library/importlib.rst:1371 msgid "" "Set :attr:`__name__`, :attr:`__loader__` :attr:`__package__` unconditionally " "to support reloading." msgstr "" #: library/importlib.rst:1375 msgid "" "The import machinery now directly performs all the functionality provided by " "this function." msgstr "" #: library/importlib.rst:1381 msgid "" "A :term:`decorator` for :meth:`importlib.abc.Loader.load_module` to set the :" "attr:`__loader__` attribute on the returned module. If the attribute is " "already set the decorator does nothing. It is assumed that the first " "positional argument to the wrapped method (i.e. ``self``) is what :attr:" "`__loader__` should be set to." msgstr "" #: library/importlib.rst:1388 msgid "" "Set ``__loader__`` if set to ``None``, as if the attribute does not exist." msgstr "" #: library/importlib.rst:1401 msgid "The import machinery takes care of this automatically." msgstr "" #: library/importlib.rst:1397 msgid "" "A :term:`decorator` for :meth:`importlib.abc.Loader.load_module` to set the :" "attr:`__package__` attribute on the returned module. If :attr:`__package__` " "is set and has a value other than ``None`` it will not be changed." msgstr "" #: library/importlib.rst:1406 msgid "" "A factory function for creating a :class:`~importlib.machinery.ModuleSpec` " "instance based on a loader. The parameters have the same meaning as they do " "for ModuleSpec. The function uses available :term:`loader` APIs, such as :" "meth:`InspectLoader.is_package`, to fill in any missing information on the " "spec." msgstr "" #: library/importlib.rst:1416 msgid "" "A factory function for creating a :class:`~importlib.machinery.ModuleSpec` " "instance based on the path to a file. Missing information will be filled in " "on the spec by making use of loader APIs and by the implication that the " "module will be file-based." msgstr "" #: library/importlib.rst:1428 msgid "" "Return the hash of *source_bytes* as bytes. A hash-based ``.pyc`` file " "embeds the :func:`source_hash` of the corresponding source file's contents " "in its header." msgstr "" #: library/importlib.rst:1436 msgid "" "A class which postpones the execution of the loader of a module until the " "module has an attribute accessed." msgstr "" #: library/importlib.rst:1439 msgid "" "This class **only** works with loaders that define :meth:`~importlib.abc." "Loader.exec_module` as control over what module type is used for the module " "is required. For those same reasons, the loader's :meth:`~importlib.abc." "Loader.create_module` method must return ``None`` or a type for which its " "``__class__`` attribute can be mutated along with not using :term:`slots " "<__slots__>`. Finally, modules which substitute the object placed into :attr:" "`sys.modules` will not work as there is no way to properly replace the " "module references throughout the interpreter safely; :exc:`ValueError` is " "raised if such a substitution is detected." msgstr "" #: library/importlib.rst:1450 msgid "" "For projects where startup time is critical, this class allows for " "potentially minimizing the cost of loading a module if it is never used. For " "projects where startup time is not essential then use of this class is " "**heavily** discouraged due to error messages created during loading being " "postponed and thus occurring out of context." msgstr "" #: library/importlib.rst:1458 msgid "" "Began calling :meth:`~importlib.abc.Loader.create_module`, removing the " "compatibility warning for :class:`importlib.machinery.BuiltinImporter` and :" "class:`importlib.machinery.ExtensionFileLoader`." msgstr "" #: library/importlib.rst:1465 msgid "" "A class method which returns a callable that creates a lazy loader. This is " "meant to be used in situations where the loader is passed by class instead " "of by instance. ::" msgstr "" #: library/importlib.rst:1478 msgid "Examples" msgstr "Exemples" #: library/importlib.rst:1481 msgid "Importing programmatically" msgstr "" #: library/importlib.rst:1483 msgid "" "To programmatically import a module, use :func:`importlib.import_module`. ::" msgstr "" #: library/importlib.rst:1492 msgid "Checking if a module can be imported" msgstr "" #: library/importlib.rst:1494 msgid "" "If you need to find out if a module can be imported without actually doing " "the import, then you should use :func:`importlib.util.find_spec`." msgstr "" #: library/importlib.rst:1497 msgid "" "Note that if ``name`` is a submodule (contains a dot), :func:`importlib.util." "find_spec` will import the parent module. ::" msgstr "" #: library/importlib.rst:1520 msgid "Importing a source file directly" msgstr "" #: library/importlib.rst:1522 msgid "To import a Python source file directly, use the following recipe::" msgstr "" #: library/importlib.rst:1539 msgid "Implementing lazy imports" msgstr "" #: library/importlib.rst:1541 msgid "The example below shows how to implement lazy imports::" msgstr "" #: library/importlib.rst:1563 msgid "Setting up an importer" msgstr "" #: library/importlib.rst:1565 msgid "" "For deep customizations of import, you typically want to implement an :term:" "`importer`. This means managing both the :term:`finder` and :term:`loader` " "side of things. For finders there are two flavours to choose from depending " "on your needs: a :term:`meta path finder` or a :term:`path entry finder`. " "The former is what you would put on :attr:`sys.meta_path` while the latter " "is what you create using a :term:`path entry hook` on :attr:`sys.path_hooks` " "which works with :attr:`sys.path` entries to potentially create a finder. " "This example will show you how to register your own importers so that import " "will use them (for creating an importer for yourself, read the documentation " "for the appropriate classes defined within this package)::" msgstr "" #: library/importlib.rst:1597 msgid "Approximating :func:`importlib.import_module`" msgstr "" #: library/importlib.rst:1599 msgid "" "Import itself is implemented in Python code, making it possible to expose " "most of the import machinery through importlib. The following helps " "illustrate the various APIs that importlib exposes by providing an " "approximate implementation of :func:`importlib.import_module`::" msgstr ""