What is pips equivalent of npm install package --save-dev

Python developers often find themselves needing to manage project dependencies, much like their JavaScript counterparts using npm. If you’re familiar with npm and its command npm install package –save-dev, you might be wondering about the equivalent in the Python world using pip. Understanding how to manage development dependencies is crucial for maintaining a clean and organized development environment. This article dives deep into pip’s counterpart for development dependencies, providing clear examples and best practices to streamline your Python project workflow.

Installing Development Dependencies with Pip

The pip equivalent of npm install package –save-dev is installing packages using the –user flag (for user-specific installations) or within a virtual environment, combined with documenting these dependencies separately. Pip doesn’t have a direct analog to –save-dev, but effective dependency management can be achieved with a little extra effort. This approach ensures that packages used only during development, like testing frameworks or linters, don’t clutter your production environment.

Using a virtual environment is highly recommended. This isolates project dependencies and prevents conflicts between different projects. Create a virtual environment using python3 -m venv .venv (or similar depending on your Python version) and activate it. Then, install your development dependencies.

Managing Dependencies with Requirements Files

The key to clearly separating development dependencies is using separate requirements files. A common practice is to have a requirements.txt file for production dependencies and a requirements-dev.txt for development-specific ones. This allows you to install only the necessary packages for each environment.

For example, you might have pytest and flake8 in your requirements-dev.txt. You can then install these dependencies using: pip install -r requirements-dev.txt.

Example requirements-dev.txt

pytest flake8 requests-mock

Clearly separates dependencies, simplifying project management.
Allows for easy installation of specific dependency sets.

Why Separate Development Dependencies?

Separating development dependencies keeps your production environment lean and efficient. It avoids potential conflicts and reduces the attack surface by minimizing installed packages. This also contributes to faster installation times and smaller deployment sizes. Just as a builder doesn’t bring their entire toolbox to a finished house, you shouldn’t include development tools in your deployed application. Keeping your production environment tidy and minimal is a hallmark of professional software development.

Imagine deploying a web application with all its testing dependencies. This unnecessarily increases the size of your deployment and potentially exposes vulnerabilities related to those dependencies. By separating them, you deploy only what is essential for the application to run.

Best Practices for Dependency Management

Maintaining well-organized dependencies is an ongoing process. Regularly review and update your requirements files to reflect changes in your project. Pinning specific versions of packages using == in your requirements files ensures consistent behavior across different environments and prevents unexpected issues from updates. Documenting the purpose of each dependency in your requirements files or a separate README can further improve maintainability and collaboration. This helps anyone working on the project understand the role of each package, making it easier to manage and troubleshoot dependency-related issues.

Use virtual environments.
Maintain separate requirements files.
Pin dependency versions.
Regularly review and update dependencies.

“Clean code and well-managed dependencies are essential for any sustainable software project.” – Robert C. Martin

Consider this real-world example: A team developing a web application uses pytest for testing and flake8 for code style checking. These tools are essential for development but unnecessary in production. By placing these in requirements-dev.txt, the deployment environment remains clean and optimized.

Learn more about virtual environments. For additional information, explore these resources:

Featured Snippet: While pip doesn’t have a direct equivalent to npm install package –save-dev, using separate requirements files (requirements.txt for production and requirements-dev.txt for development) provides the same functionality and keeps your production environment clean.

FAQ

Q: Why is managing dependencies important?

A: Proper dependency management ensures consistent project behavior across different environments, simplifies collaboration, and reduces the risk of conflicts and vulnerabilities.

Effective dependency management is fundamental to a smooth Python development workflow. By leveraging virtual environments and separate requirements files, you can mirror the functionality of npm install package –save-dev and maintain a clean, efficient, and professional project structure. Start implementing these practices today to improve your Python development process. Explore additional resources and tools to enhance your dependency management workflow further. Consider tools that help automate dependency updates and vulnerability checks, enhancing your project’s security and stability.

Question & Answer :
In nodejs, I can do npm install package --save-dev to save the installed package into the package.

How do I achieve the same thing in Python package manager pip? I would like to save the package name and its version into, say, requirements.pip just after installing the package using something like pip install package --save-dev requirements.pip.

There isn’t an equivalent with pip.

Best way is to pip install package && pip freeze > requirements.txt

You can see all the available options on their documentation page.

If it really bothers you, it wouldn’t be too difficult to write a custom bash script (pips) that takes a -s argument and freezes to your requirements.txt file automatically.

Edit 1

Since writing this there has been no change in providing an auto --save-dev option similar to NPM however Kenneth Reitz (author of requests and many more) has released some more info about a better pip workflow to better handle pip updates.

Edit 2

Linked from the “better pip workflow” article above it is now recommended to use pipenv to manage requirements and virtual environments. Having used this a lot recently I would like to summarise how simple the transition is:

Install pipenv (on Mac)

brew install pipenv

pipenv creates and manages it’s own virtual environments so in a project with an existing requirements.txt, installing all requirements (I use Python3.7 but you can remove the --three if you do not) is as simple as:

pipenv --three install

Activating the virtualenv to run commands is also easy

pipenv shell

Installing requirements will automatically update the Pipfile and Pipfile.lock

pipenv install <package>

It’s also possible to update out-of-date packages

pipenv update

I highly recommend checking it out especially if coming from a npm background as it has a similar feel to package.json and package-lock.json