diff --git a/dictionaries/howto_isolating-extensions.txt b/dictionaries/howto_isolating-extensions.txt new file mode 100644 index 0000000000..4a80230857 --- /dev/null +++ b/dictionaries/howto_isolating-extensions.txt @@ -0,0 +1,3 @@ +hack +getters +setters diff --git a/howto/isolating-extensions.po b/howto/isolating-extensions.po index f24ccfc428..31e8a336ae 100644 --- a/howto/isolating-extensions.po +++ b/howto/isolating-extensions.po @@ -20,10 +20,10 @@ msgstr "" #: ../Doc/howto/isolating-extensions.rst:5 msgid "Isolating Extension Modules" -msgstr "" +msgstr "Aislamiento de módulos de extensión" msgid "Abstract" -msgstr "" +msgstr "Resumen" #: ../Doc/howto/isolating-extensions.rst:9 msgid "" @@ -31,6 +31,10 @@ msgid "" "``static`` variables, which have process-wide scope. This document describes " "problems of such per-process state and shows a safer way: per-module state." msgstr "" +"Tradicionalmente, el estado perteneciente a los módulos de extensión de " +"Python se mantuvo en las variables C ``static``, que tienen un alcance de " +"todo el proceso. Este documento describe los problemas de dicho estado por " +"proceso y muestra una forma más segura: el estado por módulo." #: ../Doc/howto/isolating-extensions.rst:14 msgid "" @@ -39,10 +43,14 @@ msgid "" "potentially switching from static types to heap types, and—perhaps most " "importantly—accessing per-module state from code." msgstr "" +"El documento también describe cómo cambiar al estado por módulo cuando sea " +"posible. Esta transición implica asignar espacio para ese estado, cambiar " +"potencialmente de tipos estáticos a tipos de montón y, quizás lo más " +"importante, acceder al estado por módulo desde el código." #: ../Doc/howto/isolating-extensions.rst:21 msgid "Who should read this" -msgstr "" +msgstr "¿Quién debería leer esto?" #: ../Doc/howto/isolating-extensions.rst:23 msgid "" @@ -50,10 +58,13 @@ msgid "" "extensions who would like to make that extension safer to use in " "applications where Python itself is used as a library." msgstr "" +"Esta guía está escrita para los mantenedores de extensiones :ref:`C-API ` que deseen hacer que esa extensión sea más segura para usar en " +"aplicaciones donde Python se usa como biblioteca." #: ../Doc/howto/isolating-extensions.rst:29 msgid "Background" -msgstr "" +msgstr "Trasfondo" #: ../Doc/howto/isolating-extensions.rst:31 msgid "" @@ -61,24 +72,33 @@ msgid "" "configuration (e.g. the import path) and runtime state (e.g. the set of " "imported modules)." msgstr "" +"Un intérprete (*interpreter*) es el contexto en el que se ejecuta el código " +"de Python. Contiene la configuración (p. ej., la ruta de importación) y el " +"estado de tiempo de ejecución (p. ej., el conjunto de módulos importados)." #: ../Doc/howto/isolating-extensions.rst:35 msgid "" "Python supports running multiple interpreters in one process. There are two " "cases to think about—users may run interpreters:" msgstr "" +"Python admite la ejecución de varios intérpretes en un solo proceso. Hay dos " +"casos en los que pensar, los usuarios pueden ejecutar intérpretes:" #: ../Doc/howto/isolating-extensions.rst:38 msgid "" "in sequence, with several :c:func:`Py_InitializeEx`/:c:func:`Py_FinalizeEx` " "cycles, and" msgstr "" +"en secuencia, con varios ciclos :c:func:`Py_InitializeEx`/:c:func:" +"`Py_FinalizeEx`, y" #: ../Doc/howto/isolating-extensions.rst:40 msgid "" "in parallel, managing \"sub-interpreters\" using :c:func:" "`Py_NewInterpreter`/:c:func:`Py_EndInterpreter`." msgstr "" +"en paralelo, gestionando \"subintérpretes\" mediante :c:func:" +"`Py_NewInterpreter`/:c:func:`Py_EndInterpreter`." #: ../Doc/howto/isolating-extensions.rst:43 msgid "" @@ -87,6 +107,10 @@ msgid "" "about the application that uses them, which include assuming a process-wide " "\"main Python interpreter\"." msgstr "" +"Ambos casos (y combinaciones de ellos) serían más útiles al incorporar " +"Python dentro de una biblioteca. Las bibliotecas generalmente no deben hacer " +"suposiciones sobre la aplicación que las usa, lo que incluye asumir un " +"\"intérprete principal de Python\" en todo el proceso." #: ../Doc/howto/isolating-extensions.rst:48 msgid "" @@ -98,6 +122,14 @@ msgid "" "introduce edge cases that lead to crashes when a module is loaded in more " "than one interpreter in the same process." msgstr "" +"Históricamente, los módulos de extensión de Python no manejan bien este caso " +"de uso. Muchos módulos de extensión (e incluso algunos módulos stdlib) usan " +"el estado global *por-proceso*, porque las variables C ``static`` son " +"extremadamente fáciles de usar. Así, los datos que deberían ser específicos " +"de un intérprete acaban siendo compartidos entre intérpretes. A menos que el " +"desarrollador de la extensión tenga cuidado, es muy fácil introducir casos " +"extremos que provocan bloqueos cuando un módulo se carga en más de un " +"intérprete en el mismo proceso." #: ../Doc/howto/isolating-extensions.rst:56 msgid "" @@ -105,10 +137,13 @@ msgid "" "authors tend to not keep multiple interpreters in mind when developing, and " "it is currently cumbersome to test the behavior." msgstr "" +"Desafortunadamente, el estado *por-intérprete* no es fácil de lograr. Los " +"autores de extensiones tienden a no tener en cuenta múltiples intérpretes " +"cuando desarrollan, y actualmente es engorroso probar el comportamiento." #: ../Doc/howto/isolating-extensions.rst:61 msgid "Enter Per-Module State" -msgstr "" +msgstr "Ingrese al estado por módulo" #: ../Doc/howto/isolating-extensions.rst:63 msgid "" @@ -119,6 +154,12 @@ msgid "" "multiple module objects corresponding to a single extension can even be " "loaded in a single interpreter." msgstr "" +"En lugar de centrarse en el estado por intérprete, la API C de Python está " +"evolucionando para admitir mejor el estado *por-módulo* más granular. Esto " +"significa que los datos de nivel C se adjuntan a un *module object*. Cada " +"intérprete crea su propio objeto de módulo, manteniendo los datos separados. " +"Para probar el aislamiento, se pueden cargar varios objetos de módulo " +"correspondientes a una sola extensión en un solo intérprete." #: ../Doc/howto/isolating-extensions.rst:70 msgid "" @@ -128,6 +169,11 @@ msgid "" "any other :c:expr:`PyObject *`; there are no \"on interpreter shutdown\" " "hooks to think—or forget—about." msgstr "" +"El estado por módulo proporciona una manera fácil de pensar en la vida útil " +"y la propiedad de los recursos: el módulo de extensión se inicializará " +"cuando se cree un objeto de módulo y se limpiará cuando se libere. En este " +"sentido, un módulo es como cualquier otro :c:expr:`PyObject *`; no hay " +"ganchos de \"apagado del intérprete\" para pensar u olvidar." #: ../Doc/howto/isolating-extensions.rst:76 msgid "" @@ -137,10 +183,15 @@ msgid "" "exceptional cases: if you need them, you should give them additional care " "and testing. (Note that this guide does not cover them.)" msgstr "" +"Tenga en cuenta que hay casos de uso para diferentes tipos de \"globales\": " +"por proceso, por intérprete, por subproceso o por estado de tarea. Con el " +"estado por módulo como predeterminado, estos aún son posibles, pero debe " +"tratarlos como casos excepcionales: si los necesita, debe brindarles " +"atención y pruebas adicionales. (Tenga en cuenta que esta guía no los cubre)." #: ../Doc/howto/isolating-extensions.rst:85 msgid "Isolated Module Objects" -msgstr "" +msgstr "Objetos módulos aislados" #: ../Doc/howto/isolating-extensions.rst:87 msgid "" @@ -148,6 +199,9 @@ msgid "" "several module objects can be created from a single shared library. For " "example:" msgstr "" +"El punto clave a tener en cuenta al desarrollar un módulo de extensión es " +"que se pueden crear varios objetos de módulo a partir de una única " +"biblioteca compartida. Por ejemplo:" #: ../Doc/howto/isolating-extensions.rst:101 msgid "" @@ -158,6 +212,12 @@ msgid "" "are possible (see `Managing Global State`_), but they will need more thought " "and attention to edge cases." msgstr "" +"Como regla general, los dos módulos deben ser completamente independientes. " +"Todos los objetos y el estado específico del módulo deben encapsularse " +"dentro del objeto del módulo, no compartirse con otros objetos del módulo y " +"limpiarse cuando se desasigna el objeto del módulo. Dado que esto es solo " +"una regla general, las excepciones son posibles (consulte `Managing Global " +"State`_), pero necesitarán más reflexión y atención en los casos extremos." #: ../Doc/howto/isolating-extensions.rst:109 msgid "" @@ -165,10 +225,13 @@ msgid "" "modules make it easier to set clear expectations and guidelines that work " "across a variety of use cases." msgstr "" +"Si bien algunos módulos podrían funcionar con restricciones menos estrictas, " +"los módulos aislados facilitan el establecimiento de expectativas y pautas " +"claras que funcionan en una variedad de casos de uso." #: ../Doc/howto/isolating-extensions.rst:115 msgid "Surprising Edge Cases" -msgstr "" +msgstr "Casos extremos sorprendentes" #: ../Doc/howto/isolating-extensions.rst:117 msgid "" @@ -179,26 +242,37 @@ msgid "" "``binascii.Error`` are separate objects. In the following code, the " "exception is *not* caught:" msgstr "" +"Tenga en cuenta que los módulos aislados crean algunos casos extremos " +"sorprendentes. En particular, cada objeto de módulo normalmente no " +"compartirá sus clases y excepciones con otros módulos similares. Continuando " +"con `example above `__, tenga en cuenta que " +"``old_binascii.Error`` y ``binascii.Error`` son objetos separados. En el " +"código siguiente, se detecta la excepción *not*:" #: ../Doc/howto/isolating-extensions.rst:137 msgid "" "This is expected. Notice that pure-Python modules behave the same way: it is " "a part of how Python works." msgstr "" +"Esto se espera. Tenga en cuenta que los módulos de Python puro se comportan " +"de la misma manera: es una parte de cómo funciona Python." #: ../Doc/howto/isolating-extensions.rst:140 msgid "" "The goal is to make extension modules safe at the C level, not to make hacks " "behave intuitively. Mutating ``sys.modules`` \"manually\" counts as a hack." msgstr "" +"El objetivo es hacer que los módulos de extensión sean seguros en el nivel " +"C, no hacer que los piratas informáticos se comporten de manera intuitiva. " +"Mutar ``sys.modules`` \"manualmente\" cuenta como un hack." #: ../Doc/howto/isolating-extensions.rst:146 msgid "Making Modules Safe with Multiple Interpreters" -msgstr "" +msgstr "Cómo hacer que los módulos sean seguros con varios intérpretes" #: ../Doc/howto/isolating-extensions.rst:150 msgid "Managing Global State" -msgstr "" +msgstr "Administrar el estado global" #: ../Doc/howto/isolating-extensions.rst:152 msgid "" @@ -206,15 +280,20 @@ msgid "" "module, but to the entire process (or something else \"more global\" than a " "module). For example:" msgstr "" +"A veces, el estado asociado con un módulo de Python no es específico de ese " +"módulo, sino de todo el proceso (o algo más \"más global\" que un módulo). " +"Por ejemplo:" #: ../Doc/howto/isolating-extensions.rst:156 msgid "The ``readline`` module manages *the* terminal." -msgstr "" +msgstr "El módulo ``readline`` gestiona *el* terminal." #: ../Doc/howto/isolating-extensions.rst:157 msgid "" "A module running on a circuit board wants to control *the* on-board LED." msgstr "" +"Un módulo que se ejecuta en una placa de circuito quiere controlar *el* LED " +"integrado." #: ../Doc/howto/isolating-extensions.rst:160 msgid "" @@ -224,6 +303,11 @@ msgid "" "whether for Python or other languages). If that is not possible, consider " "explicit locking." msgstr "" +"En estos casos, el módulo Python debería proporcionar *acceso* al estado " +"global, en lugar de *poseerlo*. Si es posible, escriba el módulo para que " +"varias copias del mismo puedan acceder al estado de forma independiente " +"(junto con otras bibliotecas, ya sea para Python u otros lenguajes). Si eso " +"no es posible, considere el bloqueo explícito." #: ../Doc/howto/isolating-extensions.rst:166 msgid "" @@ -232,10 +316,14 @@ msgid "" "being loaded more than once per process—see `Opt-Out: Limiting to One Module " "Object per Process`_." msgstr "" +"Si es necesario usar el estado global del proceso, la forma más sencilla de " +"evitar problemas con varios intérpretes es evitar explícitamente que un " +"módulo se cargue más de una vez por proceso; consulte `Opt-Out: Limiting to " +"One Module Object per Process`_." #: ../Doc/howto/isolating-extensions.rst:173 msgid "Managing Per-Module State" -msgstr "" +msgstr "Administración del estado por módulo" #: ../Doc/howto/isolating-extensions.rst:175 msgid "" @@ -243,6 +331,9 @@ msgid "" "initialization `. This signals that your module " "supports multiple interpreters correctly." msgstr "" +"Para usar el estado por módulo, use :ref:`multi-phase extension module " +"initialization `. Esto indica que su módulo " +"admite múltiples intérpretes correctamente." #: ../Doc/howto/isolating-extensions.rst:179 msgid "" @@ -254,6 +345,14 @@ msgid "" "``csv``'s :py:data:`~csv.field_size_limit`) which the C code needs to " "function." msgstr "" +"Establezca ``PyModuleDef.m_size`` en un número positivo para solicitar " +"tantos bytes de almacenamiento local para el módulo. Por lo general, esto se " +"establecerá en el tamaño de algún ``struct`` específico del módulo, que " +"puede almacenar todo el estado de nivel C del módulo. En particular, es " +"donde debe colocar los punteros a las clases (incluidas las excepciones, " +"pero excluyendo los tipos estáticos) y configuraciones (por ejemplo, :py:" +"data:`~csv.field_size_limit` de ``csv``) que el código C necesita para " +"funcionar." #: ../Doc/howto/isolating-extensions.rst:188 msgid "" @@ -262,12 +361,18 @@ msgid "" "means error- and type-checking at the C level, which is easy to get wrong " "and hard to test sufficiently." msgstr "" +"Otra opción es almacenar el estado en el ``__dict__`` del módulo, pero debe " +"evitar fallas cuando los usuarios modifican ``__dict__`` desde el código de " +"Python. Esto generalmente significa verificación de errores y tipos en el " +"nivel C, que es fácil equivocarse y difícil de probar lo suficiente." #: ../Doc/howto/isolating-extensions.rst:193 msgid "" "However, if module state is not needed in C code, storing it in ``__dict__`` " "only is a good idea." msgstr "" +"Sin embargo, si el estado del módulo no es necesario en el código C, " +"almacenarlo solo en ``__dict__`` es una buena idea." #: ../Doc/howto/isolating-extensions.rst:196 msgid "" @@ -278,6 +383,12 @@ msgid "" "and make the code longer; this is the price for modules which can be " "unloaded cleanly." msgstr "" +"Si el estado del módulo incluye punteros ``PyObject``, el objeto del módulo " +"debe contener referencias a esos objetos e implementar los enlaces de nivel " +"de módulo ``m_traverse``, ``m_clear`` y ``m_free``. Estos funcionan como " +"``tp_traverse``, ``tp_clear`` y ``tp_free`` de una clase. Agregarlos " +"requerirá algo de trabajo y hará que el código sea más largo; este es el " +"precio de los módulos que se pueden descargar limpiamente." #: ../Doc/howto/isolating-extensions.rst:203 msgid "" @@ -285,10 +396,14 @@ msgid "" "`xxlimited `__; example module initialization shown at the bottom of the file." msgstr "" +"Un ejemplo de un módulo con estado por módulo está actualmente disponible " +"como `xxlimited `__; ejemplo de inicialización del módulo que se muestra en la " +"parte inferior del archivo." #: ../Doc/howto/isolating-extensions.rst:209 msgid "Opt-Out: Limiting to One Module Object per Process" -msgstr "" +msgstr "Exclusión voluntaria: limitación a un objeto de módulo por proceso" #: ../Doc/howto/isolating-extensions.rst:211 msgid "" @@ -297,10 +412,14 @@ msgid "" "module, you can explicitly make your module loadable only once per process. " "For example::" msgstr "" +"Un ``PyModuleDef.m_size`` no negativo indica que un módulo admite varios " +"intérpretes correctamente. Si este aún no es el caso de su módulo, puede " +"hacer que su módulo se pueda cargar explícitamente solo una vez por proceso. " +"Por ejemplo::" #: ../Doc/howto/isolating-extensions.rst:232 msgid "Module State Access from Functions" -msgstr "" +msgstr "Acceso al estado del módulo desde las funciones" #: ../Doc/howto/isolating-extensions.rst:234 msgid "" @@ -308,6 +427,9 @@ msgid "" "Functions get the module object as their first argument; for extracting the " "state, you can use ``PyModule_GetState``::" msgstr "" +"Acceder al estado desde funciones a nivel de módulo es sencillo. Las " +"funciones obtienen el objeto del módulo como su primer argumento; para " +"extraer el estado, puede usar ``PyModule_GetState``::" #: ../Doc/howto/isolating-extensions.rst:249 msgid "" @@ -315,10 +437,14 @@ msgid "" "there is no module state, i.e. ``PyModuleDef.m_size`` was zero. In your own " "module, you're in control of ``m_size``, so this is easy to prevent." msgstr "" +"``PyModule_GetState`` puede retornar ``NULL`` sin establecer una excepción " +"si no hay un estado de módulo, es decir, ``PyModuleDef.m_size`` era cero. En " +"su propio módulo, tiene el control de ``m_size``, por lo que es fácil de " +"evitar." #: ../Doc/howto/isolating-extensions.rst:256 msgid "Heap Types" -msgstr "" +msgstr "Tipos Heap" #: ../Doc/howto/isolating-extensions.rst:258 msgid "" @@ -326,6 +452,9 @@ msgid "" "PyTypeObject`` structures defined directly in code and initialized using " "``PyType_Ready()``." msgstr "" +"Tradicionalmente, los tipos definidos en código C son *estáticos*; es decir, " +"estructuras ``static PyTypeObject`` definidas directamente en el código e " +"inicializadas mediante ``PyType_Ready()``." #: ../Doc/howto/isolating-extensions.rst:262 msgid "" @@ -334,6 +463,11 @@ msgid "" "limit the possible issues, static types are immutable at the Python level: " "for example, you can't set ``str.myattribute = 123``." msgstr "" +"Tales tipos son necesariamente compartidos a lo largo del proceso. " +"Compartirlos entre objetos de módulo requiere prestar atención a cualquier " +"estado que posean o al que accedan. Para limitar los posibles problemas, los " +"tipos estáticos son inmutables en el nivel de Python: por ejemplo, no puede " +"configurar ``str.myattribute = 123``." #: ../Doc/howto/isolating-extensions.rst:268 msgid "" @@ -344,6 +478,13 @@ msgid "" "Python objects across interpreters implicitly depends on CPython's current, " "process-wide GIL." msgstr "" +"Compartir objetos verdaderamente inmutables entre intérpretes está bien, " +"siempre que no proporcionen acceso a objetos mutables. Sin embargo, en " +"CPython, cada objeto de Python tiene un detalle de implementación mutable: " +"el recuento de referencias. Los cambios en el refcount están protegidos por " +"el GIL. Por lo tanto, el código que comparte cualquier objeto de Python " +"entre intérpretes depende implícitamente del GIL actual de todo el proceso " +"de CPython." #: ../Doc/howto/isolating-extensions.rst:275 msgid "" @@ -353,14 +494,22 @@ msgid "" "*heap type* for short. These correspond more closely to classes created by " "Python's ``class`` statement." msgstr "" +"Debido a que son inmutables y globales de proceso, los tipos estáticos no " +"pueden acceder a \"su\" estado de módulo. Si algún método de este tipo " +"requiere acceso al estado del módulo, el tipo debe convertirse a *tipo " +"almacenado en memoria dinámica (heap)* o *tipo heap* para abreviar. Estos se " +"corresponden más estrechamente con las clases creadas por la instrucción " +"``class`` de Python." #: ../Doc/howto/isolating-extensions.rst:282 msgid "For new modules, using heap types by default is a good rule of thumb." msgstr "" +"Para los módulos nuevos, usar tipos heap de forma predeterminada es una " +"buena regla general." #: ../Doc/howto/isolating-extensions.rst:286 msgid "Changing Static Types to Heap Types" -msgstr "" +msgstr "Cambio de tipos estáticos a tipos heap" #: ../Doc/howto/isolating-extensions.rst:288 msgid "" @@ -371,18 +520,30 @@ msgid "" "unintentionally change a few details (e.g. pickleability or inherited " "slots). Always test the details that are important to you." msgstr "" +"Los tipos estáticos se pueden convertir en tipos heap, pero tenga en cuenta " +"que la API de tipo heap no se diseñó para la conversión \"sin pérdidas\" de " +"tipos estáticos, es decir, para crear un tipo que funcione exactamente como " +"un tipo estático determinado. Por lo tanto, al reescribir la definición de " +"clase en una nueva API, es probable que cambie sin querer algunos detalles " +"(por ejemplo, capacidad de selección o espacios heredados). Siempre pruebe " +"los detalles que son importantes para usted." #: ../Doc/howto/isolating-extensions.rst:297 msgid "" "Watch out for the following two points in particular (but note that this is " "not a comprehensive list):" msgstr "" +"Tenga cuidado con los siguientes dos puntos en particular (pero tenga en " +"cuenta que esta no es una lista completa):" #: ../Doc/howto/isolating-extensions.rst:300 msgid "" "Unlike static types, heap type objects are mutable by default. Use the :c:" "data:`Py_TPFLAGS_IMMUTABLETYPE` flag to prevent mutability." msgstr "" +"A diferencia de los tipos estáticos, los objetos de tipo heap son mutables " +"de forma predeterminada. Utilice el indicador :c:data:" +"`Py_TPFLAGS_IMMUTABLETYPE` para evitar la mutabilidad." #: ../Doc/howto/isolating-extensions.rst:302 msgid "" @@ -390,10 +551,14 @@ msgid "" "become possible to instantiate them from Python code. You can prevent this " "with the :c:data:`Py_TPFLAGS_DISALLOW_INSTANTIATION` flag." msgstr "" +"Los tipos heap heredan :c:member:`~PyTypeObject.tp_new` de forma " +"predeterminada, por lo que es posible crear instancias de ellos desde el " +"código de Python. Puede evitar esto con el indicador :c:data:" +"`Py_TPFLAGS_DISALLOW_INSTANTIATION`." #: ../Doc/howto/isolating-extensions.rst:308 msgid "Defining Heap Types" -msgstr "" +msgstr "Definición de tipos heap" #: ../Doc/howto/isolating-extensions.rst:310 msgid "" @@ -401,6 +566,9 @@ msgid "" "description or \"blueprint\" of a class, and calling :c:func:" "`PyType_FromModuleAndSpec` to construct a new class object." msgstr "" +"Los tipos heap se pueden crear completando una estructura :c:struct:" +"`PyType_Spec`, una descripción o \"modelo\" de una clase y llamando a :c:" +"func:`PyType_FromModuleAndSpec` para construir un nuevo objeto de clase." #: ../Doc/howto/isolating-extensions.rst:315 msgid "" @@ -408,16 +576,22 @@ msgid "" "but :c:func:`PyType_FromModuleAndSpec` associates the module with the class, " "allowing access to the module state from methods." msgstr "" +"Otras funciones, como :c:func:`PyType_FromSpec`, también pueden crear tipos " +"heap, pero :c:func:`PyType_FromModuleAndSpec` asocia el módulo con la clase, " +"lo que permite el acceso al estado del módulo desde los métodos." #: ../Doc/howto/isolating-extensions.rst:319 msgid "" "The class should generally be stored in *both* the module state (for safe " "access from C) and the module's ``__dict__`` (for access from Python code)." msgstr "" +"La clase generalmente debe almacenarse en *ambos*, el estado del módulo " +"(para acceso seguro desde C) y el ``__dict__`` del módulo (para acceso desde " +"código Python)." #: ../Doc/howto/isolating-extensions.rst:325 msgid "Garbage-Collection Protocol" -msgstr "" +msgstr "Protocolo de recolección de basura" #: ../Doc/howto/isolating-extensions.rst:327 msgid "" @@ -425,22 +599,31 @@ msgid "" "the type isn't destroyed before all its instances are, but may result in " "reference cycles that need to be broken by the garbage collector." msgstr "" +"Las instancias de tipos heap contienen una referencia a su tipo. Esto " +"garantiza que el tipo no se destruya antes de que se destruyan todas sus " +"instancias, pero puede generar ciclos de referencia que el recolector de " +"elementos no utilizados debe interrumpir." #: ../Doc/howto/isolating-extensions.rst:332 msgid "" "To avoid memory leaks, instances of heap types must implement the garbage " "collection protocol. That is, heap types should:" msgstr "" +"Para evitar pérdidas de memoria, las instancias de los tipos heap deben " +"implementar el protocolo de recolección de elementos no utilizados. Es " +"decir, los tipos heap deben:" #: ../Doc/howto/isolating-extensions.rst:336 msgid "Have the :c:data:`Py_TPFLAGS_HAVE_GC` flag." -msgstr "" +msgstr "Tener la bandera :c:data:`Py_TPFLAGS_HAVE_GC`." #: ../Doc/howto/isolating-extensions.rst:337 msgid "" "Define a traverse function using ``Py_tp_traverse``, which visits the type " "(e.g. using :c:expr:`Py_VISIT(Py_TYPE(self))`)." msgstr "" +"Defina una función transversal usando ``Py_tp_traverse``, que visita el tipo " +"(por ejemplo, usando :c:expr:`Py_VISIT(Py_TYPE(self))`)." #: ../Doc/howto/isolating-extensions.rst:340 msgid "" @@ -448,6 +631,9 @@ msgid "" "`Py_TPFLAGS_HAVE_GC` and :c:member:`~PyTypeObject.tp_traverse` for " "additional considerations." msgstr "" +"Consulte el :ref:`the documentation ` de :c:data:" +"`Py_TPFLAGS_HAVE_GC` y :c:member:`~PyTypeObject.tp_traverse` para obtener " +"consideraciones adicionales." #: ../Doc/howto/isolating-extensions.rst:344 msgid "" @@ -455,24 +641,31 @@ msgid "" "(or another type), ensure that ``Py_TYPE(self)`` is visited only once. Note " "that only heap type are expected to visit the type in ``tp_traverse``." msgstr "" +"Si su función transversal delega al ``tp_traverse`` de su clase base (u otro " +"tipo), asegúrese de que ``Py_TYPE(self)`` se visite solo una vez. Tenga en " +"cuenta que solo se espera que el tipo de montón visite el tipo en " +"``tp_traverse``." #: ../Doc/howto/isolating-extensions.rst:348 msgid "For example, if your traverse function includes::" -msgstr "" +msgstr "Por ejemplo, si su función poligonal incluye:" #: ../Doc/howto/isolating-extensions.rst:352 msgid "...and ``base`` may be a static type, then it should also include::" msgstr "" +"...y ``base`` puede ser un tipo estático, entonces también debe incluir:" #: ../Doc/howto/isolating-extensions.rst:360 msgid "" "It is not necessary to handle the type's reference count in ``tp_new`` and " "``tp_clear``." msgstr "" +"No es necesario manejar el recuento de referencias del tipo en ``tp_new`` y " +"``tp_clear``." #: ../Doc/howto/isolating-extensions.rst:365 msgid "Module State Access from Classes" -msgstr "" +msgstr "Acceso al estado del módulo desde las clases" #: ../Doc/howto/isolating-extensions.rst:367 msgid "" @@ -480,16 +673,22 @@ msgid "" "you can call :c:func:`PyType_GetModule` to get the associated module, and " "then :c:func:`PyModule_GetState` to get the module's state." msgstr "" +"Si tiene un objeto de tipo definido con :c:func:`PyType_FromModuleAndSpec`, " +"puede llamar a :c:func:`PyType_GetModule` para obtener el módulo asociado y " +"luego a :c:func:`PyModule_GetState` para obtener el estado del módulo." #: ../Doc/howto/isolating-extensions.rst:371 msgid "" "To save a some tedious error-handling boilerplate code, you can combine " "these two steps with :c:func:`PyType_GetModuleState`, resulting in::" msgstr "" +"Para ahorrar un tedioso código repetitivo de manejo de errores, puede " +"combinar estos dos pasos con :c:func:`PyType_GetModuleState`, lo que da como " +"resultado:" #: ../Doc/howto/isolating-extensions.rst:381 msgid "Module State Access from Regular Methods" -msgstr "" +msgstr "Acceso al estado del módulo desde métodos regulares" #: ../Doc/howto/isolating-extensions.rst:383 msgid "" @@ -498,6 +697,10 @@ msgid "" "the state, you need to first get the *defining class*, and then get the " "module state from it." msgstr "" +"Acceder al estado de nivel de módulo desde los métodos de una clase es algo " +"más complicado, pero es posible gracias a la API introducida en Python 3.9. " +"Para obtener el estado, primero debe obtener la *clase de definición* y " +"luego obtener el estado del módulo." #: ../Doc/howto/isolating-extensions.rst:388 msgid "" @@ -505,6 +708,9 @@ msgid "" "that method's \"defining class\" for short. The defining class can have a " "reference to the module it is part of." msgstr "" +"El obstáculo más grande es obtener *la clase en la que se definió un " +"método*, o la \"clase de definición\" de ese método para abreviar. La clase " +"de definición puede tener una referencia al módulo del que forma parte." #: ../Doc/howto/isolating-extensions.rst:392 msgid "" @@ -512,12 +718,17 @@ msgid "" "method is called on a *subclass* of your type, ``Py_TYPE(self)`` will refer " "to that subclass, which may be defined in different module than yours." msgstr "" +"No confunda la clase de definición con :c:expr:`Py_TYPE(self)`. Si se llama " +"al método en una *subclase* de su tipo, ``Py_TYPE(self)`` se referirá a esa " +"subclase, que puede estar definida en un módulo diferente al suyo." #: ../Doc/howto/isolating-extensions.rst:397 msgid "" "The following Python code can illustrate the concept. ``Base." "get_defining_class`` returns ``Base`` even if ``type(self) == Sub``:" msgstr "" +"El siguiente código de Python puede ilustrar el concepto. ``Base." +"get_defining_class`` retorna ``Base`` incluso si ``type(self) == Sub``:" #: ../Doc/howto/isolating-extensions.rst:413 msgid "" @@ -525,24 +736,29 @@ msgid "" "`METH_METHOD | METH_FASTCALL | METH_KEYWORDS` :c:type:`calling convention " "` and the corresponding :c:type:`PyCMethod` signature::" msgstr "" +"Para que un método obtenga su \"clase de definición\", debe usar :data:" +"`METH_METHOD | METH_FASTCALL | METH_KEYWORDS` :c:type:`calling convention " +"` y la firma :c:type:`PyCMethod` correspondiente:" #: ../Doc/howto/isolating-extensions.rst:425 msgid "" "Once you have the defining class, call :c:func:`PyType_GetModuleState` to " "get the state of its associated module." msgstr "" +"Una vez que tenga la clase de definición, llame a :c:func:" +"`PyType_GetModuleState` para obtener el estado de su módulo asociado." #: ../Doc/howto/isolating-extensions.rst:428 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/howto/isolating-extensions.rst:456 msgid "Module State Access from Slot Methods, Getters and Setters" -msgstr "" +msgstr "Acceso al estado del módulo desde métodos de Slot, Getters y Setters" #: ../Doc/howto/isolating-extensions.rst:460 msgid "This is new in Python 3.11." -msgstr "" +msgstr "Esto es nuevo en Python 3.11." #: ../Doc/howto/isolating-extensions.rst:468 msgid "" @@ -552,6 +768,12 @@ msgid "" "allow passing in the defining class, unlike with :c:type:`PyCMethod`. The " "same goes for getters and setters defined with :c:type:`PyGetSetDef`." msgstr "" +"Los métodos slot, los equivalentes rápidos de C para métodos especiales, " +"como :c:member:`~PyNumberMethods.nb_add` para :py:attr:`~object.__add__` o :" +"c:member:`~PyType.tp_new` para la inicialización, tienen una API muy simple " +"que no permite pasar la clase de definición, a diferencia de :c:type:" +"`PyCMethod`. Lo mismo ocurre con los getters y setters definidos con :c:type:" +"`PyGetSetDef`." #: ../Doc/howto/isolating-extensions.rst:475 msgid "" @@ -559,6 +781,9 @@ msgid "" "`PyType_GetModuleByDef` function, and pass in the module definition. Once " "you have the module, call :c:func:`PyModule_GetState` to get the state::" msgstr "" +"Para acceder al estado del módulo en estos casos, utilice la función :c:func:" +"`PyType_GetModuleByDef` y pase la definición del módulo. Una vez que tenga " +"el módulo, llame a :c:func:`PyModule_GetState` para obtener el estado:" #: ../Doc/howto/isolating-extensions.rst:486 msgid "" @@ -566,6 +791,9 @@ msgid "" "order` (i.e. all superclasses) for the first superclass that has a " "corresponding module." msgstr "" +"``PyType_GetModuleByDef`` funciona buscando en :term:`method resolution " +"order` (es decir, todas las superclases) la primera superclase que tiene un " +"módulo correspondiente." #: ../Doc/howto/isolating-extensions.rst:492 msgid "" @@ -574,10 +802,15 @@ msgid "" "module of the true defining class. However, it will always return a module " "with the same definition, ensuring a compatible C memory layout." msgstr "" +"En casos muy exóticos (cadenas de herencia que abarcan varios módulos " +"creados a partir de la misma definición), es posible que " +"``PyType_GetModuleByDef`` no retorne el módulo de la verdadera clase de " +"definición. Sin embargo, siempre retornará un módulo con la misma " +"definición, lo que garantiza un diseño de memoria C compatible." #: ../Doc/howto/isolating-extensions.rst:500 msgid "Lifetime of the Module State" -msgstr "" +msgstr "Vida útil del estado del módulo" #: ../Doc/howto/isolating-extensions.rst:502 msgid "" @@ -585,6 +818,9 @@ msgid "" "each pointer to (a part of) the module state, you must hold a reference to " "the module object." msgstr "" +"Cuando un objeto de módulo se recolecta como basura, se libera su estado de " +"módulo. Para cada puntero a (una parte de) el estado del módulo, debe tener " +"una referencia al objeto del módulo." #: ../Doc/howto/isolating-extensions.rst:506 msgid "" @@ -594,14 +830,21 @@ msgid "" "reference module state from other places, such as callbacks for external " "libraries." msgstr "" +"Por lo general, esto no es un problema, porque los tipos creados con :c:func:" +"`PyType_FromModuleAndSpec` y sus instancias contienen una referencia al " +"módulo. Sin embargo, debe tener cuidado en el recuento de referencias cuando " +"hace referencia al estado del módulo desde otros lugares, como devoluciones " +"de llamada para bibliotecas externas." #: ../Doc/howto/isolating-extensions.rst:515 msgid "Open Issues" -msgstr "" +msgstr "Problemas abiertos" #: ../Doc/howto/isolating-extensions.rst:517 msgid "Several issues around per-module state and heap types are still open." msgstr "" +"Varios problemas relacionados con el estado por módulo y los tipos heap " +"todavía están abiertos." #: ../Doc/howto/isolating-extensions.rst:519 msgid "" @@ -609,10 +852,13 @@ msgid "" "mailing list `__." msgstr "" +"Las discusiones sobre cómo mejorar la situación se llevan a cabo mejor en el " +"`capi-sig mailing list `__." #: ../Doc/howto/isolating-extensions.rst:524 msgid "Per-Class Scope" -msgstr "" +msgstr "Alcance por clase" #: ../Doc/howto/isolating-extensions.rst:526 msgid "" @@ -621,13 +867,20 @@ msgid "" "may change in the future—perhaps, ironically, to allow a proper solution for " "per-class scope)." msgstr "" +"Actualmente (a partir de Python 3.11) no es posible adjuntar estado a " +"*tipos* individuales sin depender de los detalles de implementación de " +"CPython (que pueden cambiar en el futuro, tal vez, irónicamente, para " +"permitir una solución adecuada para el alcance por clase)." #: ../Doc/howto/isolating-extensions.rst:533 msgid "Lossless Conversion to Heap Types" -msgstr "" +msgstr "Conversión sin pérdidas a tipos heap" #: ../Doc/howto/isolating-extensions.rst:535 msgid "" "The heap type API was not designed for \"lossless\" conversion from static " "types; that is, creating a type that works exactly like a given static type." msgstr "" +"La API de tipo heap no se diseñó para la conversión \"sin pérdidas\" de " +"tipos estáticos; es decir, crear un tipo que funcione exactamente como un " +"tipo estático determinado."