Categorías
Python

El desarrollo de la botella – Parte 2 (API plot.ly)

 

Tabla de Contenidos

    Problemas

  • que Pipenv Gestión SolvesDependency con requirements.txtDevelopment de proyectos con diferentes Resolución DependenciesDependency
  • gestión de la dependencia con requirements.txt
  • Desarrollo de proyectos con diferentes dependencias
  • Dependencia Resolución
  • Pipenv IntroductionExample de UsagePipenv Dependencia Resolución ApproachThe PipfileThe Pipfile.lockPipenv características adicionales de resolución de dependencias Enfoque de
  • Ejemplo de Uso
  • Pipenv
  • El Pipfile
  • El Pipfile.lock
  • Pipenv extra Características
  • paquete DistributionYes, necesito para distribuir mi código como packageI no es necesario distribuir mi código como un paquete
  • Sí, necesito para distribuir el código como un paquete
  • no necesito para distribuir el código como un paquete
  • ya tengo una requirements.txt. ¿Cómo se convierte a un Pipfile?
  • ¿Qué sigue? vale la pena
  • Is Pipenv retirar? Referencias
  • , otras lecturas, discusiones interesantes, y así sucesivamente
  • gestión de la dependencia con requirements.txt
  • Desarrollo de Proyectos con la resolución de dependencias Enfoque de distintas dependencias
  • Dependencia Resolución
  • Ejemplo de Uso
  • Pipenv
  • El Pipfile
  • El Pipfile.lock
  • Pipenv características adicionales
  • Sí, necesito para distribuir el código como un paquete
  • no necesito para distribuir el código como un paquete

Pipenv es una herramienta de empaquetado para Python que resuelve algunos de los problemas comunes asociados con el flujo de trabajo típico que usa pip, virtualenv, y el bien requirements.txt de edad.

Además de abordar algunos temas comunes, que consolida y simplifica el proceso de desarrollo de una única herramienta de línea de comandos.

Esta guía repasará lo que resuelve problemas Pipenv y cómo gestionar sus dependencias con Python Pipenv. Además, cubrirá cómo Pipenv encaja con los métodos anteriores para la distribución de paquetes. Bono

gratuito: Haga clic aquí para obtener acceso a una clase gratuita de 5 días de duración que muestra cómo evitar problemas de gestión de la dependencia común con herramientas como Pip, PyPI, virtualenv y archivos requisitos.

Problemas que soluciona Pipenv

Para entender los beneficios de Pipenv, es importante caminar a través de los métodos actuales para el embalaje y gestión de la dependencia en Python. inicio de

Vamos con una situación típica de manejar paquetes de terceros. a continuación, vamos a construir nuestro camino hacia la implementación de una aplicación completa de Python.

gestión de la dependencia con requirements.txt

Imagínese que está trabajando en un proyecto de Python que usa un paquete de terceros, como frasco. Tendrá que especificar que el requisito para que otros desarrolladores y los sistemas automatizados pueden ejecutar su aplicación.

por lo que decide incluir la dependencia frasco en un archivo requirements.txt:

flask

Grande, todo funciona bien a nivel local, y después de cortar lejos en su aplicación durante un tiempo, decide irse a vivir a la producción. Aquí es donde las cosas se ponen un poco de miedo …

Lo anterior archivo requirements.txt no especifica qué versión del frasco para su uso. En este caso, pipa de la instalación requirements.txt -r instalará la última versión por defecto. Esto está bien a menos que haya interfaz o comportamiento cambia en la versión más reciente que rompen nuestra aplicación.

Por el bien de este ejemplo, digamos que una nueva versión del frasco fue liberada. Sin embargo, no es compatible con la versión que utilizó durante el desarrollo.

Ahora, digamos que implementar la aplicación a la producción y hacer un pip instalar requirements.txt -r. Pip obtiene la versión más reciente, con capacidad para un no-retroceso del frasco, y al igual que sus descansos de aplicación … en la producción.

“Pero bueno, funcionó en mi máquina!” -He estado allí, y no es una gran sensación.

En este punto, se sabe que la versión del frasco que utilizó durante el desarrollo funcionaba bien. Así que, para arreglar las cosas, intenta ser un poco más específico en su requirements.txt. Se agrega una versión especificador a la dependencia frasco. Esto también se llama fijando una dependencia:

flask==0.12.1

que fija al matraz de la dependencia a una versión específica asegura que un pip instalar -r conjuntos requirements.txt hasta la versión exacta del frasco que utilizó durante el desarrollo. Pero, ¿realmente?

tener en cuenta que matraz en sí tiene dependencias, así (que se instala automáticamente PIP). Sin embargo, frasco sí no especifica las versiones exactas de sus dependencias. Para ejemplo, permite que cualquier versión de Werkzeug> = 0,14.

Una vez más, por el bien de este ejemplo, supongamos que una nueva versión de Werkzeug fue liberada, pero introduce un error show-tapón para su aplicación.

Al hacer pip instalar requirements.txt -r en la producción de este tiempo, se compra una vasija de == 0.12.1 puesto que ya has clavado ese requisito. Sin embargo, por desgracia, obtendrá la versión más reciente, con errores de Werkzeug. Una vez más, el producto se rompe en la producción.

El verdadero problema aquí es que la acumulación no es determinista . Lo que quiero decir con esto es que, dada la misma entrada (el archivo requirements.txt), pip no siempre produce el mismo entorno. Por el momento, no se puede replicar fácilmente el ambiente exacto que tiene en su equipo de desarrollo de la producción.

La solución típica a este problema es el uso de pepita congelación. Este comando le permite obtener versiones exactas de todas las bibliotecas 3 ª parte actualmente instalados, incluyendo las sub-dependencias pip instalados automáticamente. Así se puede congelar todo en el desarrollo para asegurarse de que tiene el mismo entorno de producción.

Ejecución resultados de congelación de pepita en dependencias cubrió puede agregar a un requirements.txt:

click==6.7
Flask==0.12.1
itsdangerous==0.24
Jinja2==2.10
MarkupSafe==1.0
Werkzeug==0.14.1

Con estas dependencias puestas, puede asegurarse de que los paquetes instalados en su entorno de producción coinciden con los de su entorno de desarrollo con exactitud, por lo que su producto doesn’ t inesperadamente romper. Esta “solución”, por desgracia, conduce a un nuevo conjunto de problemas.

Ahora que ha especificado las versiones exactas de cada paquete de terceros, que son responsables de mantener estas versiones hasta la fecha, aunque son sub-dependencias del frasco. ¿Qué pasa si hay un agujero de seguridad descubierto en Werkzeug == 0.14.1 que los responsables de los paquetes parcheados inmediatamente en Werkzeug == 0.14.2? Que realmente necesita para la actualización a Werkzeug == 0.14.2 para evitar cualquier problema de seguridad que surgen de la versión anterior, sin parches de Werkzeug.

En primer lugar, hay que ser consciente de que hay un problema con la versión que tiene. Entonces, es necesario obtener la nueva versión del entorno de producción antes de que alguien se aprovecha el agujero de seguridad. Por lo tanto, usted tiene que cambiar su requirements.txt manualmente para especificar la nueva versión Werkzeug == 0.14.2. Como se puede ver en esta situación, la responsabilidad de mantenerse al día con las actualizaciones necesarias cae sobre ti.

La verdad es que realmente no importa qué versión de Werkzeug se instala con tal de que no se rompa su código. De hecho, es probable que desee la versión más reciente para asegurarse de que está recibiendo correcciones de errores, parches de seguridad, nuevas funciones, más la optimización, y así sucesivamente.

La verdadera pregunta es: “¿Cómo se puede permitir el determinista construye para su proyecto de Python sin aumentar la responsabilidad de actualizar las versiones de sub-dependencias?” alerta

Spoiler: La respuesta fácil está utilizando Pipenv.

Desarrollo de Proyectos con mecanismos de conmutación de distintas dependencias

dejar que un poco para hablar de otro tema común que surge cuando se trabaja en varios proyectos. Imagínese que las necesidades ProjectA django == 1.9, pero las necesidades ProjectB django == 1.10.

Por defecto, Python trata de almacenar todos los paquetes de otros fabricantes de en un lugar de todo el sistema. Esto significa que cada vez que quiera cambiar entre ProjectA y ProjectB, usted tiene que asegurarse de que está instalada la versión correcta de Django. Esta conmutación entre los proyectos dolorosos porque hay que desinstalar y reinstalar paquetes para satisfacer los requisitos de cada proyecto hace.

La solución estándar es el uso de un entorno virtual que tiene su propio ejecutable de Python y el paquete de terceros almacenamiento. De esa manera, ProjectA y ProjectB se separan adecuadamente. Ahora se puede cambiar fácilmente entre los proyectos, ya que no están compartiendo el mismo lugar de almacenamiento paquete. PackageA puede tener cualquier versión de Django que necesita en su propio entorno, y PaqueteB puede tener lo que se necesita totalmente separada. Una herramienta muy común para esto es virtualenv (o Venv en Python 3).

Pipenv tiene la gestión de entorno virtual construido en el quedando con una sola herramienta para la gestión de su paquete.

Dependencia Resolución

¿Qué quiero decir por la dependencia de resolución? Digamos que tienes un archivo requirements.txt que se ve algo como esto: digamos package_a de

package_a
package_b

Let tiene una package_c sub-dependencia, y package_a requiere una versión específica de este paquete: package_c> = 1.0. A su vez, package_b tiene el mismo sub-dependencia pero necesita package_c <= 2,0.

Idealmente, cuando intenta instalar package_a y package_b, la herramienta de instalación sería mirar los requisitos para package_c (siendo > = 1,0 y <= 2,0) y seleccione una versión que cumple con esos requisitos. Se podría esperar que la herramienta resuelve las dependencias para que su programa funciona en el final. Esto es lo que quiero decir con “resolución de dependencias.”

Desafortunadamente, pip en sí no tiene resolución de dependencias verdadera en el momento, pero hay un tema abierto para apoyarlo.

El pip manera manejaría el escenario anterior es la siguiente:

Se instala package_a y busca una versión de package_c que cumple con el primer requisito (package_c> = 1.0).

Pip continuación, instala la última versión del package_c para cumplir con ese requisito. Digamos que la versión más reciente de package_c es de 3.1.

Aquí es donde comienza el problema (potencialmente).

Si la versión de package_c seleccionado por pip no las necesidades futuras de ajuste (tales como package_b pueda package_c <= 2,0), la instalación fallará.

La “solución” a este problema es para especificar el rango requerido para la sub-dependencia (package_c) en el archivo requirements.txt. De esa manera, pip puede resolver este conflicto e instalar un paquete que cumpla esos requisitos:

package_c>=1.0,<=2.0 package_a package_b

Al igual que antes, sin embargo, que está ahora mismo en relación directa con la sub-dependencias (package_c). El problema con esto es que si cambia su package_a requisito sin conocimiento del usuario, los requisitos que especifican (package_c> = 1,0, <= 2,0) ya no puede ser aceptable, y la instalación puede fallar ... otra vez. El verdadero problema es que, una vez más, usted es responsable de mantenerse al día con los requisitos de la sub-dependencias.

Idealmente, la herramienta de instalación sería lo suficientemente inteligente como para instalar los paquetes que cumplen con todos los requisitos sin especificar explícitamente que las versiones sub-dependencia.

Pipenv Introducción

Ahora que hemos abordado los problemas, vamos a ver cómo Pipenv los resuelve.

En primer lugar, vamos a instalarlo:

$ pip install pipenv

Una vez que hayas hecho esto, puede olvidarse de manera efectiva sobre pip desde Pipenv actúa esencialmente como un reemplazo. También introduce dos nuevos archivos, el Pipfile (que se pretende sustituir requirements.txt) y el Pipfile.lock (que permite determinista construye).

Pipenv utiliza pip y virtualenv bajo el capó pero simplifica su uso con una interfaz de línea de comandos sola.

Ejemplo de Uso

Vamos a empezar de nuevo con la creación de su aplicación impresionante Python. En primer lugar, generar una cáscara en un entorno virtual para aislar el desarrollo de esta aplicación:

$ pipenv shell

Esto creará un entorno virtual si uno no existe ya. Pipenv crea todas sus entornos virtuales en una ubicación predeterminada. Si desea cambiar el comportamiento predeterminado del Pipenv, hay algunas variables ambientales para la configuración.

Puede forzar la creación de un entorno Python 2 o 3 con los argumentos --dos y --Tres respectivamente. De lo contrario, Pipenv usará cualquier defecto virtualenv hallazgos.

Nota al margen: Si usted requiere una versión más específico de Python, puede proporcionar un argumento --python con la versión que necesita. Por ejemplo: --python 3,6

Ahora puede instalar el paquete de 3 ª parte que necesita, frasco. Ah, pero usted sabe que se necesita la versión 0.12.1 y no a la última versión, así que adelante y sea específico:

$ pipenv install flask==0.12.1

Debería ver algo como lo siguiente en su terminal:

Adding flask==0.12.1 to Pipfile's [packages]...
Pipfile.lock not found, creating...

Se dará cuenta de que los dos archivos se creado, un Pipfile y Pipfile.lock. Vamos a echar un vistazo más de cerca a estos en un segundo. Vamos a instalar otra tercera paquete de fiesta, numpy, para algunos cálculos numéricos. Usted no necesita una versión específica por lo que no especificó una:

$ pipenv install numpy

Si desea instalar algo directamente desde un sistema de control de versiones (VCS), se puede! Se especifican las ubicaciones de manera similar a cómo se haría lo mismo con PIP. Por ejemplo, para instalar la biblioteca de peticiones de control de versiones, haga lo siguiente:

$ pipenv install -e git+https://github.com/requests/requests.git#egg=requests

Tenga en cuenta el argumento -e arriba para hacer la instalación editable. Actualmente, esto se requiere para hacer Pipenv resolución sub-dependencia. digamos de

permiten también tienen algunas pruebas unitarias para esta aplicación impresionante, y que desea utilizar PYtest para el funcionamiento de ellos. No es necesario PYtest en la producción para que pueda especificar que esta dependencia es sólo para el desarrollo con el argumento --dev:

$ pipenv install pytest --dev

Proporcionar el argumento --dev pondrá a la dependencia en un especial [dev-paquetes] ubicación en el Pipfile. Estos paquetes de desarrollo solamente se instalan si se especifica el argumento --dev con pipenv instalar.

Las diferentes secciones se separan dependencias necesarias sólo para el desarrollo de los necesarios para el código base para realmente trabajo. Por lo general, esto se logra con archivos requisitos adicionales como dev-requirements.txt o prueba de requirements.txt. Ahora, todo lo que se consolida en una sola Pipfile bajo diferentes secciones.

bien, así que digamos que tienes todo de trabajo en su entorno de desarrollo local y ya está listo para empujarlo a la producción. Para ello, es necesario bloquear su entorno para que pueda asegurarse de que tiene la misma en la producción:

$ pipenv lock

Esto creará / actualizar su Pipfile.lock, que nunca necesita (y no están destinados a) edición a mano. Siempre debe usar el archivo generado.

Ahora, una vez que obtenga su código y Pipfile.lock en su entorno de producción, debe instalar el último entorno de éxito registrado:

$ pipenv install --ignore-pipfile

Esto le dice Pipenv ignorar el Pipfile para la instalación y el uso del contenido de la Pipfile.lock. Teniendo en cuenta esto Pipfile.lock, Pipenv creará exactamente el mismo entorno que tenías cuando ejecutó bloqueo pipenv, sub-dependencias y todo. archivo de bloqueo

El permite determinista construye tomando una instantánea de todas las versiones de los paquetes en un entorno (similar al resultado de la congelación de pip).

Ahora digamos que otro desarrollador quiere hacer algunas adiciones a su código. En esta situación, que obtendrían el código, incluyendo el Pipfile, y utilizar este comando:

$ pipenv install --dev

Esto instala todas las dependencias necesarias para el desarrollo, que incluye tanto las dependencias regulares y aquellos que ha especificado con el argumento --dev durante la instalación.

Cuando una versión exacta no se especifica en la Pipfile, el comando de instalación da la oportunidad de dependencias (y sub-dependencias) para actualizar sus versiones.

Esta es una nota importante porque resuelve algunos de los problemas anteriores que hemos discutido. Para demostrarlo, supongamos que una nueva versión de una de sus dependencias se encuentre disponible. Debido a que no es necesario una versión específica de esta dependencia, no se especifica una versión exacta en el Pipfile. Cuando se instala pipenv, se instalará la nueva versión de la dependencia en su entorno de desarrollo.

Ahora se hacen los cambios en el código y ejecutar algunas pruebas para verificar todo está funcionando como se esperaba. (Usted tiene pruebas de unidad, ¿verdad?) Ahora, al igual que antes, se bloquea su entorno con cerradura pipenv, y un Pipfile.lock actualizada se generará con la nueva versión de la dependencia. Al igual que antes, puede replicar este nuevo entorno en la producción con el archivo de bloqueo.

Como se puede ver en este escenario, ya no tiene que forzar las versiones exactas que realmente no necesitan hacer para asegurar que sus entornos de desarrollo y producción son los mismos. También no es necesario estar al tanto de la actualización de sub-dependencias que “no se preocupan.” Este flujo de trabajo con Pipenv, combinado con su excelente ensayo, corrige los problemas de hacer manualmente toda la gestión de su dependencia. Resolución de Dependencia Enfoque de

Pipenv

Pipenv intentará instalar sub-dependencias que cumplen todos los requisitos de sus dependencias centrales. Sin embargo, si hay dependencias en conflicto (necesidades package_a package_c> = 1.0, pero package_b necesita package_c <1,0), Pipenv no será capaz de crear un archivo de bloqueo y la salida Wil un error como el siguiente:

Warning: Your dependencies could not be resolved. You likely have a mismatch in your sub-dependencies.
You can use $ pipenv install --skip-lock to bypass this mechanism, then run $ pipenv graph to inspect the situation.
Could not find a version that matches package_c>=1.0,package_c<1.0

Como dice la advertencia, también puede mostrar un gráfico de dependencias para entender sus dependencias de primer nivel y sus sub-dependencias:

$ pipenv graph

Este comando imprimirá un árbol-como la estructura mostrando sus dependencias. He aquí un ejemplo:

Flask==0.12.1
- click [required: >=2.0, installed: 6.7]
- itsdangerous [required: >=0.21, installed: 0.24]
- Jinja2 [required: >=2.4, installed: 2.10]
- MarkupSafe [required: >=0.23, installed: 1.0]
- Werkzeug [required: >=0.7, installed: 0.14.1]
numpy==1.14.1
pytest==3.4.1
- attrs [required: >=17.2.0, installed: 17.4.0]
- funcsigs [required: Any, installed: 1.0.2]
- pluggy [required: <0.7,>=0.5, installed: 0.6.0]
- py [required: >=1.5.0, installed: 1.5.2]
- setuptools [required: Any, installed: 38.5.1]
- six [required: >=1.10.0, installed: 1.11.0]
requests==2.18.4
- certifi [required: >=2017.4.17, installed: 2018.1.18]
- chardet [required: >=3.0.2,<3.1.0, installed: 3.0.4] - idna [required: >=2.5,<2.7, installed: 2.6] - urllib3 [required: <1.23,>=1.21.1, installed: 1.22]

Desde la salida del gráfico pipenv, se puede ver las dependencias de primer nivel que instalamos previamente (Frasco, numpy, PYtest y solicitudes), y por debajo se puede ver los paquetes que dependen.

Además, se puede invertir el árbol para mostrar las sub-dependencias con el padre que lo requiera:

$ pipenv graph --reverse

Esto revirtió árbol puede ser más útil cuando se está tratando de averiguar en conflicto sub-dependencias.

El Pipfile

Pipfile pretende reemplazar requirements.txt. Pipenv actualmente es la implementación de referencia para el uso de Pipfile. Parece muy probable que el PIP en sí será capaz de manejar estos archivos. Además, vale la pena señalar que Pipenv es aún la herramienta oficial de gestión de paquetes recomendado por sí Python.

La sintaxis de la Pipfile es TOML, y el archivo se separa en secciones. [Dev-paquetes] para los paquetes de desarrollo, sólo [Paquetes] para los paquetes mínimos requeridos, y [requiere] para otros requisitos como una versión específica de Python. Ver un archivo de ejemplo a continuación:

[[source]]
url = "https://pypi.python.org/simple"
verify_ssl = true
name = "pypi"

[dev-packages]
pytest = "*"

[packages]
flask = "==0.12.1"
numpy = "*"
requests = {git = "https://github.com/requests/requests.git", editable = true}

[requires]
python_version = "3.6"

Idealmente, usted no debe tener ningún sub-dependencias en su Pipfile. Lo que quiero decir con esto es que sólo debe incluir los paquetes que realmente importación y uso. No hay necesidad de mantener Chardet en su Pipfile sólo porque es un sub-dependencia de las solicitudes. (Pipenv lo instalará automáticamente.) El Pipfile debe transmitir el nivel superior Dependencias su paquete requiere.

El Pipfile.lock

Este archivo permite determinista construye mediante la especificación de los requisitos exactos para reproducir un ambiente. Contiene versiones exactas de los paquetes y los hashes para apoyar la verificación más seguro, que ahora es compatible con pip en sí también. Un ejemplo de archivo puede tener un aspecto como el siguiente. Tenga en cuenta que la sintaxis de este archivo es JSON y que he excluido partes del archivo con ...:

{
"_meta": {
...
},
"default": {
"flask": {
"hashes": [
"sha256:6c3130c8927109a08225993e4e503de4ac4f2678678ae211b33b519c622a7242",
"sha256:9dce4b6bfbb5b062181d3f7da8f727ff70c1156cbb4024351eafd426deb5fb88"
],
"version": "==0.12.1"
},
"requests": {
"editable": true,
"git": "https://github.com/requests/requests.git",
"ref": "4ea09e49f7d518d365e7c6f7ff6ed9ca70d6ec2e"
},
"werkzeug": {
"hashes": [
"sha256:d5da73735293558eb1651ee2fddc4d0dedcfa06538b8813a2e20011583c9e49b",
"sha256:c3fd7a7d41976d9f44db327260e263132466836cef6f91512889ed60ad26557c"
],
"version": "==0.14.1"
}
...
},
"develop": {
"pytest": {
"hashes": [
"sha256:8970e25181e15ab14ae895599a0a0e0ade7d1f1c4c8ca1072ce16f25526a184d",
"sha256:9ddcb879c8cc859d2540204b5399011f842e5e8823674bf429f70ada281b3cc6"
],
"version": "==3.4.1"
},
...
}
}

Tenga en cuenta la versión exacta especificada para cada dependencia. Incluso las sub-dependencias como werkzeug que no están en nuestra Pipfile aparecen en este Pipfile.lock. Los valores hash se utilizan para asegurarse de que está recuperando el mismo paquete como lo hizo en el desarrollo. el valor de

Se señalando de nuevo que nunca se debe cambiar este archivo manualmente. Está destinado a ser generado con cerradura pipenv.

Pipenv características adicionales

Abrir un paquete de terceros en su editor por defecto con el siguiente comando:

$ pipenv open flask

Esto abrirá el paquete frasco en el editor por defecto, o puede especificar un programa con una variable ambiental EDITOR. Por ejemplo, yo uso Sublime Text, por lo que sólo set editor = subl. Esto hace que sea muy fácil de cavar en la parte interna de un paquete que está utilizando.

Puede ejecutar un comando en el entorno virtual sin necesidad de iniciar un shell:

$ pipenv run

Compruebe si hay vulnerabilidades de seguridad (PEP 508 y requerimientos) en su entorno:

$ pipenv check

Ahora, digamos que ya no es necesario un paquete. Puede desinstalarlo:

$ pipenv uninstall numpy

Además, supongamos que desea eliminar por completo todos los paquetes instalados en su entorno virtual:

$ pipenv uninstall --all

Puede reemplazar --todos con --all-dev para paquetes dev acaba de quitar.

Pipenv soporta la carga automática de las variables ambientales cuando existe un archivo .env en el directorio de nivel superior. De esa manera, cuando pipenv Shell para abrir el entorno virtual, carga las variables ambientales del archivo. El archivo .env solo contiene pares de valores clave:

SOME_ENV_CONFIG=some_value
SOME_OTHER_ENV_CONFIG=some_other_value

Por último, he aquí algunos comandos rápidos para averiguar dónde está la materia. Cómo averiguar cuál es su entorno virtual es:

$ pipenv --venv

cómo averiguar cuál es su principal del proyecto es:

$ pipenv --where

paquete de distribución

Usted puede preguntarse cómo funciona todo esto, si se va a distribuir su código como un paquete.

Sí, necesito para distribuir el código como un paquete

¿Cómo funciona con archivos Pipenv setup.py?

Hay una gran cantidad de matices a esa pregunta. En primer lugar, un archivo setup.py es necesario cuando se está utilizando setuptools como su sistema de acumulación / distribución. Este ha sido el estándar de facto desde hace un tiempo, pero los cambios recientes han hecho que el uso de setuptools opcionales.

Esto significa que proyectos como el revoloteo puede utilizar la nueva pyproject.toml para especificar un sistema de construcción diferente que no requiere un setup.py.

dicho todo esto, para los cerca de setuptools futuras y un setup.py acompaña seguirán siendo la opción por defecto para muchas personas.

Aquí hay un flujo de trabajo recomendado para cuando se está utilizando un setup.py como una manera de distribuir el paquete:

  • setup.py
  • install_requires palabra clave debe incluir cualquiera que sea el paquete “mínimamente necesita para funcionar correctamente.”
  • Pipfile
  • representa los requisitos concretos para su paquete
  • Tire de las dependencias mínimamente necesarios de setup.py mediante la instalación de su paquete usando Pipenv: Uso pipenv instalar '-e .'That se traducirá en una línea en la que se ve algo Pipfile como "e1839a8" = {path = "", editable = true}.
  • Uso pipenv instalar '-e'.
  • que se traducirá en una línea en su Pipfile que se ve algo como "e1839a8" = {path = "", editable = true}.
  • Pipfile.lock
  • detalles para un entorno reproducible generado a partir de la cerradura pipenv
  • Uso pipenv instalar '-e'.
  • que se traducirá en una línea en su Pipfile que se ve algo como "e1839a8" = {path = "", editable = true}.

Para aclarar, poner los requisitos mínimos en setup.py en lugar de directamente con pipenv instalar. A continuación, utilice el pipenv instalar '-e'. comando para instalar el paquete como editable. Esto se lleva todos los requisitos de setup.py en su entorno. A continuación, puede utilizar el bloqueo de pipenv para conseguir un entorno reproducible.

No necesito para distribuir el código como un paquete

Gran! Si está desarrollando una aplicación que no está destinado a ser distribuido o instalado (web, una aplicación de escritorio, un juego, o similar), que realmente no necesita un setup.py.

En esta situación, se podría utilizar Pipfile / Pipfile.lock combinado para la gestión de sus dependencias con el flujo descrito anteriormente para desplegar un entorno reproducibles en la producción.

Ya tengo una requirements.txt. ¿Cómo se convierte a un Pipfile?

Si ejecuta pipenv instalarlo debe detectar automáticamente el requirements.txt y convertirlo en un Pipfile, dar salida a algo como lo siguiente:

requirements.txt found, instead of Pipfile! Converting…
Warning: Your Pipfile now contains pinned versions, if your requirements.txt did.
We recommend updating your Pipfile to specify the "*" version, instead.

Tomar nota de la advertencia anterior.

Si ha fijado versiones exactas en su archivo requirements.txt, probablemente querrá cambiar su Pipfile única para especificar las versiones exactas que realmente necesita. Esto le permitirá obtener los beneficios reales de la transición. Por ejemplo, digamos que usted tiene la siguiente, pero en realidad no es necesario que la versión exacta de numpy:

[packages]
numpy = "==1.14.1"

Si usted no tiene ningún requisito versión específica para sus dependencias, se puede utilizar el carácter comodín * para decir que cualquier Pipenv versión se puede instalar:

[packages]
numpy = "*"

Si se siente nervioso por lo que cualquier versión con el *, que es normalmente una apuesta segura para especificar mayor o igual a la versión que ya se encuentra en lo que aún puede aprovechar las nuevas versiones:

[packages]
numpy = ">=1.14.1"

por supuesto, mantenerse al día con las nuevas versiones también se quiere decir es responsable de asegurarse su código todavía funciona como se espera al cambio de paquetes. Esto significa que un conjunto de pruebas es esencial para todo este flujo Pipenv si usted quiere asegurarse de que funcione la liberación de su código.

Usted permite que los paquetes para actualizar, ejecutar las pruebas, asegurarse de que todo el paso, bloquear su entorno, y entonces usted puede estar tranquilo sabiendo que usted no ha introducido cambios de última hora. Si las cosas se rompen debido a la dependencia, que tienes unas pruebas de regresión para escribir y potencialmente algunos más restricciones a las versiones de las dependencias.

Por ejemplo, si numpy == 1.15 se instala después de ejecutar pipenv instalar y te rompe el código, que es de esperar que sea previo aviso durante el desarrollo o durante sus pruebas, usted tiene un par de opciones:

actualizar el código de función con el nuevo versión de la dependencia.

Si la compatibilidad con versiones anteriores de la dependencia no es posible, también tendrá que golpearlo con la versión requerida en su Pipfile:

[packages]
numpy = ">=1.15"

Restringir la versión de la dependencia en el Pipfile ser

[packages]
numpy = ">=1.14.1,<1.15"

Opción 1 se prefiere ya que asegura que su código está utilizando la mayoría de las dependencias en marcha hasta la fecha. Sin embargo, la opción 2 toma menos tiempo y no requiere cambios en el código, sólo las restricciones a las dependencias.

También puede instalar desde los ficheros de necesidades con el mismo argumento -r pip toma:

$ pipenv install -r requirements.txt

Si usted tiene un dev-requirements.txt o algo similar, puede agregar los al Pipfile también. Sólo tiene que añadir el argumento --dev así que se puso en la sección derecha:

$ pipenv install -r dev-requirements.txt --dev

Además, se puede ir a otro lado y generar archivos requisitos de una Pipfile:

$ pipenv lock -r > requirements.txt
$ pipenv lock -r -d > dev-requirements.txt

¿qué sigue?

Me parece que una progresión natural para el ecosistema Python sería un sistema de construcción que utiliza el Pipfile para instalar las dependencias mínimamente requeridos cuando se recuperan y la construcción de un paquete de un índice de paquetes (como PyPI). Es importante tener en cuenta una vez más que la especificación de diseño Pipfile está todavía en desarrollo, y Pipenv es sólo una implementación de referencia.

Una vez dicho esto, pude ver un futuro en el que no existe la sección de install_requires setup.py, y el Pipfile se hace referencia a los requisitos mínimos en su lugar. O el setup.py ha desaparecido por completo, y se obtiene los metadatos y otra información de una manera diferente, sigue utilizando el Pipfile para obtener las dependencias necesarias. vale la pena

Is Pipenv retirar?

Definitivamente. Incluso si es sólo como una forma de consolidar las herramientas que ya utiliza (PIP) y virtualenv en una única interfaz. Sin embargo, es mucho más que eso. Con la adición de la Pipfile, sólo especifica las dependencias que realmente necesita.

Ya no tendrá el dolor de cabeza de la gestión de las versiones de todo usted mismo sólo para asegurarse de que puede replicar su entorno de desarrollo. Con la Pipfile.lock, se puede desarrollar con la tranquilidad de saber que se puede reproducir exactamente el entorno de cualquier lugar.

Además de todo eso, parece muy probable que el formato Pipfile conseguirá adoptado y con el apoyo de herramientas oficial de Python como PIP, por lo que sería beneficioso para estar por delante del juego. Ah, y asegurarse de que está actualizando todo el código a Python 3, así: 2020 se acerca rápidamente. Referencias

, otras lecturas, discusiones interesantes, y así sucesivamente documentación

  • Pipenv Oficial
  • Pipfile Oficial Proyecto
  • Edición abordar install_requires en lo que respecta a Pipfile
  • Más discusión sobre setup.py vs Pipfile
  • post hablando de PEP 518
  • Publicar en Python envasado
  • comentario a lo que sugiere el uso Pipenv Bono

gratuito: Haga clic aquí para obtener acceso a una clase gratuita de 5 días de duración que muestra cómo evitar problemas de gestión de la dependencia común con herramientas como Pip, PyPI, virtualenv y archivos de requisitos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *