Configuración de inicialización de Python
*****************************************

Nuevo en la versión 3.8.

Estructuras:

* "PyConfig"

* "PyPreConfig"

* "PyStatus"

* "PyWideStringList"

Funciones:

* "PyConfig_Clear()"

* "PyConfig_InitIsolatedConfig()"

* "PyConfig_InitPythonConfig()"

* "PyConfig_Read()"

* "PyConfig_SetArgv()"

* "PyConfig_SetBytesArgv()"

* "PyConfig_SetBytesString()"

* "PyConfig_SetString()"

* "PyConfig_SetWideStringList()"

* "PyPreConfig_InitIsolatedConfig()"

* "PyPreConfig_InitPythonConfig()"

* "PyStatus_Error()"

* "PyStatus_Error()"

* "PyStatus_Error()"

* "PyStatus_IsError()"

* "PyStatus_IsExit()"

* "PyStatus_NoMemory()"

* "PyStatus_Ok()"

* "PyWideStringList_Append()"

* "PyWideStringList_Insert()"

* "Py_ExitStatusException()"

* "Py_InitializeFromConfig()"

* "Py_PreInitialize()"

* "Py_PreInitializeFromArgs()"

* "Py_PreInitializeFromBytesArgs()"

* "Py_RunMain()"

La preconfiguración (tipo "PyPreConfig") se almacena en
"_PyRuntime.preconfig" y la configuración (tipo "PyConfig") se
almacena en "PyInterpreterState.config".

Consulte también Inicialización, finalización y subprocesos.

Ver también: **PEP 587** "Configuración de inicialización de Python".


PyWideStringList
================

PyWideStringList

   Lista de cadenas de caracteres "wchar_t*".

   Si *length* no es cero, *items* no deben ser "NULL" y todas las
   cadenas de caracteres deben ser no "NULL".

   Métodos:

   PyStatus PyWideStringList_Append(PyWideStringList *list, const wchar_t *item)

      Agregar *item* a *list*.

      Python debe estar preinicializado para llamar a esta función.

   PyStatus PyWideStringList_Insert(PyWideStringList *list, Py_ssize_t index, const wchar_t *item)

      Inserta *item* en *list* en *index*.

      Si *index* es mayor o igual que el largo de *list*, agrega
      *item* a *list*.

      *index* debe ser mayor o igual que 0.

      Python debe estar preinicializado para llamar a esta función.

   Campos de estructura:

   Py_ssize_t length

      Longitud de la lista.

   wchar_t** items

      Elementos de la lista.


PyStatus
========

PyStatus

   Estructura para almacenar el estado de una función de
   inicialización: éxito, error o salida.

   Para un error, puede almacenar el nombre de la función C que creó
   el error.

   Campos de estructura:

   int exitcode

      Código de salida El argumento pasó a "exit()".

   const char *err_msg

      Mensaje de error.

   const char *func

      El nombre de la función que creó un error puede ser "NULL".

   Funciones para crear un estado:

   PyStatus PyStatus_Ok(void)

      Éxito.

   PyStatus PyStatus_Error(const char *err_msg)

      Error de inicialización con un mensaje.

   PyStatus PyStatus_NoMemory(void)

      Error de asignación de memoria (sin memoria).

   PyStatus PyStatus_Exit(int exitcode)

      Sale de Python con el código de salida especificado.

   Funciones para manejar un estado:

   int PyStatus_Exception(PyStatus status)

      ¿Es el estado un error o una salida? Si es verdadero, la
      excepción debe ser manejada; por ejemplo llamando a
      "Py_ExitStatusException()".

   int PyStatus_IsError(PyStatus status)

      ¿Es el resultado un error?

   int PyStatus_IsExit(PyStatus status)

      ¿El resultado es una salida?

   void Py_ExitStatusException(PyStatus status)

      Llama a "exit(exitcode)" si *status* es una salida. Imprime el
      mensaje de error y sale con un código de salida distinto de cero
      si *status* es un error. Solo se debe llamar si
      "PyStatus_Exception(status)" no es cero.

Nota:

  Internamente, Python usa macros que establecen "PyStatus.func",
  mientras que las funciones para crear un estado establecen "func" en
  "NULL".

Ejemplo:

   PyStatus alloc(void **ptr, size_t size)
   {
       *ptr = PyMem_RawMalloc(size);
       if (*ptr == NULL) {
           return PyStatus_NoMemory();
       }
       return PyStatus_Ok();
   }

   int main(int argc, char **argv)
   {
       void *ptr;
       PyStatus status = alloc(&ptr, 16);
       if (PyStatus_Exception(status)) {
           Py_ExitStatusException(status);
       }
       PyMem_Free(ptr);
       return 0;
   }


PyPreConfig
===========

PyPreConfig

   Estructura utilizada para preinicializar Python:

   * Establece el asignador de memoria de Python

   * Configure el entorno local LC_CTYPE

   * Establece el modo UTF-8

   Función para inicializar una preconfiguración:

   void PyPreConfig_InitPythonConfig(PyPreConfig *preconfig)

      Inicializa la preconfiguración con Configuración de Python.

   void PyPreConfig_InitIsolatedConfig(PyPreConfig *preconfig)

      Inicializa la preconfiguración con Configuración aislada.

   Campos de estructura:

   int allocator

      Nombre del asignador de memoria:

      * "PYMEM_ALLOCATOR_NOT_SET" ("0"): no cambie los asignadores de
        memoria (use los valores predeterminados)

      * "PYMEM_ALLOCATOR_DEFAULT" ("1"): asignadores de memoria
        predeterminados

      * "PYMEM_ALLOCATOR_DEBUG" ("2"): asignadores de memoria
        predeterminados con ganchos de depuración

      * "PYMEM_ALLOCATOR_MALLOC" ("3"): fuerza el uso de "malloc()"

      * "PYMEM_ALLOCATOR_MALLOC_DEBUG" ("4"): fuerza el uso de
        "malloc()" con ganchos de depuración

      * "PYMEM_ALLOCATOR_PYMALLOC" ("5"): Python pymalloc memory
        allocator

      * "PYMEM_ALLOCATOR_PYMALLOC_DEBUG" ("6"): Python pymalloc memory
        allocator con ganchos de depuración

      "PYMEM_ALLOCATOR_PYMALLOC" y "PYMEM_ALLOCATOR_PYMALLOC_DEBUG" no
      son compatibles si Python está configurado con "--with-pymalloc"

      Ver Administración de memorias.

   int configure_locale

      ¿Establece la configuración regional LC_CTYPE en la
      configuración regional preferida por el usuario? Si es igual a
      0, establece "coerce_c_locale" y "coerce_c_locale_warn" en 0.

   int coerce_c_locale

      Si es igual a 2, coaccione la configuración regional C; si es
      igual a 1, lea la configuración regional LC_CTYPE para decidir
      si debe ser forzado.

   int coerce_c_locale_warn

      Si no es cero, emita una advertencia si la configuración
      regional C está coaccionada.

   int dev_mode

      Ver "PyConfig.dev_mode".

   int isolated

      Ver "PyConfig.isolated".

   int legacy_windows_fs_encoding(Windows only)

      Si no es cero, desactive el modo UTF-8, configure la
      codificación del sistema de archivos Python en "mbcs", configure
      el controlador de errores del sistema de archivos en "replace".

      Solo disponible en Windows. La macro "#ifdef MS_WINDOWS" se
      puede usar para el código específico de Windows.

   int parse_argv

      Si no es cero, "Py_PreInitializeFromArgs()" y
      "Py_PreInitializeFromBytesArgs()" analizan su argumento "argv"
      de la misma manera que Python analiza los argumentos de la línea
      de comandos: ver Argumentos de línea de comandos.

   int use_environment

      Ver "PyConfig.use_environment".

   int utf8_mode

      Si no es cero, habilita el modo UTF-8.


Preinicialización con PyPreConfig
=================================

Funciones para preinicializar Python:

PyStatus Py_PreInitialize(const PyPreConfig *preconfig)

   Preinicializa Python desde la preconfiguración *preconfig*.

PyStatus Py_PreInitializeFromBytesArgs(const PyPreConfig *preconfig, int argc, char * const *argv)

   Preinicializa Python desde la preconfiguración *preconfig* y
   argumentos de línea de comando (cadenas de caracteres de bytes).

PyStatus Py_PreInitializeFromArgs(const PyPreConfig *preconfig, int argc, wchar_t * const * argv)

   Preinicializa Python desde la preconfiguración *preconfig* y
   argumentos de línea de comando (cadenas de caracteres anchas).

La persona que llama es responsable de manejar las excepciones (error
o salida) usando "PyStatus_Exception()" y "Py_ExitStatusException()".

Para Configuración de Python ("PyPreConfig_InitPythonConfig()"), si
Python se inicializa con argumentos de línea de comando, los
argumentos de línea de comando también deben pasarse para
preinicializar Python, ya que tienen un efecto en la preconfiguración
como codificaciones. Por ejemplo, la opción de línea de comando "-X
utf8" habilita el modo UTF-8.

"PyMem_SetAllocator()" se puede llamar después de "Py_PreInitialize()"
y antes "Py_InitializeFromConfig()" para instalar un asignador de
memoria personalizado. Se puede llamar antes "Py_PreInitialize()" si
"PyPreConfig.allocator" está configurado en "PYMEM_ALLOCATOR_NOT_SET".

Las funciones de asignación de memoria de Python como
"PyMem_RawMalloc()" no deben usarse antes de la preinicialización de
Python, mientras que llamar directamente a "malloc()" y "free()"
siempre es seguro. "Py_DecodeLocale()" no debe llamarse antes de la
preinicialización.

Ejemplo usando la preinicialización para habilitar el modo UTF-8:

   PyStatus status;
   PyPreConfig preconfig;
   PyPreConfig_InitPythonConfig(&preconfig);

   preconfig.utf8_mode = 1;

   status = Py_PreInitialize(&preconfig);
   if (PyStatus_Exception(status)) {
       Py_ExitStatusException(status);
   }

   /* at this point, Python will speak UTF-8 */

   Py_Initialize();
   /* ... use Python API here ... */
   Py_Finalize();


PyConfig
========

PyConfig

   Estructura que contiene la mayoría de los parámetros para
   configurar Python.

   Métodos de estructura:

   void PyConfig_InitPythonConfig(PyConfig *config)

      Inicializa la configuración con Configuración de Python.

   void PyConfig_InitIsolatedConfig(PyConfig *config)

      Inicializa la configuración con Configuración aislada.

   PyStatus PyConfig_SetString(PyConfig *config, wchar_t * const *config_str, const wchar_t *str)

      Copia la cadena de caracteres anchos *str* en "*config_str".

      Preinicializa Python si es necesario.

   PyStatus PyConfig_SetBytesString(PyConfig *config, wchar_t * const *config_str, const char *str)

      Decodifica *str* usando "Py_DecodeLocale()" y configure el
      resultado en "*config_str".

      Preinicializa Python si es necesario.

   PyStatus PyConfig_SetArgv(PyConfig *config, int argc, wchar_t * const *argv)

      Establezca argumentos de línea de comando a partir de cadenas de
      caracteres anchas.

      Preinicializa Python si es necesario.

   PyStatus PyConfig_SetBytesArgv(PyConfig *config, int argc, char * const *argv)

      Establezca argumentos de línea de comando: decodifique bytes
      usando "Py_DecodeLocale()".

      Preinicializa Python si es necesario.

   PyStatus PyConfig_SetWideStringList(PyConfig *config, PyWideStringList *list, Py_ssize_t length, wchar_t **items)

      Establece la lista de cadenas de caracteres anchas *list* a
      *length* y *items*.

      Preinicializa Python si es necesario.

   PyStatus PyConfig_Read(PyConfig *config)

      Lee toda la configuración de Python.

      Los campos que ya están inicializados no se modifican.

      Preinicializa Python si es necesario.

   void PyConfig_Clear(PyConfig *config)

      Libera memoria de configuración.

   La mayoría de los métodos "PyConfig" preinicializan Python si es
   necesario. En ese caso, la configuración de preinicialización de
   Python se basa en "PyConfig". Si los campos de configuración que
   son comunes con "PyPreConfig" están ajustados, deben configurarse
   antes de llamar al método "PyConfig":

   * "dev_mode"

   * "isolated"

   * "parse_argv"

   * "use_environment"

   Además, si se utiliza "PyConfig_SetArgv()" o
   "PyConfig_SetBytesArgv()", este método debe llamarse primero, antes
   que otros métodos, ya que la configuración de preinicialización
   depende de los argumentos de la línea de comandos (si "parse_argv"
   no es cero).

   Quien llama de estos métodos es responsable de manejar las
   excepciones (error o salida) usando "PyStatus_Exception()" y
   "Py_ExitStatusException()".

   Campos de estructura:

   PyWideStringList argv

      Argumentos de línea de comando, "sys.argv". Consulta
      "parse_argv" para analizar "argv" de la misma manera que Python
      normal analiza los argumentos de la línea de comandos de Python.
      Si "argv" está vacío, se agrega una cadena de caracteres vacía
      para garantizar que "sys.argv" siempre exista y nunca esté
      vacío.

   wchar_t* base_exec_prefix

      "sys.base_exec_prefix".

   wchar_t* base_executable

      "sys._base_executable": "__PYVENV_LAUNCHER__" valor de la
      variable de entorno, o copia de "PyConfig.executable".

   wchar_t* base_prefix

      "sys.base_prefix".

   int buffered_stdio

      Si es igual a 0, habilite el modo sin búfer, haciendo que las
      secuencias stdout y stderr no tengan búfer.

      stdin siempre se abre en modo de búfer.

   int bytes_warning

      Si es igual a 1, emita una advertencia cuando compare "bytes" o
      "bytearray" con "str", o compare "bytes" con "int". Si es igual
      o mayor a 2, lanza una excepción "BytesWarning".

   wchar_t* check_hash_pycs_mode

      Controla el comportamiento de validación de los archivos ".pyc"
      basados en hash (consulte **PEP 552**): con el valor de la
      opción de línea de comando "--check-hash-based-pycs".

      Valores válidos: "always", "never" y "default".

      El valor predeterminado es: "default".

   int configure_c_stdio

      Si no es cero, configure las secuencias estándar C ("stdio",
      "stdout", "stdout"). Por ejemplo, configure su modo en
      "O_BINARY" en Windows.

   int dev_mode

      Modo de desarrollo: ver "-X dev".

   int dump_refs

      Si no es cero, volcar todos los objetos que aún están vivos en
      la salida.

      Requerir una compilación de depuración de Python (la macro
      "Py_REF_DEBUG" debe estar definida).

   wchar_t* exec_prefix

      "sys.exec_prefix".

   wchar_t* executable

      "sys.executable".

   int faulthandler

      Si no es cero, llama a "faulthandler.enable()" al inicio.

   wchar_t* filesystem_encoding

      Codificación del sistema de archivos,
      "sys.getfilesystemencoding()".

   wchar_t* filesystem_errors

      Errores de codificación del sistema de archivos,
      "sys.getfilesystemencodeerrors()".

   unsigned long hash_seed

   int use_hash_seed

      Funciones de semillas aleatorias hash.

      Si "use_hash_seed" es cero, se elige una semilla aleatoriamente
      en Pythonstartup, y "hash_seed" se ignora.

   wchar_t* home

      Directorio de inicio de Python.

      Inicializado desde valor de variable de entorno "PYTHONHOME" por
      defecto.

   int import_time

      Si no es cero, el tiempo de importación del perfil.

   int inspect

      Ingresa al modo interactivo después de ejecutar un script o un
      comando.

   int install_signal_handlers

      ¿Instala manejadores de señal?

   int interactive

      Modo interactivo.

   int isolated

      Si es mayor que 0, habilite el modo aislado:

      * "sys.path" no contiene ni el directorio del script (calculado
        a partir de "argv[0]" o el directorio actual) ni el directorio
        de paquetes del sitio del usuario.

      * Python REPL no importa "readline" ni habilita la configuración
        predeterminada de readline en mensajes interactivos.

      * Establece "use_environment" y "user_site_directory" en 0.

   int legacy_windows_stdio

      Si no es cero, usa "io.FileIO" en lugar de "io.WindowsConsoleIO"
      para "sys.stdin", "sys.stdout" y "sys.stderr".

      Solo disponible en Windows. La macro "#ifdef MS_WINDOWS" se
      puede usar para el código específico de Windows.

   int malloc_stats

      Si no es cero, volcar las estadísticas en Asignador de memoria
      Python pymalloc en la salida.

      La opción se ignora si Python se construye usando "--without-
      pymalloc".

   wchar_t* pythonpath_env

      Módulo de rutas de búsqueda como una cadena separada por "DELIM"
      ("os.path.pathsep").

      Inicializado desde valor de variable de entorno "PYTHONPATH" por
      defecto.

   PyWideStringList module_search_paths

   int module_search_paths_set

      "sys.path". Si "module_search_paths_set" es igual a 0, el
      "module_search_paths" es anulado por la función que calcula
      Configuración de ruta .

   int optimization_level

      Nivel de optimización de compilación:

      * 0: Optimizador de mirilla (y "__debug__" está configurado como
        "True")

      * 1: Elimina las aserciones, establece "__debug__" en "False"

      * 2: *Strip* docstrings

   int parse_argv

      Si no es cero, analiza "argv" de la misma manera que los
      argumentos regulares de la línea de comandos de Python, y
      elimine los argumentos de Python de "argv": vea Argumentos de
      línea de comando.

   int parser_debug

      Si no es cero, activa la salida de depuración del analizador
      (solo para expertos, dependiendo de las opciones de
      compilación).

   int pathconfig_warnings

      Si es igual a 0, suprime las advertencias al calcular
      Configuración de ruta (solo Unix, Windows no registra ninguna
      advertencia). De lo contrario, las advertencias se escriben en
      "stderr".

   wchar_t* prefix

      "sys.prefix".

   wchar_t* program_name

      Nombre del programa Se usa para inicializar "executable", y en
      los primeros mensajes de error.

   wchar_t* pycache_prefix

      "sys.pycache_prefix": prefijo de caché ".pyc".

      Si "NULL", "sys.pycache_prefix" es establecido a "None".

   int quiet

      Modo silencioso. Por ejemplo, no muestra los mensajes de
      copyright y versión en modo interactivo.

   wchar_t* run_command

      Argumento "python3 -c COMMAND". Utilizado por "Py_RunMain()".

   wchar_t* run_filename

      Argumento "python3 FILENAME". Utilizado por "Py_RunMain()".

   wchar_t* run_module

      Argumento "python3 -m MODULE". Utilizado por "Py_RunMain()".

   int show_alloc_count

      ¿Mostrar recuentos de asignación en la salida?

      Establecido en 1 por la opción de línea de comandos "-X
      showalloccount".

      Necesita una compilación especial de Python con la macro
      "COUNT_ALLOCS" definida.

   int show_ref_count

      ¿Mostrar el recuento de referencia total en la salida?

      Establecido en 1 por la opción de línea de comandos "-X
      showrefcount".

      Necesita una compilación de depuración de Python (se debe
      definir la macro "Py_REF_DEBUG").

   int site_import

      ¿Importar el módulo "site" al inicio?

   int skip_source_first_line

      ¿Saltar la primera línea de la fuente?

   wchar_t* stdio_encoding

   wchar_t* stdio_errors

      Codificación y codificación de errores de "sys.stdin",
      "sys.stdout" y "sys.stderr".

   int tracemalloc

      Si no es cero, llama a "tracemalloc.start()" al inicio.

   int use_environment

      Si es mayor que 0, use variables de entorno.

   int user_site_directory

      Si no es cero, agrega el directorio del sitio del usuario a
      "sys.path".

   int verbose

      Si no es cero, habilita el modo detallado.

   PyWideStringList warnoptions

      "sys.warnoptions": opciones del módulo "warnings" para crear
      filtros de advertencia: de menor a mayor prioridad.

      El módulo "warnings" agrega "sys.warnoptions" en el orden
      inverso: el último elemento "PyConfig.warnoptions" se convierte
      en el primer elemento de "warnings.filters" que es verificado
      primero (máxima prioridad).

   int write_bytecode

      Si no es cero, escribe los archivos ".pyc".

      "sys.dont_write_bytecode" se inicializa al valor invertido de
      "write_bytecode".

   PyWideStringList xoptions

      "sys._xoptions".

Si "parse_argv" no es cero, los argumentos "argv" se analizan de la
misma manera que Python analiza los argumentos de línea de comando, y
los argumentos de Python se eliminan de "argv": ver Argumentos de
línea de comando.

Las opciones "xoptions" se analizan para establecer otras opciones:
ver la opción "-X".


Inicialización con PyConfig
===========================

Función para inicializar Python:

PyStatus Py_InitializeFromConfig(const PyConfig *config)

   Inicializa Python desde la configuración *config*.

La persona que llama es responsable de manejar las excepciones (error
o salida) usando "PyStatus_Exception()" y "Py_ExitStatusException()".

Si se usan "PyImport_FrozenModules", "PyImport_AppendInittab()" o
"PyImport_ExtendInittab()", deben configurarse o llamarse después de
la preinicialización de Python y antes de la inicialización de Python.

Ejemplo de configuración del nombre del programa:

   void init_python(void)
   {
       PyStatus status;

       PyConfig config;
       PyConfig_InitPythonConfig(&config);

       /* Set the program name. Implicitly preinitialize Python. */
       status = PyConfig_SetString(&config, &config.program_name,
                                   L"/path/to/my_program");
       if (PyStatus_Exception(status)) {
           goto fail;
       }

       status = Py_InitializeFromConfig(&config);
       if (PyStatus_Exception(status)) {
           goto fail;
       }
       PyConfig_Clear(&config);
       return;

   fail:
       PyConfig_Clear(&config);
       Py_ExitStatusException(status);
   }

Ejemplo más completo que modifica la configuración predeterminada, lee
la configuración y luego anula algunos parámetros

   PyStatus init_python(const char *program_name)
   {
       PyStatus status;

       PyConfig config;
       PyConfig_InitPythonConfig(&config);

       /* Set the program name before reading the configuration
          (decode byte string from the locale encoding).

          Implicitly preinitialize Python. */
       status = PyConfig_SetBytesString(&config, &config.program_name,
                                     program_name);
       if (PyStatus_Exception(status)) {
           goto done;
       }

       /* Read all configuration at once */
       status = PyConfig_Read(&config);
       if (PyStatus_Exception(status)) {
           goto done;
       }

       /* Append our custom search path to sys.path */
       status = PyWideStringList_Append(&config.module_search_paths,
                                        L"/path/to/more/modules");
       if (PyStatus_Exception(status)) {
           goto done;
       }

       /* Override executable computed by PyConfig_Read() */
       status = PyConfig_SetString(&config, &config.executable,
                                   L"/path/to/my_executable");
       if (PyStatus_Exception(status)) {
           goto done;
       }

       status = Py_InitializeFromConfig(&config);

   done:
       PyConfig_Clear(&config);
       return status;
   }


Configuración aislada
=====================

"PyPreConfig_InitIsolatedConfig()" y las funciones
"PyConfig_InitIsolatedConfig()" crean una configuración para aislar
Python del sistema. Por ejemplo, para incrustar Python en una
aplicación.

Esta configuración ignora las variables de configuración global, las
variables de entorno, los argumentos de la línea de comandos
("PyConfig.argv" no se analiza) y el directorio del sitio del usuario.
Las transmisiones estándar C (por ejemplo, "stdout") y el entorno
local LC_CTYPE no se modifican. Los manejadores de señal no están
instalados.

Los archivos de configuración todavía se usan con esta configuración.
Configure Configuración de ruta ("campos de salida") para ignorar
estos archivos de configuración y evitar la función que calcula la
configuración de ruta predeterminada.


Configuración de Python
=======================

"PyPreConfig_InitPythonConfig()" y las funciones
"PyConfig_InitPythonConfig()" crean una configuración para construir
un Python personalizado que se comporta como el Python normal.

Las variables de entorno y los argumentos de la línea de comandos se
utilizan para configurar Python, mientras que las variables de
configuración global se ignoran.

Esta función permite la coerción de configuración regional C (**PEP
538**) y el modo UTF-8 (**PEP 540**) dependiendo de la configuración
regional LC_CTYPE, "PYTHONUTF8" y variables de entorno
"PYTHONCOERCECLOCALE".

Ejemplo de Python personalizado que siempre se ejecuta en modo
aislado:

   int main(int argc, char **argv)
   {
       PyStatus status;

       PyConfig config;
       PyConfig_InitPythonConfig(&config);
       config.isolated = 1;

       /* Decode command line arguments.
          Implicitly preinitialize Python (in isolated mode). */
       status = PyConfig_SetBytesArgv(&config, argc, argv);
       if (PyStatus_Exception(status)) {
           goto fail;
       }

       status = Py_InitializeFromConfig(&config);
       if (PyStatus_Exception(status)) {
           goto fail;
       }
       PyConfig_Clear(&config);

       return Py_RunMain();

   fail:
       PyConfig_Clear(&config);
       if (PyStatus_IsExit(status)) {
           return status.exitcode;
       }
       /* Display the error message and exit the process with
          non-zero exit code */
       Py_ExitStatusException(status);
   }


Configuración de ruta
=====================

"PyConfig" contiene múltiples campos para la configuración de ruta:

* Entradas de configuración de ruta:

  * "PyConfig.home"

  * "PyConfig.pathconfig_warnings"

  * "PyConfig.program_name"

  * "PyConfig.pythonpath_env"

  * directorio de trabajo actual: para obtener rutas absolutas

  * Variable de entorno "PATH" para obtener la ruta completa del
    programa (de "PyConfig.program_name")

  * Variable de entorno "__PYVENV_LAUNCHER__"

  * (Solo Windows) Rutas de aplicación en el registro en
    "SoftwarePythonPythonCoreX.YPythonPath" de HKEY_CURRENT_USER y
    HKEY_LOCAL_MACHINE (donde X.Y es la versión de Python).

* Campos de salida de configuración de ruta:

  * "PyConfig.base_exec_prefix"

  * "PyConfig.base_executable"

  * "PyConfig.base_prefix"

  * "PyConfig.exec_prefix"

  * "PyConfig.executable"

  * "PyConfig.module_search_paths_set", "PyConfig.module_search_paths"

  * "PyConfig.prefix"

Si no se establece al menos un "campo de salida", Python calcula la
configuración de la ruta para completar los campos no definidos. Si
"module_search_paths_set" es igual a 0, "module_search_paths" se
reemplaza y "module_search_paths_set" se establece en 1.

Es posible ignorar por completo la función que calcula la
configuración de ruta predeterminada al establecer explícitamente
todos los campos de salida de configuración de ruta enumerados
anteriormente. Una cadena de caracteres se considera como un conjunto,
incluso si no está vacía. "module_search_paths" se considera como
establecido si "module_search_paths_set" se establece en 1. En este
caso, los campos de entrada de configuración de ruta también se
ignoran.

Establezca "pathconfig_warnings" en 0 para suprimir las advertencias
al calcular la configuración de la ruta (solo Unix, Windows no
registra ninguna advertencia).

Si "base_prefix" o los campos "base_exec_prefix" no están
establecidos, heredan su valor de "prefix" y "exec_prefix"
respectivamente.

"Py_RunMain()" y "Py_Main()" modifican "sys.path":

* Si "run_filename" está configurado y es un directorio que contiene
  un script "__main__.py", anteponga "run_filename" a "sys.path".

* Si "isolated" es cero:

  * Si "run_module" está configurado, anteponga el directorio actual a
    "sys.path". No haga nada si el directorio actual no se puede leer.

  * Si "run_filename" está configurado, anteponga el directorio del
    nombre del archivo a "sys.path".

  * De lo contrario, anteponga una cadena de caracteres vacía a
    "sys.path".

Si "site_import" no es cero, "sys.path" puede ser modificado por el
módulo "site". Si "user_site_directory" no es cero y el directorio del
paquete del sitio del usuario existe, el módulo "site" agrega el
directorio del paquete del sitio del usuario a "sys.path".

La configuración de ruta utiliza los siguientes archivos de
configuración:

* "pyvenv.cfg"

* "python._pth" (sólo Windows)

* "pybuilddir.txt" (sólo Unix)

La variable de entorno "__PYVENV_LAUNCHER__" se usa para establecer
"PyConfig.base_executable"


Py_RunMain()
============

int Py_RunMain(void)

   Ejecuta el comando ("PyConfig.run_command"), el script
   ("PyConfig.run_filename") o el módulo ("PyConfig.run_module")
   especificado en la línea de comando o en la configuración.

   Por defecto y cuando se usa la opción "-i", ejecuta el REPL.

   Finalmente, finaliza Python y retorna un estado de salida que se
   puede pasar a la función "exit()".

Consulte Configuración de Python para ver un ejemplo de Python
personalizado que siempre se ejecuta en modo aislado usando
"Py_RunMain()".


API Provisional Privada de Inicialización Multifásica
=====================================================

Esta sección es una API provisional privada que presenta la
inicialización de múltiples fases, la característica principal de
**PEP 432**:

* Fase de inicialización "Core", "Python mínimo":

  * Tipos incorporados;

  * Excepciones incorporadas;

  * Módulos incorporados y congelados;

  * El módulo "sys" solo se inicializa parcialmente (por ejemplo
    "sys.path" aún no existe).

* Fase de inicialización "principal", Python está completamente
  inicializado:

  * Instala y configura "importlib";

  * Aplique la Configuración de ruta;

  * Instala manejadores de señal;

  * Finaliza la inicialización del módulo "sys" (por ejemplo: crea
    "sys.stdout" y "sys.path");

  * Habilita características opcionales como "faulthandler" y
    "tracemalloc";

  * Importe el módulo "site";

  * etc.

API provisional privada:

* "PyConfig._init_main": si se establece en 0,
  "Py_InitializeFromConfig()" se detiene en la fase de inicialización
  "Core".

PyStatus _Py_InitializeMain(void)

   Vaya a la fase de inicialización "Principal", finalice la
   inicialización de Python.

No se importa ningún módulo durante la fase "Core" y el módulo
"importlib" no está configurado: la Configuración de ruta solo se
aplica durante la fase "Principal". Puede permitir personalizar Python
en Python para anular o ajustar Configuración de ruta, tal vez instale
un importador personalizado "sys.meta_path" o un enlace de
importación, etc.

Puede ser posible calcular Configuración de ruta en Python, después de
la fase Core y antes de la fase Main, que es una de las motivaciones
**PEP 432**.

La fase "Núcleo" no está definida correctamente: lo que debería estar
y lo que no debería estar disponible en esta fase aún no se ha
especificado. La API está marcada como privada y provisional: la API
se puede modificar o incluso eliminar en cualquier momento hasta que
se diseñe una API pública adecuada.

Ejemplo de ejecución de código Python entre las fases de
inicialización "Core" y "Main":

   void init_python(void)
   {
       PyStatus status;

       PyConfig config;
       PyConfig_InitPythonConfig(&config);
       config._init_main = 0;

       /* ... customize 'config' configuration ... */

       status = Py_InitializeFromConfig(&config);
       PyConfig_Clear(&config);
       if (PyStatus_Exception(status)) {
           Py_ExitStatusException(status);
       }

       /* Use sys.stderr because sys.stdout is only created
          by _Py_InitializeMain() */
       int res = PyRun_SimpleString(
           "import sys; "
           "print('Run Python code before _Py_InitializeMain', "
                  "file=sys.stderr)");
       if (res < 0) {
           exit(1);
       }

       /* ... put more configuration code here ... */

       status = _Py_InitializeMain();
       if (PyStatus_Exception(status)) {
           Py_ExitStatusException(status);
       }
   }
