[pip and venv](https://docs.python.org/3/library/venv.html) are part of

Python 3's standard library as of version 3.3. However, there are numerous

other open source libraries that can be helpful when managing application

dependencies in your projects, as listed below.

* [Autoenv](https://github.com/kennethreitz/autoenv) is a tool for activating

environment variables stored in a `.env` file in your projects' home

directories. Environment variables aren't managed by virtualenv and although

virtualenvwrapper has some hooks for handling them, it's often easiest to

use a shell script or `.env` file to set them in a development environment.

* [Pipenv](https://pipenv.readthedocs.io/en/latest/) is a newer Python

packaging and dependency management library that has seen some adoption

in place of the standard `pip` library.

* [Pipreqs](https://github.com/bndr/pipreqs) searches through a project for

dependencies based on imports. It then generates a `requirements.txt` file

based on the libraries necessary to run those dependencies. Note though that

while this could come in handy with a legacy project, the version numbers

for those libraries will not be generated with the output.

* [pip-check](https://github.com/bartTC/pip-check) presents a nicely-formatted

list of all your installed dependencies and the status of whether or not

updates are available for each of them.

* [pip-name](https://github.com/prakashdanish/pip-name) is a straightforward

library that looks up package names on PyPI and tells you whether or not

the library name is already taken.

There are many steps in creating and distributing packages on PyPI and

your own hosted application dependency servers. Many of these steps involve

writing configuration files that are not as well documented as some other

areas of Python development. These resources are the best ones I have found

so far to get up to speed on building and releasing your own packages.

* [Python Packaging User Guide](https://packaging.python.org/)

provides a collection of resources to understand how to package and

distribute Python code libraries.

* [Alice in Python projectland](https://veekaybee.github.io/2017/09/26/python-packaging/)

is an amazing post that takes the reader from simple Python script

into a complete Python package.

* [Perils of packaging](https://malramsay.com/post/perils_of_packaging/)

covers several edge cases that come up when trying to put together

pieces like Travis CI, PyPI and conda. The post walks through the errors

and how to get around them until they are smoothed out by updates to the

tools.

* [How to Publish Your Package on PyPI](https://blog.jetbrains.com/pycharm/2017/05/how-to-publish-your-package-on-pypi/)

is for developers who have created a code library they would like to

share and make installable for other developers.

* [How to Submit a Package to PyPI](https://blog.easyaspy.org/post/14/2019-05-05-how-to-submit-a-package-to-pypi)

presents the basic steps like signing up for a PyPI account and other

accounts that go along with the tutorial. It then walks through the

configuration code for setting up continuous integration and deploying

your package.

* [Python Packaging Is Good Now](https://glyph.twistedmatrix.com/2016/08/python-packaging.html)

is a wonderfully written blog post. It provides historical context on why

Python's code library packaging was painful for a long time, and what's

been fixed to make building and installing application dependencies so

much better.