Como crear bytecode en python
Tags: python, bytecode, programming, tutorial
Published: 2020-11-19 21:04:29

## Introducción

Este es un tutorial de como crear bytecode pelado, o bytecode crudo en python, primero había arrancado a hacer este tutorial en [github.io](www.github.io), pero después un grupo de pandilleros virtuales me golpearon y me hicieron dar cuenta de que no tenia sentido utilizar eso teniendo esta maravilla.

## Pre-requisitos
***

   * Conocimientos básicos de Python
   * Saber que es un objeto de bytes (bytes object)
   * Conocer el concepto de [stack](https://es.wikipedia.org/wiki/Pila_de_llamadas)

## ¿Qué es Python?
Python es un lenguaje de programación interpretado multiparadigma, soporta polimorfismo, programación orientada a objetos (POO/OOP) y programación imperativa.

## ¿Como funciona?
***
Python como ya se nombró, es un lenguaje interpretado, esto quiere decir que pasa a través de un interpretador que conecta lo que la computadora va a hacer, con lo que une escriba. Python no genera un código de máquina como generaría un programa en C o C++, sino que funciona más o menos como Java, tiene una maquina virtual que interpreta bytecode. Este intérprete por defecto es CPython es el que se encarga de ejecutar el bytecode en tu computadora. Acá no vamos a utilizar compiladores, si no que vamos a manejar implementaciones del lenguaje, básicamente intérpretes que justamente, interpretan el código escrito luego de traducirlo a bytecode. Existe una amplia variedad de estos, e.g IronPython (Implementación en C#), Jython (Implementación hecha a puro Java), Micropython (Version hecha en C y optimizada para ejecutarse en microcontroladores).
Acá hay un esquema de como Python funciona y los pasos que el intérprete toma para llegar a ejecutar el código que vos escribiste.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/5uu4kxshwu8y80grgras.png)

## Como crear bytecode UTILIZABLE

Bueno, tenemos dos cosas, primero, bytecode pelado, es decír, bytes en hexadecimal representando opcodes y parámetros, y en segundo lugar, tenemos `CodeType`, un tipo de datos en Python que nos sirve para crear ByteCode que **SÍ SIRVA**. Igualmente para armar, hay que saber como se desarma, vamos a utilizar el módulo [dis](https://docs.python.org/3/library/dis.html) para desarmar nuestra función, este módulo es utiliza para des-ensamblar funciones, archivos y código.
```python
import dis

def suma(x, y):
    return x+y
dis.dis(suma)

```
La salida de ese retazo de código es la siguiente
```
1. 4           0 LOAD_FAST            0(x)
2.             2 LOAD_FAST            1(y)
3.             4 BINARY_ADD
4.             6 RETURN_VALUE
>>>
```
Como podemos ver, todo eso es bytecode, ahora la explicación.
***
Como habrán observado, enumeré las lineas que hay en la salida con el fin de hacer mas fácil esta explicación.
    Cada instrucción en Python tiene un OPCODE (Código de operación) específico, en este caso usamos 3, `LOAD_FAST BINARY_ADD RETURN_VALUE`, vamos a explicar que hace cada uno.

  * LOAD_FAST : Carga una variable a la cima del stack (Top Of Stack).
  * BINARY_ADD : Suma los dos valores que hay en la cima del stack y los devuelve a la cima del stack.
  * RETURN_VALUE : Devuelve el valor que esté en TOS.

Bueno, ahora que explicamos los opcodes, podemos darnos una idea de como funciona internamente nuestro código, pero aún hay dudas, dudas molestas pero necesarias, como por ejemplo esta "¿Qué es el 4 en la parte izquierda, el 4 que esta al inicio de la primer linea?", "¿Qué son los números a la izquierda de los OPCODES?"¿Por qué aparece un 0 a la derecha de LOAD_FAST?" "¿Y el 1?", "¿No querríamos cargar `x` e `y` para sumarlos en vez de 0 y 1?".
***
Bueno, voy a responder en orden.
  * El 4 es la línea donde comienza el bytecode des-ensamblado.
  * Estos números representan el [offset](https://es.wikipedia.org/wiki/Offset_(inform%C3%A1tica)) de los bytes.
  * El 0 y el 1 corresponden a un índice, ya que las variables del código, son almacenadas en una lista (array), los 0 y 1 representan el índice, no obstante, el módulo dis nos dice que variable es a la derecha de este número (de ahí el `0 (x)` y 1 `(y)`).*

## ¿Cómo re-creamos nuestra función para hacerla bytecode?
***
Bueno, lo primero que hacemos es importar `CodeType` y `FunctionType`(Para pasarlo a función) desde el módulo [types](https://docs.python.org/3/library/types.html#module-types)

```python
import dis
from types import CodeType, FunctionType

def suma(x, y):
    return x+y
```
Luego de esto, vamos a crear nuestro código objeto
```python
import dis
from types import CodeType, FunctionType

def suma(x, y):
    return x+y

# Esto lo voy a explicar despues, son flags
CO_OPTIMIZED = 0x0001
CO_NEWLOCALS = 0x0002
CO_NOFREE = 0x0002

mi_codigo = CodeType(
    2, #argcount
    0, #kwonlyargcount
    2, #nlocals
    2, #stacksize
    (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE), #flags
    bytes([124, 0, 124, 1, 23, 0, 83, 0]), #codestring
    (0,), #constantes
    (), #nombres de las constantes o globales (names)
    ('x','y',), #nombres de variables (varnames)
    'blog_sin_nombre', #filename
    'suma_crafteada', #name (nombre del codigo/funcion)
    9, #Firstlineno (Primer linea donde aparece este cod.)
    b'', #lnotab
    (), #freevars
    () ,#freecellvars
    )
```
Bueno bueno... Muchas cosas nuevas, vamos a explicar los argumentos a ver.

`CodeType: argcount, kwonlyargcount, nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotab, freevars, freecellvars`

<table cellpadding="10" bordercolor="#F5EDF0" border="2">
  <tbody>
    <tr>
      <th>Argumento</th>
      <th>Descripción</th>
    </tr>
    <tr>
      <td>argcount</td>
      <td>Cantidad de argumentos</td>
    </tr>
    <tr>
      <td>kwonlyargcount</td>
      <td>Cantidad de keyword arguments</td>
    </tr>
    <tr>
      <td>nlocals</td>
      <td>Numero de variables locales (En este caso 2, x e y)</td>
    </tr>
    <tr>
      <td>stacksize</td>
      <td>Máximo tamaño en bytes que va a tener el stack (En este caso 2 porque x+y requiere dos espacios en el stack frame)</td>
    </tr>
    <tr>
      <td>flags</td>
      <td>Las banderas son lo que determinan algunas condiciones del bytecode, podes guiarte por esta <a href="https://bytecode.readthedocs.io/en/latest/api.html#compiler-flags" tarte="_blank">referencia</a>. Nos vamos a adentrar en flags en un tutorial mas avanzado.</td>
    </tr>
    <tr>
      <td>codestring</td>
      <td>Esto es una lista(array) de bytes conteniendo lasequencia en cuestión, en el 124 significa LOAD_FAST, 23 BINARY_ADD y 83 RETURN_VALUE</td>
    </tr>
    <tr>
      <td>constants</td>
      <td>Una tupla con el valor de las constantes (Como numeros enteros, False, True, funciones built-in...)</td>
    </tr>
    <tr>
      <td>names</td>
      <td>Una tupla conteniendo el nombre de las constantes respectivamente</td>
    </tr>
    <tr>
      <td>varnames</td>
      <td>Nombre de variables locales</td>
    </tr>
    <tr>
      <td>filename</td>
      <td>Esta string representa el nombre del archivo, cuando no se usa este valor puede ser cualquier string</td>
    </tr>
    <tr>
      <td>name</td>
      <td>Nombre del code object o la función</td>
    </tr>
    <tr>
      <td>firstlineno</td>
      <td>Representa la primer línea en la que se ejecuta el código, relevante si importamos un archivo, de otra manera puede ser cualquier numero entero</td>
    </tr>
    <tr>
      <td>lnotab</td>
      <td>Esto es un mapeo entre los offsets del bytecode object y el offset de las lineas, si no te interesa poner información de las líneas, podes usar <code>b''</code></td>
    </tr>
    <tr>
      <td>freevars</td>
      <td>Estas variables las voy a explicar en un tutorial avanzado, se utiliza en closures</td>
    </tr>
    <tr>
      <td>cellvars</td>
      <td>Estas variables son definidas dentro de una closure</td>
    </tr>
  </tbody>
</table>

Unas ultimas dos cosas para remarcar antes de pasar a `FunctionType`, la primera es que los 0 que le siguen a los opcodes *e.g [124, 0, ...]* son el argumento, y la segunda es que cada bytecode puede variar de versión en versión, para saber u orientarte sobre el codestring, podes utilizar el siguiente [snippet](https://es.wikipedia.org/wiki/Snippet)

```python
def suma(x,y):
    return x+y
suma.__code__.co_code

# Salida esperada en Python 3.7.9 (La versión que yo uso)
# b'|\x00|\x01\x17\x00S\x00'
# Los bytes los interpreta como characters, probablemente para que sea mas legible. (Si ponemos chr(124) nos va a imprmír el carácter |)
```

## "Crafteando" la función
Vamos a utilizar FunctionType ahora.
`FunctionType: code, globals, name, argdefs, closure`



<table cellpadding="10" bordercolor="#F5EDF0" border="2">
  <tbody>
    <tr>
      <th>Argumento</th>
      <th>Descripción</th>
    </tr>
    <tr>
      <td>code</td>
      <td>Código objeto (osea, CodeType)</td>
    </tr>
    <tr>
      <td>globals</td>
      <td>Un diccionario conteniendo las globales del siguiente modo `{ "Nombre": ValorNombre}` de ese modo, Nombre pasa a ser un identificador, y luego se accede a el como si fuese una variable</td>
    </tr>
    <tr>
      <td>name (Opcional)</td>
      <td>Sobreescribe el valor que tiene el código objeto)</td>
    </tr>
    <tr>
      <td>argdefs (Opcional)</td>
      <td>Una tupla que especifica el valor de los argumentos por defecto</td>
    <tr>
      <td>closure (Opcional)</td>
      <td>Una tupla que suple los lazos para las freevars</td>
    </tr>
  </tbody>
</table>

Bueno, una vez esto claro, ahora solo nos quedaría agregar una FunctionType con nuestro código objeto (`mi_codigo`) y llamarla.

```python
import dis
from types import CodeType, FunctionType

def suma(x, y):
    return x+y
```
Luego de esto, vamos a crear nuestro código objeto
```python
import dis
from types import CodeType, FunctionType

def suma(x, y):
    return x+y

# Esto lo voy a explicar despues, son flags
CO_OPTIMIZED = 0x0001
CO_NEWLOCALS = 0x0002
CO_NOFREE = 0x0002

mi_codigo = CodeType(
    2, #argcount
    0, #kwonlyargcount
    2, #nlocals
    2, #stacksize
    (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE), #flags
    bytes([124, 0, 124, 1, 23, 0, 83, 0]), #codestring
    (0,), #constantes
    (), #nombres de las constantes o globales (names)
    ('x','y',), #nombres de variables (varnames)
    'blog_sin_nombre', #filename
    'suma_crafteada', #name (nombre del codigo/funcion)
    9, #Firstlineno (Primer linea donde aparece este cod.)
    b'', #lnotab
    (), #freevars
    () ,#freecellvars
    )

_suma = FunctionType(mi_codigo, {})
resultado = _suma(213,3)
print(resultado)

# Salida esperada
# 216
```

Esto es todo por ahora, despues voy a subír otro tutorial explicando las [closures](https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica)).

#### Fuentes
  * [Modulo dis](https://docs.python.org/3/library/dis.html)
  * [¿Cómo funciona Python?](https://www.geeksforgeeks.org/internal-working-of-python/)
  * [Flags y otros datos útiles](https://bytecode.readthedocs.io/en/latest/api.html#compiler-flags)
  * [Freevar, Cellvars y variables locales](https://github.com/universe-proton/universe-topology/issues/15)
  * [Scott Sanderson y Joe Jevnik "Playing with Python bytecode"](https://youtu.be/rpZz_emWIQA)