Reglas de Python

Reglas

py_binary
py_library
py_test
py_runtime

py_binary

py_binary(name, deps, srcs, data, args, compatible_with, deprecation, distribs, env, exec_compatible_with, exec_properties, features, imports, legacy_create_init, licenses, main, output_licenses, python_version, restricted_to, srcs_version, stamp, tags, target_compatible_with, testonly, toolchains, visibility)

Un py_binary es un programa ejecutable de Python que consta de de un conjunto de archivos de origen .py (que posiblemente pertenezcan a otras reglas py_library), una *.runfiles árbol de directorios, que contiene el código y los datos necesarios para en tiempo de ejecución y una secuencia de comandos stub que inicia el programa con el entorno y los datos iniciales correctos.

Ejemplos

py_binary(
    name = "foo",
    srcs = ["foo.py"],
    data = [":transform"],  # a cc_binary which we invoke at run time
    deps = [
        ":foolib",  # a py_library
    ],
)

Si quieres ejecutar un py_binary desde otro objeto binario o (por ejemplo, ejecutar un objeto binario de Python para configurar algún recurso simulado desde dentro de una java_test), el enfoque correcto es hacer que el otro objeto binario o la prueba dependen de py_binary en su sección de datos. El otro El objeto binario puede ubicar el py_binary en relación con la fuente .

py_binary(
    name = "test_main",
    srcs = ["test_main.py"],
    deps = [":testlib"],
)

java_library(
    name = "testing",
    srcs = glob(["*.java"]),
    data = [":test_main"]
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino. Si no se especifica `main`, debería ser igual al nombre del archivo fuente que es el punto de entrada principal de la aplicación menos la extensión. Por ejemplo, si tu punto de entrada se llama `main.py`, entonces tu nombre debería ser `main`.
`deps`	`List of labels; optional` Es la lista de otras bibliotecas que se vincularán al objetivo binario. Consulta los comentarios generales sobre `deps` en Atributos típicos definidos por la mayoría de las reglas de compilación. Estas suelen ser Reglas `py_library`.
`srcs`	`List of labels; required` La lista de archivos de origen (`.py`) que se procesan para crear el destino. Esto incluye todo el código subido y cualquier archivo fuente generado. Destinos de la biblioteca pertenecen a `deps`, mientras que otros archivos binarios necesarios en el tiempo de ejecución pertenecen `data`
`imports`	`List of strings; optional` Lista de directorios de importación que se agregarán a `PYTHONPATH`. Sujeto a la sustitución "Make variable". Estos importan directorios nuevos para esta regla y todas las reglas que dependen de ella (nota: no se aplica reglas de las que depende esta regla. Cada directorio se agregará a `PYTHONPATH` `py_binary` reglas que dependen de esta regla. Rutas de acceso absolutas (que comienzan con `/`) y que hacen referencia a una ruta de acceso sobre la raíz de ejecución no se permiten y generarán un error.
`legacy_create_init`	`Integer; optional; default is -1` Establece si se deben crear implícitamente archivos __init__.py vacíos en el árbol de archivos runfiles. Estos se crean en todos los directorios que contienen código fuente de Python o las bibliotecas compartidas y cada directorio superior de esos directorios, sin incluir la raíz del repositorio . El valor predeterminado, automático, significa verdadero, a menos que `--incompatible_default_to_explicit_init_py` está en uso. Si es falso, el usuario no responsable de crear archivos __init__.py (posiblemente vacíos) y agregarlos al `srcs` de destinos de Python, según sea necesario.
`main`	`Label; optional` El nombre del archivo fuente que es el punto de entrada principal de la aplicación. Este archivo también debe estar incluido en `srcs`. Si no se especifica, En su lugar, se usa `name` (consulta la sección anterior). Si `name` no coincide con cualquier nombre de archivo en `srcs`, se debe especificar `main`.
`python_version`	`String; optional; nonconfigurable; default is "_INTERNAL_SENTINEL"` Establece si se debe compilar este destino (y su `deps` transitivo) para Python 2 o Python. 3) Los valores válidos son `"PY2"` y `"PY3"` (el valor predeterminado). La versión de Python siempre se restablece (posiblemente de forma predeterminada) a la versión que sea especificada por este atributo, independientemente de la versión especificada en la línea de comandos o por o a otros objetivos superiores que dependen de este. Si deseas ejecutar `select()` en la versión actual de Python, puedes inspeccionar el valor de `@rules_python//python:python_version`. Consulta aquí para obtener más información. Advertencia de error: Este atributo establece la versión para la que Bazel compila tu destino. pero, debido a #4815, el La secuencia de comandos stub resultante puede invocar la versión incorrecta del intérprete en el entorno de ejecución. Consulta este solución alternativa, que implica definir un destino `py_runtime` que apunte a la versión de Python, según sea necesario, y activar `py_runtime` estableciendo `--python_top`
`srcs_version`	`String; optional; default is "PY2AND3"` Este atributo declara que el `srcs` del destino es compatible con Python. 2, Python 3 o ambos. Para configurar realmente la versión del entorno de ejecución de Python, usa el Atributo `python_version` de un ejecutable de Python (`py_binary` o `py_test`). Los valores permitidos son `"PY2AND3"`, `"PY2"` y `"PY3"`. También se permiten los valores `"PY2ONLY"` y `"PY3ONLY"` para datos históricos pero son básicamente iguales a `"PY2"` y `"PY3"` y deben evitarse. Ten en cuenta que solo las reglas ejecutables (`py_binary` y `py_library`) verifican la versión actual de Python con el valor de este atributo. (Esta es una función, ya que `py_library` no cambia la versión actual de Python versión, si hiciera la validación, sería imposible compilar `PY2ONLY` y `PY3ONLY` en la misma invocación). Además, si hay un si la versión no coincide, el error solo se informa en la fase de ejecución. En particular, el no aparecerá en una invocación `bazel build --nobuild`). Para obtener información de diagnóstico sobre las dependencias que introducen requisitos de versión, puedes ejecutar el aspecto `find_requirements` en tu destino: bazel build <your target> \ --aspects=@rules_python//python:defs.bzl%find_requirements \ --output_groups=pyversioninfo Se compilará un archivo con el sufijo `-pyversioninfo.txt` que proporcionará información por qué tu objetivo requiere una versión de Python u otra. Ten en cuenta que funciona incluso si no se pudo compilar el destino dado debido a un conflicto de versiones.
`stamp`	`Integer; optional; default is -1` Establece si se debe codificar información de compilación en el objeto binario. Valores posibles: `stamp = 1`: Siempre marca la información de la compilación en el objeto binario, incluso en `--nostamp`. Este de configuración debe evitarse, ya que puede finalizar el almacenamiento en caché remoto binario y las acciones descendentes que dependan de él. `stamp = 0`: Siempre reemplaza la información de compilación por valores constantes. Esta brinda un buen almacenamiento en caché de resultados de compilación. `stamp = -1`: la incorporación de la información de la compilación está controlada por el `--[no]stamp`. Los objetos binarios sellados no se vuelven a compilar, a menos que cambien sus dependencias.

py_library

py_library(name, deps, srcs, data, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, features, imports, licenses, restricted_to, srcs_version, tags, target_compatible_with, testonly, visibility)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino.
`deps`	`List of labels; optional` Es la lista de otras bibliotecas que se vincularán al objetivo binario. Consulta los comentarios generales sobre `deps` en Atributos típicos definidos por la mayoría de las reglas de compilación. Estas suelen ser Reglas `py_library`.
`srcs`	`List of labels; optional` La lista de archivos de origen (`.py`) que se procesan para crear el destino. Esto incluye todo el código subido y cualquier archivo fuente generado.
`imports`	`List of strings; optional` Lista de directorios de importación que se agregarán a `PYTHONPATH`. Sujeto a la sustitución "Make variable". Estos importan directorios nuevos para esta regla y todas las reglas que dependen de ella (nota: no se aplica reglas de las que depende esta regla. Cada directorio se agregará a `PYTHONPATH` `py_binary` reglas que dependen de esta regla. Rutas de acceso absolutas (que comienzan con `/`) y que hacen referencia a una ruta de acceso sobre la raíz de ejecución no se permiten y generarán un error.
`srcs_version`	`String; optional; default is "PY2AND3"` Este atributo declara que el `srcs` del destino es compatible con Python. 2, Python 3 o ambos. Para configurar realmente la versión del entorno de ejecución de Python, usa el Atributo `python_version` de un ejecutable de Python (`py_binary` o `py_test`). Los valores permitidos son `"PY2AND3"`, `"PY2"` y `"PY3"`. También se permiten los valores `"PY2ONLY"` y `"PY3ONLY"` para datos históricos pero son básicamente iguales a `"PY2"` y `"PY3"` y deben evitarse. Ten en cuenta que solo las reglas ejecutables (`py_binary` y `py_library`) verifican la versión actual de Python con el valor de este atributo. (Esta es una función, ya que `py_library` no cambia la versión actual de Python versión, si hiciera la validación, sería imposible compilar `PY2ONLY` y `PY3ONLY` en la misma invocación). Además, si hay un si la versión no coincide, el error solo se informa en la fase de ejecución. En particular, el no aparecerá en una invocación `bazel build --nobuild`). Para obtener información de diagnóstico sobre las dependencias que introducen requisitos de versión, puedes ejecutar el aspecto `find_requirements` en tu destino: bazel build <your target> \ --aspects=@rules_python//python:defs.bzl%find_requirements \ --output_groups=pyversioninfo Se compilará un archivo con el sufijo `-pyversioninfo.txt` que proporcionará información por qué tu objetivo requiere una versión de Python u otra. Ten en cuenta que funciona incluso si no se pudo compilar el destino dado debido a un conflicto de versiones.

py_test

py_test(name, deps, srcs, data, args, compatible_with, deprecation, distribs, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, imports, legacy_create_init, licenses, local, main, python_version, restricted_to, shard_count, size, srcs_version, stamp, tags, target_compatible_with, testonly, timeout, toolchains, visibility)

Una regla py_test() compila una prueba. Una prueba es un wrapper binario en torno a algún código de prueba.

Ejemplos

py_test(
    name = "runtest_test",
    srcs = ["runtest_test.py"],
    deps = [
        "//path/to/a/py/library",
    ],
)

También es posible especificar un módulo principal:

py_test(
    name = "runtest_test",
    srcs = [
        "runtest_main.py",
        "runtest_lib.py",
    ],
    main = "runtest_main.py",
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino.
`deps`	`List of labels; optional` Es la lista de otras bibliotecas que se vincularán al objetivo binario. Consulta los comentarios generales sobre `deps` en Atributos típicos definidos por la mayoría de las reglas de compilación. Estas suelen ser Reglas `py_library`.
`srcs`	`List of labels; required` La lista de archivos de origen (`.py`) que se procesan para crear el destino. Esto incluye todo el código subido y cualquier archivo fuente generado. Destinos de la biblioteca pertenecen a `deps`, mientras que otros archivos binarios necesarios en el tiempo de ejecución pertenecen `data`
`imports`	`List of strings; optional` Lista de directorios de importación que se agregarán a `PYTHONPATH`. Sujeto a la sustitución "Make variable". Estos importan directorios nuevos para esta regla y todas las reglas que dependen de ella (nota: no se aplica reglas de las que depende esta regla. Cada directorio se agregará a `PYTHONPATH` `py_binary` reglas que dependen de esta regla. Rutas de acceso absolutas (que comienzan con `/`) y que hacen referencia a una ruta de acceso sobre la raíz de ejecución no se permiten y generarán un error.
`legacy_create_init`	`Integer; optional; default is -1` Establece si se deben crear implícitamente archivos __init__.py vacíos en el árbol de archivos runfiles. Estos se crean en todos los directorios que contienen código fuente de Python o las bibliotecas compartidas y cada directorio superior de esos directorios, sin incluir la raíz del repositorio . El valor predeterminado, automático, significa verdadero, a menos que `--incompatible_default_to_explicit_init_py` está en uso. Si es falso, el usuario no responsable de crear archivos __init__.py (posiblemente vacíos) y agregarlos al `srcs` de destinos de Python, según sea necesario.
`main`	`Label; optional` El nombre del archivo fuente que es el punto de entrada principal de la aplicación. Este archivo también debe estar incluido en `srcs`. Si no se especifica, En su lugar, se usa `name` (consulta la sección anterior). Si `name` no coincide con cualquier nombre de archivo en `srcs`, se debe especificar `main`.
`python_version`	`String; optional; nonconfigurable; default is "_INTERNAL_SENTINEL"` Establece si se debe compilar este destino (y su `deps` transitivo) para Python 2 o Python. 3) Los valores válidos son `"PY2"` y `"PY3"` (el valor predeterminado). La versión de Python siempre se restablece (posiblemente de forma predeterminada) a la versión que sea especificada por este atributo, independientemente de la versión especificada en la línea de comandos o por o a otros objetivos superiores que dependen de este. Si deseas ejecutar `select()` en la versión actual de Python, puedes inspeccionar el valor de `@rules_python//python:python_version`. Consulta aquí para obtener más información. Advertencia de error: Este atributo establece la versión para la que Bazel compila tu destino. pero, debido a #4815, el La secuencia de comandos stub resultante puede invocar la versión incorrecta del intérprete en el entorno de ejecución. Consulta este solución alternativa, que implica definir un destino `py_runtime` que apunte a la versión de Python, según sea necesario, y activar `py_runtime` estableciendo `--python_top`
`srcs_version`	`String; optional; default is "PY2AND3"` Este atributo declara que el `srcs` del destino es compatible con Python. 2, Python 3 o ambos. Para configurar realmente la versión del entorno de ejecución de Python, usa el Atributo `python_version` de un ejecutable de Python (`py_binary` o `py_test`). Los valores permitidos son `"PY2AND3"`, `"PY2"` y `"PY3"`. También se permiten los valores `"PY2ONLY"` y `"PY3ONLY"` para datos históricos pero son básicamente iguales a `"PY2"` y `"PY3"` y deben evitarse. Ten en cuenta que solo las reglas ejecutables (`py_binary` y `py_library`) verifican la versión actual de Python con el valor de este atributo. (Esta es una función, ya que `py_library` no cambia la versión actual de Python versión, si hiciera la validación, sería imposible compilar `PY2ONLY` y `PY3ONLY` en la misma invocación). Además, si hay un si la versión no coincide, el error solo se informa en la fase de ejecución. En particular, el no aparecerá en una invocación `bazel build --nobuild`). Para obtener información de diagnóstico sobre las dependencias que introducen requisitos de versión, puedes ejecutar el aspecto `find_requirements` en tu destino: bazel build <your target> \ --aspects=@rules_python//python:defs.bzl%find_requirements \ --output_groups=pyversioninfo Se compilará un archivo con el sufijo `-pyversioninfo.txt` que proporcionará información por qué tu objetivo requiere una versión de Python u otra. Ten en cuenta que funciona incluso si no se pudo compilar el destino dado debido a un conflicto de versiones.
`stamp`	`Integer; optional; default is 0` Consulta la sección sobre argumentos py_binary(), excepto que el argumento de marca se establezca en 0 de forma predeterminada para las pruebas.

py_runtime

py_runtime(name, compatible_with, coverage_tool, deprecation, distribs, features, files, interpreter, interpreter_path, licenses, python_version, restricted_to, stub_shebang, tags, target_compatible_with, testonly, visibility)

Representa un entorno de ejecución de Python que se usa para ejecutar un código de Python.

Un destino py_runtime puede representar un entorno de ejecución de la plataforma o un entorno de ejecución en la compilación. El entorno de ejecución de la plataforma accede a un intérprete instalado por el sistema en un entorno mientras que un entorno de ejecución integrado apunta a un destino ejecutable que actúa como intérprete. En en ambos casos, un "intérprete" cualquier secuencia de comandos binaria o wrapper ejecutable que sea capaz de ejecutar una secuencia de comandos de Python pasada en la línea de comandos, siguiendo las mismas convenciones que la Intérprete de CPython.

Por naturaleza, el entorno de ejecución de una plataforma no es hermético. Impone un requisito en la plataforma de destino. tener un intérprete en una ruta específica. Un entorno de ejecución integrado puede o no ser hermético, según si apunta a un intérprete registrado o a una secuencia de comandos wrapper que acceda a la de sistema.

Ejemplo:

py_runtime(
    name = "python-2.7.12",
    files = glob(["python-2.7.12/**"]),
    interpreter = "python-2.7.12/bin/python",
)

py_runtime(
    name = "python-3.6.0",
    interpreter_path = "/opt/pyenv/versions/3.6.0/bin/python",
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino.
`coverage_tool`	`Label; optional` Este objetivo se utiliza para recopilar información de cobertura de código de `py_binary` y `py_test`. Si se configura, el destino debe producir un solo archivo o ser un destino ejecutable. La ruta de acceso al archivo único, o al ejecutable si el destino es ejecutable Determina el punto de entrada para la herramienta de cobertura de Python. El objetivo y su Los runfiles se agregarán a los runfiles cuando la cobertura esté habilitada. El punto de entrada de la herramienta se debe poder cargar con un intérprete de Python (p.ej., un `.py` o `.pyc`). Debe aceptar los argumentos de la línea de comandos de coverage.py, al menos incluyendo los subcomandos `run` y `lcov`.
`files`	`List of labels; optional` Para un entorno de ejecución en la compilación, este es el conjunto de archivos que comprende este entorno de ejecución. Estos archivos harán lo siguiente se agregará a los runfiles de los objetos binarios de Python que usan este entorno de ejecución. Para el entorno de ejecución de una plataforma no se debe establecer este atributo.
`interpreter`	`Label; optional` Para un entorno de ejecución en la compilación, este es el destino que se invocará como intérprete. Para una plataforma no se debe establecer este atributo.
`interpreter_path`	`String; optional` Para un entorno de ejecución de plataforma, esta es la ruta de acceso absoluta de un intérprete de Python en el destino plataforma. Para un entorno de ejecución en la compilación, no se debe configurar este atributo.
`python_version`	`String; optional; default is "_INTERNAL_SENTINEL"` Indica si este entorno de ejecución es para la versión principal 2 o 3 de Python. Los valores válidos son `"PY2"` y `"PY3"`. La marca `--incompatible_py3_is_default` controla el valor predeterminado. Sin embargo, en el futuro, este atributo será obligatorio y no tendrá un valor predeterminado.
`stub_shebang`	`String; optional; default is "#!/usr/bin/env python3"` “Shebang” expresión que se antepone a la secuencia de comandos de stub de Python de inicio que se usa cuando se ejecutan objetivos `py_binary`. Consulta el problema 8685 para motivación. No se aplica a Windows.