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 4. Dependency Management

Python programmers benefit from a rich ecosystem of third-party libraries and tools. Standing on the shoulders of giants comes at a price: the packages you depend on for your projects generally depend on a number of packages themselves. All of these are moving targets—as long as any project is alive, its maintainers will publish a stream of releases to fix bugs, add features, and adapt to the evolving ecosystem.

Managing dependencies is a major challenge when you maintain software over time. You need to keep your project up-to-date, if only to close security vulnerabilities in a timely fashion. Often this requires updating your dependencies to the latest version—few open source projects have the resources to distribute security updates for older releases. You’ll be updating dependencies all the time! Making the process as frictionless, automated, and reliable as possible comes with a huge payoff.

Dependencies of a Python project are the third-party packages that must be installed in its environment.¹ Most commonly, you incur a dependency on a package because it distributes a module you import. We also say that the project requires a package.

Many projects also use third-party tools for developer tasks—like running the test suite or building documentation. These packages are known as development dependencies: end users don’t need them to run your code. A related case is the build dependencies from Chapter 3, which let you create packages for ...