Cyclic import in Python makes impossible to call function from the upper module

Question

Here is my code below.

main.py:

import moduleA
print('It works!')

moduleA.py:

import moduleB
def functionA():
    return 0

moduleB.py:

import moduleA
globalVariableFromModuleB = moduleA.functionA()

If I run it, I get the error message:

$ python main.py 
Traceback (most recent call last):
  File "main.py", line 3, in <module>
    import moduleA
  File "/home/asa/bugs/moduleA.py", line 3, in <module>
    import moduleB
  File "/home/asa/bugs/moduleB.py", line 8, in <module>
    globalVariableFromModuleB_1 = functionB()
  File "/home/asa/bugs/moduleB.py", line 6, in functionB
    return moduleA.functionA()

Q1: In my case moduleB explicitly imports moduleA, thus I expect it to work, but it does not. Is this because Python cashes imports and does not do it twice? But why it cannot then take the already cashed moduleA.functionA() from the memory instead of failing? I suppose the current behavior is a bug therefore.

Q2: If I remove the line "globalVariableFromModuleB = moduleA.functionA()" and leave only the cyclic import "import moduleA" then I have no failure. So, cyclic dependencies are not forbidden in Python. For what are they allowed if they don't work correclty as it shows my example?

Q3: If I change "import moduleA" to "from moduleA import functionA" the main program does not work either failing with another message "ImportError: cannot import name functionA".

Also I would like to post here a workaround for the people who don't like to redesign the application, like in my case.
Workaround (found it just experimentally). To add "import moduleB" before the "import moduleA" in the main.py, that is:

# main.py
import moduleB
import moduleA
print('It works!')

But I had to leave a long comment right at this import in the code, because main.py does not use directly any API from moduleB, so it is looking ugly.

Could one suggest some better wa how to resolve such case and answer 3 questions above, please?

Answer 1

cyclic import in python are a very nasty "Gotcha"; this article explains all the ins an outs nicely - please consider carefully reading it.

To solve the problem you simply have to brake the cycle - in your case, you could drop the import ModuleA in moduleB, since it's not needed (you already import A in main)

To really understand what's going on, consider the following:

• the you do import , python will load the code for and execute it line by line and adds the to sys.modules so that it knows it was already imported

• if the imported contains another import statement, python will load and start executing that code, and then add the module name to sys.module

• in your case sys.modules contains both moduleA and moduleB, but because the execution of module A was "interrupted" by the import moduleB statement the function definition never got executed, but the module dot added to sys.modules => AttributeError: 'module' object has no attribute 'functionA'

Hope this helps.

Answer 2

For instance, I would post here more complicated case (when each module calls a function from the other module in a global context) that works without significant redesign of the program:

main.py

import moduleA
print('Value=%s' % moduleA.functionA())

moduleA.py

globalVariableFromModuleA = 'globalA'
def functionA():
    return globalVariableFromModuleA + '_functionA'

import moduleB
globalVariableFromModuleA = moduleB.functionB()

moduleB.py

globalVariableFromModuleB = 'globalB'
def functionB():
    return 'functionB'

import moduleA
globalVariableFromModuleB = moduleA.functionA()

Result:

$ python main.py 
Value=functionB_functionA

The value does not contain 'globalA' that shows that it works, because globalVariableFromModuleA from moduleA.py is correctly evaluated by moduleB.functionB().

And the next example shows that Python prevents endless recursion not only for importing of modules, but for function invocations as well. If we modify moduleB.py the following way:

moduleB.py

globalVariableFromModuleB = 'globalB'
def functionB():
    return globalVariableFromModuleB + '_functionB'

import moduleA
globalVariableFromModuleB = moduleA.functionA()

Result:

$ python main.py 
Value=globalA_functionA_functionB_functionA

(at the second entering to functionA() it decided to not evaluate globalVariableFromModuleA more, but to take an initial value 'globalA')