book

Hypermodern Python Tooling

by Claudio Jolowicz

June 2024

Intermediate to advanced

270 pages

6h 40m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Includes

Has Sandbox

Who Should Read This Book?How This Book Is OrganizedReferences and Further ReadingConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
Supporting Multiple Versions of PythonLocating Python InterpretersInstalling Python on WindowsThe Python Launcher for WindowsInstalling Python on macOSHomebrew PythonThe python.org InstallersInstalling Python on LinuxFedora LinuxUbuntu LinuxOther Linux DistributionsThe Python Launcher for UnixInstalling Python with pyenvInstalling Python from AnacondaA Brave New World: Installing with Hatch and RyeAn Overview of InstallersSummary
A Tour of Python EnvironmentsPython InstallationsThe Per-User EnvironmentVirtual EnvironmentsInstalling Applications with pipxpipx in a NutshellInstalling pipxManaging Applications with pipxRunning Applications with pipxConfiguring pipxManaging Environments with uvFinding Python ModulesModule ObjectsThe Module CacheModule SpecsFinders and LoadersThe Module PathSite PackagesBack to the BasicsSummary
The Package LifecycleAn Example ApplicationWhy Packaging?The pyproject.toml FileBuilding Packages with buildUploading Packages with TwineInstalling Projects from SourceProject LayoutManaging Packages with RyeWheels and SdistsProject MetadataNaming ProjectsVersioning ProjectsDynamic FieldsEntry-Point ScriptsEntry PointsAuthors and MaintainersThe Description and READMEKeywords and ClassifiersThe Project URLsThe LicenseThe Required Python VersionDependencies and Optional DependenciesSummary
Adding Dependencies to the Example ApplicationConsuming an API with HTTPXConsole Output with RichSpecifying Dependencies for a ProjectVersion SpecifiersExtrasEnvironment MarkersDevelopment DependenciesAn Example: Testing with pytestOptional DependenciesRequirements FilesLocking DependenciesFreezing Requirements with pip and uvCompiling Requirements with pip-tools and uvSummary
Installing PoetryCreating a ProjectThe Project MetadataThe Package ContentsThe Source CodeManaging DependenciesCaret ConstraintsExtras and Environment MarkersThe Lock FileUpdating DependenciesManaging EnvironmentsDependency GroupsPackage RepositoriesPublishing Packages to Package RepositoriesFetching Packages from Package SourcesExtending Poetry with PluginsGenerating Requirements Files with the Export PluginDeploying Environments with the Bundle PluginThe Dynamic Versioning PluginSummary
Writing a TestManaging Test DependenciesDesigning for TestabilityFixtures and ParameterizationAdvanced Techniques for FixturesExtending pytest with PluginsThe pytest-httpserver PluginThe pytest-xdist PluginThe factory-boy and faker LibrariesOther PluginsSummary

Using Coverage.pyBranch CoverageTesting in Multiple EnvironmentsParallel CoverageMeasuring in SubprocessesWhat Coverage to Aim ForSummary
First Steps with NoxWorking with SessionsWorking with Multiple Python InterpretersSession ArgumentsAutomating CoverageSession NotificationAutomating Coverage in SubprocessesParameterizing SessionsSession DependenciesUsing Nox with Poetry ProjectsLocking Dependencies with nox-poetrySummary
Linting BasicsThe Ruff LinterPyflakes and pycodestyleFantastic Linters and Where to Find ThemDisabling Rules and WarningsAutomation with NoxThe pre-commit FrameworkFirst Steps with pre-commitA Hook Up CloseAutomatic FixesRunning pre-commit from NoxRunning pre-commit from GitThe Ruff FormatterApproaches to Code Formatting: autopep8Approaches to Code Formatting: YAPFAn Uncompromising Code FormatterThe Black Code StyleFormatting Code with RuffSummary
Benefits and Costs of Type AnnotationsA Brief Tour of Python’s Typing LanguageVariable AnnotationsThe Subtype RelationUnion TypesGradual TypingFunction AnnotationsAnnotating ClassesType AliasesGenericsProtocolsCompatibility with Older Python VersionsStatic Type Checking with mypyFirst Steps with mypyRevisiting the Wikipedia ExampleStrict ModeAutomating mypy with NoxDistributing Types with Python PackagesType Checking the TestsInspecting Type Annotations at RuntimeWriting a @dataclass DecoratorRuntime Type CheckingSerialization and Deserialization with cattrsRuntime Type Checking with TypeguardSummary

Content preview from Hypermodern Python Tooling

Chapter 5. Managing Projects with Poetry

The preceding chapters introduced the building blocks for publishing production-quality Python packages. So far, you’ve written a pyproject.toml for a project; created an environment and installed dependencies with uv, pip, or pip-tools; and built and published packages with build and Twine.

By standardizing project metadata and build backends, pyproject.toml broke the setuptools monopoly (see “The Evolution of Python Project Managers”) and brought diversity to the packaging ecosystem. Defining a Python package got easier, too: a single well-specified file with great tooling support replaces the legacy boilerplate of setup.py and untold configuration files.

Yet, some problems remain.

Before you can work on a pyproject.toml-based project, you need to research packaging workflows, configuration files, and associated tooling. You have to choose one of a number of available build backends (Table 3-2)—and many people don’t know what those are, let alone how to choose them. Important aspects of Python packages remain unspecified—for example, how project sources are laid out and which files should go into the packaging artifacts.

Dependency and environment management could be easier, too. You need to handcraft your dependency specifications and compile them with pip-tools, cluttering your project with requirements files. And it can be hard to keep track of the many Python environments on a typical developer system.

The Python project manager ...