# La capa de muy alto nivel

Las funciones en este capítulo te permitirán ejecutar código fuente de Python desde un archivo o un búfer, pero no te permitirán interactuar de una manera detallada con el intérprete.

Varias de estas funciones aceptan un símbolo de inicio de la gramática como parámetro. Los símbolos de inicio disponibles son `Py_eval_input`, `Py_file_input`, y `Py_single_input`. Estos se describen siguiendo las funciones que los aceptan como parámetros.

Note also that several of these functions take `FILE*` parameters. One particular issue which needs to be handled carefully is that the `FILE` structure for different C libraries can be different and incompatible. Under Windows (at least), it is possible for dynamically linked extensions to actually use different libraries, so care should be taken that `FILE*` parameters are only passed to these functions if it is certain that they were created by the same library that the Python runtime is using.

int `Py_Main`(int argc, wchar_t **argv)

  El programa principal para el intérprete estándar. Está disponible para programas que incorporan Python. Los parámetros argc y argv deben prepararse exactamente como los que se pasan a la función `main()` de un programa en C (convertido a wchar_t de acuerdo con la configuración regional del usuario). Es importante tener en cuenta que la lista de argumentos puede ser modificada (pero el contenido de las cadenas de caracteres señaladas por la lista de argumentos no lo es). El valor de retorno será `0` si el intérprete acaba normalmente (es decir, sin excepción), `1` si el intérprete acaba debido a una excepción, o `2` si la lista de parámetros no representa una línea de comando Python válida.

  Tenga en cuenta que si se lanza un `SystemExit` no manejado, esta función no retornará `1`, pero saldrá del proceso, siempre que `Py_InspectFlag` no esté configurado.

int `Py_BytesMain`(int argc, char **argv)

  Similar a `Py_Main()` pero argv es un arreglo de cadenas de caracteres de bytes.

  Nuevo en la versión 3.8.

int `PyRun_AnyFile`(FILE *fp, const char *filename)

  Esta es una interfaz simplificada para `PyRun_AnyFileExFlags()` más abajo, dejando closeit establecido a `0` y flags establecido a `NULL`.

int `PyRun_AnyFileFlags`(FILE *fp, const char *filename, PyCompilerFlags *flags)

  Esta es una interfaz simplificada para `PyRun_AnyFileExFlags()` más abajo, dejando closeit establecido a `0`.

int `PyRun_AnyFileEx`(FILE *fp, const char *filename, int closeit)

  Esta es una interfaz simplificada para `PyRun_AnyFileExFlags()` más abajo, dejando flags establecido a `NULL`.

int `PyRun_AnyFileExFlags`(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)

  Si fp se refiere a un archivo asociado con un dispositivo interactivo (entrada de consola o terminal o pseudo-terminal Unix), retorna el valor de `PyRun_InteractiveLoop()`, de lo contrario retorna el resultado de `PyRun_SimpleFile()`. filename se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`). Si filename es `NULL`, esta función usa `"???"` como nombre de archivo.

int `PyRun_SimpleString`(const char *command)

  Esta es una interfaz simplificada para `PyRun_SimpleStringFlags()` más abajo, dejando el argumento `PyCompilerFlags`* establecido a `NULL`.

int `PyRun_SimpleStringFlags`(const char *command, PyCompilerFlags *flags)

  Ejecuta el código fuente de Python desde command en el módulo `__main__` de acuerdo con el argumento flags. Si `__main__` aún no existe, se crea. Retorna `0` en caso de éxito o `-1` si se produjo una excepción. Si hubo un error, no hay forma de obtener la información de excepción. Para el significado de flags, ver abajo.

  Tenga en cuenta que si no se maneja de otro modo `SystemExit`, esta función no retornará `-1`, pero saldrá del proceso, siempre que `Py_InspectFlag` no esté configurado.

int `PyRun_SimpleFile`(FILE *fp, const char *filename)

  Esta es una interfaz simplificada para `PyRun_SimpleStringFlags()` más abajo, dejando closeit establecido a `0` y flags establecido a `NULL`.

int `PyRun_SimpleFileEx`(FILE *fp, const char *filename, int closeit)

  Esta es una interfaz simplificada para `PyRun_SimpleStringFlags()` más abajo, dejando flags establecido a `NULL`.

int `PyRun_SimpleFileExFlags`(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)

  Similar a `PyRun_SimpleStringFlags()`, pero el código fuente de Python se lee desde fp en lugar de una cadena de caracteres en memoria. filename debe ser el nombre del archivo, se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`). Si closeit es verdadero, el archivo se cierra antes de que PyRun_SimpleFileExFlags retorne.

  Nota

  En Windows, fp debe abrirse en modo binario (por ejemplo, `fopen(filename, "rb")`. De lo contrario, Python puede no manejar correctamente el archivo de script con la terminación de línea LF.

int `PyRun_InteractiveOne`(FILE *fp, const char *filename)

  Esta es una interfaz simplificada para `PyRun_InteractiveOneFlags()` más abajo, dejando flags establecido a `NULL`.

int `PyRun_InteractiveOneFlags`(FILE *fp, const char *filename, PyCompilerFlags *flags)

  Lee y ejecuta declaraciones de un archivo asociado con un dispositivo interactivo de acuerdo al argumento flags. Se le solicitará al usuario usando `sys.ps1` y `sys.ps2`. filename se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`).

  Retorna `0` cuando la entrada se ejecuta con éxito, `-1` si hubo una excepción, o un código de error del archivo `errcode.h` distribuido como parte de Python si hubo un error de análisis gramatical. (Tenga en cuenta que `errcode.h` no está incluido en `Python.h`, por lo que debe incluirse específicamente si es necesario).

int `PyRun_InteractiveLoop`(FILE *fp, const char *filename)

  Esta es una interfaz simplificada para `PyRun_InteractiveLoopFlags()` más abajo, dejando flags establecido a `NULL`.

int `PyRun_InteractiveLoopFlags`(FILE *fp, const char *filename, PyCompilerFlags *flags)

  Lee y ejecuta declaraciones de un archivo asociado con un dispositivo interactivo hasta llegar al EOF. Se le solicitará al usuario usando `sys.ps1` y `sys.ps2`. filename se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`). Retorna `0` en EOF o un número negativo en caso de falla.

int `(*PyOS_InputHook)`(void)

  Se puede configurar para que apunte a una función con el prototipo `int func(void)`. Se llamará a la función cuando el indicador del intérprete de Python esté a punto de estar inactivo y espere la entrada del usuario desde el terminal. El valor de retorno es ignorado. Sobrescribiendo este enlace se puede utilizar para integrar la solicitud del intérprete con otros bucles de eventos, como se hace en `Modules/_tkinter.c` en el código fuente de Python.

char* `(*PyOS_ReadlineFunctionPointer)`(FILE *, FILE *, const char *)

  Se puede configurar para que apunte a una función con el prototipo `char *func (FILE *stdin, FILE *stdout, char *prompt)`, sobrescribiendo la función predeterminada utilizada para leer una sola línea de entrada desde el intérprete. Se espera que la función genere la cadena de caracteres prompt si no es `NULL`, y luego lea una línea de entrada del archivo de entrada estándar proporcionado, retornando la cadena de caracteres resultante. Por ejemplo, el módulo `readline` establece este enlace para proporcionar funciones de edición de línea y finalización de tabulación.

  El resultado debe ser una cadena de caracteres alocado por `PyMem_RawMalloc()` o `PyMem_RawRealloc()`, o `NULL` si ocurre un error.

  Distinto en la versión 3.4: El resultado debe ser alocado por `PyMem_RawMalloc()` o `PyMem_RawRealloc()`, en vez de ser alocado por `PyMem_Malloc()` o `PyMem_Realloc()`.

struct _node* `PyParser_SimpleParseString`(const char *str, int start)

  Esta es una interfaz simplificada para `PyParser_SimpleParseStringFlagsFilename()` más abajo, dejando filename establecido a `NULL` y flags establecido a `0`.

struct _node* `PyParser_SimpleParseStringFlags`(const char *str, int start, int flags)

  Esta es una interfaz simplificada para `PyParser_SimpleParseStringFlagsFilename()` más abajo, dejando filename establecido a `NULL`.

struct _node* `PyParser_SimpleParseStringFlagsFilename`(const char *str, const char *filename, int start, int flags)

  Analiza gramaticalmente el código fuente de Python desde str usando el token de inicio start de acuerdo con el argumento flags. El resultado se puede usar para crear un objeto de código que se puede evaluar de manera eficiente. Esto es útil si un fragmento de código debe evaluarse muchas veces. filename se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`).

struct _node* `PyParser_SimpleParseFile`(FILE *fp, const char *filename, int start)

  Esta es una interfaz simplificada para `PyParser_SimpleParseFileFlags()` más abajo, dejando flags establecido a `0`.

struct _node* `PyParser_SimpleParseFileFlags`(FILE *fp, const char *filename, int start, int flags)

  Similar a `PyParser_SimpleParseStringFlagsFilename()`, pero el código fuente de Python se lee desde fp en lugar de una cadena de caracteres en memoria.

PyObject* `PyRun_String`(const char *str, int start, PyObject *globals, PyObject *locals)
  Return value: New reference.

  Esta es una interfaz simplificada para `PyRun_StringFlags()` más abajo, dejando flags establecido a `NULL`.

PyObject* `PyRun_StringFlags`(const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
  Return value: New reference.

  Ejecuta el código fuente de Python desde str en el contexto especificado por los objetos globals y locals con los indicadores del compilador especificados por flags. globals debe ser un diccionario; locals puede ser cualquier objeto que implemente el protocolo de mapeo. El parámetro start especifica el token de inicio que se debe usar para analizar el código fuente.

  Retorna el resultado de ejecutar el código como un objeto Python, o `NULL`” si se produjo una excepción.

PyObject* `PyRun_File`(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
  Return value: New reference.

  Esta es una interfaz simplificada para `PyRun_FileExFlags()` más abajo, dejando closeit establecido a `0` y flags establecido a `NULL`.

PyObject* `PyRun_FileEx`(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit)
  Return value: New reference.

  Esta es una interfaz simplificada para `PyRun_FileExFlags()` más abajo, dejando flags establecido a `NULL`.

PyObject* `PyRun_FileFlags`(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags)
  Return value: New reference.

  Esta es una interfaz simplificada para `PyRun_FileExFlags()` más abajo, dejando closeit establecido a `0`.

PyObject* `PyRun_FileExFlags`(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals, int closeit, PyCompilerFlags *flags)
  Return value: New reference.

  Similar a `PyRun_StringFlags()`, pero el código fuente de Python se lee desde fp en lugar de una cadena de caracteres en memoria. filename debe ser el nombre del archivo, se decodifica a partir de la codificación del sistema de archivos (`sys.getfilesystemencoding()`). Si closeit es verdadero, el archivo se cierra antes que `PyRun_FileExFlags()` retorne.

PyObject* `Py_CompileString`(const char *str, const char *filename, int start)
  Return value: New reference.

  Esta es una interfaz simplificada para `Py_CompileStringFlags()` más abajo, dejando flags establecido a `NULL`.

PyObject* `Py_CompileStringFlags`(const char *str, const char *filename, int start, PyCompilerFlags *flags)
  Return value: New reference.

  Esta es una interfaz simplificada para `Py_CompileStringExFlags()` más abajo, con optimize establecido a `-1`.

PyObject* `Py_CompileStringObject`(const char *str, PyObject *filename, int start, PyCompilerFlags *flags, int optimize)
  Return value: New reference.

  Analiza gramaticalmente y compila el código fuente de Python en str, retornando el objeto de código resultante. El token de inicio viene dado por start; esto se puede usar para restringir el código que se puede compilar y debe ser `Py_eval_input`, `Py_file_input`, o `Py_single_input`. El nombre de archivo especificado por filename se usa para construir el objeto de código y puede aparecer en tracebacks o mensajes de excepción `SyntaxError`. Esto retorna `NULL`” si el código no se puede analizar gramaticalmente o compilar.

  El número entero optimize especifica el nivel de optimización del compilador; un valor de `-1` selecciona el nivel de optimización del intérprete como se indica en las opciones `-O`. Los niveles explícitos son `0` (sin optimización; `__debug__` es verdadero), `1` (los asserts se eliminan, `__debug__` es falso) o `2` (los docstrings también se eliminan) )

  Nuevo en la versión 3.4.

PyObject* `Py_CompileStringExFlags`(const char *str, const char *filename, int start, PyCompilerFlags *flags, int optimize)
  Return value: New reference.

  Como `Py_CompileStringObject()`, pero filename es una cadena de caracteres de byte decodificado desde la codificación del sistema de archivos (`os.fsdecode()`).

  Nuevo en la versión 3.2.

PyObject* `PyEval_EvalCode`(PyObject *co, PyObject *globals, PyObject *locals)
  Return value: New reference.

  Esta es una interfaz simplificada para `PyEval_EvalCodeEx()`, con solo el objeto de código y las variables globales y locales. Los otros argumentos están establecidos en `NULL`.

PyObject* `PyEval_EvalCodeEx`(PyObject *co, PyObject *globals, PyObject *locals, PyObject *const *args, int argcount, PyObject *const *kws, int kwcount, PyObject *const *defs, int defcount, PyObject *kwdefs, PyObject *closure)
  Return value: New reference.

  Evaluar un objeto de código precompilado, dado un entorno particular para su evaluación. Este entorno consta de un diccionario de variables globales, un objeto de mapeo de variables locales, arreglos de argumentos, palabras clave y valores predeterminados, un diccionario de valores predeterminados para argumentos keyword-only y una tupla de cierre de células.

`PyFrameObject`

  La estructura en C de los objetos utilizados para describir objetos del marco. Los campos de este tipo están sujetos a cambios en cualquier momento.

PyObject* `PyEval_EvalFrame`(PyFrameObject *f)
  Return value: New reference.

  Evaluar un marco de ejecución. Esta es una interfaz simplificada para `PyEval_EvalFrameEx()`, para compatibilidad con versiones anteriores.

PyObject* `PyEval_EvalFrameEx`(PyFrameObject *f, int throwflag)
  Return value: New reference.

  Esta es la función principal sin barnizar de la interpretación de Python. El objeto de código asociado con el marco de ejecución del marco f se ejecuta, interpretando el código de bytes y ejecutando llamadas según sea necesario. El parámetro adicional throwflag se puede ignorar por lo general; si es verdadero, entonces se genera una excepción de inmediato; esto se usa para los métodos `throw()` de objetos generadores.

  Distinto en la versión 3.4: Esta función ahora incluye una afirmación de depuración para ayudar a garantizar que no descarte silenciosamente una excepción activa.

int `PyEval_MergeCompilerFlags`(PyCompilerFlags *cf)

  Esta función cambia los flags del marco de evaluación actual, y retorna verdad (true) en caso de éxito, falso (false) en caso de fallo.

int `Py_eval_input`

  El símbolo de inicio de la gramática de Python para expresiones aisladas; para usar con `Py_CompileString()`.

int `Py_file_input`

  El símbolo de inicio de la gramática de Python para secuencias de declaración leídos desde un archivo u otra fuente; para usar con `Py_CompileString()`. Este es el símbolo usado cuando se compile un código fuente en Python arbitrariamente largo.

int `Py_single_input`

  El símbolo de inicio de la gramática de Python para una declaración única; para usar con `Py_CompileString()`. Este es el símbolo usado para el bucle interactivo del intérprete.

struct `PyCompilerFlags`

  Esta es la estructura usada para contener los flags del compilador. En casos donde el código es sólo compilado, es pasado como `int flags`, y en casos donde el código es ejecutado, es pasado como `PyCompilerFlags *flags`. En este caso, `from __future__ import` puede modificar los flags.

  Siempre y cuando `PyCompilerFlags *flags` es `NULL`, `cf_flags` es tratado como igual a `0`, y cualquier modificación debido a `from __future__ import` es descartada.

  int `cf_flags`

    Flags del compilador.

  int `cf_feature_version`

    cf_feature_version es la versión menor de Python. Debe ser inicializado a `PY_MINOR_VERSION`.

    El campo es ignorado por defecto, es usado si y solo si el flag `PyCF_ONLY_AST` está configurado en cf_flags.

  Distinto en la versión 3.8: Agregado el campo cf_feature_version.

int `CO_FUTURE_DIVISION`

  Este bit puede ser configurado en flags para causar que un operador de división `/` sea interpretado como una «división real» de acuerdo a PEP 238.