"reprlib" --- Implementação alternativa à "repr()"
**************************************************

**Código-fonte:** Lib/reprlib.py

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

O módulo "reprlib" fornece um meio de produzir representações de
objetos com limites no tamanho das strings resultantes. Isso é usado
no depurador Python e pode ser útil em outros contextos também.

Este módulo fornece uma classe, uma instância e uma função.

class reprlib.Repr

   Classe que fornece serviços de formatação úteis na implementação de
   funções semelhantes à embutida "repr()"; limites de tamanho para
   diferentes tipos de objetos são adicionados para evitar a geração
   de representações excessivamente longas.

reprlib.aRepr

   Esta é uma instância de "Repr" que é usada para fornecer a função
   "repr()" descrita abaixo. Alterar os atributos deste objeto afetará
   os limites de tamanho usados por "repr()" e pelo depurador Python.

reprlib.repr(obj)

   Este é o método "repr()" de "aRepr". Ele retorna uma string
   semelhante à retornada pela função embutida de mesmo nome, mas com
   limites na maioria dos tamanhos.

Além das ferramentas de limitação de tamanho, o módulo também fornece
um decorador para detectar chamadas recursivas para "__repr__()" e
substituir uma string de espaço reservado.

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

   Decorador para métodos "__repr__()" para detectar chamadas
   recursivas dentro da mesma thread. Se uma chamada recursiva for
   feita, o *fillvalue* é retornado; caso contrário, a chamada usual
   "__repr__()" é feita. Por exemplo:

      >>> 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'>

   Novo na versão 3.2.


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

Instâncias "Repr" fornecem vários atributos que podem ser usados para
fornecer limites de tamanho para as representações de diferentes tipos
de objetos e métodos que formatam tipos de objetos específicos.

Repr.fillvalue

   Esta string é exibida para referências recursivas. O padrão é
   "...".

   Novo na versão 3.11.

Repr.maxlevel

   Limite de profundidade na criação de representações recursivas. O
   padrão é "6".

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

   Limites no número de entradas representadas para o tipo de objeto
   nomeado. O padrão é "4" para "maxdict", "5" para "maxarray" e "6"
   para os demais.

Repr.maxlong

   Número máximo de caracteres na representação para um inteiro. Os
   dígitos são omitidos a partir do meio. O padrão é "40".

Repr.maxstring

   Limite no número de caracteres na representação da string. Observe
   que a representação "normal" da string é usada como fonte de
   caracteres: se sequências de escape forem necessárias na
   representação, elas poderão ser distorcidas quando a representação
   for encurtada. O padrão é "30".

Repr.maxother

   Este limite é usado para controlar o tamanho de tipos de objetos
   para os quais nenhum método de formatação específico está
   disponível no objeto "Repr". Ele é aplicado de maneira semelhante a
   "maxstring". O padrão é "20".

Repr.repr(obj)

   O equivalente ao "repr()" embutido que usa a formatação imposta
   pela instância.

Repr.repr1(obj, level)

   Implementação recursiva usada por "repr()". Esta usa o tipo de
   *obj* para determinar qual método de formatação chamar, passando
   *obj* e *level*. Os métodos específicos de tipo devem chamar
   "repr1()" para realizar a formatação recursiva, com "level - 1"
   para o valor de *level* na chamada recursiva.

Repr.repr_TYPE(obj, level)

   Métodos de formatação para tipos específicos são implementados como
   métodos com um nome baseado no nome do tipo. No nome do método,
   **TYPE** é substituído por "'_'.join(type(obj).__name__.split())".
   O despacho para esses métodos é tratado por "repr1()". Métodos
   específicos de tipo que precisam formatar um valor recursivamente
   devem chamar "self.repr1(subobj, level - 1)".


Estendendo objetos Repr
=======================

O uso de despacho dinâmico por "Repr.repr1()" permite que subclasses
de "Repr" adicionem suporte para tipos de objetos embutidos adicionais
ou modifiquem o tratamento de tipos já suportados. Este exemplo mostra
como suporte especial para objetos arquivo pode ser adicionado:

   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>'

   <stdin>
