annotations.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python en Español
# package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2021.
#
msgid ""
msgstr ""
"Project-Id-Version: Python en Español 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-10-21 04:10-0500\n"
"Last-Translator: José Luis Salgado Banda <josephLSalgado@outlook.com>\n"
"Language: es\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.10.3\n"

#: ../Doc/howto/annotations.rst:5
msgid "Annotations Best Practices"
msgstr "Prácticas recomendadas para las anotaciones"

#: ../Doc/howto/annotations.rst
msgid "author"
msgstr "autor"

#: ../Doc/howto/annotations.rst:7
msgid "Larry Hastings"
msgstr "Larry Hastings"

msgid "Abstract"
msgstr "Resumen"

#: ../Doc/howto/annotations.rst:11
msgid ""
"This document is designed to encapsulate the best practices for working with "
"annotations dicts.  If you write Python code that examines "
"``__annotations__`` on Python objects, we encourage you to follow the "
"guidelines described below."
msgstr ""
"Este documento se designó para encapsular las prácticas recomendadas para "
"trabajar con diccionarios de anotaciones. Si escribe código Python que "
"examina ``__annotations__`` en objetos Python, recomendamos seguir las "
"pautas que se describen a continuación."

#: ../Doc/howto/annotations.rst:16
msgid ""
"The document is organized into four sections: best practices for accessing "
"the annotations of an object in Python versions 3.10 and newer, best "
"practices for accessing the annotations of an object in Python versions 3.9 "
"and older, other best practices for ``__annotations__`` that apply to any "
"Python version, and quirks of ``__annotations__``."
msgstr ""
"El documento se organizó en 4 secciones: prácticas recomendadas para acceder "
"a las anotaciones de un objeto en las versiones de Python 3.10 y "
"posteriores, prácticas recomendadas para acceder a las anotaciones de un "
"objeto en las versiones de Python 3.9 y anteriores, otras prácticas "
"recomendadas para ``__annotations__`` que aplican a cualquier versión de "
"Python y peculiaridades de ``__annotations__``."

#: ../Doc/howto/annotations.rst:26
msgid ""
"Note that this document is specifically about working with "
"``__annotations__``, not uses *for* annotations. If you're looking for "
"information on how to use \"type hints\" in your code, please see the :mod:"
"`typing` module."
msgstr ""
"Tome en cuenta que este documento trabaja específicamente con "
"``__annotations__``, no usarlo *para* anotaciones. Si está buscando "
"información sobre cómo usar \"anotaciones de tipado\" en su código, consulte "
"el módulo :mod:`typing`."

#: ../Doc/howto/annotations.rst:33
msgid "Accessing The Annotations Dict Of An Object In Python 3.10 And Newer"
msgstr ""
"Acceder al diccionario de anotaciones de un objeto en las versiones de "
"Python 3.10 y posteriores"

#: ../Doc/howto/annotations.rst:35
msgid ""
"Python 3.10 adds a new function to the standard library: :func:`inspect."
"get_annotations`.  In Python versions 3.10 and newer, calling this function "
"is the best practice for accessing the annotations dict of any object that "
"supports annotations.  This function can also \"un-stringize\" stringized "
"annotations for you."
msgstr ""
"Python 3.10 agrega una nueva función a la biblioteca estándar: :func:"
"`inspect.get_annotations`. En las versiones de Python 3.10 y posteriores, "
"llamar esta función es la mejor práctica para acceder al diccionario de "
"anotaciones de cualquier objeto que admita anotaciones. También esta función "
"puede \"desencadenar\" anotaciones en cadena."

#: ../Doc/howto/annotations.rst:42
msgid ""
"If for some reason :func:`inspect.get_annotations` isn't viable for your use "
"case, you may access the ``__annotations__`` data member manually.  Best "
"practice for this changed in Python 3.10 as well: as of Python 3.10, ``o."
"__annotations__`` is guaranteed to *always* work on Python functions, "
"classes, and modules.  If you're certain the object you're examining is one "
"of these three *specific* objects, you may simply use ``o.__annotations__`` "
"to get at the object's annotations dict."
msgstr ""
"Si por alguna razón :func:`inspect.get_annotations` no es viable para su "
"caso de uso, puede acceder manualmente al miembro de datos "
"``__annotations__``. La práctica recomendada para esto también cambió en "
"Python 3.10: a partir de Python 3.10, se garantiza que ``o.__annotations__`` "
"*siempre* opere en funciones, clases y módulos de Python. Si está seguro de "
"que el objeto que está examinando es uno de los tres objetos *específicos*, "
"puede usar simplemente ``o.__annotations__`` para obtener el diccionario de "
"anotaciones del objeto."

#: ../Doc/howto/annotations.rst:52
msgid ""
"However, other types of callables--for example, callables created by :func:"
"`functools.partial`--may not have an ``__annotations__`` attribute defined.  "
"When accessing the ``__annotations__`` of a possibly unknown object,  best "
"practice in Python versions 3.10 and newer is to call :func:`getattr` with "
"three arguments, for example ``getattr(o, '__annotations__', None)``."
msgstr ""
"Sin embargo, otros tipos de llamadas -- por ejemplo, invocables creados por :"
"func:`functools.partial` -- pueden no tener definido un atributo "
"``__annotations__``. Al acceder a ``__annotations__`` de un objeto "
"posiblemente desconocido, la práctica recomendada de las versiones de Python "
"3.10 y posteriores es llamar :func:`getattr` con tres argumentos, por "
"ejemplo ``getattr(o, '__annotations__', None)``."

#: ../Doc/howto/annotations.rst:62
msgid "Accessing The Annotations Dict Of An Object In Python 3.9 And Older"
msgstr ""
"Acceder al diccionario de anotaciones de un objeto en las versiones de "
"Python 3.9 y anteriores"

#: ../Doc/howto/annotations.rst:64
msgid ""
"In Python 3.9 and older, accessing the annotations dict of an object is much "
"more complicated than in newer versions. The problem is a design flaw in "
"these older versions of Python, specifically to do with class annotations."
msgstr ""
"En versiones de Python 3.9 y anteriores, acceder al diccionario de "
"anotaciones de un objeto es mucho más complicado que en versiones más "
"recientes. El problema es un defecto de diseño en estas versiones anteriores "
"de Python, específicamente relacionado con las anotaciones de clase."

#: ../Doc/howto/annotations.rst:69
msgid ""
"Best practice for accessing the annotations dict of other objects--"
"functions, other callables, and modules--is the same as best practice for "
"3.10, assuming you aren't calling :func:`inspect.get_annotations`: you "
"should use three-argument :func:`getattr` to access the object's "
"``__annotations__`` attribute."
msgstr ""
"La práctica recomendada para acceder al diccionario de anotaciones de otros "
"objetos -- funciones, otros invocables y módulos -- es la misma que la de la "
"3.10, asumiendo que no está llamando :func:`inspect.get_annotations`: debe "
"usar tres argumentos de :func:`getattr` para acceder al atributo "
"``__annotations__`` del objeto."

#: ../Doc/howto/annotations.rst:76
msgid ""
"Unfortunately, this isn't best practice for classes.  The problem is that, "
"since ``__annotations__`` is optional on classes, and because classes can "
"inherit attributes from their base classes, accessing the "
"``__annotations__`` attribute of a class may inadvertently return the "
"annotations dict of a *base class.* As an example::"
msgstr ""
"Desafortunadamente, esta no es la mejor práctica para las clases. El "
"problema es que, dado que ``__annotations__`` es opcional en las clases, y "
"debido a que las clases pueden heredar atributos desde sus clases base, "
"acceder al atributo ``__annotations__`` de una clase puede retornar por "
"inadvertencia el diccionario de anotaciones de una *clase base.* Como "
"ejemplo::"

#: ../Doc/howto/annotations.rst:92
msgid "This will print the annotations dict from ``Base``, not ``Derived``."
msgstr ""
"Esto imprimirá el diccionario de anotaciones de ``Base``, no de ``Derived``."

#: ../Doc/howto/annotations.rst:95
msgid ""
"Your code will have to have a separate code path if the object you're "
"examining is a class (``isinstance(o, type)``). In that case, best practice "
"relies on an implementation detail of Python 3.9 and before: if a class has "
"annotations defined, they are stored in the class's ``__dict__`` "
"dictionary.  Since the class may or may not have annotations defined, best "
"practice is to call the ``get`` method on the class dict."
msgstr ""
"Su código deberá tener una ruta de código separada si el objeto que está "
"examinando es una clase (``isinstance(o, type)``). En este caso, la práctica "
"recomendada se basa en un detalle de implementación de las versiones de "
"Python 3.9 y anteriores: si una clase tiene anotaciones definidas, se "
"almacenan en el diccionario ``__dict__`` de la clase. Dado que la clase "
"puede o no tener anotaciones definidas, la mejor práctica es llamar al "
"método ``get`` en el diccionario de la clase."

#: ../Doc/howto/annotations.rst:103
msgid ""
"To put it all together, here is some sample code that safely accesses the "
"``__annotations__`` attribute on an arbitrary object in Python 3.9 and "
"before::"
msgstr ""
"Para ponerlo todo junto, aquí hay un código de muestra que accede de forma "
"segura al atributo ``__annotations__`` en un objeto arbitrario en las "
"versiones de Python 3.9 y anteriores::"

#: ../Doc/howto/annotations.rst:112
msgid ""
"After running this code, ``ann`` should be either a dictionary or ``None``.  "
"You're encouraged to double-check the type of ``ann`` using :func:"
"`isinstance` before further examination."
msgstr ""
"Después de ejecutar este código, ``ann`` debería ser un diccionario o "
"``None``. Recomendamos que vuelva a verificar el tipo de ``ann`` usando :"
"func:`isinstance` antes de un examen más detenido."

#: ../Doc/howto/annotations.rst:117
msgid ""
"Note that some exotic or malformed type objects may not have a ``__dict__`` "
"attribute, so for extra safety you may also wish to use :func:`getattr` to "
"access ``__dict__``."
msgstr ""
"Tome en cuenta que algunos objetos de tipo exótico o con formato incorrecto "
"pueden no tener un atributo ``__dict__``, así que para mayor seguridad, "
"también puede usar :func:`getattr` para acceder a ``__dict__``."

#: ../Doc/howto/annotations.rst:123
msgid "Manually Un-Stringizing Stringized Annotations"
msgstr "Desencadenamiento manual de anotaciones en cadena"

#: ../Doc/howto/annotations.rst:125
msgid ""
"In situations where some annotations may be \"stringized\", and you wish to "
"evaluate those strings to produce the Python values they represent, it "
"really is best to call :func:`inspect.get_annotations` to do this work for "
"you."
msgstr ""
"En situaciones donde algunas anotaciones pueden estar \"encadenadas\", y "
"desea evaluar esas cadenas de caracteres para producir los valores de Python "
"que representan, lo mejor es llamar a :func:`inspect.get_annotations` para "
"que haga este trabajo por usted."

#: ../Doc/howto/annotations.rst:131
msgid ""
"If you're using Python 3.9 or older, or if for some reason you can't use :"
"func:`inspect.get_annotations`, you'll need to duplicate its logic.  You're "
"encouraged to examine the implementation of :func:`inspect.get_annotations` "
"in the current Python version and follow a similar approach."
msgstr ""
"Si está usando la versión de Python 3.9 o anterior, o si por alguna razón no "
"puede usar :func:`inspect.get_annotations`, necesitará duplicar su lógica. "
"Recomendamos que examine la implementación de :func:`inspect."
"get_annotations` en la versión actual de Python y siga un enfoque similar."

#: ../Doc/howto/annotations.rst:137
msgid ""
"In a nutshell, if you wish to evaluate a stringized annotation on an "
"arbitrary object ``o``:"
msgstr ""
"En pocas palabras, si desea evaluar una anotación en cadena en un objeto "
"arbitrario ``o``:"

#: ../Doc/howto/annotations.rst:140
msgid ""
"If ``o`` is a module, use ``o.__dict__`` as the ``globals`` when calling :"
"func:`eval`."
msgstr ""
"Si ``o`` es un módulo, use ``o.__dict__`` como ``globals`` cuando llame a :"
"func:`eval`."

#: ../Doc/howto/annotations.rst:142
msgid ""
"If ``o`` is a class, use ``sys.modules[o.__module__].__dict__`` as the "
"``globals``, and ``dict(vars(o))`` as the ``locals``, when calling :func:"
"`eval`."
msgstr ""
"Si ``o`` es una clase, use ``sys.modules[o.__module__].__dict__`` como "
"``globals`` y ``dict(vars(o))`` como ``locals`` cuando llame a :func:`eval`."

#: ../Doc/howto/annotations.rst:145
msgid ""
"If ``o`` is a wrapped callable using :func:`functools.update_wrapper`, :func:"
"`functools.wraps`, or :func:`functools.partial`, iteratively unwrap it by "
"accessing either ``o.__wrapped__`` or ``o.func`` as appropriate, until you "
"have found the root unwrapped function."
msgstr ""
"Si ``o`` es un invocable envuelto usando :func:`functools.update_wrapper`, :"
"func:`functools.wraps` o :func:`functools.partial`, lo desenvuelve "
"iterativamente accediendo a ``o.__wrapped__`` o ``o.func`` según "
"corresponda, hasta que haya encontrado la función raíz sin envolver."

#: ../Doc/howto/annotations.rst:149
msgid ""
"If ``o`` is a callable (but not a class), use ``o.__globals__`` as the "
"globals when calling :func:`eval`."
msgstr ""
"Si ``o`` es un invocable (pero no una clase), use ``o.__globals__`` como "
"``globals`` cuando llame a :func:`eval`."

#: ../Doc/howto/annotations.rst:152
msgid ""
"However, not all string values used as annotations can be successfully "
"turned into Python values by :func:`eval`. String values could theoretically "
"contain any valid string, and in practice there are valid use cases for type "
"hints that require annotating with string values that specifically *can't* "
"be evaluated.  For example:"
msgstr ""
"Sin embargo, no todos los valores de cadena de caracteres usados como "
"anotaciones se pueden convertir correctamente en valores de Python mediante :"
"func:`eval`. Los valores de cadena de caracteres pueden contener, "
"teóricamente, cualquier cadena de caracteres válida, y en la práctica, hay "
"varios casos de uso válidos para anotaciones de tipo que requieren "
"anotaciones con valores de cadena de caracteres que *no pueden* evaluarse "
"específicamente. Por ejemplo:"

#: ../Doc/howto/annotations.rst:159
#, fuzzy
msgid ""
":pep:`604` union types using ``|``, before support for this was added to "
"Python 3.10."
msgstr ""
":pep:`604` tipos de unión usando `|`, antes de que se agregara soporte para "
"esto en Python 3.10."

#: ../Doc/howto/annotations.rst:161
msgid ""
"Definitions that aren't needed at runtime, only imported when :const:`typing."
"TYPE_CHECKING` is true."
msgstr ""
"Las definiciones que no son necesarias en tiempo de ejecución, sólo se "
"importan cuando :const:`typing.TYPE_CHECKING` es verdadero."

#: ../Doc/howto/annotations.rst:164
msgid ""
"If :func:`eval` attempts to evaluate such values, it will fail and raise an "
"exception.  So, when designing a library API that works with annotations, "
"it's recommended to only attempt to evaluate string values when explicitly "
"requested to by the caller."
msgstr ""
"Si :func:`eval` intenta evaluar tales valores, fallará y lanzará una "
"excepción. Por lo tanto, al diseñar una API de biblioteca que funcione con "
"anotaciones, se recomienda sólo intentar evaluar valores de cadena de "
"caracteres cuando la llamada lo solicite explícitamente."

#: ../Doc/howto/annotations.rst:172
msgid "Best Practices For ``__annotations__`` In Any Python Version"
msgstr ""
"Prácticas recomendadas para ``__annotations__`` en cualquier versión de "
"Python"

#: ../Doc/howto/annotations.rst:174
msgid ""
"You should avoid assigning to the ``__annotations__`` member of objects "
"directly.  Let Python manage setting ``__annotations__``."
msgstr ""
"Debe evitar asignar directamente al miembro ``__annotations__`` de objetos. "
"Deje que Python administre la configuración ``__annotations__``."

#: ../Doc/howto/annotations.rst:177
msgid ""
"If you do assign directly to the ``__annotations__`` member of an object, "
"you should always set it to a ``dict`` object."
msgstr ""
"Si asigna directamente al miembro ``__annotations__`` de un objeto, siempre "
"debe establecerlo en un objeto ``dict``."

#: ../Doc/howto/annotations.rst:180
msgid ""
"If you directly access the ``__annotations__`` member of an object, you "
"should ensure that it's a dictionary before attempting to examine its "
"contents."
msgstr ""
"Si accede directamente al miembro ``__annotations__`` de un objeto, debe "
"asegurarse de que sea un diccionario antes de intentar examinar su contenido."

#: ../Doc/howto/annotations.rst:184
msgid "You should avoid modifying ``__annotations__`` dicts."
msgstr "Debe evitar modificar los diccionarios ``__annotations__``."

#: ../Doc/howto/annotations.rst:186
msgid ""
"You should avoid deleting the ``__annotations__`` attribute of an object."
msgstr "Debe evitar eliminar el atributo ``__annotations__`` de un objeto."

#: ../Doc/howto/annotations.rst:191
msgid "``__annotations__`` Quirks"
msgstr "Peculiaridades de ``__annotations__``"

#: ../Doc/howto/annotations.rst:193
msgid ""
"In all versions of Python 3, function objects lazy-create an annotations "
"dict if no annotations are defined on that object.  You can delete the "
"``__annotations__`` attribute using ``del fn.__annotations__``, but if you "
"then access ``fn.__annotations__`` the object will create a new empty dict "
"that it will store and return as its annotations.  Deleting the annotations "
"on a function before it has lazily created its annotations dict will throw "
"an ``AttributeError``; using ``del fn.__annotations__`` twice in a row is "
"guaranteed to always throw an ``AttributeError``."
msgstr ""
"En todas las versiones de Python 3, los objetos de función crean de forma "
"diferida un diccionario de anotaciones si no hay anotaciones definidas en "
"ese objeto. Puede eliminar el atributo ``__annotations__`` usando ``del fn."
"__annotations__``, pero si luego accede a ``fn.__annotations__``, el objeto "
"creará un diccionario nuevo vacío que almacenará y retornará como sus "
"anotaciones. Eliminar las anotaciones en una función antes de que haya "
"creado su diccionario de anotaciones de forma diferida arrojará un "
"``AttributeError``; el uso de dos veces seguidas de ``del fn."
"__annotations__`` garantiza que siempre arroje un ``AttributeError``."

#: ../Doc/howto/annotations.rst:203
msgid ""
"Everything in the above paragraph also applies to class and module objects "
"in Python 3.10 and newer."
msgstr ""
"Todo en el párrafo anterior también se aplica a los objetos de clase y "
"módulo en las versiones de Python 3.10 y posteriores."

#: ../Doc/howto/annotations.rst:206
msgid ""
"In all versions of Python 3, you can set ``__annotations__`` on a function "
"object to ``None``.  However, subsequently accessing the annotations on that "
"object using ``fn.__annotations__`` will lazy-create an empty dictionary as "
"per the first paragraph of this section.  This is *not* true of modules and "
"classes, in any Python version; those objects permit setting "
"``__annotations__`` to any Python value, and will retain whatever value is "
"set."
msgstr ""
"En todas las versiones de Python 3, puede establecer ``__annotations__`` en "
"un objeto de función en ``None``. Sin embargo, al acceder después a las "
"anotaciones en ese objeto usando ``fn.__annotations__`` se creará un "
"diccionario vacío de forma diferida según el primer párrafo de esta sección. "
"Esto *no* es cierto para módulos y clases, en cualquier versión de Python; "
"esos objetos permiten establecer ``__annotations__`` en cualquier valor de "
"Python, y conservarán cualquier valor que se establezca."

#: ../Doc/howto/annotations.rst:214
msgid ""
"If Python stringizes your annotations for you (using ``from __future__ "
"import annotations``), and you specify a string as an annotation, the string "
"will itself be quoted.  In effect the annotation is quoted *twice.*  For "
"example::"
msgstr ""
"Si Python encadena sus anotaciones por usted (usando ``from __future__ "
"import annotations``), y especifica una cadena de caracteres como una "
"anotación, la cadena de caracteres en sí se citará. En efecto, la anotación "
"se cita *dos veces.* Por ejemplo::"

#: ../Doc/howto/annotations.rst:225
msgid ""
"This prints ``{'a': \"'str'\"}``.  This shouldn't really be considered a "
"\"quirk\"; it's mentioned here simply because it might be surprising."
msgstr ""
"Esto imprime ``{'a': \"'str'\"}``. En realidad, esto no debería considerarse "
"una \"peculiaridad\"; aquí se menciona simplemente porque podría "
"sorprenderle."