9. Referencia de la API

Ver también

Argumentos nuevos y cambiados de setup.py en setuptools

El proyecto setuptools añade nuevas capacidades a la función setup y otras API, hace que la API sea coherente en diferentes versiones de Python y, por lo tanto, se recomienda usar distutils directamente.

Nota

This document is being retained solely until the setuptools documentation at https://setuptools.readthedocs.io/en/latest/setuptools.html independently covers all of the relevant information currently included here.

9.1. distutils.core — Funcionalidad Core Distutils

El módulo distutils.core es el único módulo que necesita ser instalado para utilizar Distutils. Proporciona el setup() (que es llamado desde el script de configuración). Indirectamente proporciona la clase distutils.dist.Distribution y la clase distutils.cmd.Command.

distutils.core.setup(arguments)

La función básica do-everything hace casi todo lo que podrías pedir de un método Distutils.

La función de configuración toma un gran número de argumentos. Estos se presentan en la siguiente tabla.

nombre del argumento	valor	tipo
name	El nombre del paquete	un string
version	El número de versión del paquete; ver distutils.version	un string
description	Una sola línea describiendo el paquete	un string
long_description	Descripción larga del paquete	un string
author	El nombre del autor del paquete	un string
author_email	La dirección de correo electrónico del autor del paquete	un string
maintainer	El nombre del mantenedor actual, si es diferente del autor. Ten en cuenta que si se proporciona el mantenedor, distuils lo usará como el autor en PKG-INFO	un string
maintainer_email	La dirección de correo electrónico del mantenedor actual, si es diferente del autor	un string
url	Una URL para el paquete (página principal)	un string
download_url	Una URL para descargar el paquete	un string
packages	Una lista de paquetes Python que distutils podrá manipular	una lista de strings
py_modules	Una lista de módulos Python que distutils podrá manipular	una lista de strings
scripts	Una lista de archivos únicos de scripts que serán creados e instalados	una lista de strings
ext_modules	Una lista de extensiones Python para ser creadas	una lista de las instancias de la clase distutils.core.Extension
classifiers	Una lista de categorías para el paquete	una lista de strings; los clasificadores válidos están listados en PyPI.
distclass	la clase para usar la clase Distribution	una sub-clase de la clase distutils.core.Distribution
script_name	El nombre del script del setup.py - el predeterminado es sys.argv[0]	un string
script_args	Argumentos para suministrar el script de configuración	una lista de strings
options	opciones por defecto para el script de configuración	un diccionario
license	La licencia para el paquete	un string
keywords	Metadatos descriptivos, ver PEP 314	una lista de strings o un string separado por comas
platforms		una lista de strings o un string separado por comas
cmdclass	Una asignación de los nombres de los comandos a las sub-clases de la clase Command	un diccionario
data_files	Una lista de archivos de datos para instalar	una lista
package_dir	Una asignación de directorios a los nombres de los paquetes	un diccionario

distutils.core.run_setup(script_name[, script_args=None, stop_after='run'])

Ejecuta un script de instalación en un entorno algo controlado y retorna la instancia de la clase distutils.dist.Distribution que maneja las cosas. Esto es útil si se necesitan encontrar los metadatos de distribución (pasados ​​como palabra clave args desde un script a la función setup()), o el contenido de los archivos de configuración o la línea de comandos.

script_name o nombre del script es un archivo que será leído y ejecutado con la función exec(). sys.argv[0] será reemplazado con un script durante la duración de la llamada. script_args es una lista de strings; si se proporciona, sys.argv[1:] será reemplazado por script_args durante la duración de la llamada.

stop_after le dice a la función setup() cuando parar el procesamiento; los valores posibles son:

valor	descripción
init	Detiene después de que la instancia de la clase Distribution haya sido creada y llenada con los argumentos de la palabra clave para la función setup()
config	Detiene después que los archivos de configuración hayan sido analizados (y sus datos almacenados en la instancia de la clase Distribution)
commandline	Detiene después de que la línea de comandos (sys.argv[1:] o script_args) se haya analizado (y los datos almacenados en la instancia de la clase Distribution.)
run	Detiene después de que todos los comandos hayan sido ejecutados (lo mismo que si la función setup() haya sido llamada de forma habitual). Este es el valor predeterminado.

Además, el módulo distutils.core expuso una serie de clases que residen en otros lugares.

• la clase Extension del módulo distutils.extension

• la clase Command del módulo distutils.cmd

• la clase Distribution del módulo distutils.dist

A continuación una breve descripción de cada uno de estos, pero para una referencia completa consulta el módulo correspondiente.

class distutils.core.Extension

La clase Extension describe un solo módulo de extensión C o C++ en un script de configuración. Acepta los siguientes argumentos de palabras clave de su constructor:

nombre del argumento	valor	tipo
name	el nombre completo de la extensión, incluidos los paquetes — es decir, no un nombre de archivo o ruta, sino un nombre punteado Python	un string
sources	lista de nombres de archivos de origen, en relación con la raíz de distribución (donde reside el script de configuración), en forma Unix (separados por barras) para su portabilidad. Los archivos fuente pueden ser C, C ++, SWIG (.i), archivos de recursos específicos de la plataforma o cualquier otra cosa que el comando build_ext reconozca como fuente para una extensión de Python.	una lista de strings
include_dirs	lista de los directorios para buscar archivos de encabezados de C/C++ (en forma de Unix para portabilidad)	una lista de strings
define_macros	lista de macros para definir; cada macro se define usando una tupla de 2 (*name*, *value*), donde value es el string para definirla o None para definirla sin un valor particular (equivalente a #define FOO en la fuente o -DFOO en la línea de comandos de un compilador de Unix C)	una lista de tuplas
undef_macros	lista de macros para indefinir explícitamente	una lista de strings
library_dirs	lista de directorios para buscar bibliotecas C/C++ en el momento del enlace	una lista de strings
libraries	lista de nombres de bibliotecas para vincular (no nombres de archivos o rutas)	una lista de strings
runtime_library_dirs	lista de directorios para buscar bibliotecas C/C++ en tiempo de ejecución (para extensiones compartidas, esto es cuando se carga una extensión)	una lista de strings
extra_objects	lista de archivos adicionales para vincular (por ejemplo, archivos de objeto no implícitos en *sources*, una biblioteca estática que debe especificarse explicitamente, archivos de recursos binarios, etc.)	una lista de strings
extra_compile_args	cualquier adicional específico de la plataforma y del compilador para usar cuando compila los archivos fuente en *sources*. Para plataformas y compiladores donde una línea de comando tiene sentido, esta es típicamente una lista de argumentos de línea de comando pero para otras plataformas podría ser cualquier cosa.	una lista de strings
extra_link_args	cualquier adicional específico de la plataforma y del compilador para usar al vincular archivos del tipo objeto para crear la extensión (o para crear un nuevo intérprete de Python estático). Interpretación similar a la de *extra_compile_args*.	una lista de strings
export_symbols	lista de símbolos que se exportarán desde una extensión compartida. No se usa en todas las plataformas y, en general, no es necesario para las extensiones de Python, que normalmente exportan exactamente un símbolo: init + extension_name.	una lista de strings
depends	lista de archivos de los que depende la extensión	una lista de strings
language	lenguaje de extensión (es decir, 'c', 'c++', 'objc'). Se detectará en las extensiones de origen si no se proporcionan.	un string
optional	especifica que una falla de compilación en la extensión no debe abortar el proceso de compilación, sino simplemente omitir la extensión.	un booleano

Distinto en la versión 3.8: En Unix, las extensiones C ya no están vinculadas a libpython excepto en Android y Cygwin.

class distutils.core.Distribution

Una clase Distribution describe cómo construir, instalar y empaquetar un paquete de software Python.

Consulta la función setup() para obtener una lista de argumentos de palabras clave aceptados por el constructor de distribución. La función setup() crea una instancia de distribución.

Distinto en la versión 3.7: La clase Distribution ahora advierte si los campos *classifiers*, *keywords* y *platforms* no se especifican como una lista o un string.

class distutils.core.Command

Una clase Command (o más bien, una instancia de una de sus subclases) implementa un solo comando distutils.

9.2. distutils.ccompiler — Clase base CCompiler

Este módulo proporciona la clase base abstracta para las clases CCompiler. Una instancia de la clase CCompiler se puede usar para todos los pasos de compilación y enlace necesarios para construir un solo proyecto. Se proporcionan métodos para establecer opciones para el compilador — definiciones de macros, que incluyen directorios, ruta de enlace, bibliotecas y similares.

Este módulo proporciona las siguientes funciones.

distutils.ccompiler.gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries)

Genera opciones de vinculador para buscar directorios de bibliotecas y vincular con bibliotecas específicas. libraries y * library_dirs* son, respectivamente, listas de nombres de bibliotecas (no nombres de archivos!) y directorios de búsqueda. Retorna una lista de opciones de línea de comandos adecuadas para su uso con algún compilador (dependiendo de los dos strings de formato suministrados).

distutils.ccompiler.gen_preprocess_options(macros, include_dirs)

Genera opciones de preprocesador de C (-D, -U, -I) tal como lo utilizan al menos dos tipos de compiladores: el compilador típico de Unix y el Visual C++. macros es lo habitual, una lista de 1 o 2 tuplas, donde (*name*,) significa indefinir (-U) macro name, y (*name*, *value*) significa definir (-D) macro de name a value. include_dirs es solo una lista de nombres de directorio que se agregarán a la ruta de búsqueda del archivo de encabezado (-I). Retorna una lista de opciones de línea de comandos adecuadas para compiladores de Unix o Visual C++.

distutils.ccompiler.get_default_compiler(osname, platform)

Determina el compilador predeterminado que se utilizará para la plataforma dada.

osname debe ser uno de los nombres estándar de Python OS (es decir, los retornados por os.name) y platform el valor común retornado por sys.platform para la plataforma en cuestión.

Los valores predeterminados son os.name y sys.platform en caso de que no se proporcionen los parámetros.

distutils.ccompiler.new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0)

Función de fábrica para generar una instancia de alguna subclase CCompiler para la combinación de plataforma/compilador proporcionada. plat por defecto es os.name (por ejemplo, 'posix', 'nt'), y compiler por defecto es el compilador por defecto para esa plataforma. Actualmente solo se admiten 'posix' y 'nt', y los compiladores predeterminados son la «interfaz Unix tradicional» (clase UnixCCompiler) y Visual C++ (clase MSVCCompiler). Tenga en cuenta que es perfectamente posible solicitar un objeto de compilador de Unix en Windows y un objeto de compilador de Microsoft en Unix — si proporciona un valor para compiler, plat es ignorado.

distutils.ccompiler.show_compilers()

Imprime la lista de compiladores disponibles (usado por las opciones - help-compiler para build, :command: build_ext, build_clib).

class distutils.ccompiler.CCompiler([verbose=0, dry_run=0, force=0])

La clase base abstracta CCompiler define la interfaz que deben implementar las clases de compiladores reales. La clase también tiene algunos métodos de utilidad utilizados por varias clases de compiladores.

La idea básica detrás de una clase de abstracción de compilador es que cada instancia se puede usar para todos los pasos de compilación/enlace en la construcción de un solo proyecto. Por lo tanto, los atributos comunes a todos esos pasos de compilación y enlace — incluyen directorios, macros para definir, bibliotecas para enlazar, etc. — son atributos de la instancia del compilador. Para permitir la variabilidad en la forma en que se tratan los archivos individuales, la mayoría de esos atributos se pueden variar por compilación o por enlace.

El constructor de cada subclase crea una instancia del objeto Compiler. Los indicadores son verbose (muestra un resultado detallado), dry_run (en realidad no ejecuta los pasos) y force (reconstruye todo, independientemente de las dependencias). Todos estos indicadores están predeterminados en 0 (desactivado). Ten en cuenta que probablemente no desees crear una instancia de CCompiler o una de sus subclases directamente; usa la función de fábrica distutils.CCompiler.new_compiler() en su lugar.

Los siguientes métodos te permiten modificar manualmente las opciones del compilador para la instancia de la clase Compiler.

add_include_dir(dir)

Agrega dir a la lista de directorios en los que se buscarán archivos de encabezado. Se le indica al compilador que busque directorios en el orden en que son proporcionados por llamadas sucesivas a add_include_dir().

set_include_dirs(dirs)

Establece la lista de directorios que se buscarán en dirs (una lista de strings). Anula cualquier llamada anterior a add_include_dir(); llamadas posteriores a add_include_dir() agrega a la lista pasada a set_include_dirs(). Esto no afecta a ninguna lista de directorios de inclusión estándar que el compilador pueda buscar de forma predeterminada.

add_library(libname)

Agrega libname a la lista de bibliotecas que se incluirán en todos los enlaces manejados por este compilador de objeto. Ten en cuenta que libname debería no ser el nombre de un archivo que contenga una biblioteca, sino el nombre de la biblioteca en sí: el enlazador, el compilador o la clase del compilador deducirán el nombre del archivo actual (según el plataforma).

Se le indicará al enlazador que se vincule con las bibliotecas en el orden en que se proporcionaron add_library() y/o set_libraries(). Es perfectamente válido duplicar nombres de bibliotecas; se le indicará al enlazador que se vincule con las bibliotecas tantas veces como se mencionen.

set_libraries(libnames)

Establece la lista de bibliotecas que se incluirán en todos los enlaces manejados ​​por este compilador de objeto en libnames (una lista de strings). Esto no afecta a las bibliotecas del sistema estándar que el vinculador pueda incluir de forma predeterminada.

add_library_dir(dir)

Agrega dir a la lista de directorios en los que se buscarán las bibliotecas especificadas para add_library() y set_libraries(). Se le indicará al enlazador que busque bibliotecas en el orden en que se suministran a add_library_dir() y/o set_library_dirs().

set_library_dirs(dirs)

Establece la lista de directorios de búsqueda de bibliotecas en dirs (una lista de strings). Esto no afecta a ninguna ruta de búsqueda de biblioteca estándar que el enlazador pueda buscar de forma predeterminada.

add_runtime_library_dir(dir)

Agrega dir a la lista de directorios en los que se buscarán bibliotecas compartidas en tiempo de ejecución.

set_runtime_library_dirs(dirs)

Establece la lista de directorios para buscar bibliotecas compartidas en tiempo de ejecución en dirs (una lista de strings). Esto no afecta a ninguna ruta de búsqueda estándar que el enlazador en tiempo de ejecución pueda buscar de forma predeterminada.

define_macro(name[, value=None])

Define una macro de preprocesador para todas las compilaciones impulsadas por este objeto compilador. El parámetro opcional value debe ser un string; si no se proporciona, la macro se definirá sin un valor explícito y el resultado exacto depende del compilador utilizado.

undefine_macro(name)

Anula la definición de una macro de preprocesador para todas las compilaciones impulsadas por este compilador de objeto. Si la misma macro está definida por define_macro() y la indefinida por undefine_macro(), la última llamada tiene prioridad (incluidas varias redefiniciones o indefiniciones). Si la macro está redefinida/indefinida por compilación (es decir, en la llamada a compile()), entonces eso tiene prioridad.

add_link_object(object)

Agrega object a la lista de archivos de objeto (o análogos, como archivos de biblioteca nombrados explícitamente o la salida de «resource compilers» o compiladores de recursos) para que se incluyan en cada enlace impulsado por este objeto de compilador.

set_link_objects(objects)

Establece la lista de archivos de objetos (o análogos) que se incluirán en cada enlace a objects. Esto no afecta a ningún archivo de objeto estándar que el enlazador pueda incluir de forma predeterminada (como las bibliotecas del sistema).

Los siguientes métodos implementan métodos para la detección automática de opciones del compilador, proporcionando alguna funcionalidad similar a GNU :program: autoconf.

detect_language(sources)

Detecta el idioma de un archivo determinado o una lista de archivos. Utiliza los atributos de instancia language_map (un diccionario) y language_order (una lista) para hacer el trabajo.

find_library_file(dirs, lib[, debug=0])

Busca en la lista especificada de directorios un archivo de biblioteca estático o compartido y retorna la ruta completa a ese archive lib. Si debug es verdadero, busca una versión de depuración (si tiene sentido en la plataforma actual). Retorna None si lib no se encontró en ninguno de los directorios especificados.

has_function(funcname[, includes=None, include_dirs=None, libraries=None, library_dirs=None])

Retorna un valor booleano que indica si funcname es compatible con la plataforma actual. Los argumentos opcionales se pueden utilizar para aumentar el entorno de compilación proporcionando archivos y rutas de inclusión adicionales y bibliotecas y rutas.

library_dir_option(dir)

Retorna la opción del compilador para agregar dir a la lista de directorios buscados por bibliotecas.

library_option(lib)

Retorna la opción del compilador para agregar lib a la lista de bibliotecas vinculadas a la biblioteca compartida o ejecutable.

runtime_library_dir_option(dir)

Retorna la opción del compilador para agregar dir a la lista de directorios buscados por bibliotecas en tiempo de ejecución.

set_executables(**args)

Define los ejecutables (y las opciones para ellos) que se ejecutarán para realizar las distintas etapas de compilación. El conjunto exacto de ejecutables que se pueden especificar aquí depende de la clase del compilador (a través del atributo de clase “executables”), pero la mayoría tendrá:

atributo	descripción
compiler	el compilador C/C++
linker_so	enlazador utilizado para crear bibliotecas y objetos compartidos
linker_exe	enlazador utilizado para crear ejecutables binarios
archiver	creador de biblioteca estática

En plataformas con una línea de comandos (Unix, DOS/Windows), cada uno de estos es un string que se dividirá en un nombre ejecutable y una lista de argumentos (opcional). (La división de la cadena se realiza de manera similar a como funcionan los shells de Unix: las palabras están delimitadas por espacios, pero las comillas y las barras invertidas pueden anular esto. Ver distutils.util.split_quoted().)

Los siguientes métodos invocan etapas en el proceso de construcción.

compile(sources[, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None])

Compila uno o más archivos fuente. Genera archivos de objeto (por ejemplo, transforma un archivo .c en un archivo .o).

sources debe ser una lista de nombres de archivo, probablemente archivos C/C ++, pero en realidad cualquier cosa que pueda ser manejada por un compilador particular y un compilador de clase (por ejemplo MSVCCompiler puede manejar archivos de recursos en source). Retorna una lista de nombres de archivos de objetos, uno por nombre de archivo fuente en sources. Dependiendo de la implementación, no se compilarán necesariamente todos los archivos fuente, pero se retornarán todos los nombres de archivo de objeto correspondientes.

Si se indica el output_dir, los objeto de archivos se colocarán debajo de él, conservando su componente de ruta original. Es decir, foo/bar.c normalmente se compila en foo/bar.o (para una implementación de Unix); si output_dir es build, entonces se compilaría en build/foo/bar.o.

macros, si se proporciona, debe ser una lista de definiciones de una macro. Una definición de una macro es un (*name*, *value*) 2-tupla o un (*name*,) 1-tupla. El primero define una macro; si el valor es None, la macro se define sin un valor explícito. El caso de 1 tupla no define una macro. Las definiciones/redefiniciones/indefiniciones posteriores tienen prioridad.

include_dirs, si se proporciona, debe ser una lista de strings, para esta compilación solo se agregarán a la ruta de búsqueda de archivos los directorios de inclusión predeterminada.

debug es un booleano; si es verdadero, se le indicará al compilador que genere símbolos de depuración en (o junto a) los archivos de objetos.

extra_preargs y extra_postargs dependen de la implementación. En plataformas que tienen la noción de línea de comandos (por ejemplo, Unix, DOS/Windows), lo más probable es que sean listas de strings: argumentos de línea de comandos adicionales para anteponer/agregar a la línea de comandos del compilador. En otras plataformas, consulta la documentación de la clase de implementación. En cualquier caso, están pensados ​​como una vía de escape para aquellas ocasiones en las que la marco del compilador abstracto no es suficiente.

depends, si se proporciona, es una lista de nombres de archivos de los que dependen todos los destinos. Si un archivo de origen es más antiguo que cualquier archivo en depends, se volverá a compilar el archivo de origen. Esto admite el seguimiento de dependencias, pero solo con una granularidad aproximada.

Lanza CompileError en caso de falla.

create_static_lib(objects, output_libname[, output_dir=None, debug=0, target_lang=None])

Enlaza un montón de cosas para crear un archivo de biblioteca estático. El «montón de cosas» o «bunch of stuff» consiste en la lista de archivos de objeto suministrados como objects, los archivos de objeto adicionales suministrados a add_link_object() y/o set_link_objects(), las bibliotecas suministradas a add_library() y/o set_libraries(), y las bibliotecas proporcionadas como libraries (si las hay).

output_libname debe ser un nombre de biblioteca, no un nombre de archivo; el nombre del archivo se deducirá del nombre de la biblioteca. output_dir es el directorio donde se colocará el archivo de la biblioteca.

debug es un booleano; si es verdadero, la depuración se incluirá en la biblioteca (ten en cuenta que en la mayoría de las plataformas, es el paso de compilación donde esto es importante: el indicador debug se incluye aquí solo por coherencia).

target_lang es el idioma de destino para el que se compilan los objetos dados. Esto permite un tratamiento específico del tiempo de vinculación de ciertos idiomas.

Lanza LibError en caso de falla.

link(target_desc, objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])

Enlaza un montón de cosas (o bunch of stuff) juntos para crear un archivo de biblioteca ejecutable o compartido.

El «montón de cosas» o (bunch of stuff) consiste en la lista de archivos de objeto suministrados como objects *. *output_filename debe ser un nombre del archivo. Si se proporciona output_dir, output_filename es relativo a él (es decir, output_filename puede proporcionar componentes de directorio si es necesario).

libraries es una lista de bibliotecas para enlazar. Estos son nombres de bibliotecas, no nombres de archivos, ya que se traducen a nombres de archivos de una manera específica de la plataforma (por ejemplo, foo se convierte en libfoo.a en Unix y foo.lib en DOS/Windows). Sin embargo, pueden incluir un componente de directorio, lo que significa que el enlazador buscará en ese directorio específico en lugar de buscar en todas las ubicaciones normales.

library_dirs, si se proporciona, debe ser una lista de directorios para buscar bibliotecas que se especificaron como nombres de bibliotecas descubiertos (es decir, sin componentes de directorio). Estos están en la parte superior del sistema predeterminado y los suministrados a add_library_dir() y/o set_library_dirs(). runtime_library_dirs es una lista de directorios que se incrustarán en la biblioteca compartida y se usarán para buscar otras bibliotecas compartidas de las que depende en tiempo de ejecución. (Esto solo puede ser relevante en Unix).

export_symbols es una lista de símbolos que exportará la biblioteca compartida. (Esto parece ser relevante solo en Windows).

debug es para métodos como compile() y create_static_lib(), con la ligera distinción de que en realidad es relevante en la mayoría de las plataformas (a diferencia de create_static_lib(), que incluye un indicador debug principalmente por el bien de la forma).

extra_preargs y extra_postargs son para métodos como compile() (excepto, por supuesto, que proporcionan argumentos de línea de comandos para el enlazador particular que se está utilizando).

target_lang es el idioma de destino para el que se compilan los objetos dados. Esto permite un tratamiento específico del tiempo de vinculación de ciertos idiomas.

Lanza LinkError en caso de falla.

link_executable(objects, output_progname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, target_lang=None])

Enlaza un ejecutable. output_progname es el nombre del archivo ejecutable, mientras que objects son una lista de nombres de archivos de objetos para vincular. Otros argumentos son para métodos como link().

link_shared_lib(objects, output_libname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])

Enlaza una biblioteca compartida. output_libname es el nombre de la biblioteca de salida, mientras que objects es una lista de nombres de archivos de objetos para vincular. Otros argumentos son para métodos como link().

link_shared_object(objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None])

Enlaza un objeto compartido. output_filename es el nombre del objeto compartido que se creará, mientras que objects es una lista de nombres de archivos de objetos para vincular. Otros argumentos son para métodos como link().

preprocess(source[, output_file=None, macros=None, include_dirs=None, extra_preargs=None, extra_postargs=None])

Preprocesa un solo archivo fuente C/C ++, nombrado en source. La salida se escribirá en el archivo llamado output_file, o stdout si output_file no se proporciona. macros es una lista de definiciones de macros para métodos como compile(), que aumentará el conjunto de macros con define_macro() y undefine_macro(). include_dirs es una lista de nombres de directorio que se agregarán a la lista predeterminada, de la misma manera que add_include_dir().

Lanza PreprocessError en caso de falla.

Los siguientes métodos de utilidad están definidos por la clase CCompiler, para uso de las distintas subclases concretas.

executable_filename(basename[, strip_dir=0, output_dir=''])

Retorna el nombre de archivo del ejecutable para el basename dado. Por lo general, para las plataformas que no son de Windows, este es el mismo que el nombre base, mientras que Windows obtendrá un archivo .exe agregado.

library_filename(libname[, lib_type='static', strip_dir=0, output_dir=''])

Retorna el nombre de archivo para el nombre de biblioteca dado en la plataforma actual. En Unix, una biblioteca con lib_type de 'static' normalmente tendrá la forma liblibname.a, mientras que lib_type de 'dynamic' tendrá la forma liblibname.so.

object_filenames(source_filenames[, strip_dir=0, output_dir=''])

Retorna el nombre de los archivos de objeto para los archivos de origen dados. source_filenames debe ser una lista de nombres de archivo.

shared_object_filename(basename[, strip_dir=0, output_dir=''])

Retorna el nombre de un archivo de objeto compartido para el nombre de archivo basename.

execute(func, args[, msg=None, level=1])

Invoca el método distutils.util.execute(). Este método invoca una función de Python func con los argumentos args dados, después de iniciar sesión y teniendo en cuenta el indicador dry_run.

spawn(cmd)

Invoca distutils.util.spawn(). Esto invoca un proceso externo para ejecutar el comando dado.

mkpath(name[, mode=511])

Invoca distutils.dir_util.mkpath(). Esto crea un directorio y los directorios ancestros que faltan.

move_file(src, dst)

Invoca distutils.file_util.move_file(). Cambia el nombre de src a dst.

announce(msg[, level=1])

Escribe un mensaje usando distutils.log.debug().

warn(msg)

Escribe un mensaje de advertencia msg al error estándar.

debug_print(msg)

Si el indicador debug está configurado en la instancia de la clase CCompiler, imprime msg en la salida estándar; de lo contrario, no hace nada.

9.3. distutils.unixccompiler — Unix CCompiler

Este módulo proporciona la clase UnixCCompiler, una subclase de CCompiler que maneja el típico compilador C de línea de comandos estilo Unix:

• macros definidas con -Dname[= value]

• macros definidas con -Uname

• incluye directorios de búsqueda especificados con -Idir

• bibliotecas especificadas con -llib

• directorios de búsqueda de bibliotecas especificados con -Ldir

• compilación manejada por cc (o similar) ejecutable con -c opción: compilar .c a .o

• enlaza la biblioteca estática manejada por el comando ar (posiblemente con ranlib)

• enlaza la biblioteca compartida manejada por cc -shared

9.4. distutils.msvccompiler — Compilador de Microsoft

Este módulo proporciona MSVCCompiler, una implementación de la clase abstracta CCompiler para Microsoft Visual Studio. Por lo general, los módulos de extensión deben compilarse con el mismo compilador Python que se utilizó para compilar. Para Python 2.3 y versiones anteriores, el compilador fue Visual Studio 6. Para Python 2.4 y 2.5, el compilador es Visual Studio .NET 2003.

MSVCCompiler normalmente elegirá el compilador, enlazador, etc. correcto por sí solo. Para anular esta opción, las variables de entorno DISTUTILS_USE_SDK y MSSdk deben estar configuradas. MSSdk indica que el entorno actual ha sido configurado por el script SetEnv.Cmd del SDK, o que las variables de entorno se habían registrado cuando se instaló el SDK; DISTUTILS_USE_SDK indica que el usuario de distutils ha hecho una elección explícita para anular la selección del compilador por MSVCCompiler.

9.5. distutils.bcppcompiler — Compilador Borland

Este módulo proporciona BorlandCCompiler, una subclase de la clase abstracta CCompiler para el compilador Borland C++.

9.6. distutils.cygwincompiler — Compilador Cygwin

Este módulo proporciona la clase CygwinCCompiler, una subclase de UnixCCompiler que maneja el puerto Cygwin del compilador GNU C a Windows. También contiene la clase Mingw32CCompiler que maneja el puerto mingw32 de GCC (igual que cygwin en modo no-cygwin).

9.7. distutils.archive_util — Utilidades de archivo

Este módulo proporciona algunas funciones para crear archivos de almacenamiento, como tarballs o zipfiles.

distutils.archive_util.make_archive(base_name, format[, root_dir=None, base_dir=None, verbose=0, dry_run=0])

Crea un archivo de almacenamiento (por ejemplo, zip o tar). base_name es el nombre del archivo a crear, menos cualquier extensión específica del formato; format es el formato de archivo: como zip, tar, gztar, bztar, xztar o ztar. root_dir es un directorio que será el directorio raíz del archivo; es decir, normalmente chdir en root_dir antes de crear el archivo. base_dir es el directorio desde donde comenzamos a archivar; es decir, base_dir será el prefijo común de todos los archivos y directorios del archivo. root_dir y base_dir ambos predeterminados al directorio actual. Retorna el nombre del archivo de almacenamiento.

Distinto en la versión 3.5: Se agregó soporte para el formato xztar.

distutils.archive_util.make_tarball(base_name, base_dir[, compress='gzip', verbose=0, dry_run=0])

Crea un archivo (opcionalmente comprimido) como un archivo tar de todos los archivos en y bajo base_dir. compress debe ser 'gzip' (el valor predeterminado), 'bzip2', 'xz', 'compress” o None. Para el método 'compress', la utilidad de compresión nombrada por compress debe estar en la ruta de búsqueda del programa predeterminada, por lo que probablemente sea específica de Unix. El archivo tar de salida se llamará base_dir.tar, posiblemente más la extensión de compresión apropiada (.gz,``.bz2``,``.xz`` o .Z). Retorna el nombre del archivo de salida.

Distinto en la versión 3.5: Se agregó soporte para la compresión xz.

distutils.archive_util.make_zipfile(base_name, base_dir[, verbose=0, dry_run=0])

Crea un archivo zip a partir de todos los archivos incluidos en base_dir. El archivo zip de salida se llamará base_name + .zip. Utiliza el módulo Python zipfile (si está disponible) o la utilidad InfoZIP zip (si está instalada y se encuentra en la ruta de búsqueda predeterminada). Si ninguna de las herramientas está disponible, lanza DistutilsExecError. Retorna el nombre del archivo zip de salida.

9.8. distutils.dep_util — Comprobación de dependencias

Este módulo proporciona funciones para realizar una dependencia simple basada en marcas de tiempo de archivos y grupos de archivos; también, funciones basadas completamente en dicho análisis de dependencia de marca de tiempo.

distutils.dep_util.newer(source, target)

Retorna verdadero si source existe y se ha modificado más recientemente que target, o si source existe y target no. Retorna falso si ambos existen y si target tiene el mismo tiempo o es más reciente que source. Lanza DistutilsFileError si source no existe.

distutils.dep_util.newer_pairwise(sources, targets)

Recorre dos listas de nombres de archivos en paralelo, probando si cada fuente es más nueva que su correspondiente destino. Retorna un par de listas (sources, target) donde la fuente es más nueva que el destino, de acuerdo con la semántica de newer().

distutils.dep_util.newer_group(sources, target[, missing='error'])

Retorna verdadero si target no está actualizado con respecto a cualquier archivo listado en sources. En otras palabras, si target existe y es más reciente que todos los archivos en sources, retorna falso; de lo contrario, retorna verdadero. missing controla lo que hacemos cuando falta un archivo fuente; el valor predeterminado ('error') explota con un OSError desde os.stat(); si es 'ignore', eliminamos silenciosamente cualquier archivo fuente faltante; si es 'newer', cualquier archivo fuente que falte nos hace suponer que target está desactualizado (esto es útil en el modo de «dry-run» (o ejecución en seco): que hará que pretenda ejecutar comandos que no funcionaría porque faltan entradas, pero no importa porque en realidad no va a ejecutar los comandos).

9.9. distutils.dir_util — Operaciones del árbol de directorios

Este módulo proporciona funciones para operar en directorios y árboles de directorios.

distutils.dir_util.mkpath(name[, mode=0o777, verbose=0, dry_run=0])

Crea un directorio y cualquier directorio ancestro que falte. Si el directorio ya existe (o si name es el string vacío, significa que el directorio actual, por supuesto existe), no hace nada. Lanza DistutilsFileError si no puede crear algún directorio en el camino (por ejemplo, existe alguna subruta, pero es un archivo en lugar de un directorio). Si verbose es verdadero, imprime un resumen de una línea de cada mkdir en stdout. Retorna la lista de directorios realmente creados.

distutils.dir_util.create_tree(base_dir, files[, mode=0o777, verbose=0, dry_run=0])

Crea todos los directorios vacíos en base_dir necesarios para colocar files allí. base_dir es solo el nombre de un directorio que no existe necesariamente todavía; files es una lista de nombres de archivos que se interpretarán en relación con base_dir. base_dir + la parte del directorio de cada archivo en files se creará si aún no existe. Los indicadores mode, verbose y dry_run son para funciones como mkpath().

distutils.dir_util.copy_tree(src, dst[, preserve_mode=1, preserve_times=1, preserve_symlinks=0, update=0, verbose=0, dry_run=0])

Copia un árbol de directorio completo src en una nueva ubicación dst. Tanto src como dst deben ser nombres de directorio. Si src no es un directorio, lanza DistutilsFileError. Si dst no existe, se crea con mkpath(). El resultado final de la copia es que todos los archivos de src se copian en dst, y los directorios de src se copian de forma recursiva en dst. Retorna la lista de archivos que se copiaron o que podrían haberse copiado, utilizando su nombre de salida. El valor de retorno no se ve afectado por update o dry_run: es simplemente la lista de todos los archivos bajo src *, con los nombres cambiados para estar bajo *dst.

preserve_mode y preserve_times son los mismos que para distutils.file_util.copy_file(); ten en cuenta que solo se aplican a archivos normales, no a directorios. Si preserve_symlinks es verdadero, los enlaces simbólicos se copiarán como enlaces simbólicos (en plataformas que los admitan!); de lo contrario (por defecto), se copiará el destino del enlace simbólico. update y verbose son los mismos que para copy_file().

Los archivos en src que comienzan con .nfs se omiten (hay más sobre estos archivos disponible en la respuesta D2 de la página de preguntas frecuentes de`NFS <http://nfs.sourceforge.net/#section_d>`_ ).

Distinto en la versión 3.3.1: Se ignoran los archivos NFS.

distutils.dir_util.remove_tree(directory[, verbose=0, dry_run=0])

Elimina de forma recursiva directory y todos los archivos y directorios que se encuentran debajo. Cualquier error se ignora (aparte de ser informado a sys.stdout si verbose es verdadero).

9.10. distutils.file_util — Operaciones de un solo archivo

Este módulo contiene algunas funciones de utilidad para operar en archivos individuales.

distutils.file_util.copy_file(src, dst[, preserve_mode=1, preserve_times=1, update=0, link=None, verbose=0, dry_run=0])

Copia el archivo desde src a dst. Si dst es un directorio, entonces src se copia allí con el mismo nombre; de lo contrario, debe ser un nombre de archivo. (Si el archivo existe, será atacado). Si preserve_mode es verdadero (el valor predeterminado), se copia el modo del archivo (bits de tipo y permiso, o lo que sea análogo en la plataforma actual). Si preserve_times es verdadero (el valor predeterminado), también se copian las horas de última modificación y de último acceso. Si update es verdadero, src solo se copiará si dst no existe, o si dst existe pero es anterior a src.

link te permite crear enlaces físicos (usando os.link()) o enlaces simbólicos (usando os.symlink()) en lugar de copiar: configúralo en 'hard' o 'sym'; si es None (el predeterminado), los archivos se copian. No establezcas link en sistemas que no lo admitan: copy_file() pues no comprueba si hay enlaces físicos o simbólicos disponibles. Utiliza _copy_file_contents() para copiar el contenido del archivo.

Retorna una tupla (dest_name, copied): dest_name es el nombre real del archivo de salida, y copied es verdadero si el archivo fue copiado (o se habría copiado, si dry_run es verdadero).

distutils.file_util.move_file(src, dst[, verbose, dry_run])

Mueve el archivo src a dst. Si dst es un directorio, el archivo se moverá a el con el mismo nombre; de lo contrario, src simplemente se renombra a dst. Retorna el nuevo nombre completo del archivo.

Advertencia

Maneja movimientos entre dispositivos en Unix usando copy_file(). ¿Qué pasa con otros sistemas?

distutils.file_util.write_file(filename, contents)

Crea un archivo llamado filename y escribe contents (una secuencia de strings sin terminadores de línea) en el.

9.11. distutils.util — Otras funciones de utilidad varias

Este módulo contiene otras partes y piezas variadas que no encajan en ningún otro módulo de utilidad.

distutils.util.get_platform()

Retorna un string que identifica la plataforma actual. Se utiliza principalmente para distinguir los directorios de compilación específicos de la plataforma y las distribuciones compiladas específicas de la plataforma. Por lo general, incluye el nombre y la versión del sistema operativo y la arquitectura (como lo proporciona “os.uname ()”), aunque incluir la exacta depende del sistema operativo; por ejemplo, en Linux, la versión del kernel no es particularmente importante.

Ejemplos de valores retornados:

• linux-i586

• linux-alpha

• solaris-2.6-sun4u

Para las plataformas que no son POSIX, actualmente solo retorna sys.platform.

For macOS systems the OS version reflects the minimal version on which binaries will run (that is, the value of MACOSX_DEPLOYMENT_TARGET during the build of Python), not the OS version of the current system.

For universal binary builds on macOS the architecture value reflects the universal binary status instead of the architecture of the current processor. For 32-bit universal binaries the architecture is fat, for 64-bit universal binaries the architecture is fat64, and for 4-way universal binaries the architecture is universal. Starting from Python 2.7 and Python 3.2 the architecture fat3 is used for a 3-way universal build (ppc, i386, x86_64) and intel is used for a universal build with the i386 and x86_64 architectures

Examples of returned values on macOS:

• macosx-10.3-ppc

• macosx-10.3-fat

• macosx-10.5-universal

• macosx-10.6-intel

Para AIX, Python 3.9 y versiones posteriores retornan una cadena que comienza con «aix», seguida de campos adicionales (separados por '-') que representan los valores combinados de Versión de AIX, Release y Nivel de tecnología (primer campo), Fecha de Construcción (segundo campo) y tamaño de bits (tercer campo). Python 3.8 y anteriores retornaban solo un campo adicional con la versión y lanzamiento de AIX.

Ejemplos de valores retornados en AIX:

• aix-5307-0747-32 # construcción 32-bit en AIX oslevel -s: 5300-07-00-0000

• aix-7105-1731-64 # construcción 64-bit en AIX oslevel -s: 7100-05-01-1731

• aix-7.2 # Forma heredada informada en Python 3.8 y versiones anteriores

Distinto en la versión 3.9: El formato de cadena de caracteres de la plataforma AIX ahora también incluye el nivel de tecnología, la fecha de construcción y el tamaño de bits de ABI.

distutils.util.convert_path(pathname)

Retorna “pathname” (o nombre de ruta), como un nombre que funcionará en el sistema de archivos nativo, es decir, divídelo con “/” y vuelve a armarlo usando el separador de directorio actual. Necesario porque los nombres de archivo en el script de configuración siempre se proporcionan en estilo Unix y deben convertirse a la convención local antes de que podamos usarlos en el sistema de archivos. Lanza ValueError en sistemas que no son Unix-ish si pathname comienza o termina con una barra.

distutils.util.change_root(new_root, pathname)

Retorna pathname con new_root precedido. Si pathname es relativo, esto es equivalente a os.path.join (new_root, pathname). De lo contrario, requiere hacer que pathname sea relativo y luego unir los dos, lo cual es complicado en DOS/Windows.

distutils.util.check_environ()

Asegúrate de que “os.environ” tenga todas las variables de entorno garantizamos que los usuarios pueden usar en archivos de configuración, opciones de línea de comandos, etc. Actualmente, esto incluye:

• HOME - directorio de inicio del usuario (solo Unix)

• PLAT - descripción de la plataforma actual, incluido el hardware y el sistema operativo (consulta get_platform())

distutils.util.subst_vars(s, local_vars)

Realiza la sustitución de variables de estilo shell/Perl en s. Cada aparición de $ seguido de un nombre se considera una variable, y la variable se sustituye por el valor que se encuentra en el diccionario local_vars, o en os.environ si no está en local_vars. os.environ primero se comprueba/aumenta para garantizar que contiene ciertos valores: ver check_environ(). Lanza ValueError para cualquier variable que no se encuentre en local_vars u os.environ.

Ten en cuenta que esta no es una función de interpolación de string completa. Una $ variable válida que puede constar solo de letras mayúsculas y minúsculas, números y un guión bajo. No hay citas de estilo {} o () disponibles.

distutils.util.split_quoted(s)

Divide un string de acuerdo con las reglas de tipo shell de Unix para comillas y barras invertidas. En resumen: las palabras están delimitadas por espacios, siempre que esos espacios no se escapen con una barra invertida o dentro de un string entre comillas. Las comillas simples y dobles son equivalentes, y los caracteres de las comillas pueden tener un escape de barra invertida. La barra invertida se elimina de cualquier secuencia de escape de dos caracteres, dejando solo el carácter de escape. Los caracteres de comillas se eliminan de cualquier string entre comillas. Retorna una lista de palabras.

distutils.util.execute(func, args[, msg=None, verbose=0, dry_run=0])

Realiza alguna acción que afecta al mundo exterior (por ejemplo, escribir en el sistema de archivos). Tales acciones son especiales porque están deshabilitadas por el indicador dry_run. Este método se encarga de toda esa burocracia por ti; todo lo que tienes que hacer es proporcionar la función a llamar y una tupla de argumentos para esta (para incorporar la «acción externa» que se está realizando), y un mensaje opcional para imprimir.

distutils.util.strtobool(val)

Convierte una representación real de un string a verdadero (1) o falso (0).

Los valores verdaderos son y, yes, t, true, on y 1; los valores falsos son n, no, f, false, off and 0. Lanza ValueError si val es cualquier otra cosa.

distutils.util.byte_compile(py_files[, optimize=0, force=0, prefix=None, base_dir=None, verbose=1, dry_run=0, direct=None])

Byte-compile es una colección de archivos fuente de Python de .pyc en un subdirectorio __pycache__ (ver PEP 3147 y PEP 488). py_files es una lista de archivos para compilar; cualquier archivo que no termine en .py se omite silenciosamente. optimize debe ser uno de los siguientes:

• 0 - no optimizar

• 1 - optimización normal (como python -O)

• 2 - extra optimización (como python -OO)

Si force es verdadero, todos los archivos se vuelven a compilar independientemente de las marcas de tiempo.

El nombre del archivo de origen codificado en cada archivo bytecode tiene por defecto los nombres de archivo listados en py_files; puede modificarlos con prefix y basedir. prefix es un string que se eliminará de cada nombre de archivo de origen, y base_dir es un nombre de directorio que se antepondrá (después de eliminar prefix). Puedes proporcionar uno o ambos (o ninguno) de prefix y * base_dir*, como desees.

Si dry_run es verdadero, actualmente no hace nada que pueda afectar el sistema de archivos.

La compilación de bytes se realiza directamente en este proceso de interpretación con el módulo estándar py_compile, o indirectamente escribiendo un script temporal y ejecutándolo. Normalmente, debería dejar que byte_compile() se dé cuenta de si usar la compilación directa o no (consulta la fuente para obtener más detalles). El indicador direct es utilizado por el script generado en modo indirecto; a menos que sepa lo que está haciendo, se deja configurado en None.

Distinto en la versión 3.2.3: Crea archivos .pyc con una etiqueta mágica import en su nombre, en un subdirectorio __pycache__ en lugar de archivos sin etiqueta en el directorio actual.

Distinto en la versión 3.5: Crea archivos .pyc de acuerdo a PEP 488.

distutils.util.rfc822_escape(header)

Retorna una versión de header para su inclusión en un encabezado RFC 822, asegurándose de que haya 8 espacios después de cada nueva línea. Ten en cuenta que no hace ninguna otra modificación del string.

9.12. distutils.dist — La clase Distribution

Este módulo proporciona la clase Distribution, que representa la distribución del módulo que se está construyendo/instalando/distribuyendo.

9.13. distutils.extension — La clase Extension

Este módulo proporciona la clase Extension, que se utiliza para describir los módulos de extensión C/C ++ en los scripts de configuración.

9.14. distutils.debug — modo de depuración Distutils

Este módulo proporciona el indicador DEBUG.

9.15. distutils.errors — excepciones Distutils

Proporciona excepciones utilizadas por los módulos Distutils. Ten en cuenta que los módulos de Distutils pueden lanzar excepciones estándar; en particular, SystemExit generalmente se lanza por errores que obviamente son culpa del usuario final (por ejemplo, argumentos incorrectos en la línea de comandos).

Este módulo es seguro de usar en el modo from ... import*; solo exporta símbolos cuyos nombres comienzan con Distutils y terminan con Error.

9.16. distutils.fancy_getopt — Wrapper alrededor del módulo estándar getopt

Este módulo proporciona una envoltura alrededor del modulo estándar getopt que proporciona las siguientes características adicionales:

• las opciones cortas y largas están unidas

• las opciones tienen strings de ayuda, por lo que fancy_getopt() podría potencialmente crear un resumen de uso completo

• las opciones establecen atributos de un objeto pasado

• las opciones booleanas pueden tener «alias negativos» — p. ej. si -quiet es el «alias negativo» de -verbose, entonces: option:!-quiet en la línea de comando establece falso a verbose.

distutils.fancy_getopt.fancy_getopt(options, negative_opt, object, args)

Función Wrapper. options es una lista de (*long_option*, *short_option*, *help_string*) 3-tuplas como se describe en el constructor para FancyGetopt. negative_opt debe ser un diccionario de mapeo de nombres de opciones a nombres de opciones, tanto la clave como el valor deben estar en la lista de options. object es un objeto que se usará para almacenar valores (ver el método getopt() de la clase FancyGetopt). args es la lista de argumentos. Usará sys.argv [1:] si pasa None como args.

distutils.fancy_getopt.wrap_text(text, width)

Envuelve text a menos de width ancho.

class distutils.fancy_getopt.FancyGetopt([option_table=None])

La opción option_table es una lista de 3 tuplas: (long_option, short_option, help_string)

Si una opción toma un argumento, su long_option debería tener `` “=” `` anexado; short_option debe ser solo un carácter, sin `` “:” `` en cualquier caso. short_option debe ser None si long_option no tiene una short_option correspondiente. Todas las tuplas de opciones deben tener opciones largas.

La clase FancyGetopt proporciona los siguientes métodos:

FancyGetopt.getopt([args=None, object=None])

Analiza las opciones de la línea de comandos en args. Almacena como atributos en object.

Si args es None o no se proporciona, utiliza sys.argv [1:]. Si object es None o no se proporciona, crea una nueva instancia OptionDummy, que allí almacena valores de opción y retorna una tupla (args, object). Si se proporciona object, se modifica en su lugar y getopt() simplemente retorna args; en ambos casos, el args retornado es una copia modificada de la lista args pasada, que se deja intacta.

FancyGetopt.get_option_order()

Retorna la lista de tuplas (*option*, *value*) procesadas por la ejecución anterior de getopt() Lanza RuntimeError si getopt() aún no se ha llamado.

FancyGetopt.generate_help([header=None])

Genera un texto de ayuda (una lista de strings, una por cada línea de salida sugerida) de la tabla de opciones para este objeto FancyGetopt.

Si se suministra, imprime el header suministrado en la parte superior de la ayuda.

9.17. distutils.filelist — La clase FileList

Este módulo proporciona la clase FileList, utilizada para hurgar en el sistema de archivos y crear listas de archivos.

9.18. distutils.log — Simple PEP 282-registro de estilo

9.19. distutils.spawn — Genera un subproceso

Este módulo proporciona la función spawn(), un front-end para varias funciones específicas de la plataforma para iniciar otro programa en un subproceso. También proporciona find_executable() para buscar en la ruta un nombre ejecutable determinado.

9.20. distutils.sysconfig — Información de configuración del sistema

El modulo distutils.sysconfig proporciona acceso a la configuración de bajo nivel de Python. Las variables de configuración específicas disponibles dependen en gran medida de la plataforma y la configuración. Las variables específicas dependen del proceso de compilación de la versión específica de Python que se está ejecutando; las variables son las que se encuentran en el archivo Makefile y el encabezado de configuración que se instalan con Python en sistemas Unix. El encabezado de configuración se llama pyconfig.h para las versiones de Python que comienzan con 2.2, y config.h para versiones anteriores de Python.

Se proporcionan algunas funciones adicionales que realizan algunas manipulaciones útiles para otras partes del paquete distutils.

distutils.sysconfig.PREFIX

El resultado de os.path.normpath(sys.prefix).

distutils.sysconfig.EXEC_PREFIX

El resultado de os.path.normpath(sys.exec_prefix).

distutils.sysconfig.get_config_var(name)

Retorna el valor de una sola variable. Esto es equivalente a get_config_vars ().get(name).

distutils.sysconfig.get_config_vars(...)

Retorna un conjunto de definiciones de variables. Si no hay argumentos, esto retorna un diccionario que asigna los nombres de las variables de configuración a los valores. Si se proporcionan argumentos, deben ser strings y el valor de retorno será una secuencia que proporcione los valores asociados. Si un nombre de pila no tiene un valor correspondiente, se incluirá None para esa variable.

distutils.sysconfig.get_config_h_filename()

Retorna el nombre completo de la ruta del encabezado de configuración. Para Unix, este será el encabezado generado por el script configure; para otras plataformas, el encabezado habrá sido proporcionado directamente por la distribución fuente de Python. El archivo es un archivo de texto específico de la plataforma.

distutils.sysconfig.get_makefile_filename()

Retorna el nombre completo de la ruta del archivo Makefile usado para construir Python. Para Unix, este será un archivo generado por el script configure; el significado para otras plataformas variará. El archivo es un archivo de texto específico de la plataforma, si existe. Esta función solo es útil en plataformas POSIX.

distutils.sysconfig.get_python_inc([plat_specific[, prefix]])

Retorna el directorio para los archivos de inclusión de C generales o dependientes de la plataforma. Si plat_specific es verdadero, se retorna el directorio de inclusión dependiente de la plataforma; si es falso o se omite, se retorna el directorio independiente de la plataforma. Si se proporciona prefix, se usa como prefijo en lugar de PREFIX, o como exec-prefix en lugar de EXEC_PREFIX si plat_specific es verdadero.

distutils.sysconfig.get_python_lib([plat_specific[, standard_lib[, prefix]]])

Retorna el directorio para la instalación de la biblioteca general o dependiente de la plataforma. Si plat_specific es verdadero, se retorna el directorio de inclusión dependiente de la plataforma; si es falso o se omite, se retorna el directorio independiente de la plataforma. Si se proporciona prefix, se usa como prefijo en lugar de PREFIX, o como exec-prefix en lugar de EXEC_PREFIX si plat_specific es verdadero. Si standard_lib es verdadero, se retorna el directorio de la biblioteca estándar en lugar del directorio para la instalación de extensiones de terceros.

La siguiente función solo está pensada para su uso dentro del paquete distutils.

distutils.sysconfig.customize_compiler(compiler)

Realiza cualquier personalización específica de la plataforma de una instancia distutils.ccompiler.CCompiler.

Esta función solo es necesaria en Unix en este momento, pero se debe llamar de manera consistente para admitir la compatibilidad con versiones posteriores. Inserta la información que varía según los tipos de Unix y se almacena en el archivo de Python Makefile. Esta incluye el compilador seleccionado, las opciones del compilador y del enlazador, y la extensión utilizada por el enlazador para los objetos compartidos.

Esta función tiene un propósito aún más especial y solo debe usarse desde los propios procedimientos de compilación de Python.

distutils.sysconfig.set_python_build()

Informa al módulo distutils.sysconfig que se está utilizando como parte del proceso de compilación de Python. Esto cambia muchas ubicaciones relativas de los archivos, lo que les permite ubicarse en el área de compilación en lugar de en un Python instalado.

9.21. distutils.text_file — La clase TextFile

Este módulo proporciona la clase TextFile, que proporciona una interfaz a los archivos de texto que (opcionalmente) se encarga de eliminar los comentarios, ignorar las líneas en blanco y unir líneas con barras invertidas.

class distutils.text_file.TextFile([filename=None, file=None, **options])

Esta clase proporciona un objeto similar a un archivo que se encarga de todas las cosas que comúnmente desea hacer al procesar un archivo de texto que tiene alguna sintaxis línea por línea: elimina comentarios (siempre que # sea su carácter de comentario), omite líneas en blanco, une líneas adyacentes escapando de la nueva línea (es decir, barra invertida al final de la línea), elimina los espacios en blanco iniciales o finales. Todos estos son opcionales y controlables de forma independiente.

La clase proporciona un método warn() para que pueda generar mensajes de advertencia que informen el número de línea física, incluso si la línea lógica en cuestión abarca varias líneas físicas. También proporciona unreadline() para implementar una búsqueda anticipada de línea a la vez.

Las instancias de TextFile se crean con filename, file o ambos. RuntimeError se lanza si ambos son None. filename debe ser un string, y file un archive de objeto (o algo que proporcione los métodos readline() y close()). Se recomienda que proporcione al menos filename, para que TextFile pueda incluirlo en mensajes de advertencia. Si no se proporciona file, TextFile crea uno propio usando la función incorporada open().

Todas las opciones son booleanas y afectan los valores retornados por readline()

nombre de la opción	descripción	predeterminado
strip_comments	elimina desde '#' hasta el final de la línea, así como cualquier espacio en blanco que conduzca al '#' — a menos que se escape por una barra invertida	verdadero
lstrip_ws	elimina los espacios en blanco iniciales de cada línea antes de retornarlo	falso
rstrip_ws	elimina los espacios en blanco finales (incluido el terminador de línea!) de cada línea antes de retornarlo.	verdadero
skip_blanks	omite las líneas que están vacías * después de* elimina los comentarios y los espacios en blanco. (Si tanto lstrip_ws como rstrip_ws son falsos, algunas líneas pueden consistir únicamente en espacios en blanco: estos no se omitirán, incluso si skip_blanks es verdadero).	verdadero
join_lines	si una barra invertida es el último carácter que no es una nueva línea en una línea después de eliminar los comentarios y los espacios en blanco, únela a la siguiente línea para formar una línea lógica; si N líneas consecutivas terminan con una barra invertida, entonces N + 1 líneas físicas se unirán para formar una línea lógica.	falso
collapse_join	elimina los espacios en blanco iniciales de las líneas que están unidas a su predecesor; solo importa si (*join_lines* y no *lstrip_ws*)	falso

Ten en cuenta que, dado que rstrip_ws puede eliminar la nueva línea final, la semántica de readline() debe diferir de las del método readline() del objeto de archivo integrado. En particular, readline() retorna None para el final del archivo: un string vacío puede ser solo una línea en blanco (o una línea con espacios en blanco), si rstrip_ws es verdadero pero skip_blanks no es.

open(filename)

Abre un nuevo archivo filename. Esto anula cualquier file o filename argumentado del constructor.

close()

Cierra el archivo actual y olvida todo lo que sabemos sobre él (incluido el nombre del archivo y el número de línea actual).

warn(msg[, line=None])

Imprime (a stderr) un mensaje de advertencia vinculado a la línea lógica actual en el archivo actual. Si la línea lógica actual en el archivo abarca varias líneas físicas, la advertencia se refiere a todo el rango, como "lines 3-5". Si se proporciona line, anula el número de línea actual; puede ser una lista o tupla para indicar un rango de líneas físicas, o un número entero para una sola línea física.

readline()

Lee y retorna una sola línea lógica del archivo actual (o de un búfer interno si las líneas han sido «no leídas» previamente con unreadline()). Si la opción join_lines es verdadera, esto puede implicar la lectura de varias líneas físicas concatenadas en una sola cadena. Actualiza el número de línea actual, por lo que llamar a warn() después readline() emite una advertencia sobre las líneas físicas que acaba de leer. Retorna None al final del archivo, ya que un string vacío puede aparecer si rstrip_ws es verdadero pero strip_blanks no lo es.

readlines()

Lee y retorna la lista de todas las líneas lógicas restantes en el archivo actual. Esto actualiza el número de línea actual a la última línea del archivo.

unreadline(line)

Empuja line (un string) en un búfer interno que será verificado por futuras llamadas a readline(). Útil para implementar un analizador con búsqueda anticipada de línea a la vez. Tenga en cuenta que las líneas que están «no leídas» con unreadline() no se vuelven a limpiar posteriormente (se eliminan los espacios en blanco o lo que sea) cuando se leen con readline(). Si se realizan varias llamadas a unreadline() antes de una llamada a readline(), la mayoría de las líneas se retornarán en el primer orden más reciente.

9.22. distutils.version — Clases de número de versión

9.23. distutils.cmd — Clase base abstracta para comandos Distutils

Este módulo proporciona la clase base abstracta Command.

class distutils.cmd.Command(dist)

La clase base abstracta para definir clases de comando, las «worker bees» de Distutils. Una analogía útil para las clases de comando es pensar en ellas como subrutinas con variables locales llamadas options. Las opciones se declaran en initialize_options() y se definen (dados sus valores finales) en finalize_options(), los cuales deben ser definidos por cada clase de comando. La distinción entre los dos es necesaria porque los valores de las opciones pueden provenir del mundo exterior (línea de comando, archivo de configuración, …), y cualquier opción que dependa de otras opciones debe calcularse después de que se hayan procesado estas influencias externas — por lo tanto finalize_options(). El cuerpo de la subrutina, donde hace todo su trabajo basado en los valores de sus opciones, es el método run(), que también debe ser implementado por cada clase de comando.

El constructor de la clase toma un solo argumento dist, una instancia Distribution.

9.24. Creando un nuevo comando Distutils

Esta sección describe los pasos para crear un nuevo comando Distutils.

Un nuevo comando reside en un módulo en el paquete distutils.command. Hay una plantilla de muestra en ese directorio llamada command_template. Copia este archivo en un nuevo módulo con el mismo nombre que el nuevo comando que está implementando. Este módulo debe implementar una clase con el mismo nombre que el módulo (y el comando). Entonces, por ejemplo, para crear el comando peel_banana (para que los usuarios puedan ejecutar setup.py peel_banana), deben copiar command_template a distutils/command/peel_banana.py, luego edítelo para que implemente la clase peel_banana, una subclase de distutils.cmd.Command.

Las subclases de Command deben definir los siguientes métodos.

Command.initialize_options()

Establece valores predeterminados para todas las opciones que admite este comando. Ten en cuenta que estos valores predeterminados pueden ser anulados por otros comandos, por el script de configuración, por los archivos de configuración o por la línea de comandos. Por tanto, este no es el lugar para codificar dependencias entre opciones; generalmente, las implementaciones de initialize_options() son solo un montón de asignaciones self.fo = None .

Command.finalize_options()

Establece valores finales para todas las opciones que admite este comando. Esto siempre se llama lo más tarde posible, es decir. después de que se hayan realizado las asignaciones de opciones desde la línea de comandos o desde otros comandos. Por lo tanto, este es el lugar para codificar las dependencias de opciones: si foo depende de bar, entonces es seguro establecer foo desde bar siempre que foo todavía tenga el mismo valor que se asignó en initialize_options().

Command.run()

La razón de ser de un comando: llevar a cabo la acción que debe realizar, controlada por las opciones inicializadas en initialize_options(), personalizadas por otros comandos, el script de configuración, la línea de comandos y los archivos de configuración, y finalizadas en finalize_options(). Toda la salida de la terminal y la interacción del sistema de archivos debe realizarse mediante run().

Command.sub_commands

sub_commands formaliza la noción de una «familia» de comandos, p. ej. install como padre con subcomandos install_lib, install_headers, etc. El padre de una familia de comandos define sub_commands como un atributo de clase; es una lista de 2 tuplas (command_name, predicate), con command_name un string y predicate una función, un string o None. predicate es un método del comando padre que determina si el comando correspondiente es aplicable en la situación actual. (Por ejemplo, install_headers solo es aplicable si tenemos archivos de encabezado C para instalar). Si predicate es None, ese comando siempre es aplicable.

sub_commands generalmente se define al end de una clase, porque los predicados pueden ser métodos de la clase, por lo que ya deben haber sido definidos. El ejemplo canónico es el comando install.

9.25. distutils.command — Comandos individuales de Distutils

9.26. distutils.command.bdist — Construye un instalador binario

9.27. distutils.command.bdist_packager — Clase base abstracta para empaquetadores

9.28. distutils.command.bdist_dumb — Construye un instalador «dump»

9.29. distutils.command.bdist_msi — Construye un paquete binario instalador de Microsoft

class distutils.command.bdist_msi.bdist_msi

Obsoleto desde la versión 3.9: Utiliza bdist_wheel (paquetes wheel) en su lugar.

Construye un paquete binario Windows Installer (.msi)

En la mayoría de los casos, el instalador bdist_msi es una mejor opción que el instalador bdist_wininst, porque proporciona un mejor soporte para plataformas Win64, permite a los administradores realizar instalaciones no interactivas y permite la instalación a través de políticas de grupo.

9.30. distutils.command.bdist_rpm — Construye una distribución binaria como RedHat RPM y SRPM

9.31. distutils.command.bdist_wininst — Construye un instalador de Windows

Obsoleto desde la versión 3.8: Utiliza bdist_wheel (paquetes wheel) en su lugar.

9.32. distutils.command.sdist — Construye una distribución de código fuente

9.33. distutils.command.build — Construye todos los archivos de un paquete

9.34. distutils.command.build_clib — Construye cualquier biblioteca C en un paquete

9.35. distutils.command.build_ext — Construye cualquier extensión en un paquete

9.36. distutils.command.build_py — Construye los archivos .py/.pyc de un paquete

class distutils.command.build_py.build_py

class distutils.command.build_py.build_py_2to3

Implementación alternativa de build_py que también ejecuta la biblioteca de conversión 2to3 en cada archivo .py que se va a instalar. Para usar esto en un archivo setup.py de una distribución que está diseñada para ejecutarse con Python 2.x y 3.x, agrega:

try:
    from distutils.command.build_py import build_py_2to3 as build_py
except ImportError:
    from distutils.command.build_py import build_py

a su setup.py, y posteriormente:

cmdclass = {'build_py': build_py}

a la invocación de configuración setup().

9.37. distutils.command.build_scripts — Construye los scripts de un paquete

9.38. distutils.command.clean — Limpia el área de construcción de un paquete

Este comando elimina los archivos temporales creados por el comando build y sus subcomandos, como archivos de objeto compilados intermediarios. Con la opción --all, se eliminará el directorio de compilación completo.

Los módulos de extensión construidos in place no se limpiarán, ya que no están en el directorio de construcción.

9.39. distutils.command.config — Realiza la configuración de un paquete

9.40. distutils.command.install — Instala un paquete

9.41. distutils.command.install_data — Instala archivos de datos de un paquete

9.42. distutils.command.install_headers — Instala archivos de encabezado C/C++ desde un paquete

9.43. distutils.command.install_lib — Instala archivos de biblioteca desde un paquete

9.44. distutils.command.install_scripts — Instala archivos de script desde un paquete

9.45. distutils.command.register — Registra un módulo con el índice de paquetes de Python

El comando register registra el paquete con el índice de paquetes de Python. Esto se describe con más detalle en PEP 301.

9.46. distutils.command.check — Verificar los metadatos de un paquete

El comando check realiza algunas pruebas en los metadatos de un paquete. Por ejemplo, verifica que todos los metadatos requeridos se proporcionen como argumentos pasados ​​a la función setup().