Prevent package importing itself

Question

Ok, let's give you an example (original question below).

I have made a package called "myproject" which shows the problem I'm facing.

1. Download the package here: https://dl.dropbox.com/u/11013311/myproject.zip
2. Install the package (eg.: sudo python setup.py develop)
3. open an Ipython session and type: "import myproject"
4. if you start typing "myproject." and hit tab twice to get the available methods/values..., you'll see "myproject.myproject" which himself shows the same problem.

Is one of you guys able to explain me what I'm doing wrong? The answer from Andrew Alcock do not help me to fix it, or at least I don't see where could be the problem.

Of course, with such a simple example, there is no need for the package __init__.py file to be that complex, but in my real project I do need COOL instance to be accessible via myproject.COOL.

Thanks for your answers!

EDIT: I've awarded utapyngo the bounty because his solution is effective and I've learnt something more (relative imports with deep submodules). But I'd like to thanks Andrew and nehz for their answers (nehz also provided a solution that fixed my problem, but very subjectively I find it 'less beautiful' ; and Andrew provided useful advices). Too bad I can't share the bounty.

**

ORIGINAL QUESTION:

**

I'm not sure I've phrased correctly the question. I have created a large code with a number of sub-packages, and for simplicity let's call it 'CODE'.

The problem is: 'CODE' appears in the namespace so I can have CODE.CODE or CODE.CODE.CODE, etc... an infinite number of times which looks strange to me and is probably (I guess) a hint that something is wrong (although the code works perfectly without warning).

I guess the problem has something to do with my __init__.py and the structure of my code, so I give some more informations here.

Simplified code structure:

CODE
  | __init__.py
  | tools
     | __init__.py
     | mytools.py
  | other
     | __init__.py
     | init.py
  | sub
     | __init__.py
     | module.py

File: __init__.py (the first one, at the root of CODE)

import CODE.tools.mytools as MyTools
import CODE.other.init

OBJ = CODE.other.init.function()
...

The file mytools.py do not import OBJ from CODE, or any other module that may import OBJ. init.py may import modules such as mytools.py. Finally, modules like module.py may import either mytools.py or OBJ (from CODE). Usually, all import are made with absolute import, such as in: from CODE.sub.module import func.

Does anyone have an explanation for such a behavior? I did not find any related question on SO, but it may be due to the wrong phrasing of mine.

Answer 1

The problem is that the package you have imported (basically the top level __init__.py file) contains a reference to itself (the module) in and amongst the other imports. Since the module now has a namespace with itself in it, you can now accesses it as CODE.CODE. ... .CODE.MyTools.

I would suggest:

1) Have an __init__.py in each of your subpackages (tools, other)

2) Within CODE's modules, do not 'import CODE' or any subpackage. Instead make direct imports of the modules (files) you are interested in.

For example, in CODE.sub.module.py:

Do not:

import CODE.other     # "other" is a package (a directory)

Do:

import CODE.other.init    # "init" is a module (a file)

This way sanity lies.

EDIT: Reframing your specific example

The file mytools.py do not import OBJ from CODE, or any other module that may import OBJ. init.py may import modules such as mytools.py.

OK

Finally, modules like module.py may import either mytools.py or OBJ (from CODE).

This is your problem. Don't import CODE here. If you need to simplify the rather long "CODE.other.init.function", you can do it with the from .. import statement:

> from CODE.other.init import function as OBJ 

But be aware that many Pythonites dislike this as it leads to confusion.

Usually, all import are made with absolute import, such as in: from CODE.sub.module import func.

OK

Answer 2

Just delete the reference after you use an absolute import:

import atexit

import myproject.mymodule_one.suby as SubY
obj = SubY.myclass()
import myproject.mymodule_two.initialization

COOL = myproject.mymodule_two.initialization.create_cool()
del myproject

EDIT: FYI deleting the reference won't unload the module, and the instance in COOL is still valid.

Answer 3

In your main __init__.py you don't have to and even should not reference your module name (who knows, you would probably want to rename it in future).

Just replace

import myproject.mymodule_...

with

import mymodule_...

Now there is no myproject.myproject:

>>> dir(myproject)
['COOL', 'SubY', '__builtins__', '__doc__', '__file__', '__name__', '__package__',
 '__path__', '__version__', 'atexit', 'exit_report', 'mymodule_one', 'mymodule_two',
 'obj', 'toto']