CODEWITHSUNDEEP
python
Giannis
Giannis

Reputation: 5526

Python: import of Modules with mutual dependency

I have two files rest_api.py and Contact.py. Contact is similar to a domain object (contains Contact class), while rest_api has functions for setting up the application.

In rest_api I have the following lines:

from Contact import Contact
...
client = MongoClient('localhost',27017)
collection = client.crypto_database.test_collection
def dbcollection(){
     return collection
}
...
api.add_resource(Contact,'/contact/<string:contact_id>')

In Contact I try to do the following:

from rest_api import dbcollection

class Contact(Resource):
    def get(self,contact_id):
        result = {}
        result['data'] = dbcollection.find_one({'contact_id':contact_id})
        result['code'] = 200 if result['data'] else 404
        return make_response(dumps(result), result['code'],{"Content-type": "application/json"})

This fails with the following error: ImportError: cannot import name Contact

What is the correct way of importing contact, so that it can also use variables/functions from rest_api?

p.s If I move the collection code to a different file, and import that file instead things work, but I assume there is some other way..

Upvotes: 1

Views: 1090

Answers (2)

Julie in Austin
Julie in Austin

Reputation: 1003

Assuming you haven't a clue which modules are going to import which ever other ones, you can track that yourself and NOT do the import.

In your __init__.py, define these --

__module_imports__ = {}

def requires_module(name):
    return name not in __module_imports__

def importing_module(name):
    __module_imports__[name] = True

Then, at the top of each class file, where you define your classes add the following to this_module.py:

from my_modules import requires_module, importing_module

importing('ThisModule')
if requires_module('ThatModule')
    from my_modules.that_module import ThatModule

class ThisModule:
    """ Real Stuff Goes Here """
    pass

and this to that_module.py:

from my_modules import requires_module, importing_module

importing('ThatModule')
if requires_module('ThisModule')
    from my_modules.this_module import ThisModule

class ThatModule:
    """ Real Stuff Goes Here """
    pass

now you get your imports regardless of which gets imported first or whatever.

Upvotes: 0

burnpanck
burnpanck

Reputation: 2196

This is a circular import dependency, which cannot be solved as such. The problem is, that importing a python module really runs the code, which has to follow some order, one of the modules has to go first.

I would say that having the support code in a different file would be the proper way to go.

In this case however, the dbcollection is not actually needed at import time. Thus you can solve this by removing the import from the module level, into the get function. For example

class Contact(Resource):
    def get(self,contact_id):
        from rest_api import dbcollection
        result = {}
        result['data'] = dbcollection.find_one({'contact_id':contact_id})
        result['code'] = 200 if result['data'] else 404
        return make_response(dumps(result), result['code'],{"Content-type": "application/json"})

A similar approach would be the following:

import rest_api

class Contact(Resource):
    def get(self,contact_id):
        result = {}
        result['data'] = rest_api.dbcollection.find_one({'contact_id':contact_id})
        result['code'] = 200 if result['data'] else 404
        return make_response(dumps(result), result['code'],{"Content-type": "application/json"})

This should work, as python does some effort to resolve circular import dependencies: When it start importing a module, it creates an empty module dict for that one. Then when it finds a nested import, it proceeds with that one. If that in turn imports a module that is already in the import process it just skips it. Thus at the time Contact.py is being loaded, the import rest_api just takes the module dict that is already there. Since it does not contain dbcollection yet, from rest_api import dbcollection fails. A simple import rest_api does work however, since it's member is only addressed after Contact.py finishes importing (unless you call Contact.get at module level from within).

Upvotes: 2

Related Questions