"dataclasses" --- Clases de datos
*********************************

**Código fuente:** Lib/dataclasses.py

======================================================================

Este módulo provee un decorador y funciones para añadir *métodos
especiales* automáticamente, como "__init__()" y "__repr__()" por
ejemplo, a clases definidas por el usuario. Fue originalmente descrito
en **PEP 557**.

Las variables miembro a utilizar en estos métodos generados son
definidas teniendo en cuenta anotaciones de tipo **PEP 526**. Por
ejemplo, en este código:

   from dataclasses import dataclass

   @dataclass
   class InventoryItem:
       """Class for keeping track of an item in inventory."""
       name: str
       unit_price: float
       quantity_on_hand: int = 0

       def total_cost(self) -> float:
           return self.unit_price * self.quantity_on_hand

Añadirá, además de otros métodos, un método "__init__()" con la
siguiente estructura:

   def __init__(self, name: str, unit_price: float, quantity_on_hand: int = 0):
       self.name = name
       self.unit_price = unit_price
       self.quantity_on_hand = quantity_on_hand

Es importante observar que este método es añadido a la clase
automáticamente; está implícito en la definición de "InventoryItem"
implementada arriba.

Nuevo en la versión 3.7.


Decoradores, clases y funciones del módulo
==========================================

@dataclasses.dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)

   Esta función es un *decorator* utilizado para añadir a las clases
   *los métodos especiales* generados, como se describe a
   continuación.

   El decorador "dataclass()" examina la clase para encontrar
   "fields". Un "field" ('campo') se define como una variable de clase
   que tiene una *anotación de variable*. A excepción de los dos casos
   descritos debajo, nada en "dataclass()" examina el tipo
   especificado en la anotación de variable.

   El orden de los campos en los métodos generados es el mismo en el
   que se encuentran en la definición de la clase.

   El decorador "dataclass()" añade varios métodos "*dunder*"
   (abreviación de 'double underline') a la clase, descritos a
   continuación. Si alguno de los métodos añadidos ya existe en la
   definición de la clase, el comportamiento dependerá del parámetro,
   como se documenta abajo. El decorador retorna la misma clase con la
   que es llamado, no crea una nueva.

   Si "dataclass()" es llamado como un simple decorador sin
   parámetros, actúa con los valores por defecto documentados aquí.
   Específicamente, los siguientes tres usos de "dataclass()" son
   equivalentes:

      @dataclass
      class C:
          ...

      @dataclass()
      class C:
          ...

      @dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)
      class C:
         ...

   Los parámetros de "dataclass()" son:

   * "init": Si es verdadero (valor por defecto), el método
     "__init__()" será generado.

     Si la clase ya define "__init__()", este parámetro es ignorado.

   * "repr": Si es verdadero (valor por defecto), el método
     "__repr__()" es generado. La cadena de representación generada
     tendrá el nombre de la clase junto al nombre y la representación
     de cada uno de sus campos, en el mismo orden en el que están
     definidos en la clase. Es posible indicar que ciertos campos no
     sean incluidos en la representación. Por ejemplo:
     "InventoryItem(name='widget', unit_price=3.0,
     quantity_on_hand=10)".

     Si la clase ya define "__repr__()", este parámetro es ignorado.

   * "eq": Si es verdadero (por defecto), el método "__eq__()" es
     generado. Este método compara entre instancias de la clase
     representando cada una de ellas mediante una tupla, siendo los
     elementos de la misma los campos de la clase ubicados en el mismo
     orden en el que fueron definidos (dos tuplas son iguales si, y
     sólo si, sus campos son iguales).

     Si la clase ya define "__eq__()", este parámetro es ignorado.

   * "order": Si es verdadero ("False" es el valor por defecto), los
     métodos "__lt__()", "__le__()", "__gt__()" y "__ge__()" serán
     generados. Estos métodos comparan la clase como si fuera una
     tupla con sus campos, en orden. Ambas instancias en la
     comparación deben ser del mismo tipo. Si "order" es verdadero y
     "eq" falso, se lanza una excepción "ValueError".

     Si la clase ya define "__lt__()", "__le__()", "__gt__()" o
     "__ge__()", se lanza una excepción "TypeError".

   * "unsafe_hash": Si es "False" (por defecto), se genera el método
     "__hash__()" de acuerdo a los valores de "eq" y "frozen"
     definidos.

     "__hash__()" es utilizado por la función incorporada "hash()" y
     cuando los objetos definidos por la clase son añadidos a
     colecciones hash, como por ejemplo diccionarios y conjuntos.
     Definir el método "__hash__()" en una clase implica que sus
     instancias son inmutables. La mutabilidad es una propiedad
     compleja, ya que depende de cómo el programador utilice el
     objeto, la existencia y comportamiento de "__eq__()" y del valor
     asignado a las flags "eq" y "frozen" en el decorador
     "dataclass()".

     Por defecto, "dataclass()" no añade de forma implícita el método
     "__hash__()" a menos que sea seguro hacerlo. Tampoco añade o
     cambia un método "__hash__()" previamente definido de forma
     explícita. Definir el atributo de clase "__hash__ = None" tiene
     un significado específico en Python, descrito en la documentación
     dedicada a "__hash__()".

     If "__hash__()" is not explicitly defined, or if it is set to
     "None", then "dataclass()" *may* add an implicit "__hash__()"
     method. Although not recommended, you can force "dataclass()" to
     create a "__hash__()" method with "unsafe_hash=True". This might
     be the case if your class is logically immutable but can
     nonetheless be mutated. This is a specialized use case and should
     be considered carefully.

     A continuación se explican las reglas que se aplican en la
     creación implícita del método "__hash__()". Observar que no es
     compatible definir explícitamente un método "__hash__()" en su
     clase de datos y al mismo tiempo asignar "unsafe_hash=True"; esto
     lanza una excepción "TypeError".

     Si "eq" y "frozen" son ambos verdaderos, "dataclass()" genera por
     defecto un método "hash()" por ti. En el caso que "eq" sea
     verdadero y "frozen" falso, a "__hash__()" se le asigna "None",
     en consecuencia será *unhashable* (lo cual es deseable, ya que es
     mutable). Si "eq" es falso, "__hash__()" permanece sin cambios,
     por lo que en este caso se hará uso del método "hash()" heredado
     de la superclase (lo que implica que si la superclase es
     "object", se aplicará el *hashing* basado en el id de los
     objetos).

   * "frozen": Si es verdadero (el valor por defecto es "False"),
     cualquier intento de asignación a un campo de la clase lanza una
     excepción. Esto emula el comportamiento de las instancias
     congeladas (*frozen*) de sólo lectura. Si "__setattr__()" o
     "__delattr__()" son definidos en la clase, se lanzará una
     excepción "TypeError". Esto es ampliado más abajo.

   Los "fields" pueden especificar un valor por defecto opcionalmente,
   simplemente usando la sintaxis normal de Python:

      @dataclass
      class C:
          a: int       # 'a' has no default value
          b: int = 0   # assign a default value for 'b'

   En este ejemplo, tanto "a" como "b" serán incluidos en el método
   "__init__()" agregado, el cual será definido como sigue:

      def __init__(self, a: int, b: int = 0):

   Si, en la definición de una clase, a un campo con valor por defecto
   le sigue un campo sin valor por defecto será lanzada una excepción
   "TypeError". Esto se aplica también a la implementación de una
   clase única o como resultado de herencia de clases.

dataclasses.field(*, default=MISSING, default_factory=MISSING, repr=True, hash=None, init=True, compare=True, metadata=None)

   Para casos de uso común, estas funcionalidades son suficientes. Sin
   embargo, existen otras características de las clases de datos que
   requieren información adicional en ciertos campos. Para satisfacer
   esta necesidad, es posible reemplazar cualquier valor por defecto
   de un campo mediante una llamada a la función "field()". Por
   ejemplo:

      @dataclass
      class C:
          mylist: List[int] = field(default_factory=list)

      c = C()
      c.mylist += [1, 2, 3]

   Como se muestra arriba, el valor "MISSING" es un objeto centinela
   utilizado para detectar si los parámetros "default" y
   "default_factory" son provistos. Este objeto centinela es utilizado
   debido a que "None" es un valor válido para "default". Ningún
   procedimiento debe utilizar directamente el valor "MISSING".

   Los parámetros de "field()" son:

   * "default": Si es provisto, este será el valor por defecto para
     este campo. Es necesario que sea definido ya que la propia
     llamada a "field()" reemplaza la posición normal del valor por
     defecto.

   * "default_factory": Si es provisto, debe ser un objeto invocable
     sin argumentos, el cual será llamado cuando el valor por defecto
     de este campo sea necesario. Además de otros propósitos, puede
     ser utilizado para especificar campos con valores por defecto
     mutables, como se explica a continuación. Especificar tanto
     "default" como "default_factory" resulta en un error.

   * "init": Si es verdadero (por defecto), este campo es incluido
     como parámetro del método "__init__()" generado.

   * "repr": Si es verdadero (por defecto), este campo es incluido en
     la cadena de caracteres que retorna el método "__repr__()"
     generado.

   * "compare": Si es verdadero (por defecto), este campo es incluido
     en los métodos de comparación generados ("__eq__()", "__gt__()" y
     otros).

   * "hash": Su valor puede ser de tipo booleano o "None". Si es
     verdadero, este campo es incluido en el método "__hash__()"
     generado. Si es "None" (por defecto), utiliza el valor de
     "compare": normalmente éste es el comportamiento esperado. Un
     campo debería ser considerado para el *hash* si es compatible con
     operaciones de comparación. Está desaconsejado establecer este
     valor en algo que no sea "None".

     Una posible razón para definir "hash=False" y "compare=True"
     podría ser el caso en el que computar el valor *hash* para dicho
     campo es costoso pero el campo es necesario para los métodos de
     comparación, siempre que existan otros campos que contribuyen al
     valor hash del tipo. Incluso si un campo se excluye del hash, se
     seguirá utilizando a la hora de comparar.

   * "metadata": Puede ser un mapeo o *None*. *None* es tratado como
     un diccionario vacío. Este valor es envuelto en
     "MappingProxyType()" para que sea de sólo lectura y visible en el
     objeto "Field". No es utilizado por las clases de datos, mas bien
     es provisto como un mecanismo de extensión de terceros. Varios
     terceros pueden tener su propia clave para utilizar como espacio
     de nombres en *metadata*.

   Si el valor por defecto de un campo es especificado por una llamada
   a "field()", los atributos de clase para este campo serán
   reemplazados por los especificados en el valor "default". Si el
   valor de "default" no es provisto, el atributo de clase será
   eliminado. La idea es que, después que la ejecución del decorador
   "dataclass()", todos los atributos de la clase contengan los
   valores por defecto de cada campo, como si fueran definidos uno por
   uno. Por ejemplo, luego de:

      @dataclass
      class C:
          x: int
          y: int = field(repr=False)
          z: int = field(repr=False, default=10)
          t: int = 20

   El atributo de clase "C.z" será "10", el atributo de clase "C.t"
   será "20" y los atributos de clase "C.x" y "C.y" no serán
   definidos.

class dataclasses.Field

   Los objetos "Field" describen cada campo definido. Estos objetos
   son creados internamente y son retornados por el método "fields()"
   definido en este módulo (explicado más abajo). Los usuarios no
   deben instanciar un objeto "Field" directamente. Sus atributos
   documentados son:

      * "name": El nombre del campo.

      * "type": El tipo del campo.

      * "default", "default_factory", "init", "repr", "hash",
        "compare" y "metadata" tienen los mismos valores y
        significados respecto a la declaración de "field()" (ver
        arriba).

   Pueden existir otros atributos, pero son privados y no deberían ser
   considerados ni depender de ellos.

dataclasses.fields(class_or_instance)

   Retorna una tupla de objetos "Field" que definen los campos para
   esta clase de datos. Acepta tanto una clase de datos como una
   instancia de esta. Lanza una excepción "TypeError" si se le pasa
   cualquier otro objeto. No retorna pseudocampos, que son "ClassVar"
   o "InitVar".

dataclasses.asdict(instance, *, dict_factory=dict)

   Convierte la clase de datos "instance" en un diccionario (usando la
   función fábrica "dict_factory"). Cada clase de datos es convertida
   a un diccionario con sus campos como parejas "name: value". Las
   clases de datos, diccionarios, listas y tuplas son convertidas
   recursivamente. Por ejemplo:

      @dataclass
      class Point:
           x: int
           y: int

      @dataclass
      class C:
           mylist: List[Point]

      p = Point(10, 20)
      assert asdict(p) == {'x': 10, 'y': 20}

      c = C([Point(0, 0), Point(10, 4)])
      assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}

   Lanza una excepción "TypeError" si "instance" no es una instancia
   de una clase de datos.

dataclasses.astuple(instance, *, tuple_factory=tuple)

   Convierte la clase de datos "instance" a una tupla (usando la
   función fábrica "tuple_factory"). Cada clase de datos es convertida
   a una tupla con los valores de sus campos. Las clases de datos,
   diccionarios, listas y tuplas son convertidas recursivamente.

   Continuando con el ejemplo anterior:

      assert astuple(p) == (10, 20)
      assert astuple(c) == ([(0, 0), (10, 4)],)

   Lanza una excepción "TypeError" si "instance" no es una instancia
   de una clase de datos.

dataclasses.make_dataclass(cls_name, fields, *, bases=(), namespace=None, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)

   Crea una nueva clase de datos con el nombre "cls_name", con los
   campos definidos en "fields", con las clases base dadas en "bases"
   e inicializada con el espacio de nombres dado en "namespace".
   "fields" es un iterable que cumple con una de estas formas: "name",
   "(name, type)" o "(name, type, Field)". Si solo "name" es
   proporcionado, "typing.Any" es usado para "type". Los valores
   "init", "repr", "eq", "order", "unsafe_hash" y "frozen" tienen el
   mismo significado que en la función "dataclass()".

   Esta función no es estrictamente necesaria debido a que cualquier
   mecanismo de Python para crear una nueva clase con
   "__annotations__" puede usar la función "dataclass()" para
   convertir esa clase en una clase de datos. Esta función se
   proporciona simplemente por comodidad. Por ejemplo:

      C = make_dataclass('C',
                         [('x', int),
                           'y',
                          ('z', int, field(default=5))],
                         namespace={'add_one': lambda self: self.x + 1})

   Es equivalente a:

      @dataclass
      class C:
          x: int
          y: 'typing.Any'
          z: int = 5

          def add_one(self):
              return self.x + 1

dataclasses.replace(instance, **changes)

   Crea un nuevo objeto del mismo tipo que "instance", reemplazando
   los campos correspondientes con los valores de "changes". Si
   "instance" no es una clase de datos se lanza una excepción
   "TypeError". Si los valores en "changes" no especifican campos,
   también se lanza una excepción "TypeError".

   El objeto recién retornado es creado llamando al método
   "__init__()" de la clase de datos. Esto asegura que
   "__post_init__()", si existe, también será llamado.

   Las variables de solo inicialización sin valores predeterminados,
   si existen, deben especificarse en la llamada a "replace()" para
   que puedan pasarse a "__init__()" y "__post_init__()".

   Es un error que "changes" contenga cualquier campo que esté
   definido como "init=False". Una excepción "ValueError" se lanzará
   en este caso.

   Tenga en cuenta cómo funcionan los campos "init=False" durante una
   llamada a "replace()". No se copian del objeto de origen, sino que,
   de inicializarse, lo hacen en "__post_init__()". Se espera que los
   campos "init=False" se utilicen en contadas ocasiones y con
   prudencia. Si se utilizan, podría ser conveniente tener
   constructores de clase alternativos, o quizás un método
   personalizado "replace()" (o con un nombre similar) que maneje la
   copia de instancias.

dataclasses.is_dataclass(class_or_instance)

   Retorna "True" si su parámetro es una clase de datos o una
   instancia de una, en caso contrario retorna "False".

   Si se necesita conocer si una clase es una instancia de *dataclass*
   (y no una clase de datos en si misma), se debe agregar una
   verificación adicional para "not isinstance(obj, type)":

      def is_dataclass_instance(obj):
          return is_dataclass(obj) and not isinstance(obj, type)


Procesamiento posterior a la inicialización
===========================================

El código del método generado "__init__()" llamará a un método llamado
"__post_init__()", si "__post_init__()" está definido en la clase.
Normalmente se llamará como "self.__post_init__()". Sin embargo, si se
define algún campo "InitVar", también se pasarán a "__post_init__()"
en el orden en que se definieron en la clase. Si no se genera el
método "__init__()", entonces "__post_init__()" no se llamará
automáticamente.

Entre otros usos, esto permite inicializar valores de campo que
dependen de uno o más campos. Por ejemplo:

   @dataclass
   class C:
       a: float
       b: float
       c: float = field(init=False)

       def __post_init__(self):
           self.c = self.a + self.b

Consulta la sección sobre variables de solo inicialización que hay a
continuación para conocer las posibles formas de pasar parámetros a
"__post_init__()". También vea la advertencia sobre cómo "replace()"
maneja los campos "init = False".


Variables de clase
==================

Uno de los dos casos donde "dataclass()" realmente inspecciona el tipo
de un campo, es para determinar si dicho campo es una variable de
clase como se define en **PEP 526**. Lo hace comprobando si el tipo
del campo es "typing.ClassVar". Si un campo es una "ClassVar", se deja
de considerar como campo y los mecanismos de las clases de datos lo
ignoran. Tales pseudocampos "ClassVar" no son retornados por la
función del módulo "fields()".


Variable de solo inicialización
===============================

El otro caso donde "dataclass()" inspecciona una anotación de tipo es
para determinar si un campo es una variable de solo inicialización. Lo
hace comprobando si el tipo de un campo es "dataclasses.InitVar". Si
un campo es un "InitVar", se considera un pseudocampo llamado 'campo
de solo inicialización'. Como no es un campo verdadero, no es
retornado por la función del módulo "fields()". Los campos de solo
inicialización se agregan como parámetros al método generado
"__init__()" y se pasan al método opcional "__post_init__()". No son
utilizados de otra manera por las clases de datos.

Por ejemplo, supongamos que se va a inicializar un campo desde una
base de datos, de no proporcionarse un valor al crear la clase:

   @dataclass
   class C:
       i: int
       j: int = None
       database: InitVar[DatabaseType] = None

       def __post_init__(self, database):
           if self.j is None and database is not None:
               self.j = database.lookup('j')

   c = C(10, database=my_database)

En este caso, "fields()" retornará objetos "Field" para "i" y "j",
pero no para "database".


Instancias congeladas
=====================

No es posible crear objetos verdaderamente inmutables en Python. Sin
embargo, se puede emular la inmutabilidad pasando "frozen=True" al
decorador "dataclass()". En este caso, las clases de datos añadirán
los métodos "__setattr__()" y "__delattr__()" a la clase. Estos
métodos lanzarán una excepción "FrozenInstanceError" cuando sean
llamados.

Hay una pequeña penalización de rendimiento cuando se usa
"frozen=True", esto se debe a que "__init__()" no puede usar una
asignación simple para inicializar campos, viéndose obligado a usar
"object.__setattr__()".


Herencia
========

Cuando la clase de datos está siendo creada por el decorador
"dataclass()", revisa todas las clases base de la clase en el MRO
invertido (es decir, comenzando en "object") y, para cada clase de
datos que encuentra, agrega los campos de esa clase base a un mapeo
ordenado. Después de agregar todos los campos de la clase base, agrega
sus propios campos al mapeo. Todos los métodos generados utilizarán
este mapeo ordenado calculado combinando los campos. Como los campos
están en orden de inserción, las clases derivadas anulan las clases
base. Un ejemplo:

   @dataclass
   class Base:
       x: Any = 15.0
       y: int = 0

   @dataclass
   class C(Base):
       z: int = 10
       x: int = 15

La lista final de campos es, en orden, "x", "y", "z". El tipo final de
"x" es "int", como se especifica en la clase "C".

El método "__init__()" generado para "C" se verá como:

   def __init__(self, x: int = 15, y: int = 0, z: int = 10):


Funciones fábrica por defecto
=============================

   Si un "field()" especifica una "default_factory", se llama sin
   argumentos cuando se necesita un valor predeterminado para el
   campo. Por ejemplo, para crear una nueva instancia de una lista,
   debe usarse:

      mylist: list = field(default_factory=list)

   Si un campo está excluido de "__init__()" (usando "init = False") y
   el campo también especifica "default_factory", entonces la función
   de fábrica predeterminada siempre se llamará desde la función
   generada "__init__()". Esto sucede porque no existe otra forma de
   darle al campo un valor inicial.


Valores por defecto mutables
============================

   Python almacena los valores miembros por defecto en atributos de
   clase. Considera este ejemplo, sin usar clases de datos:

      class C:
          x = []
          def add(self, element):
              self.x.append(element)

      o1 = C()
      o2 = C()
      o1.add(1)
      o2.add(2)
      assert o1.x == [1, 2]
      assert o1.x is o2.x

   Tenga en cuenta que, tal como cabe esperar, las dos instancias de
   la clase "C" comparten la misma variable de clase "x".

   Usando clases de datos, *si* este código fuera válido:

      @dataclass
      class D:
          x: List = []
          def add(self, element):
              self.x += element

   generaría un código similar a:

      class D:
          x = []
          def __init__(self, x=x):
              self.x = x
          def add(self, element):
              self.x += element

      assert D().x is D().x

   Este tiene el mismo problema que el ejemplo original usando la
   clase "C". Es decir, dos instancias de la clase "D" que no
   especifican un valor para "x", al crear una instancia de la clase,
   compartirán la misma copia de "x". Debido a que las clases de datos
   usan simplemente el mecanismo normal de creación de clases de
   Python, también comparten este comportamiento. No existe una forma
   genérica de que las clases de datos detecten esta condición. En su
   lugar, las clases de datos generarán una excepción "TypeError" si
   detectan un parámetro predeterminado de tipo "list", "dict" o "set"
   (contenedores incorporados mutables). Esta es una solución parcial,
   pero protege contra muchos de los errores más comunes.

   Usar las funciones fábrica por defecto es una forma de crear nuevas
   instancias de tipos mutables como valores por defecto para campos:

      @dataclass
      class D:
          x: list = field(default_factory=list)

      assert D().x is not D().x


Excepciones
===========

exception dataclasses.FrozenInstanceError

   Raised when an implicitly defined "__setattr__()" or
   "__delattr__()" is called on a dataclass which was defined with
   "frozen=True". It is a subclass of "AttributeError".
