"tokenize" --- Conversor a tokens para código Python
****************************************************

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

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

El módulo "tokenize" provee un analizador léxico para código fuente
Python, implementado en Python. Este analizador también retorna
comentarios como tokens, siendo útil para implementar *"pretty-
printers"*, como *colorizers* para impresiones en pantalla.

Para simplificar el manejo de flujos de tokens, todos los tokens
operator y delimiter y "Ellipsis" se retorna usando el tipo genérico
"OP". El tipo exacto se puede determinar usando la propiedad
"exact_type" en la *named tuple* retornada por "tokenize.tokenize()".


Convirtiendo la entrada en *tokens*
===================================

El punto de entrada principal es un *generador*:

tokenize.tokenize(readline)

   El generador "tokenize()" requiere un argumento, *readline*, que
   debe ser un objeto invocable que provee la misma interfaz que el
   método "io.IOBase.readline()" de los objetos archivos. Cada llamada
   a la función debe retornar una línea de entrada como bytes.

   El generador produce una tupla con los siguientes 5 miembros: El
   tipo de token, la cadena del token, una tupla "(srow, scol)" de
   enteros especificando la fila y columna donde el token empieza en
   el código, una "(erow, ecol)" de enteros especificando la fila y
   columna donde el token acaba en el código, y la línea en la que se
   encontró el token. La línea pasada (el último elemento de la tupla)
   es la línea *física*. La tupla se retorna como una *named tuple*
   con los campos: "type string start end line".

   La *named tuple* retorna tiene una propiedad adicional llamada
   "exact_type" que contiene el tipo de operador exacto para tokens
   "OP". Para todos los otros tipos de token, "exact_type" es el valor
   del campo "type" de la tupla con su respectivo nombre.

   Distinto en la versión 3.1: Añadido soporte para tuplas con nombre.

   Distinto en la versión 3.3: Añadido soporte para "exact_type".

   "tokenize()" determina la codificación del fichero buscando una
   marca BOM UTF-8 o una *cookie* de codificación, de acuerdo con
   **PEP 263**.

tokenize.generate_tokens(readline)

   Convertir a tokens una fuente leyendo cadenas unicode en lugar de
   bytes.

   Como "tokenize()", el argumento *readline* es un invocable que
   retorna una sola línea de entrada. Sin embargo, "generate_tokens()"
   espera que *readline* retorne un objeto *str* en lugar de *bytes*.

   El resultado es un iterador que produce tuplas con nombre,
   exactamente como "tokenize()". No produce un token "ENCODING".

Todas las constantes del módulo "token" se exportan también desde
"tokenize".

Otra función se encarga de invertir el proceso de conversión. Esto es
útil para crear herramientas que convierten a tokens un script,
modificar el flujo de token, y escribir el script modificado.

tokenize.untokenize(iterable)

   Convierte los *tokens* de vuelta en código fuente Python. El
   *iterable* debe retornar secuencias con al menos dos elementos, el
   tipo de *token* y la cadena del *token*. Cualquier otro elemento de
   la secuencia es ignorado.

   El *script* reconstruido se retorna como una cadena simple. El
   resultado está garantizado de que se convierte en *tokens* de
   vuelta a la misma entrada, de modo que la conversión no tiene
   pérdida y que las conversiones de ida y de vuelta están aseguradas.
   La garantía aplica sólo al tipo y la cadena del *token*, ya que el
   espaciado entre *tokens* (posiciones de columna) pueden variar.

   Retorna bytes, codificados usando el token "ENCODING", que es el
   primer elemento de la secuencia retornada por "tokenize()". Si no
   hay un token de codificación en la entrada, retorna una cadena.

"tokenize()" necesita detectar la codificación de los ficheros fuente
que convierte a tokens. La función que utiliza para hacer esto está
disponible como:

tokenize.detect_encoding(readline)

   La función "detect_encoding()" se usa para detectar la codificación
   que debería usarse al leer un fichero fuente Python. Requiere un
   argumento, *readline*, del mismo modo que el generador
   "tokenize()".

   Llamará a *readline* un máximo de dos veces, retornando la
   codificación usada, como cadena, y una lista del resto de líneas
   leídas, no descodificadas de *bytes*.

   Detecta la codificación a partir de la presencia de una marca BOM
   UTF-8 o una *cookie* de codificación, como se especifica en **PEP
   263**. Si ambas están presentes pero en desacuerdo, se lanzará un
   "SyntaxError". Resaltar que si se encuentra la marca BOM, se
   retornará "'utf-8-sig'" como codificación.

   Si no se especifica una codificación, por defecto se retornará
   "'utf-8'".

   Usa "open()" para abrir ficheros fuente Python: Ésta utiliza
   "detect_encoding()" para detectar la codificación del fichero.

tokenize.open(filename)

   Abrir un fichero en modo sólo lectura usando la codificación
   detectada por "detect_encoding()".

   Nuevo en la versión 3.2.

exception tokenize.TokenError

   Lanzada cuando una expresión o docstring que puede separarse en más
   líneas no está completa en el fichero, por ejemplo:

      """Beginning of
      docstring

   o:

      [1,
       2,
       3

Destacar que cadenas con comillas simples sin finalizar no lanzan un
error. Se convertirán en tokens como "ERRORTOKEN", seguido de la
conversión de su contenido.


Uso como línea de comandos
==========================

Nuevo en la versión 3.3.

El módulo "tokenize" se puede ejecutar como script desde la línea de
comandos. Es tan simple como:

   python -m tokenize [-e] [filename.py]

Se aceptan las siguientes opciones:

-h, --help

   muestra el mensaje de ayuda y sale

-e, --exact

   muestra los nombres de token usando el tipo exacto

Si se especifica "filename.py", se convierte su contenido a tokens por
la salida estándar. En otro caso, se convierte la entrada estándar.


Ejemplos
========

Ejemplo de un script que transforma literales float en objetos
Decimal:

   from tokenize import tokenize, untokenize, NUMBER, STRING, NAME, OP
   from io import BytesIO

   def decistmt(s):
       """Substitute Decimals for floats in a string of statements.

       >>> from decimal import Decimal
       >>> s = 'print(+21.3e-5*-.1234/81.7)'
       >>> decistmt(s)
       "print (+Decimal ('21.3e-5')*-Decimal ('.1234')/Decimal ('81.7'))"

       The format of the exponent is inherited from the platform C library.
       Known cases are "e-007" (Windows) and "e-07" (not Windows).  Since
       we're only showing 12 digits, and the 13th isn't close to 5, the
       rest of the output should be platform-independent.

       >>> exec(s)  #doctest: +ELLIPSIS
       -3.21716034272e-0...7

       Output from calculations with Decimal should be identical across all
       platforms.

       >>> exec(decistmt(s))
       -3.217160342717258261933904529E-7
       """
       result = []
       g = tokenize(BytesIO(s.encode('utf-8')).readline)  # tokenize the string
       for toknum, tokval, _, _, _ in g:
           if toknum == NUMBER and '.' in tokval:  # replace NUMBER tokens
               result.extend([
                   (NAME, 'Decimal'),
                   (OP, '('),
                   (STRING, repr(tokval)),
                   (OP, ')')
               ])
           else:
               result.append((toknum, tokval))
       return untokenize(result).decode('utf-8')

Ejemplo de conversión desde la línea de comandos. El *script*:

   def say_hello():
       print("Hello, World!")

   say_hello()

se convertirá en la salida siguiente, donde la primera columna es el
rango de coordenadas línea/columna donde se encuentra el token, la
segunda columna es el nombre del token, y la última columna es el
valor del token, si lo hay

   $ python -m tokenize hello.py
   0,0-0,0:            ENCODING       'utf-8'
   1,0-1,3:            NAME           'def'
   1,4-1,13:           NAME           'say_hello'
   1,13-1,14:          OP             '('
   1,14-1,15:          OP             ')'
   1,15-1,16:          OP             ':'
   1,16-1,17:          NEWLINE        '\n'
   2,0-2,4:            INDENT         '    '
   2,4-2,9:            NAME           'print'
   2,9-2,10:           OP             '('
   2,10-2,25:          STRING         '"Hello, World!"'
   2,25-2,26:          OP             ')'
   2,26-2,27:          NEWLINE        '\n'
   3,0-3,1:            NL             '\n'
   4,0-4,0:            DEDENT         ''
   4,0-4,9:            NAME           'say_hello'
   4,9-4,10:           OP             '('
   4,10-4,11:          OP             ')'
   4,11-4,12:          NEWLINE        '\n'
   5,0-5,0:            ENDMARKER      ''

Los nombres de tipos de token exactos se pueden mostrar con la opción
"-e":

   $ python -m tokenize -e hello.py
   0,0-0,0:            ENCODING       'utf-8'
   1,0-1,3:            NAME           'def'
   1,4-1,13:           NAME           'say_hello'
   1,13-1,14:          LPAR           '('
   1,14-1,15:          RPAR           ')'
   1,15-1,16:          COLON          ':'
   1,16-1,17:          NEWLINE        '\n'
   2,0-2,4:            INDENT         '    '
   2,4-2,9:            NAME           'print'
   2,9-2,10:           LPAR           '('
   2,10-2,25:          STRING         '"Hello, World!"'
   2,25-2,26:          RPAR           ')'
   2,26-2,27:          NEWLINE        '\n'
   3,0-3,1:            NL             '\n'
   4,0-4,0:            DEDENT         ''
   4,0-4,9:            NAME           'say_hello'
   4,9-4,10:           LPAR           '('
   4,10-4,11:          RPAR           ')'
   4,11-4,12:          NEWLINE        '\n'
   5,0-5,0:            ENDMARKER      ''

Ejemplo de tokenización de un fichero programáticamente, leyendo
cadenas unicode en lugar de *bytes* con "generate_tokens()":

   import tokenize

   with tokenize.open('hello.py') as f:
       tokens = tokenize.generate_tokens(f.readline)
       for token in tokens:
           print(token)

O leyendo *bytes* directamente con "tokenize()":

   import tokenize

   with open('hello.py', 'rb') as f:
       tokens = tokenize.tokenize(f.readline)
       for token in tokens:
           print(token)
