Pyright - Detailed Review
Developer Tools
Pyright - Product Overview
Introduction to Pyright
Pyright is a static type checker and language server specifically designed for Python, developed by Microsoft. Here’s a brief overview of its primary function, target audience, and key features:Primary Function
Pyright’s main purpose is to perform static type checking for Python code. It helps developers identify type-related errors and inconsistencies in their codebase before runtime, enhancing code quality and reliability.Target Audience
Pyright is aimed at Python developers, particularly those working on large and complex projects. This includes library maintainers, developers of production applications, and data scientists who need to ensure the integrity and maintainability of their code.Key Features
Speed and Performance
Pyright is optimized for speed, making it particularly suitable for large Python source bases. It can run in a “watch” mode, performing fast incremental updates when files are modified, which is significantly faster than other type checkers like mypy, often 3x to 5x faster.Configurability
Pyright supports detailed configuration through configuration files, allowing different execution environments to be set up for subdirectories within a source base. This includes specifying module search paths, Python language versions, and platform targets.Type Checking Features
Pyright supports a wide range of type checking features, including PEP 484 type hints, generics, structural subtyping, and many other advanced typing features defined in various PEPs (Python Enhancement Proposals). It also includes type inference for function return values, instance variables, class variables, and globals.Language Server Support
Pyright functions as a language server, providing features such as intelligent type completion, automatic import statements, signature completion tips, hover-over type information and docstrings, find definitions and references, rename symbols, and view call hierarchy information. It also includes tools like organize imports and type stub generation for third-party libraries.Built-in Type Stubs
Pyright includes recent stdlib type stubs from Typeshed and can be configured to use custom or modified type stub files. This ensures comprehensive type checking even for standard library and third-party modules.Integration and Automation
Pyright can be integrated into development workflows using tools like pre-commit, allowing it to run automatically before each commit. It also supports automatic updates and can be configured using environment variables to customize its behavior. In summary, Pyright is a powerful tool for Python developers that enhances code quality through fast and comprehensive type checking, while also providing a rich set of features to improve programming efficiency. Pyright - User Interface and Experience
User Interface of Pyright
Pyright, developed by Microsoft, is a fast and lightweight Python type checker and language server that integrates seamlessly into various development environments. Here’s a breakdown of its user interface and overall user experience:Integration with IDEs and Editors
Pyright is designed to work effortlessly with popular integrated development environments (IDEs) and editors such as Visual Studio Code, Visual Studio, and JetBrains IDEs. This integration allows developers to receive real-time feedback and assistance directly within their coding environment.Real-Time Feedback
One of the key features of Pyright is its ability to provide real-time feedback on type-related issues, syntax errors, and other code anomalies. This feedback is delivered as you write your code, helping you catch bugs and errors early in the development process. This real-time interaction enhances the coding experience by reducing the time spent on debugging and improving code quality.Code Completion and Suggestions
Pyright offers intelligent code completion suggestions for keywords, symbols, and import names. It also automatically inserts import statements when necessary, which streamlines the coding process and helps developers write code more efficiently. Additionally, it provides signature completion tips, making it easier to fill in arguments for function calls.Hover and Documentation
When you hover over symbols in your code, Pyright displays type information and docstrings, providing immediate context and documentation without the need to navigate away from your current work.Navigation and Refactoring
Pyright includes several navigation features such as “Find Definitions” to quickly locate the definition of a symbol, “Find References” to identify all references to a symbol, and “Rename Symbol” to rename all references to a symbol across the code base. These features make it easier to manage and refactor code.Organize Imports
The “Organize Imports” command helps in automatically ordering imports according to PEP8 rules, keeping the code organized and adhering to best practices.Configuration and Customization
Pyright supports configuration files (e.g., `pyrightconfig.json` or `pyproject.toml`) that allow for granular control over settings. Developers can define different execution environments for subdirectories within a source base, specifying module search paths, Python language versions, and platform targets. This flexibility ensures that Pyright can be adapted to fit the specific needs of various projects.Ease of Use
- Installation: Pyright is relatively easy to install using pip, and it can be set up to run as a standalone tool or integrated into an IDE. The installation process is straightforward, and there are also wrappers available to simplify the installation for Python developers who may not have Node.js installed.
- Real-Time Feedback: The real-time nature of Pyright’s feedback makes it easy for developers to identify and fix issues as they arise, which can significantly improve the development speed and reduce the number of bugs in the final solution.
- Minimal Resource Usage: Pyright is known for being fast and lightweight, which means it does not slow down the development process or affect system performance. This makes it an efficient tool to use alongside other development tools.
Overall User Experience
The overall user experience with Pyright is positive due to its speed, real-time feedback, and seamless integration with popular IDEs. Here are some key points:- Efficiency: Pyright enhances developer efficiency by providing immediate feedback on type issues and syntax errors, allowing for quicker bug fixing and code improvement.
- Ease of Integration: The tool integrates well with various development environments, making it easy to incorporate into existing workflows.
- Customization: The ability to customize settings through configuration files ensures that Pyright can be tailored to the specific needs of different projects.
- Complementary Tools: While Pyright excels at type checking, it is recommended to use it alongside other linting tools to ensure a comprehensive analysis of code quality. This combination can provide a more thorough review of the codebase.
Pyright - Key Features and Functionality
Pyright Overview
Pyright, developed by Microsoft, is a powerful static type checker for Python that offers a range of features to enhance developer productivity and code quality. Here are the main features and how they work:Speed and Performance
Pyright is optimized for speed, making it suitable for large Python source bases. It can run in a “watch” mode, performing fast incremental updates when files are modified. This feature ensures that type checking is efficient and does not slow down the development process.Configurability
Pyright supports configuration files that provide granular control over settings for different execution environments within a source base. This allows developers to specify different module search paths, Python language versions, and platform targets for various subdirectories. This flexibility is crucial for managing complex projects with diverse requirements.Type Checking Features
Pyright implements a wide range of type checking features based on various Python Enhancement Proposals (PEPs). Some key features include:- Type Hints and Annotations: Supports PEP 484 type hints, including generics in standard collections (PEP 585), literal types (PEP 586), and typed dictionaries (PEP 589).
- Generics and Structural Subtyping: Includes support for PEP 544 structural subtyping and PEP 646 variadic generics, which enhance the expressiveness of type hints.
- Type Guards and Inference: Pyright understands conditional code flow constructs like if/else statements and performs type inference for function return values, instance variables, class variables, and globals.
- Deprecation and Final Qualifier: Allows marking deprecations (PEP 702) and using the final qualifier (PEP 591) to indicate that a variable or attribute should not be overridden.
Language Server Support
Pyright functions as both a command-line tool and a language server, providing several features to improve programming efficiency:- Intelligent Code Completion: Offers type completion of keywords, symbols, and import names.
- Automatic Import Statements: Automatically inserts import statements when necessary.
- Signature Completion Tips: Provides tips when filling in arguments for a call.
- Hover Information: Displays type information and docstrings when hovering over symbols.
- Find Definitions and References: Quickly locate the definition of a symbol or find all references to it within the code base.
- Rename Symbol: Renames all references to a symbol within the code base.
- Organize Imports: Automatically orders imports according to PEP8 rules.
Built-in Type Stubs
Pyright includes a recent copy of the stdlib type stubs from Typeshed and can be configured to use other versions or custom type stub files. This ensures accurate type checking for standard library and third-party modules.Continuous Integration (CI) Integration
Pyright can be integrated into CI pipelines using GitHub Actions or GitLab CI. This allows developers to automate type checking as part of their build process, ensuring code quality and consistency across the project. For example, you can configure Pyright to run as a GitHub Action or generate code quality reports in GitLab.AI Integration
While Pyright itself is not an AI-driven product in the sense of using machine learning or natural language processing, it leverages advanced algorithms and data structures to provide fast and accurate type checking. The efficiency and speed of Pyright can be seen as a form of “intelligence” in how it handles large codebases and complex type systems, but it does not involve AI technologies like those used in generative AI models.Conclusion
In summary, Pyright enhances developer productivity through its speed, configurability, comprehensive type checking features, and seamless integration with development tools and CI pipelines. These features collectively contribute to better code quality and maintenance without the need for explicit AI integration. Pyright - Performance and Accuracy
Performance
Pyright is notable for its high performance, particularly when dealing with large Python source bases. It has been optimized to provide quick feedback on type-related issues, making it significantly faster than other tools like Pylint. In performance tests, Pyright was found to be the fastest type checker, analyzing entire codebases in less than three minutes.Accuracy
In terms of accuracy, Pyright demonstrates strong capabilities in type checking and inference. It catches more errors than other type checkers like Pyre and Mypy, especially in areas such as type narrowing and inference. For instance, Pyright applies type narrowing for variable assignments regardless of whether the assignment includes a type annotation, which is considered more consistent behavior compared to Mypy. Pyright also supports several built-in type guards that Mypy does not, including guards for literal comparisons, membership tests, and boolean expressions. This comprehensive support for type guards enhances its accuracy in detecting type-related errors.Type Inference
Pyright’s type inference rules differ from Mypy’s in several beneficial ways. For example, Pyright retains literal types in tuple expressions, which is more precise and beneficial due to the immutable nature of tuples. In contrast, Mypy widens these types to their non-literal forms. For list, set, and dict expressions with heterogeneous types, Pyright uses unions or `Unknown` types depending on the configuration, avoiding the false positives that Mypy’s join operator can introduce.Limitations and Areas for Improvement
Despite its strengths, Pyright has some limitations. One notable area is its handling of circular references, where it may struggle with certain forms of circularities that Mypy can resolve. For example, Pyright may not handle class declarations that reference a metaclass whose declaration depends on the class, or class decorators that use the class in their own signature. Another limitation is that Pyright does not model implicit side effects of the Python import loading mechanism, treating such dependencies as errors. This is in contrast to Mypy, which models these side effects but may allow potentially unsafe code. Additionally, while Pyright is highly effective in type checking, its focus on this area means it may not cover other aspects of code quality as comprehensively as tools like Pylint. Developers may need to use complementary linting tools to ensure a thorough analysis of their code.Integration and Usage
Pyright is built on the Language Server Protocol, which makes it easy to integrate with various text editors and IDEs, providing real-time feedback on type-related issues. This integration is similar to what Pylint offers, but Pyright’s focus on type checking makes it particularly useful for developers who need precise and fast type analysis.Conclusion
In summary, Pyright offers exceptional performance and accuracy in type checking and inference, making it a valuable tool for Python developers. However, it has specific limitations, particularly in handling certain circular references and implicit import side effects, and it may need to be used alongside other linting tools for a comprehensive code analysis. Pyright - Pricing and Plans
Pricing Structure
When it comes to the pricing structure of Pyright, a static type checker for Python developed by Microsoft, there is a key point to note: Pyright is free and open-source.Free and Open-Source
Pyright does not have different pricing tiers or plans. It is completely free to use and is available for installation through various methods such as:Installation Methods
- Using Pip: `pip install pyright`
- Using Conda: `conda install pyright`
- Using NPM: `sudo npm install -g pyright`
Features
Since Pyright is free, all its features are available without any cost. These features include:Available Features
- Syntax for variable annotations
- Type-hinting generics in standard collections
- Literal types
- Typed dictionaries
- Type parameter syntax
- Override decorator for static typing
- Marking deprecations
- TypedDict: read-only items
- Performance-oriented type checking, including fast incremental updates in “watch” mode.
Conclusion
In summary, Pyright does not have multiple pricing plans or tiers; it is a completely free tool with all its features available to users at no cost. Pyright - Integration and Compatibility
Pyright Overview
Pyright, a static type checker for Python developed by Microsoft, integrates seamlessly with various developer tools and platforms, ensuring broad compatibility and usability.
Integration with IDEs and Editors
Pyright can be integrated with several popular Integrated Development Environments (IDEs) and editors. For instance, it is included as part of the Pylance extension for Visual Studio Code (VS Code), making it a convenient option for VS Code users.
For PyCharm users, there is a specific plugin, although the older Pyright Language Server plugin is now deprecated in favor of the newer Pyright plugin. To use Pyright with PyCharm, you need to set the path to the Pyright language server executable in the settings.
Continuous Integration (CI) and Pre-commit Hooks
Pyright can be easily integrated into Continuous Integration (CI) pipelines. You can run Pyright as a GitHub Action or as part of a GitLab CI/CD pipeline. For GitHub Actions, you can use the jakebailey/pyright-action to configure Pyright to run automatically.
Additionally, Pyright can be set up as a pre-commit hook using the Python wrapper for Pyright. This ensures that type checking is performed automatically before each commit, helping maintain code quality.
Configuration and Environment Compatibility
Pyright is highly configurable and can work across different environments. It supports multiple execution environments within a project, each with its own virtual environment (venv) or import paths. This makes it flexible for projects with diverse requirements.
To ensure compatibility, Pyright for Python, a wrapper project, allows you to install Pyright using pip and automatically manages the installation of Node.js if it is not already available. This makes it easier for Python developers who may not have Node.js installed on their machines.
Cross-Platform Compatibility
Pyright is compatible with various operating systems, including Windows, macOS, and Linux. The ability to run Pyright via npm or through the Python wrapper ensures it can be used in multi-platform scenarios without significant issues.
Monorepo and Large-Scale Projects
For large-scale projects, such as monorepos, Pyright can be configured to work seamlessly. You can pin the version of Pyright in a top-level dev-requirements.txt file to ensure deterministic behavior across local development and CI environments. This setup helps in maintaining reproducibility and consistency across the project.
Conclusion
In summary, Pyright integrates well with various IDEs, CI systems, and pre-commit hooks, and it is compatible across different platforms and environments, making it a versatile tool for maintaining high-quality Python code.
Pyright - Customer Support and Resources
For Developers Using Pyright
For developers using Pyright, a fast and configurable type checker for Python, several customer support options and additional resources are available to ensure a smooth and productive experience.
Configuration and Documentation
Pyright provides extensive documentation on its configuration options. You can configure Pyright using a pyrightconfig.json file or a pyright section in a pyproject.toml file. The documentation includes detailed explanations of various settings such as typeshedPath, stubPath, venvPath, pythonVersion, and typeCheckingMode, among others. This helps in fine-tuning the type checking behavior according to your project’s needs.
Community and GitHub Resources
Pyright is an open-source project hosted on GitHub, which means you can access the source code, report issues, and contribute to the project. The GitHub repository includes detailed documentation, sample configuration files, and issue tracking, making it a valuable resource for troubleshooting and feature requests.
Installation Guides
Comprehensive installation guides are available for different platforms. You can install Pyright using npm, pip, or conda-forge, depending on your preference. Step-by-step instructions are provided for various Linux distributions and other operating systems.
Language Server Features
Pyright integrates with language servers, providing features like intelligent type completion, automatic import insertion, signature completion tips, hover information, and more. These features are well-documented and can be configured to enhance your development experience.
Type Checking Features
The tool supports a wide range of Python type hinting features, including various PEPs (Python Enhancement Proposals) such as PEP 484, PEP 487, and others. This ensures that Pyright can handle complex type checking scenarios effectively.
Community Support
While specific customer support channels like forums or live chat are not mentioned, the open-source nature of Pyright means that community support is available through GitHub issues and discussions. This community-driven approach often leads to quick resolutions and feedback from other users and contributors.
Conclusion
In summary, Pyright offers extensive documentation, flexible configuration options, and integration with language servers, making it a well-supported tool for developers working with large Python source bases. The community-driven nature of the project ensures there are multiple avenues for seeking help and contributing to its development.
Pyright - Pros and Cons
Advantages
Speed and Efficiency
Pyright is renowned for its remarkable speed, providing near-instant feedback on errors and type issues. This makes it ideal for large Python source bases where rapid type checking is crucial.
Lightweight Design
Pyright is lightweight and consumes minimal system resources, ensuring it does not slow down the development process. This efficiency is particularly beneficial for quick debugging and performance optimization.
Real-time Feedback
It offers real-time feedback on type-related issues, syntax errors, and provides code completion suggestions, helping developers catch bugs early in the development process.
Integration Flexibility
Pyright can be used alongside integrated development environments (IDEs) such as Visual Studio Code or as a standalone tool. It also integrates with other tools like Node.js, TypeScript, and GNU Bash.
Incremental Updates
Pyright can run in a “watch” mode and performs fast incremental updates when files are modified, making it highly efficient for ongoing development.
Disadvantages
Limited Feature Set
While Pyright is excellent for speed and efficiency, it lacks the extensive feature set offered by tools like Pylance. It focuses primarily on type checking and does not include advanced functionalities like IntelliSense or sophisticated code navigation.
Resource Usage in Large Projects
Although Pyright is generally lightweight, it can still be slightly resource-intensive in very large and complex projects. However, this is mitigated by its ability to exclude certain files for performance improvements.
Less IDE Integration Features
Compared to Pylance, Pyright does not offer as deep an integration with IDEs, which might make it less appealing for developers seeking a more integrated development environment.
Overall, Pyright is an excellent choice for developers who prioritize speed, efficiency, and minimal overhead in their type checking and linting needs, especially in larger codebases. However, for those seeking a more comprehensive set of features and deeper IDE integration, other tools like Pylance might be more suitable.
Pyright - Comparison with Competitors
Performance and Type Checking
Pyright is renowned for its exceptional speed and efficiency in type checking. It is designed to be 3x to 5x faster than mypy, another popular Python type checker, especially when dealing with large code bases.
- This performance is due to its “lazy” or “just-in-time” type evaluation approach, which allows it to evaluate types without analyzing the entire module from top to bottom.
- Pyright also recovers gracefully from syntax errors, continuing to parse the remainder of the source file, which is not a feature of mypy.
Integration and Features
Pyright serves as a foundation for a Python language server, providing features such as completion suggestions, function signature help, type information on hover, and semantic-aware search and refactoring tools. It integrates well with Visual Studio Code, offering a seamless development experience.
Comparison with Pylance
Pylance, another tool from Microsoft, builds upon Pyright’s capabilities but offers a more comprehensive set of features.
- Pylance includes advanced functionalities like IntelliSense, sophisticated code navigation, and extensive type information, making it more suitable for collaborative and complex projects.
- While Pyright is ideal for developers who prioritize speed and simplicity, Pylance is better for those who need a richer set of integrated development environment (IDE) features.
Comparison with AI-Powered Tools
In contrast to purely type-checking tools, AI-powered coding assistants like GitHub Copilot, JetBrains AI Assistant, and OpenHands offer a broader range of features that go beyond type checking.
GitHub Copilot
- GitHub Copilot provides advanced code autocompletion, context-aware suggestions, and automated code documentation generation. It also supports multiple programming languages and integrates well with popular IDEs like Visual Studio Code.
- However, Copilot may not offer the same level of performance or type checking specificity as Pyright.
JetBrains AI Assistant
- JetBrains AI Assistant integrates into JetBrains IDEs, offering features like smart code generation, proactive bug detection, and automated testing. It also provides an interactive chat interface and seamless IDE integration.
- While it offers comprehensive AI-powered features, it may not match Pyright’s speed and efficiency in type checking.
OpenHands
- OpenHands is another AI-assisted development tool that offers natural language communication, real-time code preview, and dynamic workspace management. It supports multiple language models and has a flexible configuration.
- OpenHands is more focused on AI-driven development workflows rather than pure type checking, making it a different class of tool compared to Pyright.
Unique Features of Pyright
- Speed and Efficiency: Pyright’s standout feature is its remarkable speed in type checking, making it ideal for large and complex projects where rapid feedback is crucial.
- Lazy Type Evaluation: Its “just-in-time” type evaluation approach allows for highly responsive type evaluation during interactive code modification.
- Syntax Error Recovery: Pyright’s ability to recover from syntax errors and continue parsing the source file is a significant advantage over other type checkers like mypy.
Potential Alternatives
- For developers who need advanced IDE features and AI-driven coding assistance, Pylance, GitHub Copilot, or JetBrains AI Assistant might be more suitable.
- For those focusing strictly on speed and efficiency in type checking, Pyright remains a top choice, especially in straightforward projects or large codebases where minimal overhead is desired.
Pyright - Frequently Asked Questions
Frequently Asked Questions about Pyright
Q: How do I install Pyright?
To install Pyright, you have several options:- You can install it using npm by running the command `npm install -g pyright` in your terminal or command prompt. This method requires Node.js to be installed on your system.
- Alternatively, you can use Pip or Conda by running `pip install pyright` or `conda install pyright`, respectively. These methods are community-maintained and also require Node.js.
Q: What is the purpose of the `pyrightconfig.json` file?
The `pyrightconfig.json` file is used to customize settings specific to your project. It allows you to configure various options such as include and exclude paths, strict type checking, and other preferences. This file is essential for automated debugging and code enhancement.Q: How do I configure strict type checking in Pyright?
To enable strict type checking in Pyright, you can add the `”strict”` option to your `pyrightconfig.json` file. This can be done by specifying paths of directories or files that should use strict analysis. For example:
{
"strict": true
}
This setting enables most type-checking rules for the specified paths.
Q: Can I use different versions of Python with Pyright?
Yes, you can specify the version of Python that Pyright should use by adding the `”pythonVersion”` option to your `pyrightconfig.json` file. For example:
{
"pythonVersion": "3.9"
}
This ensures that Pyright generates errors if the source code uses language features not supported in the specified version.
Q: How do I specify the target platform for Pyright?
You can specify the target platform by adding the `”pythonPlatform”` option to your `pyrightconfig.json` file. For example:
{
"pythonPlatform": "Linux"
}
This setting helps Pyright tailor its use of type stub files based on the specified platform.
Q: Can I use custom type stubs with Pyright?
Yes, you can use custom type stubs by specifying the `”stubPath”` option in your `pyrightconfig.json` file. For example:
{
"stubPath": "./custom_typings"
}
Each package’s type stub file(s) should be in its own subdirectory within the specified path.
Q: How do I configure Pyright to use a virtual environment?
To use a virtual environment with Pyright, you need to specify the `”venvPath”` and optionally the `”venv”` options in your `pyrightconfig.json` file. For example:
{
"venvPath": "/path/to/venvs",
"venv": "myenv"
}
This setting tells Pyright to search for imports in the virtual environment’s site-packages directory rather than the default Python interpreter paths.
Q: What is the difference between using Pyright and Pylance?
Pyright is a static type checker for Python, while Pylance is an extension for VS Code that incorporates Pyright along with additional features such as semantic token highlighting and symbol indexing. If you are using VS Code, it is recommended to use the Pylance extension for its enhanced capabilities.Q: How can I verify if Pyright is installed correctly?
After installing Pyright, you can verify the installation by running the command `pyright –version` in your terminal or command prompt. This should display the version number of Pyright.Q: Can I configure Pyright to be more verbose for debugging purposes?
Yes, you can enable verbose output by adding the `”verboseOutput”` option to your `pyrightconfig.json` file. For example:
{
"verboseOutput": true
}
This setting is useful when diagnosing issues such as import resolution problems. Pyright - Conclusion and Recommendation
Final Assessment of Pyright
Pyright, developed by Microsoft, is a significant tool in the Developer Tools AI-driven product category, particularly for Python developers. Here’s a comprehensive overview of its benefits, target users, and recommendations.Key Features and Benefits
- Speed and Efficiency: Pyright is renowned for its rapid type validation, making it ideal for projects that prioritize efficiency. It provides near-instant feedback on errors, which is crucial during the development cycle.
- Lightweight Design: Pyright’s lightweight design ensures minimal system resource consumption, making it perfect for quick debugging and performance optimization, especially in larger codebases.
- Type Checking: As a static type checker, Pyright ensures swift and precise validation of data types, which is essential for maintaining code quality and security compliance.
Target Users
- Developers Emphasizing Speed: Pyright is the preferred tool for developers who prioritize speed and simplicity. It is particularly beneficial in settings where strict type checking is required without the need for extensive IDE features.
- Large Codebases: Developers managing complex projects with large files will appreciate Pyright’s ability to significantly reduce type checking time and improve performance by excluding certain files from the repository.
- Straightforward Projects: For developers working on straightforward projects where minimal overhead is desired, Pyright’s simplicity and efficiency make it an ideal choice.
Comparison with Pylance
- While Pyright focuses on speed and efficiency, Pylance builds upon Pyright’s capabilities by offering a comprehensive suite of features, including IntelliSense, sophisticated code navigation, and extensive type information. Pylance is more suitable for collaborative and complex projects where integrated functionalities can streamline workflows.
Development and Maintenance
- Pyright is authored in TypeScript, which allows for better performance compared to Python. This choice also enables the tool to be shipped in environments that already support JavaScript, enhancing its versatility.
Recommendations
- For developers who need rapid type checking and minimal overhead, Pyright is the go-to tool. Its efficiency and speed make it particularly useful in large codebases and straightforward projects.
- However, if you are working on collaborative or complex projects and need a more integrated development environment with advanced features like IntelliSense and code navigation, Pylance might be a better fit.
- Overall, Pyright is a reliable choice for ensuring type safety and code quality without adding unnecessary complexity, making it a valuable addition to any Python developer’s toolkit.