Python3 imports changes

Question

I have a module that uses enums defined in the same package. I want to run it locally for self testing and also access it from other packages, but I can't get the import for the enum to handle both situations.

I have tried a blank _ _ init _ _.py (without the spaces) in both the sub and the proj directories, with no apparent change.

I have tried variations of python -m without success.

Here is the minimal code that shows my problems:

    /my/proj
        |----sub
        |      |---e1.py
        |      |---one.py
        |      |---two.py
        |-p1.py
        |-p2.py

    ----
    $ cat /my/proj/sub/e1.py
    from enum import Enum
    class UsefulEnums(Enum):
        ZERO = 0

    ----
    $ cat /my/proj/sub/one.py
    from e1 import UsefulEnums as E
    def profound():
       print('The value of {} is {}'.format(E.ZERO.name, E.ZERO.value))
    if __name__ == '__main__':
       profound()

    /my/proj/sub$ python one.py
    The value of ZERO is 0
    ----
    $ cat /my/proj/sub/two.py
    # note the dot before the module name. No other change from one 
    from .e1 import UsefulEnums as E
    def profound():
       print('The value of {} is {}'.format(E.ZERO.name, E.ZERO.value))
    if __name__ == '__main__':
       profound()

    /proj/sub$ python two.py 
    Traceback (most recent call last):
      File "two.py", line 1, in <module>
        from .e1 import UsefulEnums as E
    ModuleNotFoundError: No module named '__main__.e1'; '__main__' is not a package

    ----
    $ cd /my/proj
    /my/proj$ cat p1.py
    import sub.one as a
    if __name__ == '__main__':
       a.profound()

    /my/proj$ python p1.py
    Traceback (most recent call last):
      File "p1.py", line 1, in <module>
        import sub.be1 as a
      File "/home/esmipau/delete_me/proj/sub/one.py", line 1, in <module>
        from e1 import UsefulEnums as E
    ModuleNotFoundError: No module named 'e1'
    ----
    /my/proj$ cat p2.py
    import sub.two as a
    if __name__ == '__main__':
       a.profound()

    /my/proj$ python p2.py
    The value of ZERO is 0

When run from the 'sub' directory, one.py works as expected, two.py fails with a 'ModuleNotFoundError' error as detailed above. When imported in parent code and run from the parent directory, two.py now works, and one.py fails with a different 'ModuleNotFoundError' error. I would like a three.py in the 'sub' directory that uses the enums defined in e1.py, and which can be run locally for self testing etc, and can be included from external module not in the same directory.

--- edit for close as duplicate suggestions --- This is not the same question as others that have been suggested such as Correct import and package structure now that __init__.py is optional as I require a way for one module to import another in the same directory regardless of whether the module is being executed locally or imported from another module.

`from e1 import UsefulEnums as E` should have a for in it too — Mad Physicist, Aug 24 '18 at 16:09
From what directory are you running trying to execute this code? That can make a difference with relative imports. — SethMMorton, Aug 24 '18 at 16:46
Possible duplicate of [Correct import and package structure now that \_\_init\_\_.py is optional](https://stackoverflow.com/questions/51397669/correct-import-and-package-structure-now-that-init-py-is-optional) — MisterMiyagi, Aug 26 '18 at 21:19

score 0 · Answer 1 · answered Aug 26 '18 at 20:58

0

I had simmilar issue and this solved it: try creating __init__ file like this:

import my.proj.sub.e1

and then in file you want to use add:

from my.proj.sub import UsefulEnums as E

answered Aug 26 '18 at 20:58

Samces857

32
6

This doesn't work for modules in the same 'sub' directory as e1 so they can not be run in standalone or self-test mode. – Paul Smith Aug 26 '18 at 21:14

Paul Smith · Accepted Answer · 2018-08-27T17:08:20.133

Given the structure :

/proj
   |---/pkg
   |    |---> usefulEnums.py
   |    |---> usefulCode.py 
   |--> myProj.py

I want to be able to run usefulCode.py in self test mode and I want to import and use it in myProj.

$ cat proj/pkg/usefulEnums.py
from enum import Enum
class UsefulEnums(Enum):
    ZERO = 0 

$ cat proj/pkg/usefulCode.py
if __package__ is None:
    # works with python <path/>tcp.py
    from usefulEnums import UsefulEnums as E
else:
    # works with python -m pkg.tcp 
    # or when imported by another module 
    from pkg.usefulEnums import UsefulEnums as E
    # This works as well and appears more more portable and pythonic
    # but the logic that makes it work is obtuse and fragile
    # and it doesn't work if __package__ is None (even though it should!) 
    # from .usefulEnums import UsefulEnums as E    

 def profound():
     print('The value of {} is {}'.format(E.ZERO.name, E.ZERO.value))
 if __name__ == '__main__':
     profound()

The main project code is as expected:

cat proj/myProj.py
from pkg.usefulEnums import UsefulEnums as E
import pkg.usefulCode as u
if __name__ == '__main__':
    u.profound()

The above is the work around I am accepting as the answer to my stated question, but the reasoning eludes me.

I do not understand why the behavior of the 'dot' import does not work as expected when __package__ is not defined. Surely it always means import relative to the current package, and if no package is explicitly defined, then why doesn't it mean import from the same directory as the current module, which could be argued to be the currently default package?

Python3 imports changes

2 Answers2