multiprocessing.shared_memory.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python en Español
# package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2020.
#
msgid ""
msgstr ""
"Project-Id-Version: Python en Español 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2021-11-08 22:08-0300\n"
"Last-Translator: \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.13.0\n"

#: ../Doc/library/multiprocessing.shared_memory.rst:2
msgid ""
":mod:`multiprocessing.shared_memory` --- Shared memory for direct access "
"across processes"
msgstr ""
":mod:`multiprocessing.shared_memory` --- Memoria compartida para acceso "
"directo a través de procesos"

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

#: ../Doc/library/multiprocessing.shared_memory.rst:18
msgid ""
"This module provides a class, :class:`SharedMemory`, for the allocation and "
"management of shared memory to be accessed by one or more processes on a "
"multicore or symmetric multiprocessor (SMP) machine.  To assist with the "
"life-cycle management of shared memory especially across distinct processes, "
"a :class:`~multiprocessing.managers.BaseManager` subclass, :class:"
"`SharedMemoryManager`, is also provided in the ``multiprocessing.managers`` "
"module."
msgstr ""
"Este módulo proporciona una clase, :class:`SharedMemory`, para la asignación "
"y administración de memoria compartida entre uno o más procesos en una "
"máquina con varios núcleos o varios procesadores simétrico (SMP). Para "
"facilitar la gestión del ciclo de vida de la memoria compartida, "
"especialmente entre múltiples procesos, el módulo ``multiprocessing."
"managers`` también proporciona la clase :class:`SharedMemoryManager`, una "
"subclase de :class:`~multiprocessing.managers.BaseManager`."

#: ../Doc/library/multiprocessing.shared_memory.rst:26
msgid ""
"In this module, shared memory refers to \"System V style\" shared memory "
"blocks (though is not necessarily implemented explicitly as such) and does "
"not refer to \"distributed shared memory\".  This style of shared memory "
"permits distinct processes to potentially read and write to a common (or "
"shared) region of volatile memory.  Processes are conventionally limited to "
"only have access to their own process memory space but shared memory permits "
"the sharing of data between processes, avoiding the need to instead send "
"messages between processes containing that data.  Sharing data directly via "
"memory can provide significant performance benefits compared to sharing data "
"via disk or socket or other communications requiring the serialization/"
"deserialization and copying of data."
msgstr ""
"En este módulo, la memoria compartida se refiere a bloques de memoria "
"compartida de \"Sistema estilo V\" (aunque no necesariamente se implementa "
"explícitamente como tal) y no se refiere a \"memoria compartida "
"distribuida\". Este tipo de memoria compartida permite que múltiples "
"procesos lean y escriban en un área común (o compartida) de memoria volátil. "
"Normalmente, los procesos solo tienen acceso a su propio espacio de memoria; "
"la memoria compartida permite compartir datos entre procesos, lo que evita "
"que tengan que enviar estos datos por mensaje. Compartir datos directamente "
"a través de la memoria puede proporcionar importantes beneficios de "
"rendimiento en comparación con compartir datos a través de un disco o socket "
"u otras comunicaciones que requieren la serialización/deserialización y "
"copia de datos."

#: ../Doc/library/multiprocessing.shared_memory.rst:41
msgid ""
"Creates a new shared memory block or attaches to an existing shared memory "
"block.  Each shared memory block is assigned a unique name. In this way, one "
"process can create a shared memory block with a particular name and a "
"different process can attach to that same shared memory block using that "
"same name."
msgstr ""
"Crea un nuevo bloque de memoria compartida o guarda un bloque ya existente. "
"Se debe dar un nombre único a cada bloque de memoria compartida; por lo "
"tanto, un proceso puede crear un nuevo bloque de memoria compartida con un "
"nombre particular y un proceso diferente se puede conectar a ese mismo "
"bloque de memoria compartida usando ese mismo nombre."

#: ../Doc/library/multiprocessing.shared_memory.rst:47
msgid ""
"As a resource for sharing data across processes, shared memory blocks may "
"outlive the original process that created them.  When one process no longer "
"needs access to a shared memory block that might still be needed by other "
"processes, the :meth:`close()` method should be called. When a shared memory "
"block is no longer needed by any process, the :meth:`unlink()` method should "
"be called to ensure proper cleanup."
msgstr ""
"Como un recurso para compartir datos entre procesos, los bloques de memoria "
"compartida pueden sobrevivir al proceso original que los creó. Cuando un "
"proceso ya no necesita acceso a un bloque de memoria compartida que otros "
"procesos aún podrían necesitar, se debe llamar al método :meth:`close()`. "
"Cuando un proceso ya no necesita un bloque de memoria compartida, se debe "
"llamar al método :meth:`unlink()` para garantizar una limpieza adecuada."

#: ../Doc/library/multiprocessing.shared_memory.rst:54
msgid ""
"*name* is the unique name for the requested shared memory, specified as a "
"string.  When creating a new shared memory block, if ``None`` (the default) "
"is supplied for the name, a novel name will be generated."
msgstr ""
"*name* es el nombre único para la memoria compartida solicitada, "
"especificada como una cadena de caracteres. Al crear un nuevo bloque de "
"memoria compartida, si se proporciona ``None`` (valor por defecto) para el "
"nombre, se generará un nombre nuevo."

#: ../Doc/library/multiprocessing.shared_memory.rst:58
msgid ""
"*create* controls whether a new shared memory block is created (``True``) or "
"an existing shared memory block is attached (``False``)."
msgstr ""
"*create* controla si se crea un nuevo bloque de memoria compartida "
"(``True``) o si se adjunta un bloque de memoria compartida existente "
"(``False``)."

#: ../Doc/library/multiprocessing.shared_memory.rst:61
msgid ""
"*size* specifies the requested number of bytes when creating a new shared "
"memory block.  Because some platforms choose to allocate chunks of memory "
"based upon that platform's memory page size, the exact size of the shared "
"memory block may be larger or equal to the size requested.  When attaching "
"to an existing shared memory block, the ``size`` parameter is ignored."
msgstr ""
"*size* especifica el número solicitado de bytes al crear un nuevo bloque de "
"memoria compartida. Debido a que algunas plataformas eligen asignar "
"fragmentos de memoria en función del tamaño de página de memoria de esa "
"plataforma, el tamaño exacto del bloque de memoria compartida puede ser "
"mayor o igual al tamaño solicitado. Cuando se conecta a un bloque de memoria "
"compartida existente, se ignora el parámetro ``size``."

#: ../Doc/library/multiprocessing.shared_memory.rst:69
msgid ""
"Closes access to the shared memory from this instance.  In order to ensure "
"proper cleanup of resources, all instances should call ``close()`` once the "
"instance is no longer needed.  Note that calling ``close()`` does not cause "
"the shared memory block itself to be destroyed."
msgstr ""
"Cierra el acceso a la memoria compartida desde esta instancia. Para "
"garantizar la limpieza adecuada de los recursos, todas las instancias deben "
"llamar a ``close()`` una vez que la instancia ya no sea necesaria. Tenga en "
"cuenta que llamar a ``close()`` no causa que el bloque de memoria compartida "
"se destruya."

#: ../Doc/library/multiprocessing.shared_memory.rst:77
msgid ""
"Requests that the underlying shared memory block be destroyed.  In order to "
"ensure proper cleanup of resources, ``unlink()`` should be called once (and "
"only once) across all processes which have need for the shared memory "
"block.  After requesting its destruction, a shared memory block may or may "
"not be immediately destroyed and this behavior may differ across platforms.  "
"Attempts to access data inside the shared memory block after ``unlink()`` "
"has been called may result in memory access errors.  Note: the last process "
"relinquishing its hold on a shared memory block may call ``unlink()`` and :"
"meth:`close()` in either order."
msgstr ""
"Solicita que se destruya el bloque de memoria compartida subyacente. Para "
"garantizar la limpieza adecuada de los recursos, se debe llamar a "
"``unlink()`` una vez (y solo una vez) en todos los procesos que necesitan el "
"bloque de memoria compartida. Después de solicitar su destrucción, un bloque "
"de memoria compartida puede o no destruirse de inmediato y este "
"comportamiento puede diferir entre plataformas. Los intentos de acceder a "
"los datos dentro del bloque de memoria compartida después de que se haya "
"llamado a ``unlink()`` pueden provocar errores de acceso a la memoria. Nota: "
"el último proceso para liberar el bloque de memoria compartida puede llamar "
"a ``unlink()`` y :meth:`close()` en cualquier orden."

#: ../Doc/library/multiprocessing.shared_memory.rst:90
msgid "A memoryview of contents of the shared memory block."
msgstr "Un *memoryview* del contenido del bloque de memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:94
msgid "Read-only access to the unique name of the shared memory block."
msgstr ""
"Acceso de solo lectura al nombre único del bloque de memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:98
msgid "Read-only access to size in bytes of the shared memory block."
msgstr ""
"Acceso de solo lectura al tamaño en bytes del bloque de memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:101
msgid ""
"The following example demonstrates low-level use of :class:`SharedMemory` "
"instances::"
msgstr ""
"El siguiente ejemplo muestra el uso de bajo nivel de instancias de :class:"
"`SharedMemory`::"

#: ../Doc/library/multiprocessing.shared_memory.rst:127
msgid ""
"The following example demonstrates a practical use of the :class:"
"`SharedMemory` class with `NumPy arrays <https://numpy.org/>`_, accessing "
"the same ``numpy.ndarray`` from two distinct Python shells:"
msgstr ""
"El siguiente ejemplo demuestra un uso práctico de la clase :class:"
"`SharedMemory` con  `arreglos NumPy <https://www.numpy.org/>`_, accediendo "
"al mismo ``numpy.ndarray`` desde dos shells de Python distintos"

#: ../Doc/library/multiprocessing.shared_memory.rst:181
msgid ""
"A subclass of :class:`~multiprocessing.managers.BaseManager` which can be "
"used for the management of shared memory blocks across processes."
msgstr ""
"Una subclase de :class:`~multiprocessing.managers.BaseManager` que se puede "
"utilizar para la gestión de bloques de memoria compartida en todos los "
"procesos."

#: ../Doc/library/multiprocessing.shared_memory.rst:184
msgid ""
"A call to :meth:`~multiprocessing.managers.BaseManager.start` on a :class:"
"`SharedMemoryManager` instance causes a new process to be started. This new "
"process's sole purpose is to manage the life cycle of all shared memory "
"blocks created through it.  To trigger the release of all shared memory "
"blocks managed by that process, call :meth:`~multiprocessing.managers."
"BaseManager.shutdown()` on the instance. This triggers a :meth:`SharedMemory."
"unlink()` call on all of the :class:`SharedMemory` objects managed by that "
"process and then stops the process itself.  By creating ``SharedMemory`` "
"instances through a ``SharedMemoryManager``, we avoid the need to manually "
"track and trigger the freeing of shared memory resources."
msgstr ""
"Una llamada al método :meth:`~multiprocessing.managers.BaseManager.start` en "
"una instancia de :class:`SharedMemoryManager` hace que se inicie un nuevo "
"proceso. El único propósito de este nuevo proceso es administrar el ciclo de "
"vida de todos los bloques de memoria compartida creados a través de él. Para "
"activar la liberación de todos los bloques de memoria compartida "
"administrados por ese proceso, llama al método :meth:`~multiprocessing."
"managers.BaseManager.shutdown()` en la instancia. Esto desencadena una "
"llamada al método :meth:`SharedMemory.unlink()` en todos los objetos de la "
"clase :class:`SharedMemory` administrados por ese proceso y luego detiene el "
"proceso en sí. Al crear instancias de ``SharedMemory`` a través de un "
"``SharedMemoryManager``, evitamos la necesidad de rastrear manualmente y "
"activar la liberación de recursos de memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:196
msgid ""
"This class provides methods for creating and returning :class:`SharedMemory` "
"instances and for creating a list-like object (:class:`ShareableList`) "
"backed by shared memory."
msgstr ""
"Esta clase proporciona métodos para crear y retornar instancias :class:"
"`SharedMemory` y para crear un objeto de tipo lista (:class:`ShareableList`) "
"basados en memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:200
msgid ""
"Refer to :class:`multiprocessing.managers.BaseManager` for a description of "
"the inherited *address* and *authkey* optional input arguments and how they "
"may be used to connect to an existing ``SharedMemoryManager`` service from "
"other processes."
msgstr ""
"Consulte :class:`multiprocessing.managers.BaseManager` para obtener una "
"descripción de los argumentos heredados opcionales *address* y *authkey* y "
"cómo se deben usar para registrar un servicio ``SharedMemoryManager`` desde "
"otro proceso."

#: ../Doc/library/multiprocessing.shared_memory.rst:207
msgid ""
"Create and return a new :class:`SharedMemory` object with the specified "
"``size`` in bytes."
msgstr ""
"Crea y retorna un nuevo objeto :class:`SharedMemory` con el tamaño ``size`` "
"especificado en bytes."

#: ../Doc/library/multiprocessing.shared_memory.rst:212
msgid ""
"Create and return a new :class:`ShareableList` object, initialized by the "
"values from the input ``sequence``."
msgstr ""
"Crea y retorna un nuevo objeto :class:`ShareableList`, inicializado por los "
"valores de la entrada ``sequence``."

#: ../Doc/library/multiprocessing.shared_memory.rst:216
msgid ""
"The following example demonstrates the basic mechanisms of a :class:"
"`SharedMemoryManager`:"
msgstr ""
"El siguiente ejemplo muestra los mecanismos básicos de :class:"
"`SharedMemoryManager`:"

#: ../Doc/library/multiprocessing.shared_memory.rst:234
msgid ""
"The following example depicts a potentially more convenient pattern for "
"using :class:`SharedMemoryManager` objects via the :keyword:`with` statement "
"to ensure that all shared memory blocks are released after they are no "
"longer needed:"
msgstr ""
"El siguiente ejemplo muestra un patrón más conveniente para usar un objeto :"
"class:`SharedMemoryManager` con la sentencia :keyword:`with` para asegurarse "
"de que todos los bloques de memoria se liberen cuando ya no son necesarios. "
"Esto suele ser más práctico que el ejemplo anterior:"

#: ../Doc/library/multiprocessing.shared_memory.rst:253
msgid ""
"When using a :class:`SharedMemoryManager` in a :keyword:`with` statement, "
"the shared memory blocks created using that manager are all released when "
"the :keyword:`with` statement's code block finishes execution."
msgstr ""
"Cuando se utiliza un :class:`SharedMemoryManager` en una sentencia :keyword:"
"`with`, los bloques de memoria compartida creados por ese administrador se "
"liberan cuando la sentencias dentro del bloque de código :keyword:`with` "
"finaliza la ejecución."

#: ../Doc/library/multiprocessing.shared_memory.rst:260
msgid ""
"Provides a mutable list-like object where all values stored within are "
"stored in a shared memory block.  This constrains storable values to only "
"the ``int`` (signed 64-bit), ``float``, ``bool``, ``str`` (less than 10M "
"bytes each when encoded as utf-8), ``bytes`` (less than 10M bytes each), and "
"``None`` built-in data types.  It also notably differs from the built-in "
"``list`` type in that these lists can not change their overall length (i.e. "
"no append, insert, etc.) and do not support the dynamic creation of new :"
"class:`ShareableList` instances via slicing."
msgstr ""
"Proporciona un objeto mutable similar a una lista donde todos los valores "
"almacenados dentro se guardan en un bloque de memoria compartida. Esto "
"limita los valores que se pueden almacenar a solo los tipos de datos "
"integrados ``int`` (de 64-bits con signo), ``float``, ``bool``, ``str`` "
"(menos de 10M bytes cada uno cuando se codifican como utf-8), ``bytes`` "
"(menos de 10M bytes cada uno) y ``None``. También difiere notablemente del "
"tipo ``list`` integrado en que estas listas no pueden cambiar su longitud "
"total (es decir, no se pueden añadir o insertar elementos) y no admiten la "
"creación dinámica de nuevas instancias de :class:`ShareableList` mediante "
"segmentación."

#: ../Doc/library/multiprocessing.shared_memory.rst:270
msgid ""
"*sequence* is used in populating a new ``ShareableList`` full of values. Set "
"to ``None`` to instead attach to an already existing ``ShareableList`` by "
"its unique shared memory name."
msgstr ""
"*sequence* se utiliza para completar una nueva ``ShareableList`` con "
"valores. Establezca en ``None`` para registrar en su lugar una "
"``ShareableList`` ya existente por su nombre único de memoria compartida."

#: ../Doc/library/multiprocessing.shared_memory.rst:274
msgid ""
"*name* is the unique name for the requested shared memory, as described in "
"the definition for :class:`SharedMemory`.  When attaching to an existing "
"``ShareableList``, specify its shared memory block's unique name while "
"leaving ``sequence`` set to ``None``."
msgstr ""
"*name* es el nombre único para la memoria compartida solicitada, como se "
"describe en la definición de :class:`SharedMemory`. Al adjuntar a una "
"``ShareableList`` existente, especifique el nombre único de su bloque de "
"memoria compartida mientras deja ``sequence`` establecida en ``None``."

#: ../Doc/library/multiprocessing.shared_memory.rst:281
msgid ""
"A known issue exists for :class:`bytes` and :class:`str` values. If they end "
"with ``\\x00`` nul bytes or characters, those may be *silently stripped* "
"when fetching them by index from the :class:`ShareableList`. This ``."
"rstrip(b'\\x00')`` behavior is considered a bug and may go away in the "
"future. See :gh:`106939`."
msgstr ""
"Existe un problema conocido para valores :class:`bytes` y :class:`str`. Si "
"terminan con bytes o caracteres nulos ``\\x00``, éstos pueden ser "
"*eliminados silenciosamente* al obtenerlos por índice desde la :class:"
"`ShareableList`. Este comportamiento ``.rstrip(b'\\x00')`` se considera un "
"error y podría desaparecer en el futuro. Ver :gh:`106939`."

#: ../Doc/library/multiprocessing.shared_memory.rst:287
msgid ""
"For applications where rstripping of trailing nulls is a problem, work "
"around it by always unconditionally appending an extra non-0 byte to the end "
"of such values when storing and unconditionally removing it when fetching:"
msgstr ""
"Para aplicaciones donde eliminar espacios nulos finales es un problema, "
"solucionarlo añadiendo siempre incondicionalmente un byte extra que no sea 0 "
"al final de dichos valores al almacenar y eliminándolo incondicionalmente al "
"recuperarlos."

#: ../Doc/library/multiprocessing.shared_memory.rst:310
msgid "Returns the number of occurrences of ``value``."
msgstr "Retorna el número de ocurrencias de ``value``."

#: ../Doc/library/multiprocessing.shared_memory.rst:314
msgid ""
"Returns first index position of ``value``.  Raises :exc:`ValueError` if "
"``value`` is not present."
msgstr ""
"Retorna la primera posición del índice de ``value``. Lanza :exc:`ValueError` "
"si ``value`` no está presente."

#: ../Doc/library/multiprocessing.shared_memory.rst:319
msgid ""
"Read-only attribute containing the :mod:`struct` packing format used by all "
"currently stored values."
msgstr ""
"Atributo de solo lectura que contiene el formato de empaquetado :mod:"
"`struct` utilizado por todos los valores almacenados actualmente."

#: ../Doc/library/multiprocessing.shared_memory.rst:324
msgid "The :class:`SharedMemory` instance where the values are stored."
msgstr "La instancia de :class:`SharedMemory` donde se almacenan los valores."

#: ../Doc/library/multiprocessing.shared_memory.rst:327
msgid ""
"The following example demonstrates basic use of a :class:`ShareableList` "
"instance:"
msgstr ""
"El siguiente ejemplo muestra el uso básico de una instancia :class:"
"`ShareableList`:"

#: ../Doc/library/multiprocessing.shared_memory.rst:360
msgid ""
"The following example depicts how one, two, or many processes may access the "
"same :class:`ShareableList` by supplying the name of the shared memory block "
"behind it:"
msgstr ""
"El siguiente ejemplo muestra cómo uno, dos o muchos procesos pueden acceder "
"al mismo :class:`ShareableList` al proporcionar el nombre del bloque de "
"memoria compartida detrás de él:"

#: ../Doc/library/multiprocessing.shared_memory.rst:375
msgid ""
"The following examples demonstrates that ``ShareableList`` (and underlying "
"``SharedMemory``) objects can be pickled and unpickled if needed. Note, that "
"it will still be the same shared object. This happens, because the "
"deserialized object has the same unique name and is just attached to an "
"existing object with the same name (if the object is still alive):"
msgstr ""
"El siguiente ejemplo demuestra que los objetos ``ShareableList`` (y de forma "
"implícita ``SharedMemory``) pueden ser serializados (*pickled*) y "
"deserializados (*unpickled*) si es que se necesitan. Nota, Este va a seguir "
"siendo el mismo objeto compartido. Esto sucede, porque el objeto "
"deserializado tiene el mismo nombre único y simplemente se adjunta a un "
"objeto existente con el mismo nombre (si el objeto todavía sigue vivo):"

#: ../Doc/library/multiprocessing.shared_memory.rst:11
msgid "Shared Memory"
msgstr "Memoria Compartida"

#: ../Doc/library/multiprocessing.shared_memory.rst:11
msgid "POSIX Shared Memory"
msgstr "Memoria Compartida POSIX"

#: ../Doc/library/multiprocessing.shared_memory.rst:11
msgid "Named Shared Memory"
msgstr "Memoria Compartida Nombrada"