Considérons python (3.x) les scripts:
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
Maintenant, bien sûr, j'ai importation circulaire et splendide ImportError.
Alors, pas pythonista, j'ai trois questions. Tout d'abord:
j'. Comment puis-je faire de cette chose que le travail ?
Et, sachant que quelqu'un va inévitablement dire "Circulaire importations de toujours indiquer un problème de conception", la deuxième question qui me vient:
ii. Pourquoi est-ce la conception de mauvais?
Et enfin, la troisième:
iii. Ce serait une meilleure alternative?
Pour être précis, la vérification du type que ci-dessus n'est qu'un exemple, il y a aussi un indice de la couche en fonction de la classe, qui permet à ie. trouver tous les utilisateurs qui sont membres d'une équipe (l'utilisateur de la classe a de nombreuses sous-classes, de sorte que l'indice est doublé, pour les utilisateurs en général et pour chaque sous-classe spécifique) ou toutes les équipes ayant donné utilisateur en tant que membre
Edit:
J'espère que de plus amples exemple permettra de clarifier ce que je cherche à atteindre. Fichiers omis pour la lisibilité (mais en avoir une de 300 ko fichier source qui me fait peur en quelque sorte, veuillez donc supposer que chaque classe est différente de fichier)
# 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}
et maintenant, certains d'utilisation:
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]
Donc, il fonctionne très bien (détails de mise en œuvre oublié, mais il n'y a rien de compliqué) en plus de ce qui est profane importation circulaire chose.
