Import Error. Circular References

Question

I have a package like this

package/
    __init__.py
    subpackage1/
        __init__.py
        moduleA.py
        moduleB.py
        moduleC.py
        moduleD.py
    subpackage2/
       __init__.py
       moduleX.py
       moduleY.py
       moduleZ.py

In moduleB.py, I am importing

from moduleA import bar

In moduleA, I am importing

from moduleB import foo

I am getting ImportError.

ImportError: cannot import name foo

What could be the problem here ? and to avoid this problem, what should I do ? and what should I write in _init_.py pf package, subpackage1, subpackage2 ?

_init_.py of subpackage1

from moduleA import *
from moduleB import *
from moudleC import *
from moudleD import *

_init_.py of subpackage2

from moduleX import *
from moduleY import *
from moduleZ import *

_init_.py of package

from subpackage1 import *
from subpackage2 import *

Is there some problem with my _init_.py files ?

EDIT: I have changed imports

moduleB

from .moduleA import bar

moduleA

from .moduleB import foo

Still, I am getting the same import error.

ImportError: cannot import name foo

EDIT:

moduleB

def Bar():
    def __init__(self):
        self.foo = Foo()
        self.val = 10
        .
        .

moduleA

def Foo():
    def __init__(self):
        self.bar = Bar()
        self.val = 5
        .
        .

I want to do this. And I insist on keeping both classes in different files. How should I import ?

I think you mean class Foo and class Bar? Either way, I show a few examples of how to do it in my answer. only one of either ModuleB or ModuleA has to follow one of the patterns I show, the other can still do it at the top. Any other questions? — B Robster, Jun 14 '12 at 08:41
thanks. it's working. but I'm getting RuntimeError: maximum recursion depth exceeded. I'm calling Foo from Bar and Bar from Foo. I'll look into it. — Froyo, Jun 14 '12 at 08:49
You're welcome. Sounds like you have some infinite recursion going on there, which is to be expected if you're creating a new one of the other each time you initialize each of them. You'll need to re-think your design. Maybe you can just pass in a reference from Foo() when you instantiate Bar(). That way, bar has a foo. E.g. in Bar: (__init__(self, foo): self.foo = foo ) and in Foo: (__init__(self): self.bar = Bar(self) ) — B Robster, Jun 14 '12 at 15:49

score 8 · Accepted Answer · edited May 23 '17 at 10:29

It actually appears to be a problem with circular imports.

Your moduleB says "from moduleA import bar", which tries to load moduleA, but the first thing it encounters in moduleA is "from moduleB import foo", which sends it back to moduleB. So you have an unresolvable bit of circular recursion there.

Typically (but not always) a circular import is an indicator that you need to rethink or re-architect how you're doing things. There are, however, a few possible work-arounds out there.

One is to move the import statement to the bottom of your python file (assuming you're using foo or bar inside of another function, so its not getting called instantly when the file loads)

e.g.

#ModuleB.py 
class Bar(object):   
  def __init__(self):
    self.foo = Foo()
    self.val = 10
    .
    .
# at bottom of file
from moduleA import Foo

another alternative is to place the import statement inside a function, called the "lazy import" pattern:

#ModuleB.py 
class Bar(object):   
  def __init__(self):
    from moduleA import Foo
    self.foo = Foo()
    self.val = 10

As to your question about the __init__.py files. I see no reason why you wouldn't leave them empty. The empty __init__.py files simply tell python "this directory is a python package" and permit imports.

Typically you would have a file in your package directory that "runs" your program by importing and utilizing modules from the subpackages. So assuming such file (e.g., package/main.py) exists, your imports would look like the following, with just empty __init__.py files.

#package/main.py
from subpackage1.moduleA import bar  # you can now call bar() directly
from subpackage1 import moduleB  # you can now call foo like: moduleB.foo()
from subpackage2.moduleX import jah

What you're doing above essentially takes all of the functions and attributes of all of the Modules in each subpackage and makes them available directly on the subpackage as if they were the subpackage's functions and attributes (so you could import subpackage1 and call subpackage1.bar() and subpackage.foo() instead of subpackage.moduleA.bar(), etc.), but I don't get the impression thats what you were trying to do, necessarily, and there's probably no reason to do it in this case.

If you need to use something in subpackage2 in a module in subpackage1, see the answers to this question. Or google how to add directories to your python path.

score 2 · Answer 2 · answered Jun 14 '12 at 08:07

This isn't to do with hierarchy, it's to do with circular references. You can't tell file A to import file B, and file B to import file A - since they depend on each other, the circle can't be resolved.

Either restructure your files so that they don't need to import each other - remember Python is not Java, you can have more than one class in a file - or move one of the imports into a function so that it doesn't have to execute at import time.

Import Error. Circular References

2 Answers2

Linked

Related