Otdfbt

My Python project uses various kind of libraries. What is the protocol if the end-user didn't have one or any of them?

Should a window pop up and notify him/her which package and version to download in his/her environment? Or I should include the libraries within my project?

What's the proper action?

Whatever your project is, you could try making it into a python package that the end-user would install. The way this works is

In the root directory of your package you would include a setup.py. You could include in this file a list of requirements/dependencies (the install_requires key) that would be installed along with your package when the end-user installs it.

The end user could then use pip to install your package eg

pip install YourPackage

and all dependencies listed in setup.py would be installed first.

Additionally, as @Devesh Kumar Singh pointed out in his comment, you could also include a requirements.txt file. The user could then install using this file with

pip install -r requirements.txt YourPackage

See this guide for building a python package,
setuptools documentation

To show other users, what libraries are needed for your project, you have multiple options. All options are some kind of files, that say which libraries are needed for this project.

Files that I am aware of

• 
  requirements.txt: very simple


• 
  setup.py: Used when you publish your project on sides like pypi https://stackoverflow.com/a/1472014/8411228
  


• 
  Pipfile: The way to go when you work in an virtualenv https://docs.pipenv.org/en/latest/
  


• 
  environment.yml: Used for Conda environments https://tdhopper.com/blog/my-python-environment-workflow-with-conda/#fn:requirements-conda
  

Another option: You can use PyInstaller to freeze (packages) Python applications into stand-alone executables, under Windows, GNU/Linux, Mac OS X, FreeBSD, Solaris and AIX.

PyInstaller Quickstart

This has worked very well for me. Indeed, you do not have to worry about whether the final user has Python installed.

Here is where packaging a python project into a module comes handy modules
We include a requirements.txt file which contains all python module requirements needed for that python library, and installs them automatically when the module is setup.

A good primer on how to setup your module to be distributable is Structuring your project

So you made a package. Now you will want to share it. What next?

Developer

Goal - make a distribution (also called a "package") to share

Preamble

You are now packaging your package and wish to distribute it. There are two main kinds of packages:

• an application: deploy a source to a server, github, website e.g. CLI


• a library: publish a source distribution (sdist) or binary (e.g. wheel) usually to PyPI via twine
  

Traditional Ways

Several files may be included in a distribution, but here are the main ones:

• source: your code


• 
  setup.py: specify metadata, and dependencies required to make an sdist.


• 
  requirements.txt: a list of dependencies

Contemporary Ways

Use pyproject.toml to specify which tool to use in creating your sdist or binary:

Modern tools to create + deploy/publish a package include:

1. 
   pipenv: makes a package and substitutes requirements.txt (recommended by PyPA)
   
   
   • develop: > pipenv install <dependency>, > pipenv install
     
   
   
   • publish: > pipenv -e . + twine
     
   
   


2. 
   poetry: makes a package and publishes to PyPI
   
   
   • develop > poetry add <dependency>, > poetry install
     
   
   
   • publish: > poetry publish
     
   
   


3. 
   flit: makes a package and publishes to PyPI
   
   
   • develop: > flit install
     
   
   
   • publish: > flit publish
     
   
   

The first two options have features to make clean virtual environments and safely install dependencies using lock files. I would encourage exploring these newer options later on as they clear up a lot of packaging headaches by obviating setup.py and setuptools.

User

Goal - get a package and install it with dependencies

Traditional Ways

Applications have a variety of deployment methods, e.g. uploading your app to a hosting service e.g. heroku, DigitalOcean, etc. The user may indirectly interface with your app through a website, CLI or more.

Libraries are often uploaded to PyPI. From here the user can usually install a package using pip independent from how they are made:

• 
  > pip install <package> (recommended)


• 
  > pip install <packatge> -r requirements (explicit, optional)

These commandline invocations will fetch the distribution from PyPI, install the package and specified dependencies.

Contemporary Ways

Here are some alternatives to pip:

1. 
   pipx: "safely" install packages in isolated environments
   
   
   • > pipx install <package>
   
   

See Also

• 
  Official docs on publishing packages by PyPA


• 
  Tutorial on How To Package Your Python Code
  


• 
  Podcast interview with B. Cannon on pyproject.toml and modern packaging tools