"reprlib" --- Implementación "repr()" alternativa
*************************************************

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

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

El módulo "reprlib" provee de los medios necesarios para producir
representaciones de objetos con límites en el tamaño de las cadenas
resultantes. Es usado en el depurador de Python y puede ser útil
también en otros contextos.

Este módulo provee una clase, una instancia y una función:

class reprlib.Repr

   Clase que provee de servicios de formateo útiles en la
   implementación de funciones similar a la integrada "repr()"; los
   límites de tamaño para diferentes tipos de objetos son añadidos
   para evitar la generación de representaciones que son excesivamente
   largas.

reprlib.aRepr

   Esta es una instancia de "Repr" que es usada para proveer la
   función "repr()" descrita debajo. Cambiar los atributos de este
   objeto afectará los límites de tamaño usados por "repr()" y el
   depurador de Python.

reprlib.repr(obj)

   Este es el método "repr()" de "aRepr". Retorna una cadena similar a
   la retornada por la función integrada del mismo nombre, pero con
   límites en la mayoría de tamaños.

Además de las herramientas de limitación de tamaño, el módulo también
provee un decorador para detectar invocaciones recursivas a
"__repr__()" y sustituyendo por un marcador de posición de cadena en
su lugar.

@reprlib.recursive_repr(fillvalue='...')

   Decorador para métodos "__repr__()" que detecta invocaciones
   recursivas dentro del mismo hilo. Si se produce una invocación
   recursiva, el *fillvalue* es retornado, si no, se produce la
   invocación "__repr__()" habitual. Por ejemplo:

   >>> from reprlib import recursive_repr
   >>> class MyList(list):
   ...     @recursive_repr()
   ...     def __repr__(self):
   ...         return '<' + '|'.join(map(repr, self)) + '>'
   ...
   >>> m = MyList('abc')
   >>> m.append(m)
   >>> m.append('x')
   >>> print(m)
   <'a'|'b'|'c'|...|'x'>

   Nuevo en la versión 3.2.


Objetos Repr
============

Las instancias "Repr" proveen varios atributos que pueden ser usados
para proporcionar límites de tamaño para las representaciones de
diferentes tipos de objetos, y métodos que formatean tipos de objetos
específicos.

Repr.maxlevel

   Límite de profundidad en la creación de representaciones
   recursivas. El valor por defecto es "6".

Repr.maxdict
Repr.maxlist
Repr.maxtuple
Repr.maxset
Repr.maxfrozenset
Repr.maxdeque
Repr.maxarray

   Límites en el número de entradas representadas por el tipo de
   objeto nombrado. El valor por defecto es "4" para "maxdict", "5"
   para  "maxarray", y "6" para los otros.

Repr.maxlong

   Máximo número de caracteres en la representación para un entero.
   Los dígitos son eliminados desde el medio. El valor por defecto es
   "40".

Repr.maxstring

   Límite en el número de caracteres en la representación de la
   cadena. Fíjese que la representación "normal" de la cadena  es la
   usada como la fuente de caracteres: si se necesitan secuencias de
   escape en la representación, estas pueden ser desordenadas cuando
   la representación se ha acortado. El valor por defecto es "30".

Repr.maxother

   Este límite es usado para controlar el tamaño de los tipos de
   objetos para los cuales no hay ningún método de formateo específico
   en el objeto "Repr". Se aplica de una manera similar a "maxstring".
   El valor por defecto es "20".

Repr.repr(obj)

   El equivalente a la función integrada "repr()" que usa el formateo
   impuesto por la instancia.

Repr.repr1(obj, level)

   Implementación recursiva usada por "repr()". Este usa el tipo de
   *obj* para determinar qué método invocar, pasándole *obj* y
   *level*. Los métodos de tipo específico deben invocar "repr1()"
   para realizar formateo recursivo, con "level - 1" para el valor de
   *level* en la invocación recursiva.

Repr.repr_TYPE(obj, level)

   Métodos de formateo para tipos específicos son implementados como
   métodos con un nombre basado en el nombre del tipo. En el nombre
   del método, **TYPE** es reemplazado por
   "'_'.join(type(obj).__name__.split())". El envío a estos métodos es
   gestionado por "repr1()". Los métodos de tipo específico que
   necesitan formatear recursivamente un valor deben invocar
   "self.repr1(subobj, level - 1)".


Subclasificando Objetos Repr
============================

El uso de envíos dinámicos por "Repr.repr1()" permite a las subclases
de "Repr" añadir soporte para tipos adicionales de objetos integrados
o modificar el manejo de tipos ya soportados. Este ejemplo muestra
como el soporte especial para objetos de tipo archivo puede ser
añadido.

   import reprlib
   import sys

   class MyRepr(reprlib.Repr):

       def repr_TextIOWrapper(self, obj, level):
           if obj.name in {'<stdin>', '<stdout>', '<stderr>'}:
               return obj.name
           return repr(obj)

   aRepr = MyRepr()
   print(aRepr.repr(sys.stdin))         # prints '<stdin>'
