This is a very typical issue, so I will leave this here for future reference.

If I have a project called: my_project

.
└── my_project
    ├── first_folder
    ├── second_folder
    └── third_folder

What you want to do is one of these two things:

1. PYTHONPATH (only Python)

cd ~/my_project && export PYTHONPATH=$(pwd)

change dir to root dir, and export that dir to PYTHONPATH, so when Python runs it looks in the PYTHONPATH.

2. PATH (everything)

cd ~/my_project && export PATH=$PATH:$(pwd)

Same as above!

This needed to live somewhere since it took me a while to figure out. So for anyone in the future who needs help with this!

All modules in Python have to have a certain directory structure. You can find details here.

Create an empty file called __init__.py under the model directory, such that your directory structure would look something like that:

.
└── project
    └── src
        ├── hello-world.py
        └── model
            ├── __init__.py
            └── order.py

Also in your hello-world.py file change the import statement to the following:

from model.order import SellOrder

That should fix it

P.S.: If you are placing your model directory in some other location (not in the same directory branch), you will have to modify the python path using sys.path.

Three possibilities come to my mind:

• The module just works for certain python versions (e.g. 3.5 but not 3.6).
• The path where your module is currently located does not appear in sys.path.
• The class you want to use must be specified while importing the module because it is not specified in the __init__.py of the module itself.

As far as I can tell, only the first option might cause your problem.
Nevertheless I would make a quick check with

import sys
sys.path

and in case that the correct path is really missing..

sys.path.append('PathToModule')

FIRST, if you want to be able to access man1.py from man1test.py AND manModules.py from man1.py, you need to properly setup your files as packages and modules.

Packages are a way of structuring Python’s module namespace by using “dotted module names”. For example, the module name A.B designates a submodule named B in a package named A.

...

When importing the package, Python searches through the directories on sys.path looking for the package subdirectory.

The __init__.py files are required to make Python treat the directories as containing packages; this is done to prevent directories with a common name, such as string, from unintentionally hiding valid modules that occur later on the module search path.

You need to set it up to something like this:

man
|- __init__.py
|- Mans
   |- __init__.py
   |- man1.py
|- MansTest
   |- __init__.py
   |- SoftLib
      |- Soft
         |- __init__.py
         |- SoftWork
            |- __init__.py
            |- manModules.py
      |- Unittests
         |- __init__.py
         |- man1test.py

SECOND, for the "ModuleNotFoundError: No module named 'Soft'" error caused by from ...Mans import man1 in man1test.py, the documented solution to that is to add man1.py to sys.path since Mans is outside the MansTest package. See The Module Search Path from the Python documentation. But if you don't want to modify sys.path directly, you can also modify PYTHONPATH:

sys.path is initialized from these locations:

• The directory containing the input script (or the current directory when no file is specified).
• PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
• The installation-dependent default.

THIRD, for from ...MansTest.SoftLib import Soft which you said "was to facilitate the aforementioned import statement in man1.py", that's now how imports work. If you want to import Soft.SoftLib in man1.py, you have to setup man1.py to find Soft.SoftLib and import it there directly.

With that said, here's how I got it to work.

man1.py:

from Soft.SoftWork.manModules import *
# no change to import statement but need to add Soft to PYTHONPATH

def foo():
    print("called foo in man1.py")
    print("foo call module1 from manModules: " + module1())

man1test.py

# no need for "from ...MansTest.SoftLib import Soft" to facilitate importing..
from ...Mans import man1

man1.foo()

manModules.py

def module1():
    return "module1 in manModules"

Terminal output:

$ python3 -m man.MansTest.Unittests.man1test
Traceback (most recent call last):
  ...
    from ...Mans import man1
  File "/temp/man/Mans/man1.py", line 2, in <module>
    from Soft.SoftWork.manModules import *
ModuleNotFoundError: No module named 'Soft'

$ PYTHONPATH=$PYTHONPATH:/temp/man/MansTest/SoftLib
$ export PYTHONPATH
$ echo $PYTHONPATH
:/temp/man/MansTest/SoftLib
$ python3 -m man.MansTest.Unittests.man1test
called foo in man1.py
foo called module1 from manModules: module1 in manModules 

As a suggestion, maybe re-think the purpose of those SoftLib files. Is it some sort of "bridge" between man1.py and man1test.py? The way your files are setup right now, I don't think it's going to work as you expect it to be. Also, it's a bit confusing for the code-under-test (man1.py) to be importing stuff from under the test folder (MansTest).

I assume that you are trying to import the orade module. PYTHONPATH represents the path to the directory that contains python modules, not the collection of paths to the modules.

So you should put the parent directory of your module in the PYTHONPATH. If the path to your module is /home/python/softwares/orade, you should put /home/python/softwares in your PYTHONPATH:

export PYTHONPATH=/usr/lib/python2.7/dist-packages:/home/python/softwares

And then you should be able to do:

>>> import orade

If the orade directory contains a __init__.py file.

Since the python interpreter is started within test, that's where it looks for imports. You can learn about pythons's search behavior for imports through the docs, if you're interested in the details.

To solve your problem, there are a bunch of ways to do it, the best one depending on how you plan to use your code. If you plan to write a library, it might make sense to package it, which would give you access to a global namespace that you can use.

But if you just want it to work right now, and only ever are going to run the interpreter from the same place (i.e. your test folder), defining the third file as a local one should do it:

second.py

from . import third

third.py

print('third here, not an import error')

This works for me:

~/test$ tree . 
.
├── first.py
└── numpad
    ├── second.py
    └── third.py
~/test$ python3.6 first.py
third here, not an import error

I think you can solve this problem the same way as in the answer by Sorin here - https://stackoverflow.com/a/6098238/1491900:

import os, sys, inspect
 # realpath() with make your script run, even if you symlink it :)
 cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
 if cmd_folder not in sys.path:
     sys.path.insert(0, cmd_folder)

 # use this if you want to include modules from a subforder
 cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"subfolder")))
 if cmd_subfolder not in sys.path:
     sys.path.insert(0, cmd_subfolder)

 # Info:
 # cmd_folder = os.path.dirname(os.path.abspath(__file__)) # DO NOT USE __file__ !!!
 # __file__ fails if script is called in different ways on Windows
 # __file__ fails if someone does os.chdir() before
 # sys.argv[0] also fails because it doesn't not always contains the path

for me its working and on linux too.

 [~/Alexzander__/programming/python3/learning/modulenotfounderror]
❱  tree
 .
├──  main.py
└──  utils
   └──  forms.py


 [~/Alexzander__/programming/python3/learning/modulenotfounderror]
❱  ca main.py

from utils.forms import search_form

print("success")%                                                                      

 [~/Alexzander__/programming/python3/learning/modulenotfounderror]
❱  python main.py
success