Zope : comprendre la « Component Architecture »

Voir aussi

Introduction

La Component Architecture, ou ZCA, historiquement issue de Zope 3 (qui s'est s'appellé ensuite BlueBream, puis qui a inspiré Pyramid), 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 vct.web en repoze.BFG, 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. C'est similaire également aux interfaces en JAVA ou aux classes de type en Haskell) :

>>> 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 commentaires 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)

En pratique

En pratique, l'adaptateur peut stocker les commentaires dans une base SQL ou n'importe quel autre conteneur. Il est de sa responsabilité d'être capable de les stocker et restituer correctement. Dans notre exemple, on les stocke simplement dans un attribut protégé. Si on travaille avec une ZODB, il peut être pratique d'utiliser un adaptateur d'annotations, qui peut les stocker de manière transparente dans un attribut privé __annotations__. Ce principe est expliqué dans le paquet zope.annotation

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 exactement 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 :

Présentation à PyconFR 2008

Le livre de référence sur le sujet :