Vamos considerar os scripts python (3.x):

main.py:

from test.team import team
from test.user import user

if __name__ == '__main__':
    u = user()
    t = team()
    u.setTeam(t)
    t.setLeader(u)

test / user.py:

from test.team import team

class user:
    def setTeam(self, t):
        if issubclass(t, team.__class__):
            self.team = t

test / team.py:

from test.user import user

class team:
    def setLeader(self, u):
        if issubclass(u, user.__class__):
            self.leader = u

Agora, é claro, tenho importação circular e ImportError esplêndido.

Então, não sendo pythonista, tenho três perguntas. Em primeiro lugar:

Eu. Como posso fazer essa coisa funcionar?

E, sabendo que alguém inevitavelmente dirá "Importações circulares sempre indicam um problema de design", a segunda pergunta vem:

ii. Por que esse design é ruim?

E o finalmente, terceiro:

iii. Qual seria a melhor alternativa?

Para ser mais preciso, a verificação de tipo, como acima, é apenas um exemplo, há também uma camada de índice baseada na classe, que permite ie. encontre todos os usuários membros de uma equipe (a classe de usuário tem muitas subclasses, portanto o índice é dobrado, para usuários em geral e para cada subclasse específica) ou todas as equipes que deram o usuário como membro

Editar:

Espero que um exemplo mais detalhado esclareça o que tento alcançar. Arquivos omitidos para facilitar a leitura (mas ter um arquivo de origem de 300kb me assusta de alguma forma, então, suponha que todas as classes estejam em um arquivo diferente)

# ENTITY

class Entity:
    _id    = None
    _defs  = {}
    _data  = None

    def __init__(self, **kwargs):
        self._id   = uuid.uuid4() # for example. or randint(). or x+1.
        self._data = {}.update(kwargs)

    def __settattr__(self, name, value):
        if name in self._defs:
            if issubclass(value.__class__, self._defs[name]):
                self._data[name] = value

                # more stuff goes here, specially indexing dependencies, so we can 
                # do Index(some_class, name_of_property, some.object) to find all   
                # objects of some_class or its children where
                # given property == some.object

            else:
                raise Exception('Some misleading message')
        else:
            self.__dict__[name] = value    

    def __gettattr__(self, name):
        return self._data[name]

# USERS 

class User(Entity):
    _defs  = {'team':Team}

class DPLUser(User):
    _defs  = {'team':DPLTeam}

class PythonUser(DPLUser)
    pass

class PerlUser(DPLUser)
    pass

class FunctionalUser(User):
    _defs  = {'team':FunctionalTeam}

class HaskellUser(FunctionalUser)
    pass

class ErlangUser(FunctionalUser)
    pass

# TEAMS

class Team(Entity):
    _defs  = {'leader':User}

class DPLTeam(Team):
    _defs  = {'leader':DPLUser}

class FunctionalTeam(Team):
    _defs  = {'leader':FunctionalUser}

e agora algum uso:

t1 = FunctionalTeam()
t2 = DLPTeam()
t3 = Team()

u1 = HaskellUser()
u2 = PythonUser()

t1.leader = u1 # ok
t2.leader = u2 # ok
t1.leader = u2 # not ok, exception
t3.leader = u2 # ok

# now , index

print(Index(FunctionalTeam, 'leader', u2)) # -> [t2]
print(Index(Team, 'leader', u2)) # -> [t2,t3]

Portanto, ele funciona muito bem (detalhes de implementação omitidos, mas não há nada complicado) além dessa coisa profana de importação circular.