What is the best way to import local modules?

Question

"What are the PEP-compatible ways to import a local package even from a parent folder with the least preassumptions" could be the long title. I am looking for a solution to make it possible to use a local package. My requirements:

1. it must be PEP-compatible, i.e. at least the most commonly accepted PEP must support it
2. OS, terminal, user and environment independent, i.e. the solution must not rely on any specific circumstances

Among these solutions, I am looking for the one that

• is the simplest to implement
• the scope of the modification is flexible (doesn't need to be executed every time, but is not permanent and system-wide)
• leaves the source code in the simplest form, i.e. the solution doesn't need a lot of extra lines in the code

Solutions

These are the ways I found on SO and other places so far. None of them suit my needs, and as it was told 8 years ago, every solution will have their cons. Yet I hope in 2021 we can find a solution that meets at least my 2 requirements.

Use conda

SO 1

Use conda environments and issue conda to include a directory in the python lookup path by conda develop <path> where <path> can be either relative to pwd or absolute. Conda then creates a conda.pth file in the site-packages folder of the environment, and python will be provided the content of that file, therefore will be available in the sys.path

Drawback: it requires conda-build, but it is not always present.

Use pip

SO 2a, SO 2b, SO 3

Use pip to install a package locally. Create a setup.py, configure it, cd into where it is, then install the package locally in editable mode with pip install -e .

Drawback: PEP 517 doesn’t support editable installs as mentioned on setuptools.

direct hack of sys.path

SO 2c

Add paths to sys.path directly within the python script, e.g.:

import os
import sys

sys.path.insert("path")

import mymodule

Here path can be absolute or relative, and the latter can be OS independent e.g. by using os.path.sep.

Drawback: it is not PEP-compatible, because not all import statements are in the top of the file. autopep8 will rearrange your code into a wrong order, however, there are workarounds. One can say that it is a good example where PEP can be neglected but I'd like to believe imports are basic enough to apply PEP without exception.

modify pythonpath

Modify your system environemnt path or pythonpath by adding the necessary directory to it.

Drawbacks: it is at least OS dependent and too global, or just the opposite, one needs to execute it every time.

use relative imports

From within the script, include the module using relative import

from ..somewhere import mymodule

This doesn't work if this module is the main, you'll get a

ImportError: attempted relative import with no known parent package

furthermore, PEP 8 says: "Relative imports for intra-package imports are highly discouraged." Guido thinks it is ok.

Related questions

This is not a duplicate of the general questions on how to import modules beyond top-level, because those questions already have accepted answers. SO 2, SO 3, SO 4, SO 5 SO 6, not even python

Answer 1

As PEP8 states in the very beginning:

A Foolish Consistency is the Hobgoblin of Little Minds.

Think about that and either use editable installs with pip or develop installs with conda,
but don't consider one of the other hacks, since they serve a different purpose.