Quatre outils de gestion de projet et de construction Python, collection recommandée !

Python ne dispose pas d'un outil de gestion de projet et de construction standard de facto depuis si longtemps, ce qui entraîne une variété de structures de projet et de méthodes de construction Python. Cela peut refléter le libre arbitre de Python.

Contrairement à Java, qui est passé par une construction manuelle initiale, à Ant semi-automatisé, puis à Maven, il s'agit fondamentalement du standard de facto. Au cours de cette période, Maven a également accepté les défis d'autres Gradle (principalement promus par des projets Android), SBT (principalement des projets Scala), Ant+Ivy, Buildr, etc., mais il était difficile d'ébranler le statut de Maven dans le monde et des autres. a presque suivi la disposition du répertoire de Maven.

De retour en Python, il existait des outils de gestion de packages comme pip, pipenv et conda, mais il n'y avait aucun accord sur la disposition des répertoires du projet.

De nombreux aspects de la construction suivent toujours la méthode traditionnelle Makefile, puis ajoutez setup.py et build.py pour utiliser le code du programme pour installer et construire. Concernant la disposition du répertoire de projet, certains créent des modèles de projet, puis créent des outils pour appliquer les modèles de projet.

Ce qui suit est un bref aperçu de l'utilisation de quatre outils

1. CookieCutter
   
2. PyScaffold
   
3. PyBuilder
   
4. Poetry
   

CookieCutter Une structure de répertoires de projet Python classique

$ pip install cookiecutter
$ cookiecutter gh:audreyr/cookiecutter-pypackage
# 以 github 上的 audreyr/cookiecutter-pypackage 为模板，再回答一堆的问题生成一个 Python 项目
......
project_name [Python Boilerplate]: sample
......

Dernière génération par cookiecutter Le modèle de projet ressemble à ceci :

$ tree sample
sample
├── AUTHORS.rst
├── CONTRIBUTING.rst
├── HISTORY.rst
├── LICENSE
├── MANIFEST.in
├── Makefile
├── README.rst
├── docs
│ ├── Makefile
│ ├── authors.rst
│ ├── conf.py
│ ├── contributing.rst
│ ├── history.rst
│ ├── index.rst
│ ├── installation.rst
│ ├── make.bat
│ ├── readme.rst
│ └── usage.rst
├── requirements_dev.txt
├── sample
│ ├── __init__.py
│ ├── cli.py
│ └── sample.py
├── setup.cfg
├── setup.py
├── tests
│ ├── __init__.py
│ └── test_sample.py
└── tox.ini
3 directories, 26 files

Il s'agit probablement du cadre principal de la structure de répertoires actuellement populaire. Les principaux éléments sont :

$ tree sample
sample
├── Makefile
├── README.rst
├── docs
│ └── index.rst
├── requirements.txt
├── sample
│ ├── __init__.py
│ └── sample.py
├── setup.cfg
├── setup.py
└── tests
 ├── __init__.py
 └── test_sample.py

Le répertoire d'exemple de projet est répété. Les fichiers sources Python sont placés dans le répertoire d'exemple. et les fichiers de test sont placés dans le répertoire tests. Ajoutez un répertoire docs pour stocker la documentation, README.rst et d'autres fichiers d'installation, setup.cfg et Makefile pour la construction.

Il s'agit en fait d'une structure de projet Python très classique. La prochaine build utilise la commande make Entrez make et vous verrez les instructions définies dans le fichier Makefile.

$ make
cleanremove all build, test, coverage and Python artifacts
clean-buildremove build artifacts
clean-pycremove Python file artifacts
clean-test remove test and coverage artifacts
lint check style
test run tests quickly with the default Python
test-all run tests on every Python version with tox
coverage check code coverage quickly with the default Python
docs generate Sphinx HTML documentation, including API docs
servedocscompile the docs watching for changes
releasepackage and upload a release
dist builds source and wheel package
installinstall the package to the active Python's site-packages

Pour utiliser le processus de construction ci-dessus, vous devez installer les packages correspondants, tels que tox, wheel, cover, sphinx, flake8, ils peuvent tous être installés via pip. Ensuite, vous pouvez faire des tests, créer une couverture, créer des documents, créer une distribution, etc. Parmi eux, make docs peut générer un beau document web.

PyScaffold Créer un projet

PyScaffold Comme son nom l'indique, il s'agit d'un outil utilisé pour créer un échafaudage pour les projets Python. Installer et utiliser :

$ pip install pyscaffold
$ putup sample

Un projet Python est créé de cette manière. le modèle sélectionné par cookiecutter plus tôt. C'est juste qu'il place les fichiers sources dans le répertoire src au lieu du répertoire exemple.

$ tree sample
sample
├── AUTHORS.rst
├── CHANGELOG.rst
├── CONTRIBUTING.rst
├── LICENSE.txt
├── README.rst
├── docs
│ ├── Makefile
│ ├── _static
│ ├── authors.rst
│ ├── changelog.rst
│ ├── conf.py
│ ├── contributing.rst
│ ├── index.rst
│ ├── license.rst
│ ├── readme.rst
│ └── requirements.txt
├── pyproject.toml
├── setup.cfg
├── setup.py
├── src
│ └── sample
│ ├── __init__.py
│ └── skeleton.py
├── tests
│ ├── conftest.py
│ └── test_skeleton.py
└── tox.ini

Tox est l'outil utilisé pour construire l'ensemble du projet. tox est un outil de test et de construction automatisé qui crée un environnement virtuel Python pendant le processus de construction, permettant un environnement propre pour les tests et la construction.

tox -av peut afficher toutes les tâches définies dans tox.ini :

$ tox -av
default environments:
default -> Invoke pytest to run automated tests
additional environments:
build -> Build the package in isolation according to PEP517, see https://github.com/pypa/build
clean -> Remove old distribution files and temporary build artifacts (./build and ./dist)
docs-> Invoke sphinx-build to build the docs
doctests-> Invoke sphinx-build to run doctests
linkcheck -> Check for broken links in the documentation
publish -> Publish the package you have been developing to a package index server. By default, it uses testpypi. If you really want to publish your package to be publicly accessible in PyPI, use the `-- --repository pypi` option.

Utilisez tox -e build, tox -e docs, etc. quelle commande exécuter

Au cours de mon expérience avec la commande tox, à chaque fois Chaque étape semble lente. La création d'une machine virtuelle devrait prendre un certain temps.

PyBuilder

Il est préférable de regarder un autre outil de build PyBuilder. La structure de répertoires qu'il crée est très proche de Maven Jetons un coup d'œil

$ pip install pybuilder
$ mkdir sample && cd sample# 项目目录需手工创建
$ pyb --start-project# 回答一些问题后创建所需的目录和文件

Après avoir terminé, jetez un œil à sa structure de répertoires :

$ tree sample
.
├── build.py
├── docs
├── pyproject.toml
├── setup.py
└── src
 ├── main
 │ ├── python
 │ └── scripts
 └── unittest
 └── python

Build. process Toujours en utilisant la commande pyb, vous pouvez utiliser pyb -h pour afficher l'aide, et pyb -t pour lister toutes les tâches PyBuilder ajoutées sous forme de plug-ins, et la configuration du plug-in est dans la build. fichier py.

$ pyb -t sample
Tasks found for project "sample":
 analyze -Execute analysis plugins.
 depends on tasks: prepare run_unit_tests
 clean - Cleans the generated output.
 compile_sources - Compiles source files that need compilation.
 depends on tasks: prepare
coverage - <no description available>
 depends on tasks: verify
 install - Installs the published project.
 depends on tasks: package publish(optional)
 package - Packages the application. Package a python application.
 depends on tasks: compile_sources run_unit_tests(optional)
 prepare - Prepares the project for building. Creates target VEnvs
 print_module_path - Print the module path.
print_scripts_path - Print the script path.
 publish - Publishes the project.
 depends on tasks: package verify(optional) coverage(optional)
 run_integration_tests - Runs integration tests on the packaged application.
 depends on tasks: package
run_unit_tests - Runs all unit tests. Runs unit tests based on Python's unittest module
 depends on tasks: compile_sources
upload - Upload a project to PyPi.
verify - Verifies the project and possibly integration tests.
 depends on tasks: run_integration_tests(optional)
$ pyb run_unit_tests sample

PyBuilder crée également un environnement virtuel avant de construire ou de tester. À partir de la version 0.12.9, vous pouvez ignorer l'étape de création d'un environnement virtuel via le paramètre --no-venvs. Si --no-venvs est utilisé, le code Python sera exécuté dans l'environnement Python actuel exécutant pyb et les dépendances requises devront être installées manuellement.

Les dépendances du projet doivent également être définies dans le fichier build.py.

@init
def set_properties(project):
 project.depends_on('boto3', '>=1.18.52')
 project.build_depends_on('mock')

Les dépendances ci-dessus seront installées lorsque pyb sera exécuté pour créer un environnement virtuel, et les tests et les builds y seront exécutés.

Poésie

La dernière poésie, je pense qu'il s'agit d'une version Python plus mature avec une activité de projet plus élevée. Elle a des fonctions de gestion de confiance plus puissantes. Utilisez la poésie add boto3 pour ajouter des dépendances, la poésie show - -tree montre l'arbre des dépendances. . Jetez un œil à comment installer et créer un projet

$ pip install poetry
$ poetry new sample

Le projet qu'il crée est plus simple que celui ci-dessus

$ tree sample
sample
├── README.rst
├── pyproject.toml
├── sample
│ └── __init__.py
└── tests
 ├── __init__.py
 └── test_sample.py

Si vous donnez de la poésie nouvelle avec le paramètre --src, l'échantillon du répertoire du fichier source sera placé dans le répertoire src , c'est-à-dire sample/src/ sample.

poetry init générera le fichier pyproject.toml dans le répertoire actuel et la génération des répertoires doit être effectuée manuellement.

Il ne se concentre pas sur la génération de documents, la vérification des spécifications du code ou la couverture du code. Sa configuration de projet est plus centralisée, le tout dans le fichier pyproject.toml. Qu'est-ce que toml ? Il s'agit d'un format de fichier de configuration Tom's Obvious, Minimal Language (https://github.com/toml-lang/toml).

pyproject.toml est quelque peu similaire au fichier package.json de NodeJS, tel que l'ajout de poésie, l'installation de poésie Ligne de commandement

# 往 pyproject.toml 中添加对boto3 的依赖并安装(add 还能从本地或 git 来安装依赖 ),
poetry add boto3
# 将依照 pyproject.toml 文件中定义安装相应的依赖到当前的 Python 虚拟环境中
# 比如在 <test-venv>/lib/python3.9/site-packages 目录中，安装好模块后也可让测试用例使用
poetry install

其他主要的

1.poetry build# 构建可安装的 *.whl 和 tar.gz 文件
2.poetry shell# 会根据定义在 pyproject.toml 文件中的依赖创建并使用虚拟环境
3.poetry run pytest# 运行使用 pytest 的测试用例，如 tests/test_sample.py
4.poetry run python -m unittest tests/sample_tests.py# 运行 unittest 测试用例
5.poetry export --without-hashes --output requirements.txt# 导出 requirements.txt 文件, --dev导出含 dev 的依赖，或者用 poetry export --without-hashes > requirements.txt

poetry run 能执行任何系统命令，只是它会在它要的虚拟环境中执行。所以可以想见，poetry 的项目要生成文档或覆盖率都必须用 poetry run ... 命令来支持 sphinx, coverage 或 flake8。

在 sample 目录(与 pyproject.toml 文件平级)中创建文件 my_module.py, 内容为

def main():
 print('hello poetry')

然后在 pyproject.toml 中写上。

[tool.poetry.scripts]
my-script="sample.my_module:main"

再执行

$ poetry run my-script

就会输出 "hello poetry"。

通过对以上四个工具的认识，项目结构的复杂度由 cookiecutter-pyproject -> PyScaffold -> PyBuilder -> Poetry 依次降低，使用的难度大略也是相同的顺序

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!