Comprendre la « Component Architecture »
La Component Architecture, ou ZCA, historiquement issue de Zope 3 (qui s'appelle maintenant BlueBream), peut être utilisée pour n'importe quel projet Python, même en dehors d'une appli web. Elle trouve son intérêt lorsqu'on veut créer un programme hautement modulable, où les composants peuvent être rempacés facilement, ou même dynamiquement, sans toucher au code. Elle est aussi idéale pour créer un framework ou un CMS, et laisser la possibilité aux utilisateurs (qui sont donc, dans ce cas, développeurs ou intégrateurs), de choisir les composants ou de les surcharger par de la configuration.
Voici un petit exemple d'utilisation qui peut aider à saisir les principes.
Cet exemple est une sorte d'extrait du projet Virtual Care Team d'Etienne Saliez sur lequel je travaille de temps en temps, et donc le but est d'implémenter un dossier médical partagé entre une équipe de soin pluridisciplinaire, et de suivre l'évolution d'un problème. Après avoir fait une maquette en repoze.BFG (vct.demo), nous tentons de repartir de plus bas niveau avec le paquet vct.core, qui consiste pour l'instant en une api de stockage minimaliste, avec un plugin pour la ZODB, et un serveur XMLRPC permettant l'utilisation depuis n'importe quel langage. J'ai réutilisé ce projet pour un atelier interne de l'équipe Python à Alter Way.
Dossier médical
Le but de l'exercice est de créer un dossier médical permettant :
- un calcul de statistiques
- l'enregistrement dans une base de données arbitraire
- la lecture depuis une des bases de données
- une gestion des commentaires
On dispose d'une classe dossier médical :
>>> from dossiermedical import Dossier >>> dossier = Dossier()
Le dossier médical possède deux attributs :
>>> dossier.patient = 'ccomb' >>> dossier.exams = ['prise sang', 'radio du genou', 'coqueluche']
Les fonctionnalités du dossier médical sont décrites par son interface :
>>> from dossiermedical import IDossier >>> IDossier.providedBy(dossier) True
Voici l'implémentation du dossier, dans un fichier dossiermedical.py :
from zope.interface import Interface, Attribute, implements class IDossier(Interface): patient = Attribute(u'nom du patient') exams = Attribute(u'liste des examens') class Dossier(object): implements (IDossier) patient = None exams = None
Ajout de fonctionnalités
On souhaite ajouter deux fonctionnalités de statistiques au dossier médical : connaître sa taille et connaître la longueur moyenne des éléments. Pour ajouter des fonctionnalités, une première idée est d'ajouter des méthodes à notre Dossier (et donc aussi dans l'interface IDossier). Mais on souhaite plutôt séparer les fonctionnalités, et ne plus toucher à notre Dossier, qui est la fonctionnalité métier de base. Ceci permettra de changer le calcul des stats facilement sans toucher à l'implémentation du Dossier médical.
On décrit donc la nouvelle fonctionnalité dans une interface (qui possède deux attributs, num_exam et avg_exam) :
>>> from dossiermedical import IStat
Pour utiliser les fonctionnalités correspondant à cette interface sur le dossier médical, on utilise la notation suivante, qui signifie « donne moi la fonctionnalité IStat pour le dossier » :
>>> s = IStat(dossier)
Cette notation, qui ressemble à une instanciation de classe, permet en réalité de récupérer un adaptateur qui fournit IStat, et qui s'adapte au dossier. Pour que ça fonctionne il faut :
- écrire l'implémentation de l'adaptateur
- inscrire cette implémentation dans le registre de composants.
On pourra donc ensuite utiliser les méthodes de stats :
>>> s.num_exam() 3 >>> s.avg_exam() 11
Ci-dessous, voici l'implémentation de l'adaptateur, ainsi que son inscription dans le registre.
On utilise ici uniquement les paquets de la ZCA, à savoir zope.interface et zope.component. Le premier permet de définir des interfaces, tandis que le second offre le registre de composants et son API (inscription, récupération, etc.) :
from zope.component import adapts class IStat(Interface): def num_exam(): "return the number of exams" def avg_exam(): "return the average lenght of the exams" class Stat(object): implements(IStat) adapts(IDossier) def __init__(self, context): self.context = context def num_exam(self): return len(self.context.exams) def avg_exam(self): return len(''.join(self.context.exams))/self.num_exam() # inscription dans le registre from zope.component import getGlobalSiteManager gsm = getGlobalSiteManager() gsm.registerAdapter(Stat)
Ajout de plugins
On souhaite ajouter encore une fonctionnalité au dossier médical : pouvoir le stocker de différentes façons (sql, zodb, csv, ini). On commence donc par décrire la fonctionnalité dans une nouvelle interface IStockage, qui possède juste une méthode save(). :
>>> from dossiermedical import IStockage
Pour que le Dossier médical puisse fournir la fonctionnalité IStockage, on doit écrire un adaptateur fournissant IStockage, et qui s'adapte à IDossier. Comme on veut la fonctionnalité de IStockage aussi bien pour du SQL que du CSV ou du ZODB, on écrit plusieurs adaptateurs. Mais on ne peut pas inscrire dans le registre de composants plusieurs implémentations pour les même interfaces. En réalité on peut le faire, mais il faut inscrire chaque implémentataion sous un nom différent. Chaque adaptateur sera un adaptateur nommé, et le nom correspondra dans notre cas au type de base de données. Ici on ne peut pas utiliser la notation IStockage(dossier), car on veut indiquer quelle implémentation utiliser. Il faut utiliser getAdapter :
>>> from zope.component import getAdapter
On peut stocker une fois en CSV :
>>> stockage_csv = getAdapter(dossier, IStockage, "csv") >>> stockage_csv.save() ok, saved in CSV
Et une fois en SQL :
>>> stockage_sql = getAdapter(dossier, IStockage, "sql") >>> stockage_sql.save() ok, saved in SQL
Voici l'implémentation correspondante, et les inscriptions dans le registre :
class IStockage(Interface): def save(): "allows to save a dossier" class StockageCSV(object): implements(IStockage) adapts(IDossier) def __init__(self, context): self.context = context def save(self): print u"ok, saved in CSV" class StockageSQL(object): implements(IStockage) adapts(IDossier) def __init__(self, context): self.context = context def save(self): print u"ok, saved in SQL" # inscriptions dans le registre gsm.registerAdapter(StockageCSV, name="csv") gsm.registerAdapter(StockageSQL, name="sql")
Service pluggable
On souhaite maintenant récupérer notre dossier médical depuis une des sources au choix (sql, zodb, etc.). Ceci correspond encore à une nouvelle fonctionnalité, décrite par une interface ILoad. Le principe est le même que pour l'adaptateur nommé, sauf que cette fois on souhaite juste obtenir un composant qui fournit ILoad, mais qui ne s'adapte à rien. Ce type de composant s'appelle un utility :
>>> from zope.component import getUtility >>> getUtility(IStockage, "csv").load() ok, loaded
Voici le utility en question et son inscription dans le registre :
class ILoad(Interface): def load(self): """load the object""" class Loader(object): implements(ILoad) def load(self): print u"ok, loaded" # inscription dans le registre gsm.registerUtility(Loader(), name="csv")
Ajout dynamique d'une fonctionnalité générique
On souhaite enfin développer une fonctionnalité générique, et réutilisable pour autre chose qu'un dossier médical : ajouter des commentaires au dossier médical. Pour obtenir une vraie généricité, on doit implémenter la fonctionnalité de commentaires sans jamais faire référence au Dossier médical.
Comment fait-on ?
La fonctionnalité de commentaire correspond à l'interface IComments. Pour utiliser cette fonctionnalité IComments sur un dossier médical, il nous faut un adaptateur fournissant IComments, et s'adaptant à IDossier. Mais comme on ne veut pas faire référence à IDossier dans notre gestion de commentaires, au lieu de créer un adaptateur s'adaptant à IDossier on crée un adapatateur s'adaptant à une interface vide, qu'on appelle interface marqueur : ICommentable. Les interfaces marqueurs sont souvent utilisées de cette façon : leur nom ressemble à un adjectif en « able », et elle indique une capacité à fournir une fonctionnalité : par exemple ICommentable, IIndexable, IStockable, etc. (C'est de cette façon que son conçues les « behaviors » dans Plone 4) :
>>> from comment import ICommentable, IComments
Comment notre dossier médical peut-il maintenant fournir la fonctionnalité de commentaire ? Il suffit d'indiquer qu'il est « commentable » en lui ajoutant dynamiquement l'interface ICommentable :
>>> from zope.interface import alsoProvides >>> alsoProvides(dossier, ICommentable)
De cette façon, comme notre dossier médical fournit maintenant l'interface ICommentable, notre adaptateur de commentaire devient disponible :
>>> IComments(dossier).add_comment("un commentaire")
Voici la fonctionnalité de commentaire, qu'on place dans un module séparé comment.py :
from zope.interface import Interface, Attribute, implements from zope.component import adapts class ICommentable(Interface): "Add this marker interface to objects you want to be commentable" class IComments(Interface): comments = Attribute("list of comments") def add_comment(comment): "add a comment" class Comments(object): implements(IComments) adapts(ICommentable) def __init__(self, context): self.context = context if not hasattr(self.context, '_comments'): self.context._comments = [] self.comments = self.context._comments def add_comment(self, comment): self.comments.append(comment) # inscription dans le registre from zope.component import getGlobalSiteManager gsm = getGlobalSiteManager() gsm.registerAdapter(Comments)
Conclusion
Cet exemple a couvert les notions suivantes de la ZCA :
- adaptateur simple
- adaptateur nommé
- utility
- interface marqueur et fonctionnalité générique
Parmi les notions non abordées, on trouve les adaptateurs multiples, qui sont exatement la même chose que les adaptateurs simples (sauf qu'ils s'adaptent à plusieurs objets), ou bien les subscribers (adaptateurs d'abonnement). Pour en savoir plus, consultez le Guide complet de la ZCA
e-mail: 
mob: +33 608 955 845
jabber: ccomb à jabber.org
Twitter
LinkedIn
Facebook