2to3 - Traducción de código Python 2 a 3
****************************************

2to3 es un programa hecho en Python que lee código fuente en Python
2.x y aplica una serie de *fixers* para transformarlo en código Python
3.x válido. La librería estándar contiene un buen conjunto de *fixers*
que se encargarán de casi todo el código. La librería soporte de 2to3
"lib2to3" es, de todas maneras, una librería flexible y genérica. Por
lo cual es posible escribir sus propios *fixers* para 2to3. "lib2to3"
también puede adaptarse a aplicaciones propias en las cuales el código
en Python necesite editarse automáticamente.


Usando 2to3
===========

2to3 generalmente estará instalada con el interprete de Python como un
*script*. También se encuentra ubicada en el directorio
"Tools/scripts" en la raíz de Python.

Los argumentos básicos de 2to3 son una lista de archivos o directorios
a convertir. Los directorios se recorren recursivamente en búsqueda de
archivos en Python.

Este es un ejemplo de un archivo en Python 2.x, :file: *example.py*:

   def greet(name):
       print "Hello, {0}!".format(name)
   print "What's your name?"
   name = raw_input()
   greet(name)

Puede ser convertido a Python 3.x vía 2to3 desde la línea de comandos:

   $ 2to3 example.py

Se imprime un *diff* del archivo fuente original. 2to3 también puede
escribir las modificaciones necesarias directamente en el archivo
fuente. (Se hace una copia de respaldo del archivo original a menos
que se proporcione "-n".) La escritura de los cambios se habilita con
la opción "-w":

   $ 2to3 -w example.py

Después de la conversión, "example.py" se ve de la siguiente manera:

   def greet(name):
       print("Hello, {0}!".format(name))
   print("What's your name?")
   name = input()
   greet(name)

Los comentarios y la identación exacta se conservan durante todo el
proceso de conversión.

Por defecto, 2to3 corre un conjunto de fixers predefinidos. La opción
"-l" lista todos los *fixers* posibles. Se puede pasar un conjunto
explícito de *fixers* con la opción "-x".  Asimismo la opción "-x"
deshabilita el *fixer* que se explicita. El siguiente ejemplo corre
solo solo los *fixers* "imports" y  "has_key":

   $ 2to3 -f imports -f has_key example.py

Este comando corre todos los *fixers* excepto el "apply" *fixer*:

   $ 2to3 -x apply example.py

Algunos *fixers* son explícitos, esto quiere decir que no corren por
defecto y deben ser listados en la línea de comando para que se
ejecuten. Acá, además de los *fixers* por defectos, se ejecuta el
*fixer* "idioms":

   $ 2to3 -f all -f idioms example.py

Puede observarse que pasar "all" habilita todos los *fixers* por
defecto.

Algunas veces 2to3 va a encontrar algo en su código que necesita ser
modificado, pero 2to3 no puede hacerlo automáticamente. En estos
casos, 2to3 va a imprimir una advertencia debajo del *diff* del
archivo. Deberá tomar nota de la advertencia para obtener un código
compatible con 3.x.

2to3 también puede refactorizar *doctest*. Para habilitar este modo,
use la opción "-d". Tenga en cuenta que *solo* los *doctest* serán
refactorizados. Esto tampoco requiere que el módulo sea válido en
Python. Por ejemplo, *doctest* de ejemplo en un documento reST también
pueden ser refactorizados con esta opción.

La opción "-v" habilita la salida de más información en el proceso de
conversión.

Como algunas declaraciones *print* pueden ser pasadas como llamadas a
funciones o declaraciones, 2to3 no siempre lee archivos que contienen
la función print. Cuando 2to3 detecta la presencia de la directiva de
compilación "from __future__ import print_function", modifica su
gramática interna para interpretar  "print()" como una función. Este
cambio también puede habilitarse manualmente con la opción "-p". Use
la opción "-p" para ejecutar los *fixers* en el código al que ya se le
han convertido sus declaraciones *print*.

La opción "-o" o la opción "--output-dir" permiten designar un
directorio alternativo para que se guarden los archivos procesados. La
opción "-n" es necesaria ya que los archivos de respaldo no tienen
sentido cuando no se sobreescriben los archivos originales.

Nuevo en la versión 3.2.3: Se agregó la opción :option:` !-o`.

La opción "-W" o "--write-unchanged-files" le dice a 2to3 que siempre
escriba archivos de salida, incluso si no se requieren hacer cambios
en el archivo. Esto es muy útil con la opción "-o" para que copie el
árbol completo de código Python con su conversión de un directorio a
otro. Esta opción incluye a la opción "-w" ya que no tendría sentido
de otra manera.

Nuevo en la versión 3.2.3: Se agregó la opción "-W".

La opción "--add-suffix" agrega un texto al final de todos los nombres
de archivo. La opción "-n" es necesaria, ya que las copias de respaldo
no son necesarias cuando escribimos a un archivo con distinto nombre.
Ejemplo:

   $ 2to3 -n -W --add-suffix=3 example.py

Hará que se escriba una archivo convertido con el nombre
"example.py3".

Nuevo en la versión 3.2.3: Se agrega la opción "--add-suffix".

Para convertir un proyecto entero de un árbol de directorios a otro
use:

   $ 2to3 --output-dir=python3-version/mycode -W -n python2-version/mycode


Fixers
======

Cada paso de la transformación del código es encapsulado en un
*fixer*. El comando "2to3 -l" los lista. Como se explicó arriba, cada
uno de estos puede habilitarse o deshabilitarse individualmente. En
esta sección se los describe más detalladamente.

apply

   Elimina el uso de "apply()". Por ejemplo "apply(function, *args,
   **kwargs)" es convertido a "function(*args, **kwargs)".

asserts

   Reemplaza los nombre de método "unittest" en desuso por los
   correctos.

   +----------------------------------+--------------------------------------------+
   | De                               | A                                          |
   |==================================|============================================|
   | "failUnlessEqual(a, b)"          | "assertEqual(a, b)"                        |
   +----------------------------------+--------------------------------------------+
   | "assertEquals(a, b)"             | "assertEqual(a, b)"                        |
   +----------------------------------+--------------------------------------------+
   | "failIfEqual(a, b)"              | "assertNotEqual(a, b)"                     |
   +----------------------------------+--------------------------------------------+
   | "assertNotEquals(a, b)"          | "assertNotEqual(a, b)"                     |
   +----------------------------------+--------------------------------------------+
   | "failUnless(a)"                  | "assertTrue(a)"                            |
   +----------------------------------+--------------------------------------------+
   | "assert_(a)"                     | "assertTrue(a)"                            |
   +----------------------------------+--------------------------------------------+
   | "failIf(a)"                      | "assertFalse(a)"                           |
   +----------------------------------+--------------------------------------------+
   | "failUnlessRaises(exc, cal)"     | "assertRaises(exc, cal)"                   |
   +----------------------------------+--------------------------------------------+
   | "failUnlessAlmostEqual(a, b)"    | "assertAlmostEqual(a, b)"                  |
   +----------------------------------+--------------------------------------------+
   | "assertAlmostEquals(a, b)"       | "assertAlmostEqual(a, b)"                  |
   +----------------------------------+--------------------------------------------+
   | "failIfAlmostEqual(a, b)"        | "assertNotAlmostEqual(a, b)"               |
   +----------------------------------+--------------------------------------------+
   | "assertNotAlmostEquals(a, b)"    | "assertNotAlmostEqual(a, b)"               |
   +----------------------------------+--------------------------------------------+

basestring

   Convierte "basestring" a "str".

buffer

   Convierte "buffer" a "memoryview". Este *fixer* es opcional porque
   la API "memoryview" es similar pero no exactamente la misma que la
   del "buffer".

dict

   Corrige los métodos de iteración del diccionario,
   "dict.iteritems()" es convertido a  "dict.items()",
   "dict.iterkeys()" a "dict.keys()", y "dict.itervalues()" a
   "dict.values()". Del mismo modo, "dict.viewitems()",
   "dict.viewkeys()" y "dict.viewvalues()" son convertidos
   respectivamente a "dict.items()", "dict.keys()" y "dict.values()".
   También incluye los usos existentes de "dict.items()",
   "dict.keys()", y "dict.values()" en una llamada a "list".

except

   Convierte "except X, T" a "except X as T".

exec

   Convierte la declaración "exec" a la función "exec()".

execfile

   Elimina el uso de la función "execfile()". El argumento para
   "execfile()" es encapsulado para las funciones "open()",
   "compile()", y "exec()".

exitfunc

   Cambia la declaración de "sys.exitfunc" para usar el módulo
   "atexit".

filter

   Encapsula la función "filter()" usando una llamada para la clase
   "list".

funcattrs

   Corrige los atributos de la función que fueron renombrados. Por
   ejemplo, "my_function.func_closure" es convertido a
   "my_function.__closure__".

future

   Elimina la declaración "from __future__ import new_feature".

getcwdu

   Renombra la función "os.getcwdu()" a "os.getcwd()".

has_key

   Cambia "dict.has_key(key)" a "key in dict".

idioms

   Este *fixer* opcional ejecuta varias transformaciones que tornan el
   código Python más idiomático. Comparaciones de tipo como "type(x)
   is SomeClass" y "type(x) == SomeClass" son convertidas a
   "isinstance(x, SomeClass)".``while 1`` cambia a "while True". Este
   *fixer* también intenta hacer uso de "sorted()" en los lugares
   apropiados. Por ejemplo, en este bloque:

      L = list(some_iterable)
      L.sort()

   es convertido a

      L = sorted(some_iterable)

import

   Detecta las importaciones entre hermanos y las convierte en
   importaciones relativas.

imports

   Maneja los cambios de nombre de módulo en la librería estándar.

imports2

   Maneja otros cambios de nombre de módulo en la biblioteca estándar.
   Está separada del *fixer* "imports" solo por motivos de
   limitaciones técnicas.

input

   Convierte "input(prompt)" a "eval(input(prompt))".

intern

   Convierte "intern()" a "sys.intern()".

isinstance

   Corrige tipos duplicados en el segundo argumento de "isinstance()".
   Por ejemplo,``isinstance(x, (int, int))`` es convertido a
   "isinstance(x, int)" y "isinstance(x, (int, float, int))" es
   convertido a "isinstance(x, (int, float))".

itertools_imports

   Elimina importaciones de "itertools.ifilter()", "itertools.izip()",
   y "itertools.imap()". Importación de "itertools.ifilterfalse()"
   también se cambian a "itertools.filterfalse()".

itertools

   Cambia el uso de "itertools.ifilter()", "itertools.izip()", y
   "itertools.imap()" para sus equivalentes integrados
   "itertools.ifilterfalse()" es cambiado a "itertools.filterfalse()".

long

   Renombra "long" a "int".

map

   Encapsula "map()" en una llamada a "list". También cambia
   "map(None, x)" a "list(x)". Usando``from future_builtins import
   map`` se deshabilita este *fixer*.

metaclass

   Convierte la vieja sintaxis de metaclase ("__metaclass__ = Meta" en
   el cuerpo de la clase) a la nueva sintaxis ("class
   X(metaclass=Meta)").

methodattrs

   Corrige nombres de atributos de métodos antiguos. Por ejemplo,
   "meth.im_func" is convertido a "meth.__func__".

ne

   Convierte la antigua sintaxis no-igual, "<>", a "!=".

next

   Convierte el uso de métodos iteradores "next()" para la función
   "next()". También renombra métodos "next()" a "__next__()".

nonzero

   Renombra el método "__nonzero__()" a "__bool__()".

numliterals

   Convierte literales octales a la nueva sintaxis.

operator

   Convierte llamadas para varias funciones en el módulo "operator" a
   otras, pero equivalentes, llamadas de funciones. Cuando es
   necesario, se agregan las declaraciones "import" apropiadas, por
   ejemplo "import collections.abc". Se realizan los siguientes
   mapeos:

   +------------------------------------+-----------------------------------------------+
   | De                                 | A                                             |
   |====================================|===============================================|
   | "operator.isCallable(obj)"         | "callable(obj)"                               |
   +------------------------------------+-----------------------------------------------+
   | "operator.sequenceIncludes(obj)"   | "operator.contains(obj)"                      |
   +------------------------------------+-----------------------------------------------+
   | "operator.isSequenceType(obj)"     | "isinstance(obj, collections.abc.Sequence)"   |
   +------------------------------------+-----------------------------------------------+
   | "operator.isMappingType(obj)"      | "isinstance(obj, collections.abc.Mapping)"    |
   +------------------------------------+-----------------------------------------------+
   | "operator.isNumberType(obj)"       | "isinstance(obj, numbers.Number)"             |
   +------------------------------------+-----------------------------------------------+
   | "operator.repeat(obj, n)"          | "operator.mul(obj, n)"                        |
   +------------------------------------+-----------------------------------------------+
   | "operator.irepeat(obj, n)"         | "operator.imul(obj, n)"                       |
   +------------------------------------+-----------------------------------------------+

paren

   Agrega los paréntesis extra donde sean necesarios en las listas de
   comprensión. Por ejemplo "[x for x in 1, 2]" se convierte en "[x
   for x in (1, 2)]".

print

   Convierte la declaración "print" en la función "print()".

raise

   Convierte "raise E, V" a "raise E(V)", y "raise E, V, T" a "raise
   E(V).with_traceback(T)". SI "E" es una tupla, la conversión será
   incorrecta porque sustituir tuplas por excepciones fue eliminado en
   Python 3.0.

raw_input

   Conviertes "raw_input()" to "input()".

reduce

   Maneja el movimiento de "reduce()" a "functools.reduce()".

reload

   Convierte "reload()" a "importlib.reload()".

renames

   Cambia "sys.maxint" a "sys.maxsize".

repr

   Sustituye el *backtick* repr por la función "repr()".

set_literal

   Sustituye el uso de la clase constructora "set" por su literal.
   Este *fixer* es opcional.

standarderror

   Renombra "StandardError" a "Exception".

sys_exc

   Cambia los "sys.exc_value", "sys.exc_type", "sys.exc_traceback" en
   desuso para usar la función "sys.exc_info()".

throw

   Corrige el cambio de la API en el método generador "throw()".

tuple_params

   Elimina el desempaquetamiento implícito del parámetro de tupla.
   Este *fixer* inserta variables temporarias.

types

   Corrige el código roto por la remoción de algunos miembros en el
   módulo "types".

unicode

   Renombra "unicode" a "str".

urllib

   Maneja el renombramiento de los módulos "urllib" y "urllib2" para
   el paquete "urllib".

ws_comma

   Remueve el exceso de espacios blancos de los ítems separados por
   coma. Este *fixer* es opcional.

xrange

   Renombra "xrange()" a "range()" y encapsula la llamada a la función
   existente "range()" con "list".

xreadlines

   Cambia "for x in file.xreadlines()" por "for x in file".

zip

   Encapsula el uso de la función  "zip()" en una llamada a la clase
   "list". Esto está deshabilitado cuando "from future_builtins import
   zip" aparece.


"lib2to3" - librería 2to3
=========================

**Código fuente:** Lib/lib2to3/

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

Nota:

  La API del módulo "lib2to3" debe considerarse inestable y puede
  cambiar drásticamente en el futuro.
