imp.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-03-19 11:16+0100\n"
"PO-Revision-Date: 2021-08-04 21:33+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language: es_AR\n"
"Language-Team: \n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.8.0\n"
"X-Generator: Poedit 3.0\n"

#: ../Doc/library/imp.rst:2
msgid ":mod:`imp` --- Access the :ref:`import <importsystem>` internals"
msgstr ":mod:`imp` --- Acceda a :ref:`import <importsystem>` internamente"

#: ../Doc/library/imp.rst:8
msgid "**Source code:** :source:`Lib/imp.py`"
msgstr "**Código fuente:** :source:`Lib/imp.py`"

#: ../Doc/library/imp.rst:10
msgid "The :mod:`imp` module is deprecated in favor of :mod:`importlib`."
msgstr "El módulo :mod:`imp` está obsoleto en favor de :mod:`importlib`."

#: ../Doc/library/imp.rst:17
msgid ""
"This module provides an interface to the mechanisms used to implement the :"
"keyword:`import` statement.  It defines the following constants and "
"functions:"
msgstr ""
"Este módulo proporciona una interfaz a los mecanismos utilizados para "
"implementar la sentencia :keyword:`import`.  Define las siguientes "
"constantes y funciones:"

#: ../Doc/library/imp.rst:25
msgid ""
"Return the magic string value used to recognize byte-compiled code files (:"
"file:`.pyc` files).  (This value may be different for each Python version.)"
msgstr ""
"Retorna el valor de la cadena de caracteres mágica que se utiliza para "
"reconocer archivos de código compilados por bytes (archivos :file:`.pyc`). "
"(Este valor puede ser diferente para cada versión de Python)."

#: ../Doc/library/imp.rst:28
msgid "Use :attr:`importlib.util.MAGIC_NUMBER` instead."
msgstr "Utilice :attr:`importlib.util.MAGIC_NUMBER` en su lugar."

#: ../Doc/library/imp.rst:34
msgid ""
"Return a list of 3-element tuples, each describing a particular type of "
"module. Each triple has the form ``(suffix, mode, type)``, where *suffix* is "
"a string to be appended to the module name to form the filename to search "
"for, *mode* is the mode string to pass to the built-in :func:`open` function "
"to open the file (this can be ``'r'`` for text files or ``'rb'`` for binary "
"files), and *type* is the file type, which has one of the values :const:"
"`PY_SOURCE`, :const:`PY_COMPILED`, or :const:`C_EXTENSION`, described below."
msgstr ""
"Retorna una lista de tuplas de 3 elementos, cada una de las cuales describe "
"un tipo particular de módulo. Cada triple tiene la forma ``(suffix, mode, "
"type)``, donde *suffix* es una cadena de caracteres que se agregará al "
"nombre del módulo para formar el nombre de archivo a buscar, *mode* es la "
"cadena de caracteres de modo para pasar a la función incorporada :func:"
"`open` para abrir el archivo (esto puede ser ``'r'`` para archivos de texto "
"o ``'rb'`` para archivos binarios), y *type* es el tipo de archivo, que "
"tiene uno de los valores :const:`PY_SOURCE`, :const:`PY_COMPILED`, o :const:"
"`C_EXTENSION`, que se describen a continuación."

#: ../Doc/library/imp.rst:43
msgid "Use the constants defined on :mod:`importlib.machinery` instead."
msgstr ""
"Utilice las constantes definidas en :mod:`importlib.machinery` en su lugar."

#: ../Doc/library/imp.rst:49
msgid ""
"Try to find the module *name*.  If *path* is omitted or ``None``, the list "
"of directory names given by ``sys.path`` is searched, but first a few "
"special places are searched: the function tries to find a built-in module "
"with the given name (:const:`C_BUILTIN`), then a frozen module (:const:"
"`PY_FROZEN`), and on some systems some other places are looked in as well "
"(on Windows, it looks in the registry which may point to a specific file)."
msgstr ""
"Intente encontrar el módulo *name*.  Si se omite *path* o ``None``, se busca "
"la lista de nombres de directorio dados por ``sys.path``, pero primero se "
"buscan algunos lugares especiales: la función intenta encontrar un módulo "
"integrado con el nombre dado (:const:`C_BUILTIN`), a continuación, un módulo "
"congelado (:const:`PY_FROZEN`), y en algunos sistemas algunos otros lugares "
"se buscan también (en Windows, se ve en el registro que puede apuntar a un "
"archivo específico)."

#: ../Doc/library/imp.rst:56
msgid ""
"Otherwise, *path* must be a list of directory names; each directory is "
"searched for files with any of the suffixes returned by :func:`get_suffixes` "
"above.  Invalid names in the list are silently ignored (but all list items "
"must be strings)."
msgstr ""
"De lo contrario, *path* debe ser una lista de nombres de directorio; cada "
"directorio se busca archivos con cualquiera de los sufijos retornados por :"
"func:`get_suffixes` arriba.  Los nombres no válidos de la lista se omiten "
"silenciosamente (pero todos los elementos de lista deben ser cadenas)."

#: ../Doc/library/imp.rst:61
msgid ""
"If search is successful, the return value is a 3-element tuple ``(file, "
"pathname, description)``:"
msgstr ""
"Si la búsqueda se realiza correctamente, el valor retornado es una tupla de "
"3 elementos ``(file, pathname, description)``:"

#: ../Doc/library/imp.rst:64
msgid ""
"*file* is an open :term:`file object` positioned at the beginning, "
"*pathname* is the pathname of the file found, and *description* is a 3-"
"element tuple as contained in the list returned by :func:`get_suffixes` "
"describing the kind of module found."
msgstr ""
"*file* es un abierto :term:`file object` posicionado al principio, "
"*pathname* es el nombre de ruta del archivo encontrado, y *description* es "
"una tupla de 3 elementos tal como se encuentra en la lista retornada por :"
"func:`get_suffixes` que describe el tipo de módulo encontrado."

#: ../Doc/library/imp.rst:69
msgid ""
"If the module is built-in or frozen then *file* and *pathname* are both "
"``None`` and the *description* tuple contains empty strings for its suffix "
"and mode; the module type is indicated as given in parentheses above.  If "
"the search is unsuccessful, :exc:`ImportError` is raised.  Other exceptions "
"indicate problems with the arguments or environment."
msgstr ""
"Si el módulo no vive en un archivo, el archivo *file* retornado es ``None``, "
"*pathname* es la cadena vacía y la tupla *description* contiene cadenas "
"vacías para su sufijo y modo; el tipo de módulo se indica como se indica "
"entre paréntesis arriba.  Si la búsqueda no se realiza correctamente, se "
"provoca :exc:`ImportError`.  Otras excepciones indican problemas con los "
"argumentos o el entorno."

#: ../Doc/library/imp.rst:75
msgid ""
"If the module is a package, *file* is ``None``, *pathname* is the package "
"path and the last item in the *description* tuple is :const:`PKG_DIRECTORY`."
msgstr ""
"Si el módulo es un paquete, *file* es ``None``, *pathname* es la ruta de "
"acceso del paquete y el último elemento de la tupla *description* es :const:"
"`PKG_DIRECTORY`."

#: ../Doc/library/imp.rst:78
msgid ""
"This function does not handle hierarchical module names (names containing "
"dots).  In order to find *P.M*, that is, submodule *M* of package *P*, use :"
"func:`find_module` and :func:`load_module` to find and load package *P*, and "
"then use :func:`find_module` with the *path* argument set to ``P.__path__``. "
"When *P* itself has a dotted name, apply this recipe recursively."
msgstr ""
"Esta función no controla los nombres de módulo jerárquico (nombres que "
"contienen puntos).  Para encontrar *P.M*, es decir, submódulo *M* del "
"paquete *P*, use :func:`find_module` y :func:`load_module` para buscar y "
"cargar el paquete *P*, y luego use :func:`find_module` con el argumento "
"*path* establecido en ``P.__path__``. Cuando *P* tenga un nombre punteado, "
"aplique esta receta de forma recursiva."

#: ../Doc/library/imp.rst:84
msgid ""
"Use :func:`importlib.util.find_spec` instead unless Python 3.3 compatibility "
"is required, in which case use :func:`importlib.find_loader`. For example "
"usage of the former case, see the :ref:`importlib-examples` section of the :"
"mod:`importlib` documentation."
msgstr ""
"Utilice :func:`importlib.util.find_spec` en su lugar a menos que se requiera "
"compatibilidad con Python 3.3, en cuyo caso use :func:`importlib."
"find_loader`. Para ver el uso del caso anterior, consulte la sección :ref:"
"`importlib-examples` de la documentación :mod:`importlib`."

#: ../Doc/library/imp.rst:94
msgid ""
"Load a module that was previously found by :func:`find_module` (or by an "
"otherwise conducted search yielding compatible results).  This function does "
"more than importing the module: if the module was already imported, it will "
"reload the module!  The *name* argument indicates the full module name "
"(including the package name, if this is a submodule of a package).  The "
"*file* argument is an open file, and *pathname* is the corresponding file "
"name; these can be ``None`` and ``''``, respectively, when the module is a "
"package or not being loaded from a file.  The *description* argument is a "
"tuple, as would be returned by :func:`get_suffixes`, describing what kind of "
"module must be loaded."
msgstr ""
"Cargue un módulo que fue encontrado anteriormente por :func:`find_module` (o "
"por una búsqueda realizada de otro modo que produce resultados "
"compatibles).  Esta función hace más que importar el módulo: si el módulo ya "
"estaba importado, se recargará el módulo!  El argumento *name* indica el "
"nombre completo del módulo (incluido el nombre del paquete, si se trata de "
"un submódulo de un paquete).  El argumento *file* es un archivo abierto y "
"*pathname* es el nombre de archivo correspondiente; pueden ser ``None`` y "
"``''``, respectivamente, cuando el módulo es un paquete o no se carga desde "
"un archivo.  El argumento *description* es una tupla, como sería retornada "
"por :func:`get_suffixes`, que describe qué tipo de módulo se debe cargar."

#: ../Doc/library/imp.rst:105
msgid ""
"If the load is successful, the return value is the module object; otherwise, "
"an exception (usually :exc:`ImportError`) is raised."
msgstr ""
"Si la carga se realiza correctamente, el valor retornado es el objeto "
"modulo; de lo contrario, se produce una excepción (normalmente :exc:"
"`ImportError`)."

#: ../Doc/library/imp.rst:108
msgid ""
"**Important:** the caller is responsible for closing the *file* argument, if "
"it was not ``None``, even when an exception is raised.  This is best done "
"using a :keyword:`try` ... :keyword:`finally` statement."
msgstr ""
"**Importante:** el autor de la llamada es responsable de cerrar el argumento "
"*file*, si no era ``None``, incluso cuando se genera una excepción.  Esto se "
"hace mejor usando una declaración :keyword:`try` ... :keyword:`finally`."

#: ../Doc/library/imp.rst:112
msgid ""
"If previously used in conjunction with :func:`imp.find_module` then consider "
"using :func:`importlib.import_module`, otherwise use the loader returned by "
"the replacement you chose for :func:`imp.find_module`. If you called :func:"
"`imp.load_module` and related functions directly with file path arguments "
"then use a combination of :func:`importlib.util.spec_from_file_location` "
"and :func:`importlib.util.module_from_spec`. See the :ref:`importlib-"
"examples` section of the :mod:`importlib` documentation for details of the "
"various approaches."
msgstr ""
"Si se utiliza anteriormente junto con :func:`imp.find_module` considere "
"usar :func:`importlib.import_module`, de lo contrario utilice el cargador "
"retornado por el reemplazo que eligió para :func:`imp.find_module`. Si llamó "
"a :func:`imp.load_module` y funciones relacionadas directamente con "
"argumentos de ruta de archivo, utilice una combinación de :func:`importlib."
"util.spec_from_file_location` y :func:`importlib.util.module_from_spec`. "
"Consulte la sección :ref:`importlib-examples` de la documentación :mod:"
"`importlib` para obtener más información sobre los distintos enfoques."

#: ../Doc/library/imp.rst:126
msgid ""
"Return a new empty module object called *name*.  This object is *not* "
"inserted in ``sys.modules``."
msgstr ""
"Retorna un nuevo objeto de módulo vacío denominado *name*.  Este objeto es "
"*not* insertado en ``sys.modules``."

#: ../Doc/library/imp.rst:129
msgid "Use :func:`importlib.util.module_from_spec` instead."
msgstr "Utilice :func:`importlib.util.module_from_spec` en su lugar."

#: ../Doc/library/imp.rst:135
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 (the same as the *module* argument)."
msgstr ""
"Vuelva a cargar un *módulo* importado anteriormente.  El argumento debe ser "
"un objeto module, por lo que debe haberse importado correctamente antes.  "
"Esto es útil si ha editado el archivo de origen del módulo utilizando un "
"editor externo y desea probar la nueva versión sin salir del intérprete de "
"Python.  El valor retornado es el objeto module (el mismo que el argumento "
"*module*)."

#: ../Doc/library/imp.rst:141
msgid "When ``reload(module)`` is executed:"
msgstr "Cuando se ejecuta ``reload(module)``:"

#: ../Doc/library/imp.rst:143
msgid ""
"Python modules' code is recompiled and the module-level code reexecuted, "
"defining a new set of objects which are bound to names in the module's "
"dictionary.  The ``init`` function of extension modules is not called a "
"second time."
msgstr ""
"El código de los módulos de Python se vuelve a compilar y se vuelve a "
"ejecutar el código de nivel de módulo, definiendo un nuevo conjunto de "
"objetos que están enlazados a nombres en el diccionario del módulo.  La "
"función ``init`` de los módulos de extensión no se llama una segunda vez."

#: ../Doc/library/imp.rst:148
msgid ""
"As with all other objects in Python the old objects are only reclaimed after "
"their reference counts drop to zero."
msgstr ""
"Al igual que con todos los demás objetos de Python, los objetos antiguos "
"solo se recuperan después de que sus recuentos de referencia caigan a cero."

#: ../Doc/library/imp.rst:151
msgid ""
"The names in the module namespace are updated to point to any new or changed "
"objects."
msgstr ""
"Los nombres del espacio de nombres del módulo se actualizan para que apunten "
"a cualquier objeto nuevo o modificado."

#: ../Doc/library/imp.rst:154
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 ""
"Otras referencias a los objetos antiguos (como nombres externos al módulo) "
"no se rebotan para hacer referencia a los nuevos objetos y deben "
"actualizarse en cada espacio de nombres donde se producen si se desea."

#: ../Doc/library/imp.rst:158
msgid "There are a number of other caveats:"
msgstr "Hay una serie de otras advertencias:"

#: ../Doc/library/imp.rst:160
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 ""
"Cuando se vuelve a cargar un módulo, se conserva su diccionario (que "
"contiene las variables globales del módulo).  Las redefiniciones de nombres "
"invalidarán las definiciones antiguas, por lo que esto generalmente no es un "
"problema.  Si la nueva versión de un módulo no define un nombre previamente "
"definido, la definición anterior permanece.  Esta característica se puede "
"utilizar en beneficio del módulo si mantiene una tabla global o caché de "
"objetos --- con una instrucción :keyword:`try` puede probar la presencia de "
"la tabla y omitir su inicialización si se desea:"

#: ../Doc/library/imp.rst:173
msgid ""
"It is legal though generally not very useful to reload built-in or "
"dynamically loaded modules, except for :mod:`sys`, :mod:`__main__` and :mod:"
"`builtins`. In many cases, however, extension modules are not designed to be "
"initialized more than once, and may fail in arbitrary ways when reloaded."
msgstr ""
"Es legal, aunque generalmente no es muy útil para recargar módulos "
"incorporados o cargados dinámicamente, excepto para :mod:`sys`, :mod:"
"`__main__` y :mod:`builtins`. En muchos casos, sin embargo, los módulos de "
"extensión no están diseñados para inicializarse más de una vez y pueden "
"fallar de forma arbitraria cuando se vuelven a cargar."

#: ../Doc/library/imp.rst:178
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 ""
"Si un módulo importa objetos de otro módulo utilizando :keyword:`from`... :"
"keyword:`import` ..., llamando a :func:`reload` para el otro módulo no "
"redefine los objetos importados de él --- de una manera alrededor de esto es "
"volver a ejecutar la sentencia :keyword:`!from`, otra es usar :keyword:`!"
"import` y nombres calificados (*module*.*name*) en su lugar."

#: ../Doc/library/imp.rst:184
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 ""
"Si un módulo crea instancias de una clase, volver a cargar el módulo que "
"define la clase no afecta a las definiciones de método de las instancias --- "
"siguen utilizando la definición de clase antigua.  Lo mismo es cierto para "
"las clases derivadas."

#: ../Doc/library/imp.rst:188
msgid ""
"Relies on both ``__name__`` and ``__loader__`` being defined on the module "
"being reloaded instead of just ``__name__``."
msgstr ""
"Se basa en que tanto ``__name__`` como ``__loader__`` que se definen en el "
"módulo que se está recargando en lugar de simplemente ``__name__``."

#: ../Doc/library/imp.rst:192
msgid "Use :func:`importlib.reload` instead."
msgstr "Utilice :func:`importlib.reload` en su lugar."

#: ../Doc/library/imp.rst:196
msgid ""
"The following functions are conveniences for handling :pep:`3147` byte-"
"compiled file paths."
msgstr ""
"Las siguientes funciones son comodidades para controlar las rutas de acceso "
"de archivo :pep:`3147` compiladas en bytes."

#: ../Doc/library/imp.rst:203
msgid ""
"Return the :pep:`3147` 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). By passing in ``True`` or ``False`` "
"for *debug_override* you can override the system's value for ``__debug__``, "
"leading to optimized bytecode."
msgstr ""
"Retorna la ruta de acceso :pep:`3147` al archivo compilado por bytes "
"asociado con la ruta *path* de origen. Por ejemplo, si *path* es ``/foo/bar/"
"baz.py`` el valor retornado sería ``/foo/bar/__pycache__/baz.cpython-32."
"pyc`` para Python 3.2. La cadena ``cpython-32`` proviene de la etiqueta "
"mágica actual (consulte :func:`get_tag`; si :attr:`sys.implementation."
"cache_tag` no está definida entonces :exc:`NotImplementedError` se "
"generará). Al pasar ``True`` o ``False`` para *debug_override* puede "
"reemplazar el valor del sistema para ``__debug__``, lo que da lugar a un "
"código de bytes optimizado."

#: ../Doc/library/imp.rst:212
msgid "*path* need not exist."
msgstr "*ruta* no necesita existir."

#: ../Doc/library/imp.rst:214
msgid ""
"If :attr:`sys.implementation.cache_tag` is ``None``, then :exc:"
"`NotImplementedError` is raised."
msgstr ""
"Lanza :exc:`NotImplementedError` cuando no se define :attr:`sys."
"implementation.cache_tag`."

#: ../Doc/library/imp.rst:218
msgid "Use :func:`importlib.util.cache_from_source` instead."
msgstr "Utilice :func:`importlib.util.source_from_cache` en su lugar."

#: ../Doc/library/imp.rst:221
msgid "The *debug_override* parameter no longer creates a ``.pyo`` file."
msgstr "El parámetro *debug_override* ya no crea un archivo ``.pyo``."

#: ../Doc/library/imp.rst:227
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` format, a :exc:"
"`ValueError` is raised. If :attr:`sys.implementation.cache_tag` is not "
"defined, :exc:`NotImplementedError` is raised."
msgstr ""
"Dada la ruta *path* a un nombre de archivo :pep:`3147`, retorne la ruta de "
"acceso del archivo de código fuente asociada.  Por ejemplo, si *path* es ``/"
"foo/bar/__pycache__/baz.cpython-32.pyc`` la ruta retornada sería ``/foo/bar/"
"baz.py``.  *path* no necesita existir, sin embargo, si no se ajusta al "
"formato :pep:`3147`, se genera un :exc:`ValueError`. Si :attr:`sys."
"implementation.cache_tag` no está definido, se genera :exc:"
"`NotImplementedError`."

#: ../Doc/library/imp.rst:235
msgid ""
"Raise :exc:`NotImplementedError` when :attr:`sys.implementation.cache_tag` "
"is not defined."
msgstr ""
"Provoca :exc:`NotImplementedError` cuando no se define :attr:`sys."
"implementation.cache_tag`."

#: ../Doc/library/imp.rst:239
msgid "Use :func:`importlib.util.source_from_cache` instead."
msgstr "Utilice :func:`importlib.util.source_from_cache` en su lugar."

#: ../Doc/library/imp.rst:245
msgid ""
"Return the :pep:`3147` magic tag string matching this version of Python's "
"magic number, as returned by :func:`get_magic`."
msgstr ""
"Retorna la cadena de etiqueta mágica :pep:`3147` que coincida con esta "
"versión del número mágico de Python, como lo retorna :func:`get_magic`."

#: ../Doc/library/imp.rst:248
msgid ""
"Use :attr:`sys.implementation.cache_tag` directly starting in Python 3.3."
msgstr ""
"Utilice :attr:`sys.implementation.cache_tag` directamente a partir de Python "
"3.3."

#: ../Doc/library/imp.rst:253
msgid ""
"The following functions help interact with the import system's internal "
"locking mechanism.  Locking semantics of imports are an implementation "
"detail which may vary from release to release.  However, Python ensures that "
"circular imports work without any deadlocks."
msgstr ""
"Las siguientes funciones ayudan a interactuar con el mecanismo de bloqueo "
"interno del sistema de importación.  La semántica de bloqueo de las "
"importaciones es un detalle de implementación que puede variar de una "
"versión a una.  Sin embargo, Python garantiza que las importaciones "
"circulares funcionen sin interbloqueos."

#: ../Doc/library/imp.rst:261
msgid ""
"Return ``True`` if the global import lock is currently held, else ``False``. "
"On platforms without threads, always return ``False``."
msgstr ""
"Retorna ``True`` si el bloqueo de importación global está actualmente "
"retenido, de lo contrario, ``False``. En plataformas sin hilos, siempre "
"retorna ``False``."

#: ../Doc/library/imp.rst:264
msgid ""
"On platforms with threads, a thread executing an import first holds a global "
"import lock, then sets up a per-module lock for the rest of the import.  "
"This blocks other threads from importing the same module until the original "
"import completes, preventing other threads from seeing incomplete module "
"objects constructed by the original thread.  An exception is made for "
"circular imports, which by construction have to expose an incomplete module "
"object at some point."
msgstr ""
"En plataformas con subprocesos, un subproceso que ejecuta una importación "
"primero contiene un bloqueo de importación global y, a continuación, "
"configura un bloqueo por módulo para el resto de la importación.  Esto "
"impide que otros subprocesos importen el mismo módulo hasta que se complete "
"la importación original, lo que impide que otros subprocesos vean objetos de "
"módulo incompletos construidos por el subproceso original.  Se hace una "
"excepción para las importaciones circulares, que por construcción tienen que "
"exponer un objeto de módulo incompleto en algún momento."

#: ../Doc/library/imp.rst:272 ../Doc/library/imp.rst:292
#: ../Doc/library/imp.rst:305
msgid ""
"The locking scheme has changed to per-module locks for the most part.  A "
"global import lock is kept for some critical tasks, such as initializing the "
"per-module locks."
msgstr ""
"El esquema de bloqueo ha cambiado a bloqueos por módulo en su mayor parte.  "
"Se mantiene un bloqueo de importación global para algunas tareas críticas, "
"como la inicialización de los bloqueos por módulo."

#: ../Doc/library/imp.rst:282
msgid ""
"Acquire the interpreter's global import lock for the current thread. This "
"lock should be used by import hooks to ensure thread-safety when importing "
"modules."
msgstr ""
"Adquiera el bloqueo de importación global del intérprete para el subproceso "
"actual. Este bloqueo debe ser utilizado por los ganchos de importación para "
"garantizar la seguridad de subprocesos al importar módulos."

#: ../Doc/library/imp.rst:286
msgid ""
"Once a thread has acquired the import lock, the same thread may acquire it "
"again without blocking; the thread must release it once for each time it has "
"acquired it."
msgstr ""
"Una vez que un subproceso ha adquirido el bloqueo de importación, el mismo "
"subproceso puede adquirirlo de nuevo sin bloquear; el subproceso debe "
"liberarlo una vez por cada vez que lo ha adquirido."

#: ../Doc/library/imp.rst:290
msgid "On platforms without threads, this function does nothing."
msgstr "En plataformas sin subprocesos, esta función no hace nada."

#: ../Doc/library/imp.rst:302
msgid ""
"Release the interpreter's global import lock. On platforms without threads, "
"this function does nothing."
msgstr ""
"Suelte el bloqueo de importación global del intérprete. En plataformas sin "
"subprocesos, esta función no hace nada."

#: ../Doc/library/imp.rst:313
msgid ""
"The following constants with integer values, defined in this module, are "
"used to indicate the search result of :func:`find_module`."
msgstr ""
"Las siguientes constantes con valores enteros, definidas en este módulo, se "
"utilizan para indicar el resultado de búsqueda de :func:`find_module`."

#: ../Doc/library/imp.rst:319
msgid "The module was found as a source file."
msgstr "El módulo se encontró como un archivo de origen."

#: ../Doc/library/imp.rst:326
msgid "The module was found as a compiled code object file."
msgstr "El módulo se encontró como un archivo de objeto de código compilado."

#: ../Doc/library/imp.rst:333
msgid "The module was found as dynamically loadable shared library."
msgstr ""
"El módulo se encontró como biblioteca compartida cargable dinámicamente."

#: ../Doc/library/imp.rst:340
msgid "The module was found as a package directory."
msgstr "El módulo se encontró como un directorio de paquetes."

#: ../Doc/library/imp.rst:347
msgid "The module was found as a built-in module."
msgstr "El módulo fue encontrado como un módulo incorporado."

#: ../Doc/library/imp.rst:354
msgid "The module was found as a frozen module."
msgstr "El módulo fue encontrado como un módulo congelado."

#: ../Doc/library/imp.rst:361
msgid ""
"The :class:`NullImporter` type is a :pep:`302` import hook that handles non-"
"directory path strings by failing to find any modules.  Calling this type "
"with an existing directory or empty string raises :exc:`ImportError`. "
"Otherwise, a :class:`NullImporter` instance is returned."
msgstr ""
"El tipo :class:`NullImporter` es un enlace de importación :pep:`302` que "
"controla cadenas de ruta de acceso que no son de directorio al no encontrar "
"ningún módulo.  Llamar a este tipo con un directorio existente o una cadena "
"vacía genera :exc:`ImportError`. De lo contrario, se retorna una instancia :"
"class:`NullImporter`."

#: ../Doc/library/imp.rst:366
msgid "Instances have only one method:"
msgstr "Las instancias solo tienen un método:"

#: ../Doc/library/imp.rst:370
msgid ""
"This method always returns ``None``, indicating that the requested module "
"could not be found."
msgstr ""
"Este método siempre retorna ``None``, lo que indica que no se pudo encontrar "
"el módulo solicitado."

#: ../Doc/library/imp.rst:373
msgid ""
"``None`` is inserted into ``sys.path_importer_cache`` instead of an instance "
"of :class:`NullImporter`."
msgstr ""
"``None`` se inserta en ``sys.path_importer_cache`` en lugar de una instancia "
"de :class:`NullImporter`."

#: ../Doc/library/imp.rst:377
msgid "Insert ``None`` into ``sys.path_importer_cache`` instead."
msgstr "Inserte ``None`` en ``sys.path_importer_cache`` en su lugar."

#: ../Doc/library/imp.rst:384
msgid "Examples"
msgstr "Ejemplos"

#: ../Doc/library/imp.rst:386
msgid ""
"The following function emulates what was the standard import statement up to "
"Python 1.4 (no hierarchical module names).  (This *implementation* wouldn't "
"work in that version, since :func:`find_module` has been extended and :func:"
"`load_module` has been added in 1.4.) ::"
msgstr ""
"La siguiente función emula lo que era la instrucción de importación estándar "
"hasta Python 1.4 (sin nombres de módulo jerárquico).  (Esta *implementación* "
"no funcionaría en esa versión, ya que :func:`find_module` se ha ampliado y :"
"func:`load_module` se ha añadido en 1.4.) ::"