Q:

Modules that rely on each other

I have a bind_form custom decorator that assigns a specified django form to a function.  This decorator will allow validation to be 'automatically' performed on function arguments - e.g., check if age is in required range, or check that user exists.  This is done for DRY reasons. 
Each form that is referenced in the decorator live in the forms module. 
An example of this form validation could be users.check_user_exists - and hence I must import the users module in the form module. 
So, now you see that I have forms module, that imports the users module so users.user_exists can be referenced, but users imports the forms module so a form can be used in the forms decorator:
forms.py:
import users

def bind_form(func):
    # binds form to function
    ...

class Create_User(Forms. Form):
    # validated create_user function
    ...
    def clean(self): #using for validation
        if users.user_exists(user):
           ...

users.py:
import forms

@forms.bind_form(form=forms. Create_User)
def create_user(**kwargs):
    ...

so as soon as users is imported, users attempts to reference bind_form, but this has not been 'seen' yet by forms. 
Is this a design flaw of mine, or am I missing something simple?  If a design flaw - suggestions welcome to improve. 
** constraints:**

there are many forms in the forms module. 
there are many functions in users module that have a validation form attached. 
the validation forms use many functions from users, and other modules. 

explained in another way:
a. forms imports users at line 4 of forms module
b. users.create_user references forms. Create_User
c. forms doesnt know about Create_User yet becasue it's declared on line 5 of forms module

A:

The trick with cyclic dependencies is to separate the statements in the global scope, such that all the statements which don't reference any symbols imported from the other module all occur before you import it.  For example...
forms.py:
# This statement doesn't reference 'users' at compile time
def bind_form(func):
    ...

# This statement doesn't reference 'users' at compile time
class Create_User(Forms. Form):

    # This statement declares a new scope
    def clean(self):

        # This statement references 'users' at runtime, but not at compile time
        if users.user_exists(user):
            ...

# Now import
import users

users.py:
# Import
import forms

# This statement references 'forms' at compile time
@forms.bind_form(form=forms. Create_User)
def create_user(**kwargs):
    ...

The usage of the users symbol in the Create_User.clean() method is not in the global scope, so it doesn't actually need the symbol to be defined until the point where the function is actually called.