From 3f8f856b8c2244c15b7e5ec5b23d12fa350096c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Sun, 10 May 2020 20:36:56 +0200 Subject: [PATCH 01/14] Traduccion parcial de typing, hasta cadena 60 --- library/typing.po | 188 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 165 insertions(+), 23 deletions(-) diff --git a/library/typing.po b/library/typing.po index 7530356269..1ee4420a4a 100644 --- a/library/typing.po +++ b/library/typing.po @@ -6,27 +6,28 @@ # Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-05-10 20:35+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" -"Content-Type: text/plain; charset=utf-8\n" +"Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" +"Last-Translator: Héctor Canto \n" +"Language: es\n" +"X-Generator: Poedit 2.0.6\n" #: ../Doc/library/typing.rst:2 msgid ":mod:`typing` --- Support for type hints" -msgstr "" +msgstr ":mod:`typing` --- Soporte para *type hints*" #: ../Doc/library/typing.rst:9 msgid "**Source code:** :source:`Lib/typing.py`" -msgstr "" +msgstr "**Source code:** :source:`Lib/typing.py`" #: ../Doc/library/typing.rst:13 msgid "" @@ -34,6 +35,9 @@ msgid "" "They can be used by third party tools such as type checkers, IDEs, linters, " "etc." msgstr "" +"En tiempo de ejecución, Python no impone las anotaciones de tipado en " +"funciones y variables. Pueden ser utilizadas por herramientas de terceros " +"como validadores de tipado, IDEs, linters, etc." #: ../Doc/library/typing.rst:19 msgid "" @@ -44,11 +48,20 @@ msgid "" "full specification please see :pep:`484`. For a simplified introduction to " "type hints see :pep:`483`." msgstr "" +"Este módulo proporciona soporte en tiempo de ejecución (*runtime*) para " +"anotaciones de tipado, tal y como se especifica en :pep:`484`, :pep:`526`, :" +"pep:`544`, :pep:`586`, :pep:`589`, y :pep:`591`. Lo características " +"fundamenteales consisten en los tipos :data:`Any`, :data:`Union`, :data:" +"`Tuple`, :data:`Callable`, :class:`TypeVar`, and :class:`Generic`. Para la " +"especificación completa véase :pep:`484`. Para una introducción " +"simplificada a *type hints* véase :pep:`483`." #: ../Doc/library/typing.rst:27 msgid "" "The function below takes and returns a string and is annotated as follows::" msgstr "" +"La siguiente función toma y retorna una cadena de texto, que se anota de la " +"siguiente manera::" #: ../Doc/library/typing.rst:32 msgid "" @@ -56,42 +69,54 @@ msgid "" "type :class:`str` and the return type :class:`str`. Subtypes are accepted as " "arguments." msgstr "" +"En la función ``greeting``, se espera que el argumento ``name`` sea de " +"tipo. :class:`str` y que el tipo retornado :class:`str`. Los subtipos " +"también son aceptados como argumento válido." #: ../Doc/library/typing.rst:37 msgid "Type aliases" -msgstr "" +msgstr "Alias de tipo" #: ../Doc/library/typing.rst:39 msgid "" "A type alias is defined by assigning the type to the alias. In this example, " "``Vector`` and ``List[float]`` will be treated as interchangeable synonyms::" msgstr "" +"Un alias de tipo se define asignando el tipo al alias. En este ejemplo, " +"``Vector`` y ``List[float]`` serán tratados como sinónimos intercambiables::" #: ../Doc/library/typing.rst:51 msgid "" "Type aliases are useful for simplifying complex type signatures. For " "example::" msgstr "" +"Los alias de tipo son útiles para simplificar indicadores de tipo complejos. " +"Por ejemplo::" #: ../Doc/library/typing.rst:69 msgid "" "Note that ``None`` as a type hint is a special case and is replaced by " "``type(None)``." msgstr "" +"Nótese que ``None`` como indicador de tipo es un caso especial y es " +"substituido por ``type(None)``." #: ../Doc/library/typing.rst:75 msgid "NewType" -msgstr "" +msgstr "NewType" #: ../Doc/library/typing.rst:77 msgid "Use the :func:`NewType` helper function to create distinct types::" -msgstr "" +msgstr "Úsese la función auxiliar func:`NewType` para crear distintos tipos::" #: ../Doc/library/typing.rst:84 +#, fuzzy msgid "" "The static type checker will treat the new type as if it were a subclass of " "the original type. This is useful in helping catch logical errors::" msgstr "" +"El validador estático de tipos tratará el nuevo tipo como si fuera una " +"subclase del tipo original. Esto es útil para capturar errores lógicos::" #: ../Doc/library/typing.rst:96 msgid "" @@ -100,6 +125,10 @@ msgid "" "pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent " "you from accidentally creating a ``UserId`` in an invalid way::" msgstr "" +"Se pueden realizar todas las operaciones de ``int`` en una variable de tipo " +"``UserId``, pero el resultado siempre será de tipo ``int``. Esto permite " +"pasar un ``UserId`` allí donde se espere un ``int``, pero evitará la " +"creación accidental de un ``UserId`` de manera incorrecta::" #: ../Doc/library/typing.rst:104 msgid "" @@ -109,32 +138,46 @@ msgid "" "it. That means the expression ``Derived(some_value)`` does not create a new " "class or introduce any overhead beyond that of a regular function call." msgstr "" +"Nótese que estas comprobaciones son impuestas solo en la validación de " +"tipado estática. En tiempo de ejecución, la sentencia `Derived = " +"NewType('Derived', Base)` hará de ``Derived`` una función que retornará " +"inmediatamente el parámetro que se le pase. Esto implica que la expresión " +"``Derived(some_value)`` no crea una nueva clase o genera más coste que la " +"llamada a una función normal." #: ../Doc/library/typing.rst:110 msgid "" "More precisely, the expression ``some_value is Derived(some_value)`` is " "always true at runtime." msgstr "" +"Más concretamente, la expresión ``some_value is Derived(some_value)`` será " +"siempre verdadera en tiempo de ejecución." #: ../Doc/library/typing.rst:113 msgid "" "This also means that it is not possible to create a subtype of ``Derived`` " "since it is an identity function at runtime, not an actual type::" msgstr "" +"Esto también implica que no es imposible crear un subtipo de ``Derived`` ya " +"que una función de identidad en tiempo de ejecución, no un tipo propiamente " +"dicho::" #: ../Doc/library/typing.rst:123 msgid "" "However, it is possible to create a :func:`NewType` based on a 'derived' " "``NewType``::" msgstr "" +"Sin embargo, es posible crear un :func:`NewType` basado en un ``NewType`` " +"'derivado::" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." msgstr "" +"y la comprobación de tipo para ``ProUserId`` funcionará como se espera." #: ../Doc/library/typing.rst:133 msgid "See :pep:`484` for more details." -msgstr "" +msgstr "Véase :pep:`484` para más detalle." #: ../Doc/library/typing.rst:137 msgid "" @@ -143,8 +186,15 @@ msgid "" "treat ``Alias`` as being *exactly equivalent* to ``Original`` in all cases. " "This is useful when you want to simplify complex type signatures." msgstr "" +"Recuérdese que el uso de alias de tipo implica que los dos tipos son " +"*equivalentes* entre sí. Haciendo que ``Alias = Original`` provocará que el " +"Validador estático de tipos trate ``Alias`` como algo *exactamente " +"equivalente* a ``Original`` en todos los casos. Esto es útil para cuando se " +"quiera simplificar indicadores de tipo complejos." +# buscar mejor traduccion para In contrast #: ../Doc/library/typing.rst:142 +#, fuzzy msgid "" "In contrast, ``NewType`` declares one type to be a *subtype* of another. " "Doing ``Derived = NewType('Derived', Original)`` will make the static type " @@ -153,10 +203,16 @@ msgid "" "``Derived`` is expected. This is useful when you want to prevent logic " "errors with minimal runtime cost." msgstr "" +"En cotraste, ``NewType`` de clara un tipo que es *subtipo* de otro. " +"Haciendo ``Derived = NewType('Derived', Original)`` hará que el Validador " +"estático de tipos trate ``Derived`` como una *subclase* de ``Original``, lo " +"que implica que un valor de tipo ``Original`` no puede ser usado allí donde " +"se espere un valor de tipo ``Derived``. Esto es útil para prevenir errores " +"lógicos con un coste de ejecución mínimo." #: ../Doc/library/typing.rst:152 msgid "Callable" -msgstr "" +msgstr "Callable" #: ../Doc/library/typing.rst:154 msgid "" @@ -166,7 +222,7 @@ msgstr "" #: ../Doc/library/typing.rst:157 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/library/typing.rst:168 msgid "" @@ -174,69 +230,98 @@ msgid "" "the call signature by substituting a literal ellipsis for the list of " "arguments in the type hint: ``Callable[..., ReturnType]``." msgstr "" +"Es posible declarar el tipo de retorno de un *callable* sin especificar " +"tipos en los parámetros substituyendo la lista de argumentos por unos puntos " +"suspensivos (...) en el indicador de tipo: ``Callable[..., ReturnType]``." #: ../Doc/library/typing.rst:175 +#, fuzzy msgid "Generics" -msgstr "" +msgstr "Genéricos" #: ../Doc/library/typing.rst:177 +#, fuzzy msgid "" "Since type information about objects kept in containers cannot be statically " "inferred in a generic way, abstract base classes have been extended to " "support subscription to denote expected types for container elements." msgstr "" +"Ya que la información de tipo sobre objetos se mantiene en contenedores no " +"es posible inferir estáticamente de manera genérica, ..." #: ../Doc/library/typing.rst:188 msgid "" "Generics can be parameterized by using a new factory available in typing " "called :class:`TypeVar`." msgstr "" +"Los genéricos se pueden parametrizar usando una nueva factoría disponible en " +"*typing* llamada :class:`TypeVar`." #: ../Doc/library/typing.rst:202 msgid "User-defined generic types" -msgstr "" +msgstr "Tipos genéricos definidos por el usuario" #: ../Doc/library/typing.rst:204 msgid "A user-defined class can be defined as a generic class." msgstr "" +"Una clase definida por el usario puede ser definida como una clase genérica." #: ../Doc/library/typing.rst:230 +#, fuzzy msgid "" "``Generic[T]`` as a base class defines that the class ``LoggedVar`` takes a " "single type parameter ``T`` . This also makes ``T`` valid as a type within " "the class body." msgstr "" +"``Generic[T]`` como clase base define que la clase ``LoggedVar`` toma un " +"solo parámetro ``T``. Esto también implica que ``T`` es un tipo válido " +"dentro del cuerpo de la clase." +# revisar en su contexto #: ../Doc/library/typing.rst:234 +#, fuzzy msgid "" "The :class:`Generic` base class defines :meth:`__class_getitem__` so that " "``LoggedVar[t]`` is valid as a type::" msgstr "" +"La clase base :class:`Generic` define :meth:`__class_getitem__` para que " +"``LoggedVar[t]`` sea válido como tipo::" +# revisar constrained y que es una type variable en su contexto #: ../Doc/library/typing.rst:243 +#, fuzzy msgid "" "A generic type can have any number of type variables, and type variables may " "be constrained::" msgstr "" +"Un tipo genérico puede tener un número indefinido de variables de tipo, y " +"las variables de tipo estar limitadas::" +# revisar la relacion argumento-variable-clase #: ../Doc/library/typing.rst:255 +#, fuzzy msgid "" "Each type variable argument to :class:`Generic` must be distinct. This is " "thus invalid::" msgstr "" +"Cada argumento de variable de tipo en una clase :class:`Generic` debe ser " +"distinto. Así, será inválido::" #: ../Doc/library/typing.rst:266 msgid "You can use multiple inheritance with :class:`Generic`::" -msgstr "" +msgstr "Se puede utilizar herencia múltiple con :class:`Generic`::" #: ../Doc/library/typing.rst:275 +#, fuzzy msgid "" "When inheriting from generic classes, some type variables could be fixed::" msgstr "" +"Cuando se hereda de clases genéricas, se pueden fijar algunas variables de " +"tipo::" #: ../Doc/library/typing.rst:284 msgid "In this case ``MyDict`` has a single parameter, ``T``." -msgstr "" +msgstr "En este caso ``MyDict`` tiene un solo parámetro ``T``." #: ../Doc/library/typing.rst:286 msgid "" @@ -244,26 +329,39 @@ msgid "" "for each position. In the following example, ``MyIterable`` is not generic " "but implicitly inherits from ``Iterable[Any]``::" msgstr "" +"Al usar una clase genérica sin especificar parámetros de tipo se asume :data:" +"`Any` para todas las posiciones. En el siguiente ejemplo, ``MyIterable`` no " +"es genérico pero hereda implicitamente de ``Iterable[Any]``::" #: ../Doc/library/typing.rst:294 msgid "User defined generic type aliases are also supported. Examples::" msgstr "" +"Son posibles los alias de tipos genéricos definidos por el usuario . " +"Ejemplos::" +# custom: personalizada, personalizable o propia? #: ../Doc/library/typing.rst:310 +#, fuzzy msgid ":class:`Generic` no longer has a custom metaclass." -msgstr "" +msgstr ":class:`Generic` ya no posee una metaclase personalizable." #: ../Doc/library/typing.rst:313 +#, fuzzy msgid "" "A user-defined generic class can have ABCs as base classes without a " "metaclass conflict. Generic metaclasses are not supported. The outcome of " "parameterizing generics is cached, and most types in the typing module are " "hashable and comparable for equality." msgstr "" +"Un clase genérica definida por el usuario puede tener clases ABC como clase " +"base sin conflicto de metaclase. Las metaclases genéricas no son posibles. " +"El resultado de parametrizar clases genéricas se cachea, y la mayoría de los " +"tipos en el módulo *typing* pueden tener un hash (*hasheable*) y ser " +"comparable por igualdad (*comparable for equility*)." #: ../Doc/library/typing.rst:320 msgid "The :data:`Any` type" -msgstr "" +msgstr "El tipo :data:`Any`" #: ../Doc/library/typing.rst:322 msgid "" @@ -271,12 +369,18 @@ msgid "" "every type as being compatible with :data:`Any` and :data:`Any` as being " "compatible with every type." msgstr "" +"Un caso especial de tipo es :data:`Any`. Un Validador estático de tipos " +"tratará cualquier tipo como compatible con :data:`Any`, y :data:`Any` como " +"compatible con todos los tipos." #: ../Doc/library/typing.rst:326 +#, fuzzy msgid "" "This means that it is possible to perform any operation or method call on a " "value of type on :data:`Any` and assign it to any variable::" msgstr "" +"Esto significa que es posible realizar cualquier operación o llamada a un " +"método on a value of type en :data:`Any`y asignarlo a cualquier variable::" #: ../Doc/library/typing.rst:344 msgid "" @@ -286,18 +390,27 @@ msgid "" "declared to be of type :class:`str` and receives an :class:`int` value at " "runtime!" msgstr "" +"Nótese que no se realiza comprobación de tipo cuando se asigna un valor de " +"tipo :data:`Any` a un tipo más preciso. Por ejemplo, el Validador estático " +"de tipos no reportó ningún error cuando se asignó ``a`` a ``s``, aún cuando " +"se declaró``s`` como de tipo :class:`str y recibió un valor :class:`int` en " +"tiempo de ejecución." #: ../Doc/library/typing.rst:350 msgid "" "Furthermore, all functions without a return type or parameter types will " "implicitly default to using :data:`Any`::" msgstr "" +"Además, todas las funciones sin un tipo de retorno o tipos en los parámetros " +"serán asignadas implícitamente a :data:`Any` por defecto::" #: ../Doc/library/typing.rst:363 msgid "" "This behavior allows :data:`Any` to be used as an *escape hatch* when you " "need to mix dynamically and statically typed code." msgstr "" +"Este comportamiento permite que :data:`Any` sea usado como una *vía de " +"escape* cuando es necesario mezclar código tipado estática y dinámicamente." #: ../Doc/library/typing.rst:366 msgid "" @@ -306,6 +419,10 @@ msgid "" "unlike :data:`Any`, the reverse is not true: :class:`object` is *not* a " "subtype of every other type." msgstr "" +"Compárese el comportamiento de :data:`Any` con el de :class:`object`. De " +"manera similar a :data:`Any`, todo tipo es un subtipo de :class:`object`. " +"Sin embargo, en oposición a :data:`Any`, lo contrario no es cierto: :class:" +"`object` *no* es un subtipo de ningún otro tipo." #: ../Doc/library/typing.rst:371 msgid "" @@ -314,16 +431,23 @@ msgid "" "it as a return value) of a more specialized type is a type error. For " "example::" msgstr "" +"Esto implica que cuando el tipo de un valor es :class:`object`, un validador " +"de tipos rechazará prácticamente todas las operaciones con él, y al " +"asignarlo a una variable (o usarlo como valor de retorno) de un tipo más " +"preciso será un error de tipo. Por ejemplo::" #: ../Doc/library/typing.rst:393 msgid "" "Use :class:`object` to indicate that a value could be any type in a typesafe " "manner. Use :data:`Any` to indicate that a value is dynamically typed." msgstr "" +"Úsese :class:`object` para indicar que un valor puede ser de cualquier tipo " +"de manera segura. Úsese :data:`Any` para indicar que un valor es de tipado " +"dinámico." #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" -msgstr "" +msgstr "Tipado nominal vs estructural" #: ../Doc/library/typing.rst:400 msgid "" @@ -331,7 +455,11 @@ msgid "" "subtyping*. This means that a class ``A`` is allowed where a class ``B`` is " "expected if and only if ``A`` is a subclass of ``B``." msgstr "" +"Inicialmente, el :pep:`484` definió el sistema de tipado estático de Python " +"como *nominal*. Esto implica que una clase ``A`` será permitida allí donde " +"se espere una clase ``be si y solo si ``A`` es una subclase de ``B``." +# Frase ultracompleja, necesitar una revisión fuerte #: ../Doc/library/typing.rst:404 msgid "" "This requirement previously also applied to abstract base classes, such as :" @@ -340,6 +468,12 @@ msgid "" "would normally do in idiomatic dynamically typed Python code. For example, " "this conforms to the :pep:`484`::" msgstr "" +"Este requisito se aplicaba anteriormente a clases base abstractas (ABC), " +"tales como :class:`Iterable`. El problema con esta estrategia es que una " +"clase tiene que ser marcada explícitamente para proporcionar tal " +"funcionalidad, lo que resulta poco *pythónico* (idiomático) y poco ajustado " +"a lo que uno normalmente haría en un código Python tipado dinámicamente. Por " +"ejemplo, esto se ajusta al :pep:`484`::" #: ../Doc/library/typing.rst:417 msgid "" @@ -349,6 +483,11 @@ msgid "" "``Iterable[int]`` by static type checkers. This is known as *structural " "subtyping* (or static duck-typing)::" msgstr "" +"El :pep:`544` permite resolver este problema al permitir escribir el código " +"anterior sin una clase base explícita en la definición de la clase, " +"permitiendo que el Validador estático de tipo considere implícitamente que " +"``Bucket`` es un subtipo tanto de ``Sized`` como de ``Iterable[int]``. Esto " +"se conoce como tipado *estructural* (o *duck-typing* estático)::" #: ../Doc/library/typing.rst:433 msgid "" @@ -356,22 +495,25 @@ msgid "" "define new custom protocols to fully enjoy structural subtyping (see " "examples below)." msgstr "" +"Por otra parte, creando subclases de la clase especial :class:`Protocol`, " +"el usuario puede definir nuevos protocolos personalizados y beneficiarse del " +"tipado estructual (véanse los ejemplos de abajo)." #: ../Doc/library/typing.rst:439 msgid "Classes, functions, and decorators" -msgstr "" +msgstr "Clases, funciones y decoradores" #: ../Doc/library/typing.rst:441 msgid "The module defines the following classes, functions and decorators:" -msgstr "" +msgstr "El módulo define las siguientes clases, funciones y decoradores:" #: ../Doc/library/typing.rst:445 msgid "Type variable." -msgstr "" +msgstr "Variable de tipo" #: ../Doc/library/typing.rst:447 ../Doc/library/typing.rst:915 msgid "Usage::" -msgstr "" +msgstr "Uso::" #: ../Doc/library/typing.rst:452 msgid "" From cf6f6d6421e02651df5195a46eab8f55e77d9b41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Sun, 10 May 2020 20:38:41 +0200 Subject: [PATCH 02/14] Arreglar translator, actualizar memoria --- .overrides/translation-memory.rst | 21 +++++++++++++++++++-- TRANSLATORS | 2 +- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/.overrides/translation-memory.rst b/.overrides/translation-memory.rst index fbb379151e..aeac077ae7 100644 --- a/.overrides/translation-memory.rst +++ b/.overrides/translation-memory.rst @@ -74,8 +74,25 @@ Términos y bigramas Ruta. ``glossary.po`` realease - version ``HOWTO`` - + version ``HOWTO`` + + runtime + tiempo de ejecución ``tutorial/classes.po`` + + static type checker + Validador estático de tipos + Notas: mantener la mayúscula, usar validación cuando se refiera a la acción y no al agente. + + third-party + de terceros ``library/typing.po`` + + type hint + indicador de tipo ``library/typing.po`` + + type annotation ``library/typing.po`` + anotación de tipo + Nota: úsese como sinónimo de *type hint* + underscore guión bajo ``glossary.po`` diff --git a/TRANSLATORS b/TRANSLATORS index 6fe4ae3705..eb6cc33f27 100644 --- a/TRANSLATORS +++ b/TRANSLATORS @@ -1,4 +1,4 @@ -Héctor Canto (@hectorcanto_dev) +Héctor Canto (@hectorcanto) Carlos Crespo (@cacrespo) Raúl Cumplido (@raulcd) Nicolás Demarchi (@gilgamezh) From 50424f8ae65bed92136c5e78e1652cc0e7c1522e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Wed, 20 May 2020 20:07:13 +0200 Subject: [PATCH 03/14] Casi todas las cadenas revisadas, falta revision --- library/typing.po | 387 ++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 323 insertions(+), 64 deletions(-) diff --git a/library/typing.po b/library/typing.po index 1ee4420a4a..803e1106fa 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-10 20:35+0200\n" +"PO-Revision-Date: 2020-05-20 20:06+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -515,6 +515,7 @@ msgstr "Variable de tipo" msgid "Usage::" msgstr "Uso::" +# parece que falta un link en Generic #: ../Doc/library/typing.rst:452 msgid "" "Type variables exist primarily for the benefit of static type checkers. " @@ -522,6 +523,11 @@ msgid "" "function definitions. See class Generic for more information on generic " "types. Generic functions work as follows::" msgstr "" +"Las variables de tipo son principalmente para ayudar a los validadores " +"estáticos de tipos. Sirven tanto como de parámetros para tipos genéricos " +"como para definición de funciones genéricas. Véase la clase *Generic* para " +"más información sobre tipos genéricos. Las funciones genéricas funcionan " +"como sigue::" #: ../Doc/library/typing.rst:465 msgid "" @@ -530,12 +536,19 @@ msgid "" "arguments are instances of some subclass of :class:`str`, the return type is " "still plain :class:`str`." msgstr "" +"La interfaz de los ejemplos anteriores es esencialmente una sobrecarga de " +"``(0str, str) -> str`` y ``(bytes, bytes) -> bytes``. Nótese también que " +"aunque los argumentos sean instancias de alguna subclase de :class:`str`, el " +"tipo retornado aún será una simple :class:`str`." #: ../Doc/library/typing.rst:470 msgid "" "At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`. In general, :" "func:`isinstance` and :func:`issubclass` should not be used with types." msgstr "" +"En tiempo de ejecución, ``isinstance(x, T)`` lanzará una excepción :exc:" +"`TypeError`. En general, :func:`isinstance` y :func:`issubclass` no se " +"deben usar con tipos." #: ../Doc/library/typing.rst:473 msgid "" @@ -546,10 +559,17 @@ msgid "" "an actual type substituted (explicitly or implicitly) for the type variable " "must be a subclass of the boundary type, see :pep:`484`." msgstr "" +"Las variables de tipo pueden ser marcadas como covariantes o contravariantes " +"pasando ``covariant=True`` o ``contravariant=True``, respectivamente. Véase :" +"pep:`484` para más detalles. Por defecto, las variables de tipo son " +"invariantes. Opcionalmente, una variable de tipo puede especificar un límite " +"superior usando ``bound=``. Esto significa que el tipo " +"(explícitamente o implícitamente) tiene que ser una subclase del tipo " +"limite, véase :pep:`484`." #: ../Doc/library/typing.rst:483 msgid "Abstract base class for generic types." -msgstr "" +msgstr "Clase base abstracta para tipos genéricos." #: ../Doc/library/typing.rst:485 msgid "" @@ -557,33 +577,44 @@ msgid "" "this class with one or more type variables. For example, a generic mapping " "type might be defined as::" msgstr "" +"Un tipo genérico se declara habitualmente heredando de una instancia de " +"esta clase con una o más variables de tipo. Por ejemplo, un tipo de mapeo " +"genérico se podría definir como::" #: ../Doc/library/typing.rst:494 msgid "This class can then be used as follows::" -msgstr "" +msgstr "Entonces, esta clase se puede usar como sigue::" #: ../Doc/library/typing.rst:507 msgid "" "Base class for protocol classes. Protocol classes are defined like this::" msgstr "" +"Clase base para clases protocolo. Las clases protocolo se definen así::" #: ../Doc/library/typing.rst:513 msgid "" "Such classes are primarily used with static type checkers that recognize " "structural subtyping (static duck-typing), for example::" msgstr "" +"Tales clases son usadas principalmente con validadores estáticos de tipos " +"que detectan subtipado estructural (*duck-typing* estático), por ejemplo::" #: ../Doc/library/typing.rst:525 +#, fuzzy msgid "" "See :pep:`544` for details. Protocol classes decorated with :func:" "`runtime_checkable` (described later) act as simple-minded runtime protocols " "that check only the presence of given attributes, ignoring their type " "signatures." msgstr "" +"Véase :pep:`544` para más detalles. Las clases protocolo decoradas con func:" +"`runtime_checkable` (que se explica más adelante) se comportan como " +"protocolos naif en tiempo de ejecución que solo comprueban la presencia de " +"atributos dados, ignorando su firma de tipo." #: ../Doc/library/typing.rst:530 msgid "Protocol classes can be generic, for example::" -msgstr "" +msgstr "Las clases protocolo pueden ser genéricas, por ejemplo::" #: ../Doc/library/typing.rst:540 msgid "" @@ -592,10 +623,14 @@ msgid "" "classes themselves -- specifically, it will accept the *class object* of " "``C``. For example::" msgstr "" +"Una variable indicada como ``C`` puede aceptar valores de tipo ``C``. Sin " +"embargo, un variable indicada como ``Type[C]`` puede aceptar valores que son " +"clases en sí mismas -- específicamente, aceptará el *objecto clase* de " +"``C``. Por ejemplo.::" #: ../Doc/library/typing.rst:549 msgid "Note that ``Type[C]`` is covariant::" -msgstr "" +msgstr "Nótese que ``Type[C]`` es covariante::" #: ../Doc/library/typing.rst:561 msgid "" @@ -606,124 +641,148 @@ msgid "" "the indicated base class. How the type checker is required to handle this " "particular case may change in future revisions of :pep:`484`." msgstr "" +"El hecho de que ``Type[C]`` sea covariante implica que todas las subclases " +"de ``C`` deben implementar la misma interfaz del constructor y las mismas " +"interfaces de los métodos de clase que ``C``. El validador de tipos marcará " +"cualquier incumplimiente de esto, pero permitirá llamadas al constructor que " +"coincida con la llamada al constructor de la clase base indicada. El modo en " +"que el validador de tipos debe gestionar este caso particular podría cambiar " +"en futuras revisiones de :pep:`484`." #: ../Doc/library/typing.rst:569 msgid "" "The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:" "`type variables `, and unions of any of these types. For example::" msgstr "" +"Lo únicos parámetros válidos de :class:`Type` son clases, :data:`Any`, :ref:" +"`type variables `, y uniones de cualquiera de los tipos " +"anteriores. Por ejemplo::" #: ../Doc/library/typing.rst:575 msgid "" "``Type[Any]`` is equivalent to ``Type`` which in turn is equivalent to " "``type``, which is the root of Python's metaclass hierarchy." msgstr "" +"``Type[Any]`` es equivalente a ``Type``, que a su vez es equivalente a " +"``type``, que es la raíz de la jerarquía de metaclases de Python." #: ../Doc/library/typing.rst:582 msgid "A generic version of :class:`collections.abc.Iterable`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Iterable`." #: ../Doc/library/typing.rst:586 msgid "A generic version of :class:`collections.abc.Iterator`." -msgstr "" +msgstr "Una versión genérica de :class:`collections.abc.Iterator`." #: ../Doc/library/typing.rst:590 msgid "A generic version of :class:`collections.abc.Reversible`." -msgstr "" +msgstr "Una versión genérica de :class:`collections.abc.Reversible`." #: ../Doc/library/typing.rst:594 msgid "An ABC with one abstract method ``__int__``." -msgstr "" +msgstr "Una ABC con un método abstracto ``__int__``." #: ../Doc/library/typing.rst:598 msgid "An ABC with one abstract method ``__float__``." -msgstr "" +msgstr "Una ABC con un método abstracto ``__float__``." #: ../Doc/library/typing.rst:602 msgid "An ABC with one abstract method ``__complex__``." -msgstr "" +msgstr "Una ABC con un método abstracto ``__complex__``." #: ../Doc/library/typing.rst:606 msgid "An ABC with one abstract method ``__bytes__``." -msgstr "" +msgstr "Una ABC con un método abstracto ``__bytes__``." #: ../Doc/library/typing.rst:610 msgid "An ABC with one abstract method ``__index__``." -msgstr "" +msgstr "Una ABC con un método abstracto ``__index__``." #: ../Doc/library/typing.rst:616 msgid "" "An ABC with one abstract method ``__abs__`` that is covariant in its return " "type." msgstr "" +"Una ABC con un método abstracto ``__abs__`` que es covariante en su tipo " +"retornado." #: ../Doc/library/typing.rst:621 msgid "" "An ABC with one abstract method ``__round__`` that is covariant in its " "return type." msgstr "" +"Una ABC con un método abstracto ``__round__`` que es covariantes en su tipo " +"retornado." #: ../Doc/library/typing.rst:626 msgid "A generic version of :class:`collections.abc.Container`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Container`." #: ../Doc/library/typing.rst:630 msgid "An alias to :class:`collections.abc.Hashable`" -msgstr "" +msgstr "Un alias de :class:`collections.abc.Hashable`" #: ../Doc/library/typing.rst:634 msgid "An alias to :class:`collections.abc.Sized`" -msgstr "" +msgstr "Un alias de :class:`collections.abc.Sized`" #: ../Doc/library/typing.rst:638 msgid "A generic version of :class:`collections.abc.Collection`" -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Collection`" #: ../Doc/library/typing.rst:644 msgid "A generic version of :class:`collections.abc.Set`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Set`." #: ../Doc/library/typing.rst:648 msgid "A generic version of :class:`collections.abc.MutableSet`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.MutableSet`." #: ../Doc/library/typing.rst:652 msgid "" "A generic version of :class:`collections.abc.Mapping`. This type can be used " "as follows::" msgstr "" +"Un versión genérica de :class:`collections.abc.Mapping`. Este tipo se puede " +"usar de la siguiente manera::" #: ../Doc/library/typing.rst:660 msgid "A generic version of :class:`collections.abc.MutableMapping`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.MutableMapping`." #: ../Doc/library/typing.rst:664 msgid "A generic version of :class:`collections.abc.Sequence`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Sequence`." #: ../Doc/library/typing.rst:668 msgid "A generic version of :class:`collections.abc.MutableSequence`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.MutableSequence`." #: ../Doc/library/typing.rst:672 msgid "A generic version of :class:`collections.abc.ByteString`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.ByteString`." #: ../Doc/library/typing.rst:674 msgid "" "This type represents the types :class:`bytes`, :class:`bytearray`, and :" "class:`memoryview`." msgstr "" +"Este tipo representa a los tipos :class:`bytes`, :class:`bytearray`, y :" +"class:`memoryview`." +# shorthand #: ../Doc/library/typing.rst:677 +#, fuzzy msgid "" "As a shorthand for this type, :class:`bytes` can be used to annotate " "arguments of any of the types mentioned above." msgstr "" +"Como abreviación para este tipo, :class:`bytes` se puede usar para anotar " +"argumentos de cualquiera de los tipos mencionados arriba." #: ../Doc/library/typing.rst:682 msgid "A generic version of :class:`collections.deque`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.deque`." #: ../Doc/library/typing.rst:689 msgid "" @@ -731,10 +790,13 @@ msgid "" "annotate arguments it is preferred to use an abstract collection type such " "as :class:`Sequence` or :class:`Iterable`." msgstr "" +"Versión genérica de :class:`list`. Útil para anotar tipos de retorno. Para " +"anotar argumentos es preferible usar un tipo abstracto de colección como :" +"class:`Sequence` o :class:`Iterable`." #: ../Doc/library/typing.rst:694 msgid "This type may be used as follows::" -msgstr "" +msgstr "Este tipo se puede usar del siguiente modo::" #: ../Doc/library/typing.rst:706 msgid "" @@ -742,30 +804,33 @@ msgid "" "return types. To annotate arguments it is preferred to use an abstract " "collection type such as :class:`AbstractSet`." msgstr "" +"Un versión genérica de :class:`builtins.set `. Útil para anotar tipos " +"de retornos. Para anotar argumentos es preferible usar un tipo abstracto de " +"colección como :class:`AbstractSet`." #: ../Doc/library/typing.rst:712 msgid "A generic version of :class:`builtins.frozenset `." -msgstr "" +msgstr "Un versión genérica de :class:`builtins.frozenset `." #: ../Doc/library/typing.rst:716 msgid "A generic version of :class:`collections.abc.MappingView`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.MappingView`." #: ../Doc/library/typing.rst:720 msgid "A generic version of :class:`collections.abc.KeysView`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.KeysView`." #: ../Doc/library/typing.rst:724 msgid "A generic version of :class:`collections.abc.ItemsView`." -msgstr "" +msgstr "Un versión genérica def:class:`collections.abc.ItemsView`." #: ../Doc/library/typing.rst:728 msgid "A generic version of :class:`collections.abc.ValuesView`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.ValuesView`." #: ../Doc/library/typing.rst:732 msgid "A generic version of :class:`collections.abc.Awaitable`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.Awaitable`." #: ../Doc/library/typing.rst:738 msgid "" @@ -773,22 +838,26 @@ msgid "" "order of type variables correspond to those of :class:`Generator`, for " "example::" msgstr "" +"Un versión genérica de :class:`collections.abc.Coroutine.y orden de las " +"variables de tipo se corresponde con aquellas de :class:`Generator`, por " +"ejemplo::" #: ../Doc/library/typing.rst:753 msgid "A generic version of :class:`collections.abc.AsyncIterable`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.AsyncIterable`." #: ../Doc/library/typing.rst:759 msgid "A generic version of :class:`collections.abc.AsyncIterator`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.abc.AsyncIterator`." #: ../Doc/library/typing.rst:765 msgid "A generic version of :class:`contextlib.AbstractContextManager`." -msgstr "" +msgstr "Un versión genérica de :class:`contextlib.AbstractContextManager`." #: ../Doc/library/typing.rst:772 msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`." msgstr "" +"Un versión genérica de :class:`contextlib.AbstractAsyncContextManager`." #: ../Doc/library/typing.rst:779 msgid "" @@ -796,32 +865,37 @@ msgid "" "annotate arguments it is preferred to use an abstract collection type such " "as :class:`Mapping`." msgstr "" +"Un versión genérica de :class:`dict`. Útil para anotar tipos de retorno. " +"Para anotar argumentos es preferible usar un tipo abstracto de colección " +"como :class:`Mapping`." #: ../Doc/library/typing.rst:783 msgid "This type can be used as follows::" -msgstr "" +msgstr "Este tipo se puede usar de la siguiente manera::" #: ../Doc/library/typing.rst:790 msgid "A generic version of :class:`collections.defaultdict`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.defaultdict`." #: ../Doc/library/typing.rst:796 msgid "A generic version of :class:`collections.OrderedDict`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.OrderedDict`." #: ../Doc/library/typing.rst:802 msgid "A generic version of :class:`collections.Counter`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.Counter`." #: ../Doc/library/typing.rst:809 msgid "A generic version of :class:`collections.ChainMap`." -msgstr "" +msgstr "Un versión genérica de :class:`collections.ChainMap`." #: ../Doc/library/typing.rst:816 msgid "" "A generator can be annotated by the generic type ``Generator[YieldType, " "SendType, ReturnType]``. For example::" msgstr "" +"Un generador puede ser anotado con un tipo genérico ``Generator[YieldType, " +"SendType, ReturnType]``. Por ejemplo::" #: ../Doc/library/typing.rst:825 msgid "" @@ -829,24 +903,33 @@ msgid "" "of :class:`Generator` behaves contravariantly, not covariantly or " "invariantly." msgstr "" +"Nótese que en contraste con muchos otros genéricos en el módulo *typing*, el " +"``SendType`` de :class:`Generator` se comporta como contravariante, no " +"covariante ni invariante." #: ../Doc/library/typing.rst:829 msgid "" "If your generator will only yield values, set the ``SendType`` and " "``ReturnType`` to ``None``::" msgstr "" +"Si tu generador solo devolverá valores con *yield*, establece ``SendType`` y " +"``ReturnType`` como ``None``::" #: ../Doc/library/typing.rst:837 msgid "" "Alternatively, annotate your generator as having a return type of either " "``Iterable[YieldType]`` or ``Iterator[YieldType]``::" msgstr "" +"Opcionalmente, anota tu generador con un tipo de retorno de " +"``Iterable[YieldType]`` o ``Iterator[YieldType]``::" #: ../Doc/library/typing.rst:847 msgid "" "An async generator can be annotated by the generic type " "``AsyncGenerator[YieldType, SendType]``. For example::" msgstr "" +"Un generador asíncrono se puede anotar con el tipo genérico " +"``AsyncGenerator[YieldType, SendType]``. Por ejemplo::" #: ../Doc/library/typing.rst:856 msgid "" @@ -859,19 +942,24 @@ msgstr "" msgid "" "If your generator will only yield values, set the ``SendType`` to ``None``::" msgstr "" +"Si tu generador solo devolverá valores con *yield*, establece el " +"``SendType`` como ``None``::" #: ../Doc/library/typing.rst:868 msgid "" "Alternatively, annotate your generator as having a return type of either " "``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::" msgstr "" +"Opcionalmente, anota el generador con un tipo de retorno " +"``AsyncIterable[YieldType]`` o ``AsyncIterator[YieldType]``::" #: ../Doc/library/typing.rst:880 +#, fuzzy msgid "" "``Text`` is an alias for ``str``. It is provided to supply a forward " "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " "``unicode``." -msgstr "" +msgstr "``Text`` es un alias para ``str``. " #: ../Doc/library/typing.rst:884 msgid "" @@ -885,14 +973,22 @@ msgid "" "``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned " "by :func:`open`." msgstr "" +"El tipo genérico ``IO[AnyStr]`` y sus subclases ``TextIO(IO[str])`` y " +"``BinaryIO(IO[bytes])`` representan tipos de flujo de entrada/salida (*I/O " +"streams*) como los usados por la función :func:`open`." #: ../Doc/library/typing.rst:904 +#, fuzzy msgid "" "These type aliases correspond to the return types from :func:`re.compile` " "and :func:`re.match`. These types (and the corresponding functions) are " "generic in ``AnyStr`` and can be made specific by writing ``Pattern[str]``, " "``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``." msgstr "" +"Estos aliases de tipo se corresponden con los tipos de retorno de :func:`re." +"compile` y :func:`re.match`. Estos tipos (y sus correspondientes funciones) " +"son genéricos en ``AnyStr`` y se puede especificar escribiendo " +"``Pattern[str]``, ``Pattern[bytes]``, ``Match[str]``, o ``Match[bytes]``." #: ../Doc/library/typing.rst:913 msgid "Typed version of :func:`collections.namedtuple`." @@ -900,7 +996,7 @@ msgstr "" #: ../Doc/library/typing.rst:921 msgid "This is equivalent to::" -msgstr "" +msgstr "Esto es equivalente a:" #: ../Doc/library/typing.rst:925 msgid "" @@ -926,15 +1022,17 @@ msgstr "" #: ../Doc/library/typing.rst:952 msgid "Backward-compatible usage::" -msgstr "" +msgstr "Uso compatible hacia atrás::" #: ../Doc/library/typing.rst:956 msgid "Added support for :pep:`526` variable annotation syntax." msgstr "" +"Soporte añadido para la sintaxis de anotación de variables propuesto en :pep:" +"`526`." #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." -msgstr "" +msgstr "Soporte añadido para valores por defectos, métodos y *docstrings*" #: ../Doc/library/typing.rst:965 msgid "" @@ -947,13 +1045,18 @@ msgid "" "The ``_field_types`` and ``__annotations__`` attributes are now regular " "dictionaries instead of instances of ``OrderedDict``." msgstr "" +"Los atributos ``_field_types`` y ``__annotations__`` son simples " +"diccionarios en vez de instancias de ``OrderedDict``." #: ../Doc/library/typing.rst:972 msgid "" "A simple typed namespace. At runtime it is equivalent to a plain :class:" "`dict`." msgstr "" +"Un espacio de nombre con un tipado simple. En tiempo de ejecución es " +"equivalente a un simple :class:`dict`." +# sinonimo para imposicion/imponer #: ../Doc/library/typing.rst:975 msgid "" "``TypedDict`` creates a dictionary type that expects all of its instances to " @@ -961,6 +1064,10 @@ msgid "" "consistent type. This expectation is not checked at runtime but is only " "enforced by type checkers. Usage::" msgstr "" +"``TypedDict`` crea un tipo de diccionario que espera que todas sus " +"instancias tenga un cierto set de claves, donde cada clave está asociado con " +"un valor de un tipo determinado. Esta exigencia no se comprueba en tiempo de " +"ejecución y solo es impuesta por validadores de tipo. Uso::" #: ../Doc/library/typing.rst:991 msgid "" @@ -969,25 +1076,39 @@ msgid "" "with older versions of Python that do not support :pep:`526`, ``TypedDict`` " "supports two additional equivalent syntactic forms::" msgstr "" +"Se puede acceder a la información de tipo para introspección via ``Point2D." +"__annotations__`` y ``Point2D.__total__``. Para poder utilizar esta " +"características con versiones antiguas de Python que no soporten :pep:`526`, " +"``TypedDict`` proporciona adicionalmente dos formatos sintácticos " +"equivalentes::" #: ../Doc/library/typing.rst:999 msgid "" "By default, all keys must be present in a TypedDict. It is possible to " "override this by specifying totality. Usage::" msgstr "" +"Por defecto, todas las claves deben estar presentes en un TypedDict. Es " +"posible anularlo especificando el parámetro *total*. De esta manera::" #: ../Doc/library/typing.rst:1007 +#, fuzzy msgid "" "This means that a point2D TypedDict can have any of the keys omitted. A type " "checker is only expected to support a literal False or True as the value of " "the total argument. True is the default, and makes all items defined in the " "class body be required." msgstr "" +"Esto significa que un TypedDict point2D puede omitir cualquiera de sus " +"claves. Un validador de tipos solo esperará un valor literal *False* o " +"*True* como valor del argumento *total. True es el valor por defecto, y hace " +"que todos los ítems definidos en el cuerpo de la clases sean obligatorios." #: ../Doc/library/typing.rst:1012 msgid "" "See :pep:`589` for more examples and detailed rules of using ``TypedDict``." msgstr "" +"Véase :pep:`589` para más ejemplos y reglas detalladas del uso de " +"``TypedDict``." #: ../Doc/library/typing.rst:1018 msgid "" @@ -996,32 +1117,50 @@ msgid "" "into ``List[ForwardRef(\"SomeClass\")]``. This class should not be " "instantiated by a user, but may be used by introspection tools." msgstr "" +"Una clase usada para la representación de tipado interno de referencias " +"directas en forma de cadenas de texto. Por ejemplo, ``List[\"SomeClass\"]`` " +"se transformado implícitamente en ``List[ForwardRef(\"SomeClass\")]``. Esta " +"clase no debe ser instanciada por el usuario, pero puede ser usada por " +"herramientas de introspección." +# Aquí distinto (por distinct) no funciona, el tema es que esos tipos nuevos son personalizados por el usuario. #: ../Doc/library/typing.rst:1025 +#, fuzzy msgid "" "A helper function to indicate a distinct types to a typechecker, see :ref:" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" +"Un función auxiliar para indicar un tipo personalizado a un validador de " +"tipos, véase :ref:`distinct`. En tiempo de ejecución, devuelve una función " +"que devuelve su argumento. Uso::" #: ../Doc/library/typing.rst:1036 msgid "Cast a value to a type." -msgstr "" +msgstr "Convertir un valor a su tipo." +# el "esto" del final queda muy colgado #: ../Doc/library/typing.rst:1038 msgid "" "This returns the value unchanged. To the type checker this signals that the " "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" +"Esto retorna el valor sin modificar. Esto indica al validador de tipos que " +"el valor de retorno tiene el tipo señalado, pero, de manera intencionada, en " +"tiempo de ejecución no se comprobará (se da preferencia a que esto sea lo " +"más rápido posible)." #: ../Doc/library/typing.rst:1045 msgid "" "Return a dictionary containing type hints for a function, method, module or " "class object." msgstr "" +"Devuelve un diccionario que contiene indicaciones de tipo para una función, " +"método, módulo o objeto clase." #: ../Doc/library/typing.rst:1048 +#, fuzzy msgid "" "This is often the same as ``obj.__annotations__``. In addition, forward " "references encoded as string literals are handled by evaluating them in " @@ -1030,18 +1169,35 @@ msgid "" "``None`` is set. For a class ``C``, return a dictionary constructed by " "merging all the ``__annotations__`` along ``C.__mro__`` in reverse order." msgstr "" +"Esto es habitualmente lo mismo que ``obj.__annotations__``. Además, las " +"referencias directas codificadas como cadenas de texto se gestionan " +"evaluándolas en los espacios de nombres``globals`` y ``locals``. Si es " +"necesario, se añade``Optional[t]`` para anotar una función o método, si se " +"establece ``None`` como valor por defecto. Para un clase ``C``, se devuelve " +"un diccionario construído por la combinación de ``__annotations__`` y ``C." +"__mro`` en orden inverso. " +# ver el término typing en contexto #: ../Doc/library/typing.rst:1059 +#, fuzzy msgid "Provide basic introspection for generic types and special typing forms." msgstr "" +"Provee introspección básica para tipos genéricos y formas especiales de " +"tipado." #: ../Doc/library/typing.rst:1061 +#, fuzzy msgid "" "For a typing object of the form ``X[Y, Z, ...]`` these functions return " "``X`` and ``(Y, Z, ...)``. If ``X`` is a generic alias for a builtin or :mod:" "`collections` class, it gets normalized to the original class. For " "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" +"Para un objeto de tipado de la forma ``X[Y,Z, ...]``, esta funciones " +"devuelven ``X`` y ``(Y, Z, ...)``. Si ``X`` es un alias genérico para un " +"clase estándar o una clase de :mod:`collections`, se normaliza a su clase " +"original. Lo objetos no soportados devuelven ``None`` y ``()`` " +"respectivamente. Ejemplos::" #: ../Doc/library/typing.rst:1077 msgid "" @@ -1067,16 +1223,23 @@ msgid "" "A decorator to indicate to type checkers that the decorated method cannot be " "overridden, and the decorated class cannot be subclassed. For example::" msgstr "" +"Un decorador que indica a los validadores de tipos que el método decorado no " +"se puede sobreescribir, o que la clase decorada no se puede derivar " +"(*subclassed*). Por ejemplo::" #: ../Doc/library/typing.rst:1123 ../Doc/library/typing.rst:1350 msgid "" "There is no runtime checking of these properties. See :pep:`591` for more " "details." msgstr "" +"No hay comprobación en tiempo de ejecución para estas propiedades. Véase :" +"pep:`591` para más detalles." +# annotations y type hints parecen sinónimos intercambiables, pero aquí no, se contraponen. Hay que entender el matiz #: ../Doc/library/typing.rst:1130 +#, fuzzy msgid "Decorator to indicate that annotations are not type hints." -msgstr "" +msgstr "Un decorador que indica que la anotaciones no son indicadores de tipo." #: ../Doc/library/typing.rst:1132 msgid "" @@ -1084,41 +1247,62 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" +"Esto funciona como un :term:`decorador (decorador) de clase o función. Con " +"una clase, se aplica recursivamente a todos los métodos definidos en dichas " +"clase (pero no a lo métodos definidos en sus superclases y subclases)." +# ver en contexto #: ../Doc/library/typing.rst:1136 msgid "This mutates the function(s) in place." -msgstr "" +msgstr "Esto modifica la función o funciones presentes." #: ../Doc/library/typing.rst:1140 msgid "Decorator to give another decorator the :func:`no_type_check` effect." msgstr "" +"Un decorador que asigna a otro decorador el efecto de :func:`no_type_check` " +"(no comprobar tipo)." +# El original es algo vago y complejo, intentar traducir el significado intentando no ser literal. #: ../Doc/library/typing.rst:1142 +#, fuzzy msgid "" "This wraps the decorator with something that wraps the decorated function " "in :func:`no_type_check`." msgstr "" +"Esto habilita al decorador para añadir el efecto de `no_type_check`. a la " +"función decorada." #: ../Doc/library/typing.rst:1147 msgid "Decorator to mark a class or function to be unavailable at runtime." msgstr "" +"Un decorador que marca un clase o función como no disponible en tiempo de " +"ejecución." +# como traducimos los archivos stub (pyi y similares) #: ../Doc/library/typing.rst:1149 +#, fuzzy msgid "" "This decorator is itself not available at runtime. It is mainly intended to " "mark classes that are defined in type stub files if an implementation " "returns an instance of a private class::" msgstr "" +"Este decorador no está disponible en tiempo de ejecución. Existe " +"principalmente para marcar clases que se definen en archivos *stub* para " +"cuando una implementación devuelve una instancia de una clase privada::" #: ../Doc/library/typing.rst:1160 msgid "" "Note that returning instances of private classes is not recommended. It is " "usually preferable to make such classes public." msgstr "" +"Nótese que no se recomienda devolver instancias de clases privadas. " +"Normalmente es preferible convertirlas en clases públicas." +# que es un runtime protocol? ver contexto #: ../Doc/library/typing.rst:1165 +#, fuzzy msgid "Mark a protocol class as a runtime protocol." -msgstr "" +msgstr "Marca una clase protocolo como protocolo en tiempo de ejecución." #: ../Doc/library/typing.rst:1167 msgid "" @@ -1127,68 +1311,79 @@ msgid "" "allows a simple-minded structural check, very similar to \"one trick ponies" "\" in :mod:`collections.abc` such as :class:`Iterable`. For example::" msgstr "" +"Tal protocolo se puede usar con :func:`isinstance` y :func:`issubclass`. " +"Esto lanzará una excepción :exc:`TypeError` cuando se aplique a una clase " +"que no es un *protocolo*. Esto permite una comprobación estructural simple, " +"muy semejante a \"one trick ponies\" en mod:`collections.abc` como es :class:" +"`Iterable`. Por ejemplo::" #: ../Doc/library/typing.rst:1178 msgid "" "**Warning:** this will check only the presence of the required methods, not " "their type signatures!" msgstr "" +"**Atención:*** esto solo comprobará la presencia de los métodos requeridos, " +"no su interfaz." #: ../Doc/library/typing.rst:1185 msgid "Special type indicating an unconstrained type." -msgstr "" +msgstr "Tipo especial que indica un tipo sin restricciones." #: ../Doc/library/typing.rst:1187 msgid "Every type is compatible with :data:`Any`." -msgstr "" +msgstr "Todos los tipos son compatibles con :data:`Any`." #: ../Doc/library/typing.rst:1188 msgid ":data:`Any` is compatible with every type." -msgstr "" +msgstr ":data:`Any` es compatible con todos los tipos." +# returns significa que no acaba o que no devuelve nada? ver contexto #: ../Doc/library/typing.rst:1192 +#, fuzzy msgid "Special type indicating that a function never returns. For example::" -msgstr "" +msgstr "Tipo especial que indica que una funciona nunca retorna. Por ejemplo::" #: ../Doc/library/typing.rst:1205 msgid "Union type; ``Union[X, Y]`` means either X or Y." -msgstr "" +msgstr "Tipo unión; ``Union[X, Y]`` significa que o bien X o bien Y." #: ../Doc/library/typing.rst:1207 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" -msgstr "" +msgstr "Para definir una unión, úsese p.e. ``Union[int, str]. Más detalles:" #: ../Doc/library/typing.rst:1209 msgid "The arguments must be types and there must be at least one." -msgstr "" +msgstr "Los argumentos deben ser tipo y haber al menos uno." #: ../Doc/library/typing.rst:1211 msgid "Unions of unions are flattened, e.g.::" -msgstr "" +msgstr "Las uniones de uniones se simplifican (se aplanan), p.e.::" #: ../Doc/library/typing.rst:1215 msgid "Unions of a single argument vanish, e.g.::" -msgstr "" +msgstr "Las uniones con un solo argumento se eliminan, p.e.::" #: ../Doc/library/typing.rst:1219 msgid "Redundant arguments are skipped, e.g.::" -msgstr "" +msgstr "Argumentos repetidos se omiten, p.e.::" #: ../Doc/library/typing.rst:1223 msgid "When comparing unions, the argument order is ignored, e.g.::" msgstr "" +"Cuando se comparan uniones, el orden de los argumentos se ignoran, p.e.::" #: ../Doc/library/typing.rst:1227 msgid "You cannot subclass or instantiate a union." -msgstr "" +msgstr "No se puede derivar (*subclass*) o instanciar una unión." #: ../Doc/library/typing.rst:1229 msgid "You cannot write ``Union[X][Y]``." -msgstr "" +msgstr "No es posible escribir ``Union[X][Y]``." #: ../Doc/library/typing.rst:1231 msgid "You can use ``Optional[X]`` as a shorthand for ``Union[X, None]``." msgstr "" +"Se puede usar ``Optional[X]`` como una versión corta de ``Union[X, None]``." #: ../Doc/library/typing.rst:1233 msgid "Don't remove explicit subclasses from unions at runtime." @@ -1196,11 +1391,11 @@ msgstr "" #: ../Doc/library/typing.rst:1238 msgid "Optional type." -msgstr "" +msgstr "Tipo Optional." #: ../Doc/library/typing.rst:1240 msgid "``Optional[X]`` is equivalent to ``Union[X, None]``." -msgstr "" +msgstr "``Optional[X]`` es equivalente a ``Union[X, None]``." #: ../Doc/library/typing.rst:1242 msgid "" @@ -1209,6 +1404,10 @@ msgid "" "the ``Optional`` qualifier on its type annotation just because it is " "optional. For example::" msgstr "" +"Nótese que no es lo mismo que un argumento opcional, que es aquel que tiene " +"un valor por defecto. Un argumento opcional con un valor por defecto no " +"necesita el indicador ``Optional``en su anotación de tipo simplemente por " +"que sea opcional. Por ejemplo::" #: ../Doc/library/typing.rst:1250 msgid "" @@ -1216,6 +1415,8 @@ msgid "" "``Optional`` is appropriate, whether the argument is optional or not. For " "example::" msgstr "" +"Por otro lado, si se permite un valor ``None``, es apropiado el uso de " +"``Optional``, independientemente de que sea opcional o no. Por ejemplo::" #: ../Doc/library/typing.rst:1259 msgid "" @@ -1223,6 +1424,9 @@ msgid "" "first item of type X and the second of type Y. The type of the empty tuple " "can be written as ``Tuple[()]``." msgstr "" +"El tipo Tuple, ``Tuple[X, Y]`` es el tipo de una tupla de dos ítems con el " +"primer ítem de tipo X y el segundo de tipo Y. El tipo de una tupla vacía se " +"puede escribir así: ``Tuple[()]``." #: ../Doc/library/typing.rst:1263 msgid "" @@ -1230,6 +1434,10 @@ msgid "" "variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " "float and a string." msgstr "" +"Ejemplo: ``Tuple[T1, T2]`` es una tupla de dos elementos con sus " +"correspondientes variables de tipo T1 y T2. ``Tuple[int, float, str]`` es un " +"tupla con un entero, un número de coma flotante, un float y una cadena de " +"texto." #: ../Doc/library/typing.rst:1267 msgid "" @@ -1237,10 +1445,13 @@ msgid "" "ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to " "``Tuple[Any, ...]``, and in turn to :class:`tuple`." msgstr "" +"Para especificar una tupla de longitud variable y tipo homogéneo, se usan " +"puntos suspensivos, p.e. ``Tuple[int, ...]``. Un simple :data:`Tuple` es " +"equivalente a ``Tuple[Any, ...]`` y, a su vez, a :class:`tuple`." #: ../Doc/library/typing.rst:1273 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." -msgstr "" +msgstr "Tipo Callable; ``Callable[[int], str] es una función de (int) -> str." #: ../Doc/library/typing.rst:1275 msgid "" @@ -1248,6 +1459,10 @@ msgid "" "argument list and the return type. The argument list must be a list of " "types or an ellipsis; the return type must be a single type." msgstr "" +"La sintaxis de subscripción (con corchetes *[]*) debe usarse siempre con dos " +"valores: la lista de argumentos y el tipo de retorno. La lista de argumentos " +"debe ser una lista de tipos o unos puntos suspensivos; el tipo de retorno " +"debe ser un único tipo." #: ../Doc/library/typing.rst:1280 msgid "" @@ -1258,13 +1473,23 @@ msgid "" "equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc." "Callable`." msgstr "" +"No existe una sintaxis para indicar argumentos opcionales o con clave " +"(*keyword*); tales funciones rara vez se utilizan como tipos para llamadas. " +"``Callable``[..., ReturnType]`` (puntos suspensivos) se puede usar para " +"indicar que un *callable* admite un número indeterminado de argumentos y " +"retorna ``ReturnType``. Un simple :data:`Callable` es equivalente a " +"``Callable[..., Any]``y, a su vez, a :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1290 +#, fuzzy msgid "" "A type that can be used to indicate to type checkers that the corresponding " "variable or function parameter has a value equivalent to the provided " "literal (or one of several literals). For example::" msgstr "" +"Un tipo puede ser utilizado para indicar a los validadores de tipos que un " +"variable o un parámetro de una función tiene un valor equivalente al valor " +"proveído (o uno de los proveídos). Por ejemplo::" #: ../Doc/library/typing.rst:1304 msgid "" @@ -1272,21 +1497,34 @@ msgid "" "allowed as type argument to ``Literal[...]``, but type checkers may impose " "restrictions. See :pep:`586` for more details about literal types." msgstr "" +"``Literal[...]`` no puede ser derivado. En tiempo de ejecución, se permite " +"un valor arbitrario como argumento de tipo de ``Literal[...]``, pero los " +"validadores de tipos pueden imponer sus restricciones. Véase :pep:`585`` " +"para más detalles sobre tipos literales." #: ../Doc/library/typing.rst:1312 +#, fuzzy msgid "Special type construct to mark class variables." -msgstr "" +msgstr "Construcción de tipo especial para marcar variables de clase." +# Puede haber una entrada mejor para "As introduced" #: ../Doc/library/typing.rst:1314 +#, fuzzy msgid "" "As introduced in :pep:`526`, a variable annotation wrapped in ClassVar " "indicates that a given attribute is intended to be used as a class variable " "and should not be set on instances of that class. Usage::" msgstr "" +"Tal y como introduce :pep:`526`, una anotación de variable rodeado por " +"ClassVar indica que la intención de un atributo dado es ser usado como " +"variable de clase y que no debería ser modificado en las instancias de esa " +"clase. Uso::" +# buscar algo mejro para traducir subscribed sin ser literal, ver solucion para subscription syntax (p.e. subindice -> subindicado) #: ../Doc/library/typing.rst:1322 +#, fuzzy msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." -msgstr "" +msgstr ":data:`ClassVar` solo acepta tipos y no puede ser detallarse más." #: ../Doc/library/typing.rst:1324 msgid "" @@ -1295,30 +1533,46 @@ msgid "" "runtime behavior, but it can be used by third-party type checkers. For " "example, a type checker might flag the following code as an error::" msgstr "" +":data:`ClassVar` no es un clase en sí misma, y no debe ser usado con :func:" +"`isinstance` o :func:`issubclass`. :data:`ClassVar` no modifica el " +"comportamiento do Python en tiempo de ejecución pero puede ser utilizado por " +"validadores de terceros. Por ejemplo, un validador de tipos puede marcar el " +"siguiente código como erróneo::" #: ../Doc/library/typing.rst:1338 msgid "" "A special typing construct to indicate to type checkers that a name cannot " "be re-assigned or overridden in a subclass. For example::" msgstr "" +"Un construcción especial para tipado que indica a los validadores de tipo " +"que un nombre no puede ser reasignado o sobrescrito en una subclase. Por " +"ejemplo::" #: ../Doc/library/typing.rst:1357 msgid "" "``AnyStr`` is a type variable defined as ``AnyStr = TypeVar('AnyStr', str, " "bytes)``." msgstr "" +"``AnyStr`` es una variable de tipo definida como ``AnyStr = " +"TypeVar('AnyStr', str, bytes)``." #: ../Doc/library/typing.rst:1360 msgid "" "It is meant to be used for functions that may accept any kind of string " "without allowing different kinds of strings to mix. For example::" msgstr "" +"Su objetivo es ser usada por funciones que pueden aceptar cualquier tipo de " +"cadena de texto sin permitir mezclar diferentes tipos al mismo tiempo. Por " +"ejemplo::" #: ../Doc/library/typing.rst:1372 msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" +"Un constante especial que se asume como cierta (``True``) por validadores " +"estáticos de tipos de terceros. Es falsa (``False``) en tiempo de ejecución. " +"Uso::" #: ../Doc/library/typing.rst:1381 msgid "" @@ -1327,3 +1581,8 @@ msgid "" "interpreter runtime. Type annotations for local variables are not " "evaluated, so the second annotation does not need to be enclosed in quotes." msgstr "" +"Nótese que la primera anotación de tipo debe estar rodeada por comillas, " +"convirtiéndola en una \"referencia directa\", para ocultar al intérprete la " +"referencia ``expensive_mod`` en tiempo de ejecución. Las anotaciones de tipo " +"para variables locales no se evalúan, así que la segunda anotación no " +"necesita comillas." From a064abf74bb1700bc9df19cc33373becd88bf733 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Thu, 21 May 2020 18:36:56 +0200 Subject: [PATCH 04/14] dos entradas nuevas en la memoria --- .overrides/translation-memory.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.overrides/translation-memory.rst b/.overrides/translation-memory.rst index aeac077ae7..5e34d4aa3d 100644 --- a/.overrides/translation-memory.rst +++ b/.overrides/translation-memory.rst @@ -55,12 +55,18 @@ Términos y bigramas docstring docstring. ``library/idle.po`` + key + clave + handler gestor ``tutorial/errors.po`` handle exception Gestionar excepción. ``tutorial/inputoutput.po`` + helper function + función auxiliar ``library/typing.po`` + loop Bucle. ``tutorial/controlflow.po`` From 443e99272e995bfe29bf5f2fd761c66961be1173 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Sat, 23 May 2020 20:27:38 +0200 Subject: [PATCH 05/14] =?UTF-8?q?Revisar=20todas=20las=20fuzzy=20y=20a?= =?UTF-8?q?=C3=B1adir=20sugerencias=20de=20PR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/typing.po | 354 ++++++++++++++++++++++++---------------------- 1 file changed, 183 insertions(+), 171 deletions(-) diff --git a/library/typing.po b/library/typing.po index 803e1106fa..4c4b9d996e 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-20 20:06+0200\n" +"PO-Revision-Date: 2020-05-23 20:18+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -50,7 +50,7 @@ msgid "" msgstr "" "Este módulo proporciona soporte en tiempo de ejecución (*runtime*) para " "anotaciones de tipado, tal y como se especifica en :pep:`484`, :pep:`526`, :" -"pep:`544`, :pep:`586`, :pep:`589`, y :pep:`591`. Lo características " +"pep:`544`, :pep:`586`, :pep:`589`, y :pep:`591`. Las características " "fundamenteales consisten en los tipos :data:`Any`, :data:`Union`, :data:" "`Tuple`, :data:`Callable`, :class:`TypeVar`, and :class:`Generic`. Para la " "especificación completa véase :pep:`484`. Para una introducción " @@ -70,7 +70,7 @@ msgid "" "arguments." msgstr "" "En la función ``greeting``, se espera que el argumento ``name`` sea de " -"tipo. :class:`str` y que el tipo retornado :class:`str`. Los subtipos " +"tipo. :class:`str` y que el tipo retornado sea :class:`str`. Los subtipos " "también son aceptados como argumento válido." #: ../Doc/library/typing.rst:37 @@ -107,10 +107,11 @@ msgstr "NewType" #: ../Doc/library/typing.rst:77 msgid "Use the :func:`NewType` helper function to create distinct types::" -msgstr "Úsese la función auxiliar func:`NewType` para crear distintos tipos::" +msgstr "" +"Úsese la función auxiliar func:`NewType` para crear tipos distinguibles " +"entre sí::" #: ../Doc/library/typing.rst:84 -#, fuzzy msgid "" "The static type checker will treat the new type as if it were a subclass of " "the original type. This is useful in helping catch logical errors::" @@ -139,8 +140,8 @@ msgid "" "class or introduce any overhead beyond that of a regular function call." msgstr "" "Nótese que estas comprobaciones son impuestas solo en la validación de " -"tipado estática. En tiempo de ejecución, la sentencia `Derived = " -"NewType('Derived', Base)` hará de ``Derived`` una función que retornará " +"tipado estática. En tiempo de ejecución, la sentencia ``Derived = " +"NewType('Derived', Bas`` hará de ``Derived`` una función que retornará " "inmediatamente el parámetro que se le pase. Esto implica que la expresión " "``Derived(some_value)`` no crea una nueva clase o genera más coste que la " "llamada a una función normal." @@ -158,9 +159,9 @@ msgid "" "This also means that it is not possible to create a subtype of ``Derived`` " "since it is an identity function at runtime, not an actual type::" msgstr "" -"Esto también implica que no es imposible crear un subtipo de ``Derived`` ya " -"que una función de identidad en tiempo de ejecución, no un tipo propiamente " -"dicho::" +"Esto también implica que no es posible crear un subtipo de ``Derived`` ya " +"que, en tiempo de ejecución, es una función de identidad, no un tipo " +"propiamente dicho::" #: ../Doc/library/typing.rst:123 msgid "" @@ -168,7 +169,7 @@ msgid "" "``NewType``::" msgstr "" "Sin embargo, es posible crear un :func:`NewType` basado en un ``NewType`` " -"'derivado::" +"'derivado'::" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." @@ -187,14 +188,12 @@ msgid "" "This is useful when you want to simplify complex type signatures." msgstr "" "Recuérdese que el uso de alias de tipo implica que los dos tipos son " -"*equivalentes* entre sí. Haciendo que ``Alias = Original`` provocará que el " +"*equivalentes* entre sí. Haciendo ``Alias = Original`` provocará que el " "Validador estático de tipos trate ``Alias`` como algo *exactamente " "equivalente* a ``Original`` en todos los casos. Esto es útil para cuando se " "quiera simplificar indicadores de tipo complejos." -# buscar mejor traduccion para In contrast #: ../Doc/library/typing.rst:142 -#, fuzzy msgid "" "In contrast, ``NewType`` declares one type to be a *subtype* of another. " "Doing ``Derived = NewType('Derived', Original)`` will make the static type " @@ -203,22 +202,26 @@ msgid "" "``Derived`` is expected. This is useful when you want to prevent logic " "errors with minimal runtime cost." msgstr "" -"En cotraste, ``NewType`` de clara un tipo que es *subtipo* de otro. " -"Haciendo ``Derived = NewType('Derived', Original)`` hará que el Validador " -"estático de tipos trate ``Derived`` como una *subclase* de ``Original``, lo " -"que implica que un valor de tipo ``Original`` no puede ser usado allí donde " -"se espere un valor de tipo ``Derived``. Esto es útil para prevenir errores " -"lógicos con un coste de ejecución mínimo." +"En cambio, ``NewType`` declara un tipo que es *subtipo* de otro. Haciendo " +"``Derived = NewType('Derived', Original)`` hará que el Validador estático de " +"tipos trate ``Derived`` como una *subclase* de ``Original``, lo que implica " +"que un valor de tipo ``Original`` no puede ser usado allí donde se espere un " +"valor de tipo ``Derived``. Esto es útil para prevenir errores lógicos con un " +"coste de ejecución mínimo." #: ../Doc/library/typing.rst:152 msgid "Callable" msgstr "Callable" +# que significa aqué Frameworks? parace algo genérico tipo "entidades" #: ../Doc/library/typing.rst:154 +#, fuzzy msgid "" "Frameworks expecting callback functions of specific signatures might be type " "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." msgstr "" +"Entidades que esperen llamadas a funciones con interfaces específicas puede " +"ser anotadas usando ``Callable[[Arg1Type, Arg2Type], ReturnType]``." #: ../Doc/library/typing.rst:157 msgid "For example::" @@ -235,19 +238,19 @@ msgstr "" "suspensivos (...) en el indicador de tipo: ``Callable[..., ReturnType]``." #: ../Doc/library/typing.rst:175 -#, fuzzy msgid "Generics" msgstr "Genéricos" #: ../Doc/library/typing.rst:177 -#, fuzzy msgid "" "Since type information about objects kept in containers cannot be statically " "inferred in a generic way, abstract base classes have been extended to " "support subscription to denote expected types for container elements." msgstr "" -"Ya que la información de tipo sobre objetos se mantiene en contenedores no " -"es posible inferir estáticamente de manera genérica, ..." +"Ya que no es posible inferir estáticamente y de una manera genérica la " +"información de tipo de objetos dentro de contenedores, las clases base " +"abstractas han sido mejoradas para permitir sintaxis de subíndice para " +"denotar los tipos esperados en elementos contenedores." #: ../Doc/library/typing.rst:188 msgid "" @@ -264,10 +267,9 @@ msgstr "Tipos genéricos definidos por el usuario" #: ../Doc/library/typing.rst:204 msgid "A user-defined class can be defined as a generic class." msgstr "" -"Una clase definida por el usario puede ser definida como una clase genérica." +"Una clase definida por el usuario puede ser definida como una clase genérica." #: ../Doc/library/typing.rst:230 -#, fuzzy msgid "" "``Generic[T]`` as a base class defines that the class ``LoggedVar`` takes a " "single type parameter ``T`` . This also makes ``T`` valid as a type within " @@ -279,7 +281,6 @@ msgstr "" # revisar en su contexto #: ../Doc/library/typing.rst:234 -#, fuzzy msgid "" "The :class:`Generic` base class defines :meth:`__class_getitem__` so that " "``LoggedVar[t]`` is valid as a type::" @@ -289,30 +290,27 @@ msgstr "" # revisar constrained y que es una type variable en su contexto #: ../Doc/library/typing.rst:243 -#, fuzzy msgid "" "A generic type can have any number of type variables, and type variables may " "be constrained::" msgstr "" "Un tipo genérico puede tener un número indefinido de variables de tipo, y " -"las variables de tipo estar limitadas::" +"pueden limitarse a tipos concretos::" # revisar la relacion argumento-variable-clase #: ../Doc/library/typing.rst:255 -#, fuzzy msgid "" "Each type variable argument to :class:`Generic` must be distinct. This is " "thus invalid::" msgstr "" "Cada argumento de variable de tipo en una clase :class:`Generic` debe ser " -"distinto. Así, será inválido::" +"distinto. Así, no será válido::" #: ../Doc/library/typing.rst:266 msgid "You can use multiple inheritance with :class:`Generic`::" msgstr "Se puede utilizar herencia múltiple con :class:`Generic`::" #: ../Doc/library/typing.rst:275 -#, fuzzy msgid "" "When inheriting from generic classes, some type variables could be fixed::" msgstr "" @@ -321,7 +319,7 @@ msgstr "" #: ../Doc/library/typing.rst:284 msgid "In this case ``MyDict`` has a single parameter, ``T``." -msgstr "En este caso ``MyDict`` tiene un solo parámetro ``T``." +msgstr "En este caso ``MyDict`` tiene un solo parámetro, ``T``." #: ../Doc/library/typing.rst:286 msgid "" @@ -336,17 +334,14 @@ msgstr "" #: ../Doc/library/typing.rst:294 msgid "User defined generic type aliases are also supported. Examples::" msgstr "" -"Son posibles los alias de tipos genéricos definidos por el usuario . " +"Son posibles los alias de tipos genéricos definidos por el usuario. " "Ejemplos::" -# custom: personalizada, personalizable o propia? #: ../Doc/library/typing.rst:310 -#, fuzzy msgid ":class:`Generic` no longer has a custom metaclass." msgstr ":class:`Generic` ya no posee una metaclase personalizable." #: ../Doc/library/typing.rst:313 -#, fuzzy msgid "" "A user-defined generic class can have ABCs as base classes without a " "metaclass conflict. Generic metaclasses are not supported. The outcome of " @@ -354,10 +349,10 @@ msgid "" "hashable and comparable for equality." msgstr "" "Un clase genérica definida por el usuario puede tener clases ABC como clase " -"base sin conflicto de metaclase. Las metaclases genéricas no son posibles. " -"El resultado de parametrizar clases genéricas se cachea, y la mayoría de los " -"tipos en el módulo *typing* pueden tener un hash (*hasheable*) y ser " -"comparable por igualdad (*comparable for equility*)." +"base sin conflicto de metaclase. Las metaclases genéricas no están " +"permitidas. El resultado de parametrizar clases genéricas se cachea, y la " +"mayoría de los tipos en el módulo *typing* pueden tener un hash y ser " +"comparables por igualdad (*equality*)." #: ../Doc/library/typing.rst:320 msgid "The :data:`Any` type" @@ -374,13 +369,12 @@ msgstr "" "compatible con todos los tipos." #: ../Doc/library/typing.rst:326 -#, fuzzy msgid "" "This means that it is possible to perform any operation or method call on a " "value of type on :data:`Any` and assign it to any variable::" msgstr "" "Esto significa que es posible realizar cualquier operación o llamada a un " -"método on a value of type en :data:`Any`y asignarlo a cualquier variable::" +"método en un valor de tipo :data:`Any`y asignarlo a cualquier variable::" #: ../Doc/library/typing.rst:344 msgid "" @@ -393,7 +387,7 @@ msgstr "" "Nótese que no se realiza comprobación de tipo cuando se asigna un valor de " "tipo :data:`Any` a un tipo más preciso. Por ejemplo, el Validador estático " "de tipos no reportó ningún error cuando se asignó ``a`` a ``s``, aún cuando " -"se declaró``s`` como de tipo :class:`str y recibió un valor :class:`int` en " +"se declaró ``s`` como de tipo :class:`str y recibió un valor :class:`int` en " "tiempo de ejecución." #: ../Doc/library/typing.rst:350 @@ -433,7 +427,7 @@ msgid "" msgstr "" "Esto implica que cuando el tipo de un valor es :class:`object`, un validador " "de tipos rechazará prácticamente todas las operaciones con él, y al " -"asignarlo a una variable (o usarlo como valor de retorno) de un tipo más " +"asignarlo a una variable (o usarlo como valor de retorno) de un tipo más " "preciso será un error de tipo. Por ejemplo::" #: ../Doc/library/typing.rst:393 @@ -447,7 +441,7 @@ msgstr "" #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" -msgstr "Tipado nominal vs estructural" +msgstr "Subtipado nominal vs estructural" #: ../Doc/library/typing.rst:400 msgid "" @@ -457,7 +451,7 @@ msgid "" msgstr "" "Inicialmente, el :pep:`484` definió el sistema de tipado estático de Python " "como *nominal*. Esto implica que una clase ``A`` será permitida allí donde " -"se espere una clase ``be si y solo si ``A`` es una subclase de ``B``." +"se espere una clase ``B`` si y solo si ``A`` es una subclase de ``B``." # Frase ultracompleja, necesitar una revisión fuerte #: ../Doc/library/typing.rst:404 @@ -468,12 +462,12 @@ msgid "" "would normally do in idiomatic dynamically typed Python code. For example, " "this conforms to the :pep:`484`::" msgstr "" -"Este requisito se aplicaba anteriormente a clases base abstractas (ABC), " -"tales como :class:`Iterable`. El problema con esta estrategia es que una " -"clase tiene que ser marcada explícitamente para proporcionar tal " +"Este requisito también se aplicaba anteriormente a clases base abstractas " +"(ABC), tales como :class:`Iterable`. El problema con esta estrategia es que " +"una clase debía de ser marcada explícitamente para proporcionar tal " "funcionalidad, lo que resulta poco *pythónico* (idiomático) y poco ajustado " "a lo que uno normalmente haría en un código Python tipado dinámicamente. Por " -"ejemplo, esto se ajusta al :pep:`484`::" +"ejemplo, esto sí se ajusta al :pep:`484`::" #: ../Doc/library/typing.rst:417 msgid "" @@ -495,9 +489,9 @@ msgid "" "define new custom protocols to fully enjoy structural subtyping (see " "examples below)." msgstr "" -"Por otra parte, creando subclases de la clase especial :class:`Protocol`, " -"el usuario puede definir nuevos protocolos personalizados y beneficiarse del " -"tipado estructual (véanse los ejemplos de abajo)." +"Asimismo, creando subclases de la clase especial :class:`Protocol`, el " +"usuario puede definir nuevos protocolos personalizados y beneficiarse del " +"tipado estructural (véanse los ejemplos de abajo)." #: ../Doc/library/typing.rst:439 msgid "Classes, functions, and decorators" @@ -563,9 +557,9 @@ msgstr "" "pasando ``covariant=True`` o ``contravariant=True``, respectivamente. Véase :" "pep:`484` para más detalles. Por defecto, las variables de tipo son " "invariantes. Opcionalmente, una variable de tipo puede especificar un límite " -"superior usando ``bound=``. Esto significa que el tipo " -"(explícitamente o implícitamente) tiene que ser una subclase del tipo " -"limite, véase :pep:`484`." +"superior usando ``bound=``. Esto significa que el tipo (explícitamente " +"o implícitamente) tiene que ser una subclase del tipo limite, véase :pep:" +"`484`." #: ../Doc/library/typing.rst:483 msgid "Abstract base class for generic types." @@ -577,8 +571,8 @@ msgid "" "this class with one or more type variables. For example, a generic mapping " "type might be defined as::" msgstr "" -"Un tipo genérico se declara habitualmente heredando de una instancia de " -"esta clase con una o más variables de tipo. Por ejemplo, un tipo de mapeo " +"Un tipo genérico se declara habitualmente heredando de una instancia de esta " +"clase con una o más variables de tipo. Por ejemplo, un tipo de mapeo " "genérico se podría definir como::" #: ../Doc/library/typing.rst:494 @@ -600,7 +594,6 @@ msgstr "" "que detectan subtipado estructural (*duck-typing* estático), por ejemplo::" #: ../Doc/library/typing.rst:525 -#, fuzzy msgid "" "See :pep:`544` for details. Protocol classes decorated with :func:" "`runtime_checkable` (described later) act as simple-minded runtime protocols " @@ -609,8 +602,8 @@ msgid "" msgstr "" "Véase :pep:`544` para más detalles. Las clases protocolo decoradas con func:" "`runtime_checkable` (que se explica más adelante) se comportan como " -"protocolos naif en tiempo de ejecución que solo comprueban la presencia de " -"atributos dados, ignorando su firma de tipo." +"protocolos simplistas en tiempo de ejecución que solo comprueban la " +"presencia de atributos dados, ignorando su firma de tipo." #: ../Doc/library/typing.rst:530 msgid "Protocol classes can be generic, for example::" @@ -644,7 +637,7 @@ msgstr "" "El hecho de que ``Type[C]`` sea covariante implica que todas las subclases " "de ``C`` deben implementar la misma interfaz del constructor y las mismas " "interfaces de los métodos de clase que ``C``. El validador de tipos marcará " -"cualquier incumplimiente de esto, pero permitirá llamadas al constructor que " +"cualquier incumplimiento de esto, pero permitirá llamadas al constructor que " "coincida con la llamada al constructor de la clase base indicada. El modo en " "que el validador de tipos debe gestionar este caso particular podría cambiar " "en futuras revisiones de :pep:`484`." @@ -668,7 +661,7 @@ msgstr "" #: ../Doc/library/typing.rst:582 msgid "A generic version of :class:`collections.abc.Iterable`." -msgstr "Un versión genérica de :class:`collections.abc.Iterable`." +msgstr "Una versión genérica de :class:`collections.abc.Iterable`." #: ../Doc/library/typing.rst:586 msgid "A generic version of :class:`collections.abc.Iterator`." @@ -716,7 +709,7 @@ msgstr "" #: ../Doc/library/typing.rst:626 msgid "A generic version of :class:`collections.abc.Container`." -msgstr "Un versión genérica de :class:`collections.abc.Container`." +msgstr "Una versión genérica de :class:`collections.abc.Container`." #: ../Doc/library/typing.rst:630 msgid "An alias to :class:`collections.abc.Hashable`" @@ -728,39 +721,39 @@ msgstr "Un alias de :class:`collections.abc.Sized`" #: ../Doc/library/typing.rst:638 msgid "A generic version of :class:`collections.abc.Collection`" -msgstr "Un versión genérica de :class:`collections.abc.Collection`" +msgstr "Una versión genérica de :class:`collections.abc.Collection`" #: ../Doc/library/typing.rst:644 msgid "A generic version of :class:`collections.abc.Set`." -msgstr "Un versión genérica de :class:`collections.abc.Set`." +msgstr "Una versión genérica de :class:`collections.abc.Set`." #: ../Doc/library/typing.rst:648 msgid "A generic version of :class:`collections.abc.MutableSet`." -msgstr "Un versión genérica de :class:`collections.abc.MutableSet`." +msgstr "Una versión genérica de :class:`collections.abc.MutableSet`." #: ../Doc/library/typing.rst:652 msgid "" "A generic version of :class:`collections.abc.Mapping`. This type can be used " "as follows::" msgstr "" -"Un versión genérica de :class:`collections.abc.Mapping`. Este tipo se puede " +"Una versión genérica de :class:`collections.abc.Mapping`. Este tipo se puede " "usar de la siguiente manera::" #: ../Doc/library/typing.rst:660 msgid "A generic version of :class:`collections.abc.MutableMapping`." -msgstr "Un versión genérica de :class:`collections.abc.MutableMapping`." +msgstr "Una versión genérica de :class:`collections.abc.MutableMapping`." #: ../Doc/library/typing.rst:664 msgid "A generic version of :class:`collections.abc.Sequence`." -msgstr "Un versión genérica de :class:`collections.abc.Sequence`." +msgstr "Una versión genérica de :class:`collections.abc.Sequence`." #: ../Doc/library/typing.rst:668 msgid "A generic version of :class:`collections.abc.MutableSequence`." -msgstr "Un versión genérica de :class:`collections.abc.MutableSequence`." +msgstr "Una versión genérica de :class:`collections.abc.MutableSequence`." #: ../Doc/library/typing.rst:672 msgid "A generic version of :class:`collections.abc.ByteString`." -msgstr "Un versión genérica de :class:`collections.abc.ByteString`." +msgstr "Una versión genérica de :class:`collections.abc.ByteString`." #: ../Doc/library/typing.rst:674 msgid "" @@ -770,9 +763,7 @@ msgstr "" "Este tipo representa a los tipos :class:`bytes`, :class:`bytearray`, y :" "class:`memoryview`." -# shorthand #: ../Doc/library/typing.rst:677 -#, fuzzy msgid "" "As a shorthand for this type, :class:`bytes` can be used to annotate " "arguments of any of the types mentioned above." @@ -782,7 +773,7 @@ msgstr "" #: ../Doc/library/typing.rst:682 msgid "A generic version of :class:`collections.deque`." -msgstr "Un versión genérica de :class:`collections.deque`." +msgstr "Una versión genérica de :class:`collections.deque`." #: ../Doc/library/typing.rst:689 msgid "" @@ -804,33 +795,33 @@ msgid "" "return types. To annotate arguments it is preferred to use an abstract " "collection type such as :class:`AbstractSet`." msgstr "" -"Un versión genérica de :class:`builtins.set `. Útil para anotar tipos " +"Una versión genérica de :class:`builtins.set `. Útil para anotar tipos " "de retornos. Para anotar argumentos es preferible usar un tipo abstracto de " "colección como :class:`AbstractSet`." #: ../Doc/library/typing.rst:712 msgid "A generic version of :class:`builtins.frozenset `." -msgstr "Un versión genérica de :class:`builtins.frozenset `." +msgstr "Una versión genérica de :class:`builtins.frozenset `." #: ../Doc/library/typing.rst:716 msgid "A generic version of :class:`collections.abc.MappingView`." -msgstr "Un versión genérica de :class:`collections.abc.MappingView`." +msgstr "Una versión genérica de :class:`collections.abc.MappingView`." #: ../Doc/library/typing.rst:720 msgid "A generic version of :class:`collections.abc.KeysView`." -msgstr "Un versión genérica de :class:`collections.abc.KeysView`." +msgstr "Una versión genérica de :class:`collections.abc.KeysView`." #: ../Doc/library/typing.rst:724 msgid "A generic version of :class:`collections.abc.ItemsView`." -msgstr "Un versión genérica def:class:`collections.abc.ItemsView`." +msgstr "Una versión genérica def:class:`collections.abc.ItemsView`." #: ../Doc/library/typing.rst:728 msgid "A generic version of :class:`collections.abc.ValuesView`." -msgstr "Un versión genérica de :class:`collections.abc.ValuesView`." +msgstr "Una versión genérica de :class:`collections.abc.ValuesView`." #: ../Doc/library/typing.rst:732 msgid "A generic version of :class:`collections.abc.Awaitable`." -msgstr "Un versión genérica de :class:`collections.abc.Awaitable`." +msgstr "Una versión genérica de :class:`collections.abc.Awaitable`." #: ../Doc/library/typing.rst:738 msgid "" @@ -838,26 +829,26 @@ msgid "" "order of type variables correspond to those of :class:`Generator`, for " "example::" msgstr "" -"Un versión genérica de :class:`collections.abc.Coroutine.y orden de las " +"Una versión genérica de :class:`collections.abc.Coroutine.y orden de las " "variables de tipo se corresponde con aquellas de :class:`Generator`, por " "ejemplo::" #: ../Doc/library/typing.rst:753 msgid "A generic version of :class:`collections.abc.AsyncIterable`." -msgstr "Un versión genérica de :class:`collections.abc.AsyncIterable`." +msgstr "Una versión genérica de :class:`collections.abc.AsyncIterable`." #: ../Doc/library/typing.rst:759 msgid "A generic version of :class:`collections.abc.AsyncIterator`." -msgstr "Un versión genérica de :class:`collections.abc.AsyncIterator`." +msgstr "Una versión genérica de :class:`collections.abc.AsyncIterator`." #: ../Doc/library/typing.rst:765 msgid "A generic version of :class:`contextlib.AbstractContextManager`." -msgstr "Un versión genérica de :class:`contextlib.AbstractContextManager`." +msgstr "Una versión genérica de :class:`contextlib.AbstractContextManager`." #: ../Doc/library/typing.rst:772 msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`." msgstr "" -"Un versión genérica de :class:`contextlib.AbstractAsyncContextManager`." +"Una versión genérica de :class:`contextlib.AbstractAsyncContextManager`." #: ../Doc/library/typing.rst:779 msgid "" @@ -865,7 +856,7 @@ msgid "" "annotate arguments it is preferred to use an abstract collection type such " "as :class:`Mapping`." msgstr "" -"Un versión genérica de :class:`dict`. Útil para anotar tipos de retorno. " +"Una versión genérica de :class:`dict`. Útil para anotar tipos de retorno. " "Para anotar argumentos es preferible usar un tipo abstracto de colección " "como :class:`Mapping`." @@ -875,26 +866,26 @@ msgstr "Este tipo se puede usar de la siguiente manera::" #: ../Doc/library/typing.rst:790 msgid "A generic version of :class:`collections.defaultdict`." -msgstr "Un versión genérica de :class:`collections.defaultdict`." +msgstr "Una versión genérica de :class:`collections.defaultdict`." #: ../Doc/library/typing.rst:796 msgid "A generic version of :class:`collections.OrderedDict`." -msgstr "Un versión genérica de :class:`collections.OrderedDict`." +msgstr "Una versión genérica de :class:`collections.OrderedDict`." #: ../Doc/library/typing.rst:802 msgid "A generic version of :class:`collections.Counter`." -msgstr "Un versión genérica de :class:`collections.Counter`." +msgstr "Una versión genérica de :class:`collections.Counter`." #: ../Doc/library/typing.rst:809 msgid "A generic version of :class:`collections.ChainMap`." -msgstr "Un versión genérica de :class:`collections.ChainMap`." +msgstr "Una versión genérica de :class:`collections.ChainMap`." #: ../Doc/library/typing.rst:816 msgid "" "A generator can be annotated by the generic type ``Generator[YieldType, " "SendType, ReturnType]``. For example::" msgstr "" -"Un generador puede ser anotado con un tipo genérico ``Generator[YieldType, " +"Un generador puede ser anotado con el tipo genérico ``Generator[YieldType, " "SendType, ReturnType]``. Por ejemplo::" #: ../Doc/library/typing.rst:825 @@ -937,6 +928,10 @@ msgid "" "is no ``ReturnType`` type parameter. As with :class:`Generator`, the " "``SendType`` behaves contravariantly." msgstr "" +"A diferencia de los generadores normales, los generadores asíncronos no " +"pueden devolver un valor, por lo que no hay un parámetro de " +"tipo``ReturnType``. Igual que :class:`Generator`, ``SendType`` se comporta " +"como contravariante." #: ../Doc/library/typing.rst:860 msgid "" @@ -950,22 +945,26 @@ msgid "" "Alternatively, annotate your generator as having a return type of either " "``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::" msgstr "" -"Opcionalmente, anota el generador con un tipo de retorno " +"Opcionalmente, anota el generador con un tipo de retorno " "``AsyncIterable[YieldType]`` o ``AsyncIterator[YieldType]``::" #: ../Doc/library/typing.rst:880 -#, fuzzy msgid "" "``Text`` is an alias for ``str``. It is provided to supply a forward " "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " "``unicode``." -msgstr "``Text`` es un alias para ``str``. " +msgstr "" +"``Text`` es un alias para ``str``. Ésta disponible para proporcionar un " +"mecanismo compatible hacia delante para código en Python 2: en Python 2, " +"``Text`` es un alias de ``unicode``." #: ../Doc/library/typing.rst:884 msgid "" "Use ``Text`` to indicate that a value must contain a unicode string in a " "manner that is compatible with both Python 2 and Python 3::" msgstr "" +"Úsese ``Text`` para indicar que un valor debe contener una cadena de texto " +"Unicode de manera que sea compatible con Python 2 y Python 3::" #: ../Doc/library/typing.rst:896 msgid "" @@ -978,7 +977,6 @@ msgstr "" "streams*) como los usados por la función :func:`open`." #: ../Doc/library/typing.rst:904 -#, fuzzy msgid "" "These type aliases correspond to the return types from :func:`re.compile` " "and :func:`re.match`. These types (and the corresponding functions) are " @@ -992,7 +990,7 @@ msgstr "" #: ../Doc/library/typing.rst:913 msgid "Typed version of :func:`collections.namedtuple`." -msgstr "" +msgstr "Versión para anotación de tipos de :func:`collections.namedtuple`." #: ../Doc/library/typing.rst:921 msgid "This is equivalent to::" @@ -1002,11 +1000,15 @@ msgstr "Esto es equivalente a:" msgid "" "To give a field a default value, you can assign to it in the class body::" msgstr "" +"Para proporcionar a un campo un valor por defecto se puede asignar en el " +"cuerpo de la clase::" #: ../Doc/library/typing.rst:934 msgid "" "Fields with a default value must come after any fields without a default." msgstr "" +"Los campos con un valor por defecto deben ir después de los campos sin valor " +"por defecto." #: ../Doc/library/typing.rst:936 msgid "" @@ -1015,14 +1017,20 @@ msgid "" "``_fields`` attribute and the default values are in the ``_field_defaults`` " "attribute both of which are part of the namedtuple API.)" msgstr "" +"La clase resultante tiene un atributo extra ``__annotations__`` que " +"proporciona un diccionario que mapea el nombre de los campos con su tipo. " +"(Lo nombres de los campo están en el atributo ``_fields`` y sus valores por " +"defecto en el atributo ``_field_defaults``, ambos parte de la API de " +"namedtuple.)" #: ../Doc/library/typing.rst:942 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" msgstr "" +"Las subclases de ``NamedTuple`` también pueden tener *docstrings* y métodos::" #: ../Doc/library/typing.rst:952 msgid "Backward-compatible usage::" -msgstr "Uso compatible hacia atrás::" +msgstr "Uso retrocompatible::" #: ../Doc/library/typing.rst:956 msgid "Added support for :pep:`526` variable annotation syntax." @@ -1032,13 +1040,15 @@ msgstr "" #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." -msgstr "Soporte añadido para valores por defectos, métodos y *docstrings*" +msgstr "Soporte añadido para valores por defecto, métodos y *docstrings*" #: ../Doc/library/typing.rst:965 msgid "" "Deprecated the ``_field_types`` attribute in favor of the more standard " "``__annotations__`` attribute which has the same information." msgstr "" +"Convierte en obsoleto el atributo ``_field_types`` en favor del atributo más " +"estándar ``__annotations__``, que tiene la misma información." #: ../Doc/library/typing.rst:966 msgid "" @@ -1065,9 +1075,9 @@ msgid "" "enforced by type checkers. Usage::" msgstr "" "``TypedDict`` crea un tipo de diccionario que espera que todas sus " -"instancias tenga un cierto set de claves, donde cada clave está asociado con " -"un valor de un tipo determinado. Esta exigencia no se comprueba en tiempo de " -"ejecución y solo es impuesta por validadores de tipo. Uso::" +"instancias tenga un cierto conjunto de claves, donde cada clave está " +"asociada con un valor de un tipo determinado. Esta exigencia no se comprueba " +"en tiempo de ejecución y solo es impuesta por validadores de tipo. Uso::" #: ../Doc/library/typing.rst:991 msgid "" @@ -1091,7 +1101,6 @@ msgstr "" "posible anularlo especificando el parámetro *total*. De esta manera::" #: ../Doc/library/typing.rst:1007 -#, fuzzy msgid "" "This means that a point2D TypedDict can have any of the keys omitted. A type " "checker is only expected to support a literal False or True as the value of " @@ -1099,9 +1108,10 @@ msgid "" "class body be required." msgstr "" "Esto significa que un TypedDict point2D puede omitir cualquiera de sus " -"claves. Un validador de tipos solo esperará un valor literal *False* o " -"*True* como valor del argumento *total. True es el valor por defecto, y hace " -"que todos los ítems definidos en el cuerpo de la clases sean obligatorios." +"claves. Un validador de tipos solo se esperará un valor literal *False* o " +"*True* como valor del argumento *total*. *True* es el valor por defecto, y " +"hace que todos los elementos definidos en el cuerpo de la clases sean " +"obligatorios." #: ../Doc/library/typing.rst:1012 msgid "" @@ -1119,19 +1129,18 @@ msgid "" msgstr "" "Una clase usada para la representación de tipado interno de referencias " "directas en forma de cadenas de texto. Por ejemplo, ``List[\"SomeClass\"]`` " -"se transformado implícitamente en ``List[ForwardRef(\"SomeClass\")]``. Esta " +"es transformado implícitamente en ``List[ForwardRef(\"SomeClass\")]``. Esta " "clase no debe ser instanciada por el usuario, pero puede ser usada por " "herramientas de introspección." -# Aquí distinto (por distinct) no funciona, el tema es que esos tipos nuevos son personalizados por el usuario. +# Aquí se a preferido distinguible antes que distinto ya que UserId no es un tipo disting a int, es un int, pero es difirenciable por el validador. #: ../Doc/library/typing.rst:1025 -#, fuzzy msgid "" "A helper function to indicate a distinct types to a typechecker, see :ref:" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" -"Un función auxiliar para indicar un tipo personalizado a un validador de " +"Un función auxiliar para indicar un tipo distinguible a validadores de " "tipos, véase :ref:`distinct`. En tiempo de ejecución, devuelve una función " "que devuelve su argumento. Uso::" @@ -1146,10 +1155,9 @@ msgid "" "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" -"Esto retorna el valor sin modificar. Esto indica al validador de tipos que " -"el valor de retorno tiene el tipo señalado, pero, de manera intencionada, en " -"tiempo de ejecución no se comprobará (se da preferencia a que esto sea lo " -"más rápido posible)." +"Esto devuelve el valor sin modificar. Para el validador de tipos esto indica " +"que el valor de retorno tiene el tipo señalado pero, de manera intencionada, " +"no se comprobará en tiempo de ejecución (para maximizar la velocidad)." #: ../Doc/library/typing.rst:1045 msgid "" @@ -1160,7 +1168,6 @@ msgstr "" "método, módulo o objeto clase." #: ../Doc/library/typing.rst:1048 -#, fuzzy msgid "" "This is often the same as ``obj.__annotations__``. In addition, forward " "references encoded as string literals are handled by evaluating them in " @@ -1169,35 +1176,32 @@ msgid "" "``None`` is set. For a class ``C``, return a dictionary constructed by " "merging all the ``__annotations__`` along ``C.__mro__`` in reverse order." msgstr "" -"Esto es habitualmente lo mismo que ``obj.__annotations__``. Además, las " -"referencias directas codificadas como cadenas de texto se gestionan " -"evaluándolas en los espacios de nombres``globals`` y ``locals``. Si es " -"necesario, se añade``Optional[t]`` para anotar una función o método, si se " -"establece ``None`` como valor por defecto. Para un clase ``C``, se devuelve " -"un diccionario construído por la combinación de ``__annotations__`` y ``C." +"Habitualmente, esto es lo mismo que ``obj.__annotations__``. Además, las " +"referencias indicadas como cadenas de texto se gestionan evaluándolas en los " +"espacios de nombres``globals`` y ``locals``. Si es necesario, se " +"añade``Optional[t]`` para anotar una función o método, si se establece " +"``None`` como valor por defecto. Para una clase ``C``, se devuelve un " +"diccionario construido por la combinación de ``__annotations__`` y ``C." "__mro`` en orden inverso. " -# ver el término typing en contexto +# special forms se refiere a tipado exclusivo de typing (no el nativo como str o int): Union, Optional ... #: ../Doc/library/typing.rst:1059 -#, fuzzy msgid "Provide basic introspection for generic types and special typing forms." msgstr "" -"Provee introspección básica para tipos genéricos y formas especiales de " -"tipado." +"Provee introspección básica para tipos genéricos y construcciones especiales " +"de tipado." #: ../Doc/library/typing.rst:1061 -#, fuzzy msgid "" "For a typing object of the form ``X[Y, Z, ...]`` these functions return " "``X`` and ``(Y, Z, ...)``. If ``X`` is a generic alias for a builtin or :mod:" "`collections` class, it gets normalized to the original class. For " "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" -"Para un objeto de tipado de la forma ``X[Y,Z, ...]``, esta funciones " -"devuelven ``X`` y ``(Y, Z, ...)``. Si ``X`` es un alias genérico para un " -"clase estándar o una clase de :mod:`collections`, se normaliza a su clase " -"original. Lo objetos no soportados devuelven ``None`` y ``()`` " -"respectivamente. Ejemplos::" +"Para un objeto de tipado de la forma ``X[Y,Z, ...]``, estas funciones " +"devuelven ``X`` y ``(Y, Z, ...)``. Si ``X`` es un alias genérico para una " +"clase *built-in* o una clase de :mod:`collections`, se normaliza a su clase " +"original. Los objetos no soportados devuelven ``None`` y ``()``. Ejemplos::" #: ../Doc/library/typing.rst:1077 msgid "" @@ -1213,10 +1217,21 @@ msgid "" "gives a more precise type than can be expressed using a union or a type " "variable::" msgstr "" +"El decorador ``@overload`` permite describir funciones y métodos que " +"soportan diferentes combinaciones de tipos de argumento. A una serie de " +"definiciones decoradas con ``@overload` debe seguir exactamente una " +"definición no decorada con ``@overload`` (para la misma función o método). " +"Las definiciones decoradas con ``@overload`` son solo para el beneficio " +"validador de tipos, ya que serán sobrescritas por la definición no decorada " +"con ``@overload``. Esta última se usa en tiempo de ejecución y debería ser " +"ignorada por el validador de tipos. En tiempo de ejecución, llamar a una " +"función decorada con ``@overload`` lanzará directamente :exc:" +"`NotImplementedError`. Un ejemplo de sobrecarga que proporciona un tipo más " +"preciso se puede expresar con una unión o una variable de tipo::" #: ../Doc/library/typing.rst:1101 msgid "See :pep:`484` for details and comparison with other typing semantics." -msgstr "" +msgstr "Véase :pep:`484` para más detalle, y compárese con " #: ../Doc/library/typing.rst:1105 msgid "" @@ -1235,11 +1250,12 @@ msgstr "" "No hay comprobación en tiempo de ejecución para estas propiedades. Véase :" "pep:`591` para más detalles." -# annotations y type hints parecen sinónimos intercambiables, pero aquí no, se contraponen. Hay que entender el matiz +# se extrae del contexto que el decorador elimina la comprobacion de tipo en el validador, por lo tanto solo anota/comenta (annotation), no indica/sugiere tipo (type hint) #: ../Doc/library/typing.rst:1130 -#, fuzzy msgid "Decorator to indicate that annotations are not type hints." -msgstr "Un decorador que indica que la anotaciones no son indicadores de tipo." +msgstr "" +"Un decorador para indicar que la anotaciones no deben ser comprobadas como " +"indicadores de tipo." #: ../Doc/library/typing.rst:1132 msgid "" @@ -1247,14 +1263,14 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" -"Esto funciona como un :term:`decorador (decorador) de clase o función. Con " +"Esto funciona como un :term:`decorator` (decorador) de clase o función. Con " "una clase, se aplica recursivamente a todos los métodos definidos en dichas " "clase (pero no a lo métodos definidos en sus superclases y subclases)." # ver en contexto #: ../Doc/library/typing.rst:1136 msgid "This mutates the function(s) in place." -msgstr "Esto modifica la función o funciones presentes." +msgstr "Esto modifica la función o funciones *in situ*." #: ../Doc/library/typing.rst:1140 msgid "Decorator to give another decorator the :func:`no_type_check` effect." @@ -1262,25 +1278,21 @@ msgstr "" "Un decorador que asigna a otro decorador el efecto de :func:`no_type_check` " "(no comprobar tipo)." -# El original es algo vago y complejo, intentar traducir el significado intentando no ser literal. #: ../Doc/library/typing.rst:1142 -#, fuzzy msgid "" "This wraps the decorator with something that wraps the decorated function " "in :func:`no_type_check`." msgstr "" -"Esto habilita al decorador para añadir el efecto de `no_type_check`. a la " -"función decorada." +"Esto hace que el decorador decorado añada el efecto de :func:`no_type_check` " +"a la función decorada." #: ../Doc/library/typing.rst:1147 msgid "Decorator to mark a class or function to be unavailable at runtime." msgstr "" -"Un decorador que marca un clase o función como no disponible en tiempo de " +"Un decorador que marca una clase o función como no disponible en tiempo de " "ejecución." -# como traducimos los archivos stub (pyi y similares) #: ../Doc/library/typing.rst:1149 -#, fuzzy msgid "" "This decorator is itself not available at runtime. It is mainly intended to " "mark classes that are defined in type stub files if an implementation " @@ -1298,11 +1310,11 @@ msgstr "" "Nótese que no se recomienda devolver instancias de clases privadas. " "Normalmente es preferible convertirlas en clases públicas." -# que es un runtime protocol? ver contexto #: ../Doc/library/typing.rst:1165 -#, fuzzy msgid "Mark a protocol class as a runtime protocol." -msgstr "Marca una clase protocolo como protocolo en tiempo de ejecución." +msgstr "" +"Marca una clase protocolo como aplicable en tiempo de ejecución (lo " +"convierte en un *runtime protocol*)." #: ../Doc/library/typing.rst:1167 msgid "" @@ -1337,11 +1349,12 @@ msgstr "Todos los tipos son compatibles con :data:`Any`." msgid ":data:`Any` is compatible with every type." msgstr ":data:`Any` es compatible con todos los tipos." -# returns significa que no acaba o que no devuelve nada? ver contexto +# se añade valor para matizar que la funcion retorna (devuelve el control) pero no de manera normal. En el ejemplo lanza una excepción. #: ../Doc/library/typing.rst:1192 -#, fuzzy msgid "Special type indicating that a function never returns. For example::" -msgstr "Tipo especial que indica que una funciona nunca retorna. Por ejemplo::" +msgstr "" +"Tipo especial que indica que una función nunca retorna un valor. Por " +"ejemplo::" #: ../Doc/library/typing.rst:1205 msgid "Union type; ``Union[X, Y]`` means either X or Y." @@ -1353,7 +1366,7 @@ msgstr "Para definir una unión, úsese p.e. ``Union[int, str]. Más detalles:" #: ../Doc/library/typing.rst:1209 msgid "The arguments must be types and there must be at least one." -msgstr "Los argumentos deben ser tipo y haber al menos uno." +msgstr "Los argumentos deben ser tipos y haber al menos uno." #: ../Doc/library/typing.rst:1211 msgid "Unions of unions are flattened, e.g.::" @@ -1387,7 +1400,7 @@ msgstr "" #: ../Doc/library/typing.rst:1233 msgid "Don't remove explicit subclasses from unions at runtime." -msgstr "" +msgstr "No elimina subclases explícitas de una unión en tiempo de ejecución." #: ../Doc/library/typing.rst:1238 msgid "Optional type." @@ -1436,7 +1449,7 @@ msgid "" msgstr "" "Ejemplo: ``Tuple[T1, T2]`` es una tupla de dos elementos con sus " "correspondientes variables de tipo T1 y T2. ``Tuple[int, float, str]`` es un " -"tupla con un entero, un número de coma flotante, un float y una cadena de " +"tupla con un número entero, un número de punto flotante y una cadena de " "texto." #: ../Doc/library/typing.rst:1267 @@ -1451,7 +1464,9 @@ msgstr "" #: ../Doc/library/typing.rst:1273 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." -msgstr "Tipo Callable; ``Callable[[int], str] es una función de (int) -> str." +msgstr "" +"Tipo Callable (invocable); ``Callable[[int], str]`` es una función de (int) -" +"> str." #: ../Doc/library/typing.rst:1275 msgid "" @@ -1481,15 +1496,14 @@ msgstr "" "``Callable[..., Any]``y, a su vez, a :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1290 -#, fuzzy msgid "" "A type that can be used to indicate to type checkers that the corresponding " "variable or function parameter has a value equivalent to the provided " "literal (or one of several literals). For example::" msgstr "" -"Un tipo puede ser utilizado para indicar a los validadores de tipos que un " -"variable o un parámetro de una función tiene un valor equivalente al valor " -"proveído (o uno de los proveídos). Por ejemplo::" +"Un tipo que puede ser utilizado para indicar a los validadores de tipos que " +"una variable o un parámetro de una función tiene un valor equivalente al " +"valor literal proveído (o uno de los proveídos). Por ejemplo::" #: ../Doc/library/typing.rst:1304 msgid "" @@ -1503,28 +1517,26 @@ msgstr "" "para más detalles sobre tipos literales." #: ../Doc/library/typing.rst:1312 -#, fuzzy msgid "Special type construct to mark class variables." -msgstr "Construcción de tipo especial para marcar variables de clase." +msgstr "Construcción especial para tipado para marcar variables de clase." # Puede haber una entrada mejor para "As introduced" #: ../Doc/library/typing.rst:1314 -#, fuzzy msgid "" "As introduced in :pep:`526`, a variable annotation wrapped in ClassVar " "indicates that a given attribute is intended to be used as a class variable " "and should not be set on instances of that class. Usage::" msgstr "" -"Tal y como introduce :pep:`526`, una anotación de variable rodeado por " +"Tal y como introduce :pep:`526`, una anotación de variable rodeada por " "ClassVar indica que la intención de un atributo dado es ser usado como " "variable de clase y que no debería ser modificado en las instancias de esa " -"clase. Uso::" +"misma clase. Uso::" -# buscar algo mejro para traducir subscribed sin ser literal, ver solucion para subscription syntax (p.e. subindice -> subindicado) +# subscribed se substituye por niveles de subindice #: ../Doc/library/typing.rst:1322 -#, fuzzy msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." -msgstr ":data:`ClassVar` solo acepta tipos y no puede ser detallarse más." +msgstr "" +":data:`ClassVar` solo acepta tipos y no admite más niveles de subíndices." #: ../Doc/library/typing.rst:1324 msgid "" @@ -1533,9 +1545,9 @@ msgid "" "runtime behavior, but it can be used by third-party type checkers. For " "example, a type checker might flag the following code as an error::" msgstr "" -":data:`ClassVar` no es un clase en sí misma, y no debe ser usado con :func:" +":data:`ClassVar` no es un clase en sí misma, y no debe ser usado con :func:" "`isinstance` o :func:`issubclass`. :data:`ClassVar` no modifica el " -"comportamiento do Python en tiempo de ejecución pero puede ser utilizado por " +"comportamiento de Python en tiempo de ejecución pero puede ser utilizado por " "validadores de terceros. Por ejemplo, un validador de tipos puede marcar el " "siguiente código como erróneo::" @@ -1570,7 +1582,7 @@ msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" -"Un constante especial que se asume como cierta (``True``) por validadores " +"Una constante especial que se asume como cierta (``True``) por validadores " "estáticos de tipos de terceros. Es falsa (``False``) en tiempo de ejecución. " "Uso::" From ebd625ab5b5623d520636e08d4f905fbb767e410 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Sat, 23 May 2020 20:49:17 +0200 Subject: [PATCH 06/14] cambios menores --- library/typing.po | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/library/typing.po b/library/typing.po index 4c4b9d996e..8f9e31b28b 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-23 20:18+0200\n" +"PO-Revision-Date: 2020-05-23 20:47+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -530,8 +530,8 @@ msgid "" "arguments are instances of some subclass of :class:`str`, the return type is " "still plain :class:`str`." msgstr "" -"La interfaz de los ejemplos anteriores es esencialmente una sobrecarga de " -"``(0str, str) -> str`` y ``(bytes, bytes) -> bytes``. Nótese también que " +"La signatura de los ejemplos anteriores es esencialmente la superposición de " +"``(str, str) -> str`` y ``(bytes, bytes) -> bytes``. Nótese también que " "aunque los argumentos sean instancias de alguna subclase de :class:`str`, el " "tipo retornado aún será una simple :class:`str`." @@ -1133,14 +1133,14 @@ msgstr "" "clase no debe ser instanciada por el usuario, pero puede ser usada por " "herramientas de introspección." -# Aquí se a preferido distinguible antes que distinto ya que UserId no es un tipo disting a int, es un int, pero es difirenciable por el validador. +# Aquí se ha preferido distinguible antes que distinto ya que UserId no es un tipo disting a int, es un int, pero es difirenciable por el validador. #: ../Doc/library/typing.rst:1025 msgid "" "A helper function to indicate a distinct types to a typechecker, see :ref:" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" -"Un función auxiliar para indicar un tipo distinguible a validadores de " +"Un función auxiliar para indicar un tipo distinguible a los validadores de " "tipos, véase :ref:`distinct`. En tiempo de ejecución, devuelve una función " "que devuelve su argumento. Uso::" @@ -1362,7 +1362,7 @@ msgstr "Tipo unión; ``Union[X, Y]`` significa que o bien X o bien Y." #: ../Doc/library/typing.rst:1207 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" -msgstr "Para definir una unión, úsese p.e. ``Union[int, str]. Más detalles:" +msgstr "Para definir una unión, úsese p. ej. ``Union[int, str]. Más detalles:" #: ../Doc/library/typing.rst:1209 msgid "The arguments must be types and there must be at least one." @@ -1370,20 +1370,20 @@ msgstr "Los argumentos deben ser tipos y haber al menos uno." #: ../Doc/library/typing.rst:1211 msgid "Unions of unions are flattened, e.g.::" -msgstr "Las uniones de uniones se simplifican (se aplanan), p.e.::" +msgstr "Las uniones de uniones se simplifican (se aplanan), p. ej.::" #: ../Doc/library/typing.rst:1215 msgid "Unions of a single argument vanish, e.g.::" -msgstr "Las uniones con un solo argumento se eliminan, p.e.::" +msgstr "Las uniones con un solo argumento se eliminan, p. ej.::" #: ../Doc/library/typing.rst:1219 msgid "Redundant arguments are skipped, e.g.::" -msgstr "Argumentos repetidos se omiten, p.e.::" +msgstr "Argumentos repetidos se omiten, p. ej.::" #: ../Doc/library/typing.rst:1223 msgid "When comparing unions, the argument order is ignored, e.g.::" msgstr "" -"Cuando se comparan uniones, el orden de los argumentos se ignoran, p.e.::" +"Cuando se comparan uniones, el orden de los argumentos se ignoran, p. ej.::" #: ../Doc/library/typing.rst:1227 msgid "You cannot subclass or instantiate a union." @@ -1459,7 +1459,7 @@ msgid "" "``Tuple[Any, ...]``, and in turn to :class:`tuple`." msgstr "" "Para especificar una tupla de longitud variable y tipo homogéneo, se usan " -"puntos suspensivos, p.e. ``Tuple[int, ...]``. Un simple :data:`Tuple` es " +"puntos suspensivos, p. ej. ``Tuple[int, ...]``. Un simple :data:`Tuple` es " "equivalente a ``Tuple[Any, ...]`` y, a su vez, a :class:`tuple`." #: ../Doc/library/typing.rst:1273 From f02f6f27a0d3027973ded858cc728ddadf12fc26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Sun, 24 May 2020 20:52:10 +0200 Subject: [PATCH 07/14] Arreglar referenicas mal cerradas --- library/typing.po | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/library/typing.po b/library/typing.po index 8f9e31b28b..168a16f410 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-23 20:47+0200\n" +"PO-Revision-Date: 2020-05-24 20:51+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -374,7 +374,7 @@ msgid "" "value of type on :data:`Any` and assign it to any variable::" msgstr "" "Esto significa que es posible realizar cualquier operación o llamada a un " -"método en un valor de tipo :data:`Any`y asignarlo a cualquier variable::" +"método en un valor de tipo :data:`Any` y asignarlo a cualquier variable::" #: ../Doc/library/typing.rst:344 msgid "" @@ -387,8 +387,8 @@ msgstr "" "Nótese que no se realiza comprobación de tipo cuando se asigna un valor de " "tipo :data:`Any` a un tipo más preciso. Por ejemplo, el Validador estático " "de tipos no reportó ningún error cuando se asignó ``a`` a ``s``, aún cuando " -"se declaró ``s`` como de tipo :class:`str y recibió un valor :class:`int` en " -"tiempo de ejecución." +"se declaró ``s`` como de tipo :class:`str` y recibió un valor :class:`int` " +"en tiempo de ejecución." #: ../Doc/library/typing.rst:350 msgid "" @@ -600,7 +600,7 @@ msgid "" "that check only the presence of given attributes, ignoring their type " "signatures." msgstr "" -"Véase :pep:`544` para más detalles. Las clases protocolo decoradas con func:" +"Véase :pep:`544` para más detalles. Las clases protocolo decoradas con :func:" "`runtime_checkable` (que se explica más adelante) se comportan como " "protocolos simplistas en tiempo de ejecución que solo comprueban la " "presencia de atributos dados, ignorando su firma de tipo." @@ -813,7 +813,7 @@ msgstr "Una versión genérica de :class:`collections.abc.KeysView`." #: ../Doc/library/typing.rst:724 msgid "A generic version of :class:`collections.abc.ItemsView`." -msgstr "Una versión genérica def:class:`collections.abc.ItemsView`." +msgstr "Una versión genérica de :class:`collections.abc.ItemsView`." #: ../Doc/library/typing.rst:728 msgid "A generic version of :class:`collections.abc.ValuesView`." @@ -829,7 +829,7 @@ msgid "" "order of type variables correspond to those of :class:`Generator`, for " "example::" msgstr "" -"Una versión genérica de :class:`collections.abc.Coroutine.y orden de las " +"Una versión genérica de :class:`collections.abc.Coroutine`.y orden de las " "variables de tipo se corresponde con aquellas de :class:`Generator`, por " "ejemplo::" @@ -1362,7 +1362,8 @@ msgstr "Tipo unión; ``Union[X, Y]`` significa que o bien X o bien Y." #: ../Doc/library/typing.rst:1207 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" -msgstr "Para definir una unión, úsese p. ej. ``Union[int, str]. Más detalles:" +msgstr "" +"Para definir una unión, úsese p. ej. ``Union[int, str]``. Más detalles:" #: ../Doc/library/typing.rst:1209 msgid "The arguments must be types and there must be at least one." @@ -1419,7 +1420,7 @@ msgid "" msgstr "" "Nótese que no es lo mismo que un argumento opcional, que es aquel que tiene " "un valor por defecto. Un argumento opcional con un valor por defecto no " -"necesita el indicador ``Optional``en su anotación de tipo simplemente por " +"necesita el indicador ``Optional`` en su anotación de tipo simplemente por " "que sea opcional. Por ejemplo::" #: ../Doc/library/typing.rst:1250 @@ -1490,7 +1491,7 @@ msgid "" msgstr "" "No existe una sintaxis para indicar argumentos opcionales o con clave " "(*keyword*); tales funciones rara vez se utilizan como tipos para llamadas. " -"``Callable``[..., ReturnType]`` (puntos suspensivos) se puede usar para " +"``Callable[..., ReturnType]`` (puntos suspensivos) se puede usar para " "indicar que un *callable* admite un número indeterminado de argumentos y " "retorna ``ReturnType``. Un simple :data:`Callable` es equivalente a " "``Callable[..., Any]``y, a su vez, a :class:`collections.abc.Callable`." @@ -1513,8 +1514,8 @@ msgid "" msgstr "" "``Literal[...]`` no puede ser derivado. En tiempo de ejecución, se permite " "un valor arbitrario como argumento de tipo de ``Literal[...]``, pero los " -"validadores de tipos pueden imponer sus restricciones. Véase :pep:`585`` " -"para más detalles sobre tipos literales." +"validadores de tipos pueden imponer sus restricciones. Véase :pep:`585` para " +"más detalles sobre tipos literales." #: ../Doc/library/typing.rst:1312 msgid "Special type construct to mark class variables." From c58058acd935bd0bfad8861f4ff50900c5539373 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Mon, 25 May 2020 20:21:09 +0200 Subject: [PATCH 08/14] Arreglo en referencia --- library/typing.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/typing.po b/library/typing.po index 168a16f410..d712840830 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-24 20:51+0200\n" +"PO-Revision-Date: 2020-05-24 22:03+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -1326,8 +1326,8 @@ msgstr "" "Tal protocolo se puede usar con :func:`isinstance` y :func:`issubclass`. " "Esto lanzará una excepción :exc:`TypeError` cuando se aplique a una clase " "que no es un *protocolo*. Esto permite una comprobación estructural simple, " -"muy semejante a \"one trick ponies\" en mod:`collections.abc` como es :class:" -"`Iterable`. Por ejemplo::" +"muy semejante a \"one trick ponies\" en :mod:`collections.abc` como es :" +"class:`Iterable`. Por ejemplo::" #: ../Doc/library/typing.rst:1178 msgid "" From 0936fb77ef1b1f4fd9ed65190d35afd86fa7682d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Mon, 25 May 2020 21:03:26 +0200 Subject: [PATCH 09/14] Corregidos errores detectados en revision de la build --- library/typing.po | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/library/typing.po b/library/typing.po index d712840830..ea3b6fea78 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-24 22:03+0200\n" +"PO-Revision-Date: 2020-05-25 21:02+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -23,7 +23,7 @@ msgstr "" #: ../Doc/library/typing.rst:2 msgid ":mod:`typing` --- Support for type hints" -msgstr ":mod:`typing` --- Soporte para *type hints*" +msgstr ":mod:`typing` --- Soporte para *type hints*" #: ../Doc/library/typing.rst:9 msgid "**Source code:** :source:`Lib/typing.py`" @@ -70,7 +70,7 @@ msgid "" "arguments." msgstr "" "En la función ``greeting``, se espera que el argumento ``name`` sea de " -"tipo. :class:`str` y que el tipo retornado sea :class:`str`. Los subtipos " +"tipo :class:`str` y que el tipo retornado sea :class:`str`. Los subtipos " "también son aceptados como argumento válido." #: ../Doc/library/typing.rst:37 @@ -108,7 +108,7 @@ msgstr "NewType" #: ../Doc/library/typing.rst:77 msgid "Use the :func:`NewType` helper function to create distinct types::" msgstr "" -"Úsese la función auxiliar func:`NewType` para crear tipos distinguibles " +"Úsese la función auxiliar :func:`NewType` para crear tipos distinguibles " "entre sí::" #: ../Doc/library/typing.rst:84 @@ -141,7 +141,7 @@ msgid "" msgstr "" "Nótese que estas comprobaciones son impuestas solo en la validación de " "tipado estática. En tiempo de ejecución, la sentencia ``Derived = " -"NewType('Derived', Bas`` hará de ``Derived`` una función que retornará " +"NewType('Derived', Base)`` hará de ``Derived`` una función que devolverá " "inmediatamente el parámetro que se le pase. Esto implica que la expresión " "``Derived(some_value)`` no crea una nueva clase o genera más coste que la " "llamada a una función normal." @@ -213,9 +213,8 @@ msgstr "" msgid "Callable" msgstr "Callable" -# que significa aqué Frameworks? parace algo genérico tipo "entidades" +# Aquí frameworks parace indicar un término abierto referiéndose a elementos que interactuarán con las llamadas anotadas. Por ello, se escoge el término genérico "entidades" #: ../Doc/library/typing.rst:154 -#, fuzzy msgid "" "Frameworks expecting callback functions of specific signatures might be type " "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." @@ -233,9 +232,10 @@ msgid "" "the call signature by substituting a literal ellipsis for the list of " "arguments in the type hint: ``Callable[..., ReturnType]``." msgstr "" -"Es posible declarar el tipo de retorno de un *callable* sin especificar " -"tipos en los parámetros substituyendo la lista de argumentos por unos puntos " -"suspensivos (...) en el indicador de tipo: ``Callable[..., ReturnType]``." +"Es posible declarar el tipo de retorno de un *callable* (invocable) sin " +"especificar tipos en los parámetros substituyendo la lista de argumentos por " +"unos puntos suspensivos (...) en el indicador de tipo: ``Callable[..., " +"ReturnType]``." #: ../Doc/library/typing.rst:175 msgid "Generics" @@ -503,7 +503,7 @@ msgstr "El módulo define las siguientes clases, funciones y decoradores:" #: ../Doc/library/typing.rst:445 msgid "Type variable." -msgstr "Variable de tipo" +msgstr "Variable de tipo." #: ../Doc/library/typing.rst:447 ../Doc/library/typing.rst:915 msgid "Usage::" @@ -542,7 +542,7 @@ msgid "" msgstr "" "En tiempo de ejecución, ``isinstance(x, T)`` lanzará una excepción :exc:" "`TypeError`. En general, :func:`isinstance` y :func:`issubclass` no se " -"deben usar con tipos." +"deben usar con variables de tipo." #: ../Doc/library/typing.rst:473 msgid "" @@ -1040,7 +1040,7 @@ msgstr "" #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." -msgstr "Soporte añadido para valores por defecto, métodos y *docstrings*" +msgstr "Soporte añadido para valores por defecto, métodos y *docstrings*." #: ../Doc/library/typing.rst:965 msgid "" @@ -1182,7 +1182,7 @@ msgstr "" "añade``Optional[t]`` para anotar una función o método, si se establece " "``None`` como valor por defecto. Para una clase ``C``, se devuelve un " "diccionario construido por la combinación de ``__annotations__`` y ``C." -"__mro`` en orden inverso. " +"__mro`` en orden inverso." # special forms se refiere a tipado exclusivo de typing (no el nativo como str o int): Union, Optional ... #: ../Doc/library/typing.rst:1059 @@ -1231,7 +1231,9 @@ msgstr "" #: ../Doc/library/typing.rst:1101 msgid "See :pep:`484` for details and comparison with other typing semantics." -msgstr "Véase :pep:`484` para más detalle, y compárese con " +msgstr "" +"Véase :pep:`484` para más detalle, y compárese con otras semánticas de " +"tipado." #: ../Doc/library/typing.rst:1105 msgid "" @@ -1334,7 +1336,7 @@ msgid "" "**Warning:** this will check only the presence of the required methods, not " "their type signatures!" msgstr "" -"**Atención:*** esto solo comprobará la presencia de los métodos requeridos, " +"**Atención:** esto solo comprobará la presencia de los métodos requeridos, " "no su interfaz." #: ../Doc/library/typing.rst:1185 From 8f013bae792eed5569032dc86475117db425b6cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Mon, 25 May 2020 21:09:34 +0200 Subject: [PATCH 10/14] Mejorar redaccion en un texto --- library/typing.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/typing.po b/library/typing.po index ea3b6fea78..bc90ae0d3e 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-25 21:02+0200\n" +"PO-Revision-Date: 2020-05-25 21:06+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -1063,7 +1063,7 @@ msgid "" "A simple typed namespace. At runtime it is equivalent to a plain :class:" "`dict`." msgstr "" -"Un espacio de nombre con un tipado simple. En tiempo de ejecución es " +"Un espacio de nombres con un tipado simple. En tiempo de ejecución es " "equivalente a un simple :class:`dict`." # sinonimo para imposicion/imponer @@ -1221,7 +1221,7 @@ msgstr "" "soportan diferentes combinaciones de tipos de argumento. A una serie de " "definiciones decoradas con ``@overload` debe seguir exactamente una " "definición no decorada con ``@overload`` (para la misma función o método). " -"Las definiciones decoradas con ``@overload`` son solo para el beneficio " +"Las definiciones decoradas con ``@overload`` son solo para beneficio del " "validador de tipos, ya que serán sobrescritas por la definición no decorada " "con ``@overload``. Esta última se usa en tiempo de ejecución y debería ser " "ignorada por el validador de tipos. En tiempo de ejecución, llamar a una " From 64ce80ac9ab9991d59f8e849746e5f004da0f7db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Mon, 1 Jun 2020 09:51:33 +0200 Subject: [PATCH 11/14] =?UTF-8?q?Arreglo=20peque=C3=B1o?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/typing.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/typing.po b/library/typing.po index bc90ae0d3e..4823544071 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-05-25 21:06+0200\n" +"PO-Revision-Date: 2020-06-01 09:51+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -1496,7 +1496,7 @@ msgstr "" "``Callable[..., ReturnType]`` (puntos suspensivos) se puede usar para " "indicar que un *callable* admite un número indeterminado de argumentos y " "retorna ``ReturnType``. Un simple :data:`Callable` es equivalente a " -"``Callable[..., Any]``y, a su vez, a :class:`collections.abc.Callable`." +"``Callable[..., Any]`` y, a su vez, a :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1290 msgid "" From 2246c919cb7575ad88866a9753aeac69316184b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Wed, 3 Jun 2020 17:36:27 +0200 Subject: [PATCH 12/14] =?UTF-8?q?Revisar=20dict,=20corregir=20ortograf?= =?UTF-8?q?=C3=ADa=20en=20un=20campo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dict | 27 +++++++-------------------- library/typing.po | 4 ++-- 2 files changed, 9 insertions(+), 22 deletions(-) diff --git a/dict b/dict index 0f71ba4e7c..d04c9a630c 100644 --- a/dict +++ b/dict @@ -26,7 +26,6 @@ Cookbook Ctrl Cython Distutils -Distutils FLTK Fibonacci Finder @@ -42,7 +41,6 @@ Gtk+ HTML Hammond Hat -Hat Henstridge Hewlett Hugunin @@ -66,7 +64,6 @@ Mac MacOS Macintosh Mandrake -Mandrake Mark Microsoft Mitch @@ -106,10 +103,8 @@ SciPy SimpleFileExFlags Smalltalk Solaris -Solaris Spot Stein -subdirectorios TCP Tcl Tix @@ -144,7 +139,6 @@ backspace bash batch bdist -bdist big-endian bloqueante booleano @@ -183,14 +177,11 @@ criptográficamente curses customización customizarlo -códec datagramas debugueando default desasignar descompresor -deserialización -deserializar desreferenciar desalojable desambiguar @@ -204,9 +195,7 @@ desasignarán desasignador desasignadores descargable -desasignada descargable -descompresor deserialización deserializar desinstalador @@ -338,8 +327,15 @@ multi multicast multihilo multilínea +multiprocesamiento +mutex +mxBase naif +naíf +naífs nonlocal +ncurses +normalización object obsérvese option @@ -347,15 +343,6 @@ or ordenables path pathlib -multiprocesamiento -mutex -mxBase -mxBase -naíf -naífs -ncurses -nonlocal -normalización object operando operandos diff --git a/library/typing.po b/library/typing.po index 4823544071..e7f7da3eef 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-06-01 09:51+0200\n" +"PO-Revision-Date: 2020-06-03 17:36+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -329,7 +329,7 @@ msgid "" msgstr "" "Al usar una clase genérica sin especificar parámetros de tipo se asume :data:" "`Any` para todas las posiciones. En el siguiente ejemplo, ``MyIterable`` no " -"es genérico pero hereda implicitamente de ``Iterable[Any]``::" +"es genérico pero hereda implícitamente de ``Iterable[Any]``::" #: ../Doc/library/typing.rst:294 msgid "User defined generic type aliases are also supported. Examples::" From ad9b738029a44a6aea6812178cccfe7d980bde7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Tue, 9 Jun 2020 11:41:26 +0200 Subject: [PATCH 13/14] Quitar mas duplicados --- dict | 77 +++++++++++++++++++++++++++--------------------------------- 1 file changed, 34 insertions(+), 43 deletions(-) diff --git a/dict b/dict index d04c9a630c..89b84862b0 100644 --- a/dict +++ b/dict @@ -56,6 +56,7 @@ Katz Kivy L Laird +Latin Linux Lloyd Ltd @@ -91,8 +92,8 @@ PySide Python Pythónico Qt +R Randal -redireccionamiento Reilly Rezinsky Rossum @@ -111,11 +112,13 @@ Tix Tk Tkinter Tutorial +UTF Unicode Unix Usenet VM WWW +Win Windows X Xt @@ -145,31 +148,29 @@ booleano booleanos buffer bug -built build +built byte bytecode bytes +bzip búfer búferes -bzip cargable cargables class coerción -collector coleccionable coleccionables +collector comilla command compilada computacionales -conversor -códec -códecs -configúrelo computacionalmente +configúrelo consolelib +conversor correlacionan corrutina corrutinas @@ -177,30 +178,30 @@ criptográficamente curses customización customizarlo +códec +códecs datagramas debugueando default -desasignar -descompresor -desreferenciar desalojable desambiguar desasigna -desasigne desasignación desasignada desasignado -descargable -desasignarán desasignador desasignadores +desasignar +desasignarán +desasigne descargable -descargable +descompresor deserialización deserializar -desinstalador designadores +desinstalador desreferenciación +desreferenciar desreferenciarlas dict dinámicamente @@ -214,15 +215,14 @@ enrutamiento entendible enumerador env -ésimo especificador especificadores estáticamente except exclude +exit explícitamente exponenciación -exit f finalizador finalizadores @@ -247,8 +247,8 @@ host i idiomáticas if -implementación implementaciones +implementación implementadores import imports @@ -264,8 +264,8 @@ indexables indexación inf inicializa -inicialización inicializaciones +inicialización inicializada inicializado inicializador @@ -291,9 +291,8 @@ iterador iteradores j json -Latin -latin l +latin letter lexicográfica lexicográfico @@ -333,29 +332,24 @@ mxBase naif naíf naífs -nonlocal ncurses +nonlocal normalización object obsérvese -option -or -ordenables -path -pathlib -object -operando -operandos onexit +operando operandos option -operandos or +ordenables os pads parsea parseada parsear +path +pathlib permitiéndole permutaciones personalizadamente @@ -383,7 +377,6 @@ pseudo py pyc python -R quit read readline @@ -397,11 +390,12 @@ recursivamente redefinido redefinidos redefinir -redimensionar -redimensionado -redimensionados redimensionable redimensionables +redimensionado +redimensionados +redimensionar +redireccionamiento redondeándolo ref refactorización @@ -418,15 +412,14 @@ reinicializar remove reordenar request -root reubicar +root run s script scripting scripts sdux -sdux search secuencialmente seguirle @@ -455,8 +448,6 @@ stdin stdout strings sub -subárbol -subárboles subcadena subcadenas subcarpetas @@ -469,9 +460,11 @@ submódulos subpaquete subpaquetes subsecuencias -subíndices subtipable subtiparse +subárbol +subárboles +subíndices sys t tab @@ -498,9 +491,7 @@ unicode uninstall urllib utf -UTF vía -Win wchar web widget From 259e6d42b0ee13a59d47b8915c62d79289c38f0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Canto?= Date: Mon, 15 Jun 2020 10:29:04 +0200 Subject: [PATCH 14/14] Actualizar dict y errores ortograficos en typing --- dict | 36 ++++++++++++++++++++++++++++++------ library/typing.po | 6 +++--- 2 files changed, 33 insertions(+), 9 deletions(-) diff --git a/dict b/dict index e47d5ccb49..d693123b91 100644 --- a/dict +++ b/dict @@ -82,6 +82,7 @@ NumPy Numerical Octales Olsen +Optional POSIX POST PVM @@ -106,6 +107,7 @@ Randal Refactorizados Refactorizar Reilly +ReturnType Rezinsky Rossum Ruby @@ -124,7 +126,10 @@ Tcl Tix Tk Tkinter +Transactions +Tuple Tutorial +TypedDict UTF Unicode Unix @@ -182,16 +187,22 @@ coleccionables collector comilla command +compárese +comparablemente compilada computacionales computacionalmente configúrelo conceptualmente consolelib +contravariante +contravariantes conversor correlacionan corrutina corrutinas +covariante +covariantes criptográficamente curses customización @@ -262,6 +273,7 @@ from garbage gcc gid +globals granularidad gzip h @@ -332,6 +344,8 @@ lexicográfica lexicográfico libtclsam libtksam +linters +log lowecase m main @@ -372,6 +386,7 @@ mxBase naif naíf naífs +namedtuple ncurses nonlocal normalización @@ -379,6 +394,7 @@ object obsérvese octales octale +one onexit operando operandos @@ -387,6 +403,7 @@ options or ordenables os +p pads parsea parseada @@ -399,8 +416,10 @@ permutaciones personalizadamente pip podés +point polimórfica popen +ponies portabilidad portable posicional @@ -490,6 +509,7 @@ situ sobreescriban sobreescribe sobreescriben +sobreescribir socket sockets solucionadores @@ -505,8 +525,10 @@ subcarpetas subclasificación subcadena subcadenas +subclaseada subclasificar subcomandos +subscripción subdirectorio subdirectorios subinterprete @@ -516,12 +538,17 @@ submódulos subpaquete subpaquetes subproceso +subprocesos +subsectores subsecuencias subtipable +subtipado subtiparse subárbol subárboles +subíndice subíndices +superclases sys t tab @@ -536,6 +563,7 @@ tipado tipear token tokens +trick tty tupla tuplas @@ -571,29 +599,25 @@ option octales permutación Gaussianas -log von semiabierto Twister -subprocesos determinístico -subclaseada Matsumoto Nishimura -Transactions on Modeling and +Callable +ClassVar Computer Simulation January -comparablemente reestablece Mersenne cumulativos interopere random -subsectores gaussiana Pareto Weibull diff --git a/library/typing.po b/library/typing.po index e7f7da3eef..1dbf359765 100644 --- a/library/typing.po +++ b/library/typing.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-06-03 17:36+0200\n" +"PO-Revision-Date: 2020-06-15 10:28+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -51,7 +51,7 @@ msgstr "" "Este módulo proporciona soporte en tiempo de ejecución (*runtime*) para " "anotaciones de tipado, tal y como se especifica en :pep:`484`, :pep:`526`, :" "pep:`544`, :pep:`586`, :pep:`589`, y :pep:`591`. Las características " -"fundamenteales consisten en los tipos :data:`Any`, :data:`Union`, :data:" +"fundamentales consisten en los tipos :data:`Any`, :data:`Union`, :data:" "`Tuple`, :data:`Callable`, :class:`TypeVar`, and :class:`Generic`. Para la " "especificación completa véase :pep:`484`. Para una introducción " "simplificada a *type hints* véase :pep:`483`." @@ -1086,7 +1086,7 @@ msgid "" "with older versions of Python that do not support :pep:`526`, ``TypedDict`` " "supports two additional equivalent syntactic forms::" msgstr "" -"Se puede acceder a la información de tipo para introspección via ``Point2D." +"Se puede acceder a la información de tipo para introspección vía ``Point2D." "__annotations__`` y ``Point2D.__total__``. Para poder utilizar esta " "características con versiones antiguas de Python que no soporten :pep:`526`, " "``TypedDict`` proporciona adicionalmente dos formatos sintácticos "