# 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-03-23 09:47+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:17 msgid "Introduction" msgstr "Introduction" #: library/importlib.rst:19 msgid "" "The purpose of the :mod:`importlib` package is two-fold. 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:26 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 ":ref:`import`" msgstr ":ref:`import`" #: library/importlib.rst:33 msgid "The language reference for the :keyword:`import` statement." msgstr "" #: library/importlib.rst:38 msgid "" "`Packages specification `__" msgstr "" #: library/importlib.rst:36 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:41 msgid "The :func:`.__import__` function" msgstr "La fonction :func:`.__import__`" #: library/importlib.rst:41 msgid "The :keyword:`import` statement is syntactic sugar for this function." msgstr "" #: library/importlib.rst:44 msgid ":pep:`235`" msgstr ":pep:`235`" #: library/importlib.rst:44 msgid "Import on Case-Insensitive Platforms" msgstr "" #: library/importlib.rst:47 msgid ":pep:`263`" msgstr ":pep:`263`" #: library/importlib.rst:47 msgid "Defining Python Source Code Encodings" msgstr "" #: library/importlib.rst:50 msgid ":pep:`302`" msgstr ":pep:`302`" #: library/importlib.rst:50 msgid "New Import Hooks" msgstr "" #: library/importlib.rst:53 msgid ":pep:`328`" msgstr ":pep:`328`" #: library/importlib.rst:53 msgid "Imports: Multi-Line and Absolute/Relative" msgstr "" #: library/importlib.rst:56 msgid ":pep:`366`" msgstr ":pep:`366`" #: library/importlib.rst:56 msgid "Main module explicit relative imports" msgstr "" #: library/importlib.rst:59 msgid ":pep:`420`" msgstr ":pep:`420`" #: library/importlib.rst:59 msgid "Implicit namespace packages" msgstr "" #: library/importlib.rst:62 msgid ":pep:`451`" msgstr ":pep:`451`" #: library/importlib.rst:62 msgid "A ModuleSpec Type for the Import System" msgstr "" #: library/importlib.rst:65 msgid ":pep:`488`" msgstr ":pep:`488`" #: library/importlib.rst:65 msgid "Elimination of PYO files" msgstr "" #: library/importlib.rst:68 msgid ":pep:`489`" msgstr ":pep:`489`" #: library/importlib.rst:68 msgid "Multi-phase extension module initialization" msgstr "" #: library/importlib.rst:71 msgid ":pep:`552`" msgstr ":pep:`552`" #: library/importlib.rst:71 msgid "Deterministic pycs" msgstr "" #: library/importlib.rst:74 msgid ":pep:`3120`" msgstr ":pep:`3120`" #: library/importlib.rst:74 msgid "Using UTF-8 as the Default Source Encoding" msgstr "" #: library/importlib.rst:76 msgid ":pep:`3147`" msgstr ":pep:`3147`" #: library/importlib.rst:77 msgid "PYC Repository Directories" msgstr "" #: library/importlib.rst:81 msgid "Functions" msgstr "Fonctions" #: library/importlib.rst:85 msgid "An implementation of the built-in :func:`__import__` function." msgstr "" #: library/importlib.rst:88 msgid "" "Programmatic importing of modules should use :func:`import_module` instead " "of this function." msgstr "" #: library/importlib.rst:93 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:101 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:108 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:113 msgid "Parent packages are automatically imported." msgstr "" #: library/importlib.rst:118 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:124 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:131 msgid "" "If ``__loader__`` is not set, raise :exc:`ValueError`, just like when the " "attribute is set to ``None``." msgstr "" #: library/importlib.rst:135 msgid "Use :func:`importlib.util.find_spec` instead." msgstr "" #: library/importlib.rst:140 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:150 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:157 msgid "When :func:`reload` is executed:" msgstr "" #: library/importlib.rst:159 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:165 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:168 msgid "" "The names in the module namespace are updated to point to any new or changed " "objects." msgstr "" #: library/importlib.rst:171 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:175 msgid "There are a number of other caveats:" msgstr "" #: library/importlib.rst:177 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:191 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:197 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:203 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:209 msgid "" ":exc:`ModuleNotFoundError` is raised when the module being reloaded lacks a :" "class:`ModuleSpec`." msgstr "" #: library/importlib.rst:215 msgid ":mod:`importlib.abc` -- Abstract base classes related to import" msgstr "" #: library/importlib.rst:220 #, fuzzy msgid "**Source code:** :source:`Lib/importlib/abc.py`" msgstr "**Code source :** :source:`Lib/imaplib.py`" #: library/importlib.rst:225 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:229 msgid "ABC hierarchy::" msgstr "" #: library/importlib.rst:245 msgid "An abstract base class representing a :term:`finder`." msgstr "" #: library/importlib.rst:247 msgid "Use :class:`MetaPathFinder` or :class:`PathEntryFinder` instead." msgstr "" #: library/importlib.rst:252 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:256 msgid "" "Returns ``None`` when called instead of raising :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:263 msgid "" "An abstract base class representing a :term:`meta path finder`. For " "compatibility, this is a subclass of :class:`Finder`." msgstr "" #: library/importlib.rst:270 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:284 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:290 msgid "" "If :meth:`find_spec` is defined, backwards-compatible functionality is " "provided." msgstr "" #: library/importlib.rst:293 msgid "" "Returns ``None`` when called instead of raising :exc:`NotImplementedError`. " "Can use :meth:`find_spec` to provide functionality." msgstr "" #: library/importlib.rst:352 library/importlib.rst:1086 msgid "Use :meth:`find_spec` instead." msgstr "utilisez plutôt :meth:`find_spec`." #: library/importlib.rst:303 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:307 msgid "Returns ``None`` when called instead of ``NotImplemented``." msgstr "" #: library/importlib.rst:313 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:" "`PathFinder`. This ABC is a subclass of :class:`Finder` for compatibility " "reasons only." msgstr "" #: library/importlib.rst:323 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:335 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:345 msgid "" "If :meth:`find_spec` is defined then backwards-compatible functionality is " "provided." msgstr "" #: library/importlib.rst:348 msgid "" "Returns ``(None, [])`` instead of raising :exc:`NotImplementedError`. Uses :" "meth:`find_spec` when available to provide functionality." msgstr "" #: library/importlib.rst:357 msgid "" "A concrete implementation of :meth:`Finder.find_module` which is equivalent " "to ``self.find_loader(fullname)[0]``." msgstr "" #: library/importlib.rst:365 msgid "" "An optional method which, when called, should invalidate any internal cache " "used by the finder. Used by :meth:`PathFinder.invalidate_caches` when " "invalidating the caches of all cached finders." msgstr "" #: library/importlib.rst:372 msgid "" "An abstract base class for a :term:`loader`. See :pep:`302` for the exact " "definition for a loader." msgstr "" #: library/importlib.rst:836 msgid "" "Loaders that wish to support resource reading should implement a " "``get_resource_reader(fullname)`` method as specified by :class:`importlib." "abc.ResourceReader`." msgstr "" #: library/importlib.rst:379 msgid "Introduced the optional ``get_resource_reader()`` method." msgstr "" #: library/importlib.rst:384 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:390 msgid "" "Starting in Python 3.6, this method will not be optional when :meth:" "`exec_module` is defined." msgstr "" #: library/importlib.rst:396 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 ``exec_module()`` is called. When this method exists, :meth:`~importlib." "abc.Loader.create_module` must be defined." msgstr "" #: library/importlib.rst:403 msgid ":meth:`~importlib.abc.Loader.create_module` must also be defined." msgstr "" #: library/importlib.rst:408 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:412 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:421 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:426 msgid ":attr:`__name__`" msgstr ":attr:`__name__`" #: library/importlib.rst:426 msgid "The name of the module." msgstr "" #: library/importlib.rst:430 msgid ":attr:`__file__`" msgstr ":attr:`__file__`" #: library/importlib.rst:429 msgid "" "The path to where the module data is stored (not set for built-in modules)." msgstr "" #: library/importlib.rst:434 msgid ":attr:`__cached__`" msgstr ":attr:`__cached__`" #: library/importlib.rst:433 msgid "" "The path to where a compiled version of the module is/should be stored (not " "set when the attribute would be inappropriate)." msgstr "" #: library/importlib.rst:438 msgid ":attr:`__path__`" msgstr ":attr:`__path__`" #: library/importlib.rst:437 msgid "" "A list of strings specifying the search path within a package. This " "attribute is not set on modules." msgstr "" #: library/importlib.rst:445 msgid ":attr:`__package__`" msgstr ":attr:`__package__`" #: library/importlib.rst:441 msgid "" "The fully-qualified name of the package under which the module was loaded as " "a submodule (or the empty string for top-level modules). For packages, it is " "the same as :attr:`__name__`. The :func:`importlib.util.module_for_loader` " "decorator can handle the details for :attr:`__package__`." msgstr "" #: library/importlib.rst:450 msgid ":attr:`__loader__`" msgstr ":attr:`__loader__`" #: library/importlib.rst:448 msgid "" "The loader used to load the module. The :func:`importlib.util." "module_for_loader` decorator can handle the details for :attr:`__package__`." msgstr "" #: library/importlib.rst:452 msgid "" "When :meth:`exec_module` is available then backwards-compatible " "functionality is provided." msgstr "" #: library/importlib.rst:455 msgid "" "Raise :exc:`ImportError` when called instead of :exc:`NotImplementedError`. " "Functionality provided when :meth:`exec_module` is available." msgstr "" #: library/importlib.rst:460 msgid "" "The recommended API for loading a module is :meth:`exec_module` (and :meth:" "`create_module`). Loaders should implement it instead of load_module(). " "The import machinery takes care of all the other responsibilities of " "load_module() when exec_module() is implemented." msgstr "" #: library/importlib.rst:469 msgid "" "A legacy method which when implemented calculates and returns the given " "module's repr, as a string. The module type's default repr() will use the " "result of this method as appropriate." msgstr "" #: library/importlib.rst:475 msgid "Made optional instead of an abstractmethod." msgstr "" #: library/importlib.rst:478 msgid "The import machinery now takes care of this automatically." msgstr "" #: library/importlib.rst:484 msgid "" "An :term:`abstract base class` to provide the ability to read *resources*." msgstr "" #: library/importlib.rst:487 msgid "" "From the perspective of this ABC, a *resource* is a binary artifact that is " "shipped within a package. Typically this is something like a data file that " "lives next to the ``__init__.py`` file of the package. The purpose of this " "class is to help abstract out the accessing of such data files so that it " "does not matter if the package and its data file(s) are stored in a e.g. zip " "file versus on the file system." msgstr "" #: library/importlib.rst:495 msgid "" "For any of methods of this class, a *resource* argument is expected to be a :" "term:`path-like object` which represents conceptually just a file name. This " "means that no subdirectory paths should be included in the *resource* " "argument. This is because the location of the package the reader is for, " "acts as the \"directory\". Hence the metaphor for directories and file names " "is packages and resources, respectively. This is also why instances of this " "class are expected to directly correlate to a specific package (instead of " "potentially representing multiple packages or a module)." msgstr "" #: library/importlib.rst:506 msgid "" "Loaders that wish to support resource reading are expected to provide a " "method called ``get_resource_reader(fullname)`` which returns an object " "implementing this ABC's interface. If the module specified by fullname is " "not a package, this method should return :const:`None`. An object compatible " "with this ABC should only be returned when the specified module is a package." msgstr "" #: library/importlib.rst:517 msgid "" "Returns an opened, :term:`file-like object` for binary reading of the " "*resource*." msgstr "" #: library/importlib.rst:520 msgid "If the resource cannot be found, :exc:`FileNotFoundError` is raised." msgstr "" "Si la ressource ne peut pas être trouvée, :exc:`FileNotFoundError` est levée." #: library/importlib.rst:525 msgid "Returns the file system path to the *resource*." msgstr "Renvoie le chemin de *resource* dans le système de fichiers." #: library/importlib.rst:527 msgid "" "If the resource does not concretely exist on the file system, raise :exc:" "`FileNotFoundError`." msgstr "" #: library/importlib.rst:532 msgid "" "Returns ``True`` if the named *name* is considered a resource. :exc:" "`FileNotFoundError` is raised if *name* does not exist." msgstr "" #: library/importlib.rst:537 msgid "" "Returns an :term:`iterable` of strings over the contents of the package. Do " "note that it is not required that all names returned by the iterator be " "actual resources, e.g. it is acceptable to return names for which :meth:" "`is_resource` would be false." msgstr "" #: library/importlib.rst:543 msgid "" "Allowing non-resource names to be returned is to allow for situations where " "how a package and its resources are stored are known a priori and the non-" "resource names would be useful. For instance, returning subdirectory names " "is allowed so that when it is known that the package and resources are " "stored on the file system then those subdirectory names can be used directly." msgstr "" #: library/importlib.rst:551 msgid "The abstract method returns an iterable of no items." msgstr "" #: library/importlib.rst:556 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:560 msgid "" "This ABC is deprecated in favour of supporting resource loading through :" "class:`importlib.abc.ResourceReader`." msgstr "" #: library/importlib.rst:566 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:574 msgid "Raises :exc:`OSError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:580 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:585 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:591 msgid "" "While the method has a default implementation, it is suggested that it be " "overridden if possible for performance." msgstr "" #: library/importlib.rst:597 msgid "No longer abstract and a concrete implementation is provided." msgstr "" #: library/importlib.rst:602 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:617 library/importlib.rst:667 msgid "Raises :exc:`ImportError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:613 msgid "" "An abstract 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:622 msgid "Create a code object from Python source." msgstr "" #: library/importlib.rst:624 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:629 msgid "" "With the subsequent code object one can execute it in a module by running " "``exec(code, module.__dict__)``." msgstr "" #: library/importlib.rst:634 msgid "Made the method static." msgstr "" #: library/importlib.rst:639 msgid "Implementation of :meth:`Loader.exec_module`." msgstr "" #: library/importlib.rst:645 msgid "Implementation of :meth:`Loader.load_module`." msgstr "" #: library/importlib.rst:647 msgid "use :meth:`exec_module` instead." msgstr "" #: library/importlib.rst:653 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:659 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:663 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:673 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:677 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:684 msgid "The name of the module the loader can handle." msgstr "" #: library/importlib.rst:688 msgid "Path to the file of the module." msgstr "" #: library/importlib.rst:692 msgid "Calls super's ``load_module()``." msgstr "" #: library/importlib.rst:694 msgid "Use :meth:`Loader.exec_module` instead." msgstr "" #: library/importlib.rst:1285 msgid "Returns :attr:`path`." msgstr "" #: library/importlib.rst:703 msgid "Reads *path* as a binary file and returns the bytes from it." msgstr "" #: library/importlib.rst:708 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:712 msgid ":meth:`ResourceLoader.get_data`" msgstr ":meth:`ResourceLoader.get_data`" #: library/importlib.rst:715 msgid ":meth:`ExecutionLoader.get_filename`" msgstr ":meth:`ExecutionLoader.get_filename`" #: library/importlib.rst:714 msgid "" "Should only return the path to the source file; sourceless loading is not " "supported." msgstr "" #: library/importlib.rst:717 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:728 msgid "" "Optional abstract method which returns a :class:`dict` containing metadata " "about the specified path. Supported dictionary keys are:" msgstr "" #: library/importlib.rst:731 msgid "" "``'mtime'`` (mandatory): an integer or floating-point number representing " "the modification time of the source code;" msgstr "" #: library/importlib.rst:733 msgid "``'size'`` (optional): the size in bytes of the source code." msgstr "" #: library/importlib.rst:735 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:753 msgid "Raise :exc:`OSError` instead of :exc:`NotImplementedError`." msgstr "" #: library/importlib.rst:745 msgid "" "Optional abstract method which returns the modification time for the " "specified path." msgstr "" #: library/importlib.rst:748 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:758 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:762 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:766 msgid "No longer raises :exc:`NotImplementedError` when called." msgstr "" #: library/importlib.rst:771 msgid "Concrete implementation of :meth:`InspectLoader.get_code`." msgstr "" #: library/importlib.rst:775 msgid "Concrete implementation of :meth:`Loader.exec_module`." msgstr "" #: library/importlib.rst:781 msgid "Concrete implementation of :meth:`Loader.load_module`." msgstr "" #: library/importlib.rst:783 msgid "Use :meth:`exec_module` instead." msgstr "utilisez plutôt :meth:`exec_module`." #: library/importlib.rst:788 msgid "Concrete implementation of :meth:`InspectLoader.get_source`." msgstr "" #: library/importlib.rst:792 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:800 msgid ":mod:`importlib.resources` -- Resources" msgstr "" #: library/importlib.rst:805 msgid "**Source code:** :source:`Lib/importlib/resources.py`" msgstr "" #: library/importlib.rst:811 msgid "" "This module leverages Python's import system to provide access to " "*resources* within *packages*. If you can import a package, you can access " "resources within that package. Resources can be opened or read, in either " "binary or text mode." msgstr "" #: library/importlib.rst:816 msgid "" "Resources are roughly akin to files inside directories, though it's " "important to keep in mind that this is just a metaphor. Resources and " "packages **do not** have to exist as physical files and directories on the " "file system." msgstr "" #: library/importlib.rst:822 msgid "" "This module provides functionality similar to `pkg_resources `_ `Basic Resource " "Access `_ without the performance overhead of that package. This " "makes reading resources included in packages easier, with more stable and " "consistent semantics." msgstr "" #: library/importlib.rst:830 msgid "" "The standalone backport of this module provides more information on `using " "importlib.resources `_ and `migrating from pkg_resources to importlib.resources " "`_." msgstr "" #: library/importlib.rst:840 msgid "The following types are defined." msgstr "" #: library/importlib.rst:844 msgid "" "The ``Package`` type is defined as ``Union[str, ModuleType]``. This means " "that where the function describes accepting a ``Package``, you can pass in " "either a string or a module. Module objects must have a resolvable " "``__spec__.submodule_search_locations`` that is not ``None``." msgstr "" #: library/importlib.rst:851 msgid "" "This type describes the resource names passed into the various functions in " "this package. This is defined as ``Union[str, os.PathLike]``." msgstr "" #: library/importlib.rst:855 msgid "The following functions are available." msgstr "" #: library/importlib.rst:859 msgid "Open for binary reading the *resource* within *package*." msgstr "" #: library/importlib.rst:861 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements. *resource* is the name of the resource to open " "within *package*; it may not contain path separators and it may not have sub-" "resources (i.e. it cannot be a directory). This function returns a ``typing." "BinaryIO`` instance, a binary I/O stream open for reading." msgstr "" #: library/importlib.rst:870 msgid "" "Open for text reading the *resource* within *package*. By default, the " "resource is opened for reading as UTF-8." msgstr "" #: library/importlib.rst:873 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements. *resource* is the name of the resource to open " "within *package*; it may not contain path separators and it may not have sub-" "resources (i.e. it cannot be a directory). *encoding* and *errors* have the " "same meaning as with built-in :func:`open`." msgstr "" #: library/importlib.rst:879 msgid "" "This function returns a ``typing.TextIO`` instance, a text I/O stream open " "for reading." msgstr "" #: library/importlib.rst:885 msgid "" "Read and return the contents of the *resource* within *package* as ``bytes``." msgstr "" #: library/importlib.rst:888 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements. *resource* is the name of the resource to open " "within *package*; it may not contain path separators and it may not have sub-" "resources (i.e. it cannot be a directory). This function returns the " "contents of the resource as :class:`bytes`." msgstr "" #: library/importlib.rst:897 msgid "" "Read and return the contents of *resource* within *package* as a ``str``. By " "default, the contents are read as strict UTF-8." msgstr "" #: library/importlib.rst:900 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements. *resource* is the name of the resource to open " "within *package*; it may not contain path separators and it may not have sub-" "resources (i.e. it cannot be a directory). *encoding* and *errors* have the " "same meaning as with built-in :func:`open`. This function returns the " "contents of the resource as :class:`str`." msgstr "" #: library/importlib.rst:910 msgid "" "Return the path to the *resource* as an actual file system path. This " "function returns a context manager for use in a :keyword:`with` statement. " "The context manager provides a :class:`pathlib.Path` object." msgstr "" #: library/importlib.rst:914 msgid "" "Exiting the context manager cleans up any temporary file created when the " "resource needs to be extracted from e.g. a zip file." msgstr "" #: library/importlib.rst:917 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements. *resource* is the name of the resource to open " "within *package*; it may not contain path separators and it may not have sub-" "resources (i.e. it cannot be a directory)." msgstr "" #: library/importlib.rst:925 msgid "" "Return ``True`` if there is a resource named *name* in the package, " "otherwise ``False``. Remember that directories are *not* resources! " "*package* is either a name or a module object which conforms to the " "``Package`` requirements." msgstr "" #: library/importlib.rst:933 msgid "" "Return an iterable over the named items within the package. The iterable " "returns :class:`str` resources (e.g. files) and non-resources (e.g. " "directories). The iterable does not recurse into subdirectories." msgstr "" #: library/importlib.rst:937 msgid "" "*package* is either a name or a module object which conforms to the " "``Package`` requirements." msgstr "" #: library/importlib.rst:942 msgid ":mod:`importlib.machinery` -- Importers and path hooks" msgstr "" #: library/importlib.rst:947 msgid "**Source code:** :source:`Lib/importlib/machinery.py`" msgstr "" #: library/importlib.rst:951 msgid "" "This module contains the various objects that help :keyword:`import` find " "and load modules." msgstr "" #: library/importlib.rst:956 msgid "" "A list of strings representing the recognized file suffixes for source " "modules." msgstr "" #: library/importlib.rst:963 msgid "" "A list of strings representing the file suffixes for non-optimized bytecode " "modules." msgstr "" #: library/importlib.rst:978 msgid "Use :attr:`BYTECODE_SUFFIXES` instead." msgstr "" #: library/importlib.rst:973 msgid "" "A list of strings representing the file suffixes for optimized bytecode " "modules." msgstr "" #: library/importlib.rst:983 msgid "" "A list of strings representing the recognized file suffixes for bytecode " "modules (including the leading dot)." msgstr "" #: library/importlib.rst:988 msgid "The value is no longer dependent on ``__debug__``." msgstr "" #: library/importlib.rst:993 msgid "" "A list of strings representing the recognized file suffixes for extension " "modules." msgstr "" #: library/importlib.rst:1000 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:1011 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:1030 library/importlib.rst:1058 msgid "" "Only class methods are defined by this class to alleviate the need for " "instantiation." msgstr "" #: library/importlib.rst:1019 msgid "" "As part of :pep:`489`, the builtin importer now implements :meth:`Loader." "create_module` and :meth:`Loader.exec_module`" msgstr "" #: library/importlib.rst:1026 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:1033 msgid "" "Gained :meth:`~Loader.create_module` and :meth:`~Loader.exec_module` methods." msgstr "" #: library/importlib.rst:1040 msgid "" ":term:`Finder ` for modules declared in the Windows registry. This " "class implements the :class:`importlib.abc.MetaPathFinder` ABC." msgstr "" #: library/importlib.rst:1048 msgid "" "Use :mod:`site` configuration instead. Future versions of Python may not " "enable this finder by default." msgstr "" #: library/importlib.rst:1055 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:1063 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:1077 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:1084 msgid "A legacy wrapper around :meth:`find_spec`." msgstr "" #: library/importlib.rst:1091 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:1096 msgid "Entries of ``None`` in :data:`sys.path_importer_cache` are deleted." msgstr "" #: library/importlib.rst:1099 msgid "" "Calls objects in :data:`sys.path_hooks` with the current working directory " "for ``''`` (i.e. the empty string)." msgstr "" #: library/importlib.rst:1106 msgid "" "A concrete implementation of :class:`importlib.abc.PathEntryFinder` which " "caches results from the file system." msgstr "" #: library/importlib.rst:1109 msgid "" "The *path* argument is the directory for which the finder is in charge of " "searching." msgstr "" #: library/importlib.rst:1112 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:1117 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:1131 msgid "The path the finder will search in." msgstr "" #: library/importlib.rst:1135 msgid "Attempt to find the spec to handle *fullname* within :attr:`path`." msgstr "" #: library/importlib.rst:1141 msgid "Attempt to find the loader to handle *fullname* within :attr:`path`." msgstr "" #: library/importlib.rst:1145 msgid "Clear out the internal cache." msgstr "" #: library/importlib.rst:1149 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:1154 msgid "" "If the argument to the closure is not an existing directory, :exc:" "`ImportError` is raised." msgstr "" #: library/importlib.rst:1160 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:1168 msgid "The name of the module that this loader will handle." msgstr "" #: library/importlib.rst:1172 msgid "The path to the source file." msgstr "" #: library/importlib.rst:1176 msgid "Return ``True`` if :attr:`path` appears to be for a package." msgstr "" #: library/importlib.rst:1180 msgid "" "Concrete implementation of :meth:`importlib.abc.SourceLoader.path_stats`." msgstr "" #: library/importlib.rst:1184 msgid "Concrete implementation of :meth:`importlib.abc.SourceLoader.set_data`." msgstr "" #: library/importlib.rst:1231 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:1236 msgid "Use :meth:`importlib.abc.Loader.exec_module` instead." msgstr "" #: library/importlib.rst:1198 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:1201 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:1210 msgid "The name of the module the loader will handle." msgstr "" #: library/importlib.rst:1214 msgid "The path to the bytecode file." msgstr "" #: library/importlib.rst:1218 msgid "Determines if the module is a package based on :attr:`path`." msgstr "" #: library/importlib.rst:1222 msgid "Returns the code object for :attr:`name` created from :attr:`path`." msgstr "" #: library/importlib.rst:1226 msgid "" "Returns ``None`` as bytecode files have no source when this loader is used." msgstr "" #: library/importlib.rst:1241 msgid "" "A concrete implementation of :class:`importlib.abc.ExecutionLoader` for " "extension modules." msgstr "" #: library/importlib.rst:1244 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:1251 msgid "Name of the module the loader supports." msgstr "" #: library/importlib.rst:1255 msgid "Path to the extension module." msgstr "" #: library/importlib.rst:1259 msgid "" "Creates the module object from the given specification in accordance with :" "pep:`489`." msgstr "" #: library/importlib.rst:1266 msgid "Initializes the given module object in accordance with :pep:`489`." msgstr "" #: library/importlib.rst:1272 msgid "" "Returns ``True`` if the file path points to a package's ``__init__`` module " "based on :attr:`EXTENSION_SUFFIXES`." msgstr "" #: library/importlib.rst:1277 msgid "Returns ``None`` as extension modules lack a code object." msgstr "" #: library/importlib.rst:1281 msgid "Returns ``None`` as extension modules do not have source code." msgstr "" #: library/importlib.rst:1292 msgid "" "A specification for a module's import-system-related state. This is " "typically exposed as the module's ``__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. Thus it is possible to update the module's " "``__path__`` at runtime, and this will not be automatically reflected in " "``__spec__.submodule_search_locations``." msgstr "" #: library/importlib.rst:1306 msgid "(``__name__``)" msgstr "" #: library/importlib.rst:1308 msgid "A string for the fully-qualified name of the module." msgstr "" #: library/importlib.rst:1312 msgid "(``__loader__``)" msgstr "" #: library/importlib.rst:1314 msgid "" "The :term:`Loader ` that should be used when loading the module. :" "term:`Finders ` should always set this." msgstr "" #: library/importlib.rst:1319 msgid "(``__file__``)" msgstr "" #: library/importlib.rst:1321 msgid "" "Name of the place from which the module is loaded, e.g. \"builtin\" for " "built-in modules and the filename for modules loaded from source. Normally " "\"origin\" should be set, but it may be ``None`` (the default) which " "indicates it is unspecified (e.g. for namespace packages)." msgstr "" #: library/importlib.rst:1328 msgid "(``__path__``)" msgstr "" #: library/importlib.rst:1330 msgid "" "List of strings for where to find submodules, if a package (``None`` " "otherwise)." msgstr "" #: library/importlib.rst:1335 msgid "" "Container of extra module-specific data for use during loading (or ``None``)." msgstr "" #: library/importlib.rst:1340 msgid "(``__cached__``)" msgstr "" #: library/importlib.rst:1342 msgid "String for where the compiled module should be stored (or ``None``)." msgstr "" #: library/importlib.rst:1346 msgid "(``__package__``)" msgstr "" #: library/importlib.rst:1348 msgid "" "(Read-only) The fully-qualified name of the package under which the module " "should be loaded as a submodule (or the empty string for top-level modules). " "For packages, it is the same as :attr:`__name__`." msgstr "" #: library/importlib.rst:1354 msgid "" "Boolean indicating whether or not the module's \"origin\" attribute refers " "to a loadable location." msgstr "" #: library/importlib.rst:1358 msgid ":mod:`importlib.util` -- Utility code for importers" msgstr "" #: library/importlib.rst:1364 msgid "**Source code:** :source:`Lib/importlib/util.py`" msgstr "" #: library/importlib.rst:1368 msgid "" "This module contains the various objects that help in the construction of " "an :term:`importer`." msgstr "" #: library/importlib.rst:1373 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:1380 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:1387 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:1397 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:1405 msgid "" "The *optimization* parameter was added and the *debug_override* parameter " "was deprecated." msgstr "" #: library/importlib.rst:1425 library/importlib.rst:1569 msgid "Accepts a :term:`path-like object`." msgstr "Accepte un :term:`path-like object`." #: library/importlib.rst:1415 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:1430 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:1438 msgid "Resolve a relative module name to an absolute one." msgstr "" #: library/importlib.rst:1440 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:1445 msgid "" ":exc:`ValueError` is raised if **name** is a relative module name but " "package is a false value (e.g. ``None`` or the empty string). :exc:" "`ValueError` is also raised a relative name would escape its containing " "package (e.g. requesting ``..bacon`` from within the ``spam`` package)." msgstr "" #: library/importlib.rst:1454 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:1461 msgid "" "If **name** is for a submodule (contains a dot), the parent module is " "automatically imported." msgstr "" #: library/importlib.rst:1464 msgid "**name** and **package** work the same as for :func:`import_module`." msgstr "" #: library/importlib.rst:1468 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:1475 msgid "" "Create a new module based on **spec** and :meth:`spec.loader.create_module " "`." msgstr "" #: library/importlib.rst:1478 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:1483 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:1491 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:1500 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:1508 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:1513 msgid "" ":attr:`__loader__` and :attr:`__package__` are automatically set (when " "possible)." msgstr "" #: library/importlib.rst:1517 msgid "" "Set :attr:`__name__`, :attr:`__loader__` :attr:`__package__` unconditionally " "to support reloading." msgstr "" #: library/importlib.rst:1521 msgid "" "The import machinery now directly performs all the functionality provided by " "this function." msgstr "" #: library/importlib.rst:1527 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:1534 msgid "" "Set ``__loader__`` if set to ``None``, as if the attribute does not exist." msgstr "" #: library/importlib.rst:1547 msgid "The import machinery takes care of this automatically." msgstr "" #: library/importlib.rst:1543 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:1552 msgid "" "A factory function for creating a :class:`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:1562 msgid "" "A factory function for creating a :class:`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:1574 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:1582 msgid "" "A class which postpones the execution of the loader of a module until the " "module has an attribute accessed." msgstr "" #: library/importlib.rst:1585 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:1596 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:1604 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:1611 msgid "" "A static 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:1624 msgid "Examples" msgstr "Exemples" #: library/importlib.rst:1627 msgid "Importing programmatically" msgstr "" #: library/importlib.rst:1629 msgid "" "To programmatically import a module, use :func:`importlib.import_module`. ::" msgstr "" #: library/importlib.rst:1638 msgid "Checking if a module can be imported" msgstr "" #: library/importlib.rst:1640 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:1663 msgid "Importing a source file directly" msgstr "" #: library/importlib.rst:1665 msgid "" "To import a Python source file directly, use the following recipe (Python " "3.5 and newer only)::" msgstr "" #: library/importlib.rst:1684 msgid "Setting up an importer" msgstr "" #: library/importlib.rst:1686 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:1718 msgid "Approximating :func:`importlib.import_module`" msgstr "" #: library/importlib.rst:1720 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` (Python 3.4 " "and newer for the importlib usage, Python 3.6 and newer for other parts of " "the code). ::" msgstr ""