6 janvier 2022

Prototype – Design Patterns

I. Contexte

Pour gérer et analyser les portefeuilles des fonds qui contiennent de nombreux ordres chez les clients, on fait d’abord les requêtes via les objets d’accès aux données vers les différentes sources, par exemple, les bases de données sur les ordres, les clients, les comptes, les parts, etc. avant de créer une liste de records instanciés contenant les informations complètes sous les contrôles et vérifications pour chaque portefeuille. En fait, les recherches des sources et les manipulations des données pourraient être très coûteuses à chaque appel d’accès vers leurs sources originales. En effet, un objet d’ordre se composerait par au moins les instances de client, compte et part. On aurait souvent le recours aux caches pour stocker les résultats de ces instances en mémoire, pour que tous les appels lisent les mêmes données mises en cache. Néanmoins, si on veut retoucher localement un champ d’un objet d’accès pendant une simulation, il faut récupérer une copie superficielle ou profonde, afin de ne pas déranger les autres réutilisations de l’application qui demandent toujours les objets originaux. Par exemple, s’il ne fallait chiffrer les données clientèles dans les ordres pendant qu’une seule génération d’un résultat, on aurait dû avoir besoin d’une copie profonde des ordres qui comprennent les objets de client depuis la source, et à la fois les copies superficielles des clients à modifier. Les données de source sont donc protégées grâce au clonage.

En fait, le patron de conception de création : Prototype permet de cloner des objets complexes et coûteux, sans se coupler à leurs classes. Dans cet article, on va apprendre le patron de conception de prototype en guise d’une mise en place d’un portefeuille à dupliquer avec les ordres encapsulant les informations de client, compte et part. Les prototypes servent à préparer les diverses manières à cloner tous ces composants du portefeuille en fonction des besoins. L’héritage multiple et la composition sont introduits pour leurs mises en œuvre en Python 3, tandis que le programme respecte le principe SOLID.

II. Conception de prototype

Le diagramme ULM démontre la conception du Prototype. En général, toutes les classes prototype devraient dériver d’une interface commune IPrototype déclarant une méthode abstraite clone, même sans connaître leur classe concrète de client à copier. Les objets prototype sont capables de créer les copies complètes du client, à condition qu’ils puissent accéder aux attributs privés des autres objets dans la classe de client. Au lieu d’évoquer __new__ ou __init__ de la classe, on appelle directement la méthode clone pour la création. Le client peut exploiter ces prototypes par l’héritage multiple ou la composition.

Selon notre contexte, dans un portefeuille les ordres sont les instances complexes comprenant plusieurs objets élémentaires comme le client, le compte et la part. Leurs informations sont fréquemment manipulées et réutilisées pour les analyses, par exemple, dans différents modèles évaluant les performances du portefeuille. Du coup, si une modification a lieu éventuellement sur un élément, les clones en profondeur devront être demandés chez les ordres ainsi que le portefeuille, afin que leurs informations originales soient toutes intouchables en application. Toutefois, les duplicatas des objets compris dans un ordre n’auront besoin que les duplications superficielles, si l’on appelle leurs méthodes de clone

III. Développement de prototype

Dans notre exemple, les objets client, compte, part composent une instance ordre, lorsque qu’un portefeuille contient une liste d’ordres instanciés. On va vérifier si grâce au prototype, les données resteront inchangées chez tous les ordres du portefeuille à la source, à la suite d’un chiffrement sur leurs informations clientèles dans une copie.

Afin de simplifier la démonstration, on cherche simplement les attributs basiques dont les valeurs viennent des sources extérieures pour les instances. Du fait, à part les identifiants uniques pour chacun, on définit la date d’exécution, le montant d’exécution et la devise chez l’ordre ; le nom et le pays du client ; le nom et le type du compte ; le nom et l’état de la part. En plus, dans cet exemple le portefeuille ne contient que dix ordres exécutés hier chez un client dans le même compte sur les parts identiques. Les montants des ordres à la source sont générés de la façon aléatoire à la distribution uniforme entre -100000,0 et 100000,0, lorsque leurs devises sont toujours en euro.   

Dans un premier temps, on conçoit en Python 3 l’interface de prototype IPrototype avec la méthode de clone, qui est mise en œuvre dans les deux classes dérivées pour obtenir les copies superficielles ou profondes. Les classes client, compte, part, ordre et portefeuille héritent des deux prototypes concrets en fonction de leurs attributs internes. D’ailleurs, on introduit les propiétés et le __slots__ pour rendre les attributs concisément utilisables pour le prototype et optimaux en mémoire. Sinon, en Python 3 les méthodes copy et deepcopy permettraient de fournir aux prototypes une duplication superficielle ou profonde respectivement au gré du besoin. Tandis que l’on veut chiffrer les informations de client par Fernet chez les ordres, on cherche uniquement un duplicata profond de tous les ordres du portefeuille. Par conséquent, lors du prochain appel du clone du portefeuille, on pourra retrouver constamment les informations originales de client dans les ordres.

# prototype_shallow_deep_clones.py

from abc import ABC, abstractmethod
from copy import copy, deepcopy
from cryptography.fernet import Fernet
from datetime import datetime, timedelta
from pytest import raises
from random import uniform

key = Fernet.generate_key()


class IPrototype(ABC):
    __slots__ = ()
    
    @abstractmethod
    def clone(self):
        raise NotImplemented


class ShallowClone(IPrototype):
    __slots__ = () 
    
    def clone(self):
        return copy(self)
        
        
class DeepClone(IPrototype):
    __slots__ = () 
    
    def clone(self):
        return deepcopy(self)
        
        

class Client(ShallowClone):
    
    __slots__ = ('_client_id', '_client_name', '_client_country')
    
    def __init__(self):
        self._client_id = None
        self._client_name = None
        self._client_country = None
        
    @property
    def client_id(self):
        return self._client_id
        
    @property
    def client_name(self):
        return self._client_name
        
    @property
    def client_country(self):
        return self._client_country
        
    @client_id.setter
    def client_id(self, value):
        self._client_id = value
        
    @client_name.setter
    def client_name(self, value):
        self._client_name = value
        
    @client_country.setter
    def client_country(self, value):
        self._client_country = value 
        
        
class Account(ShallowClone):
    
    __slots__ = ('_account_id', '_account_name', '_account_type')
    
    def __init__(self):
        self._account_id = None
        self._account_name = None
        self._account_type = None
        
    @property
    def account_id(self):
        return self._account_id
        
    @property
    def account_name(self):
        return self._account_name
        
    @property
    def account_type(self):
        return self._account_type
        
    @account_id.setter
    def account_id(self, value):
        self._account_id = value
        
    @account_name.setter
    def account_name(self, value):
        self._account_name = value
        
    @account_type.setter
    def account_type(self, value):
        self._account_type = value 


class Share(ShallowClone):
    
    __slots__ = ('_share_id', '_share_name', '_share_state')
    
    def __init__(self):
        self._share_id = None
        self._share_name = None
        self._share_state = None
        
    @property
    def share_id(self):
        return self._share_id
        
    @property
    def share_name(self):
        return self._share_name
        
    @property
    def share_state(self):
        return self._share_state
        
    @share_id.setter
    def share_id(self, value):
        self._share_id = value
        
    @share_name.setter
    def share_name(self, value):
        self._share_name = value
        
    @share_state.setter
    def share_state(self, value):
        self._share_state = value 


class Order(DeepClone):
    
    __slots__ = ('_order_id', '_pricing_date', '_amount', '_currency',
                 '_client', '_account', '_share')
    
    def __init__(self):
        self._order_id = None
        self._client = None
        self._account = None
        self._share = None
        self._pricing_date = None
        self._amount = None 
        self._currency = None 
        
    @property
    def order_id(self):
        return self._order_id
        
    @property
    def pricing_date(self):
        return self._pricing_date
        
    @property
    def amount(self):
        return self._amount
        
    @property
    def currency(self):
        return self._currency
        
    @property
    def client(self):
        return self._client
        
    @property
    def account(self):
        return self._account
        
    @property
    def share(self):
        return self._share
        
    @order_id.setter
    def order_id(self, value):
        self._order_id = value
        
    @pricing_date.setter
    def pricing_date(self, value):
        self._pricing_date = value
        
    @amount.setter
    def amount(self, value):
        self._amount = value
        
    @currency.setter
    def currency(self, value):
        self._currency = value
        
    @client.setter
    def client(self, value):
        self._client = value
        
    @account.setter
    def account(self, value):
        self._account = value
        
    @share.setter
    def share(self, value):
        self._share = value 
        
class Portfolio(DeepClone):
    
    __slots__ = ('_portfolio_id', '_orders')
    
    def __init__(self):
        self._portfolio_id = None
        self._orders = None 
        
    @property
    def portfolio_id(self):
        return self._portfolio_id
        
    @property
    def orders(self):
        return self._orders

    @portfolio_id.setter
    def portfolio_id(self, value):
        self._portfolio_id = value
        
    @orders.setter
    def orders(self, value):
        self._orders = value


def get_original_portfolio(): 
    original_orders = []
    for i in range(10):
        original_client = Client()
        original_client.client_id = 100
        original_client.client_name = 'Clement' 
        original_client.client_country = 'France'
        
        original_account = Account()
        original_account.account_id = 'A00'
        original_account.account_name = 'BKSG'
        original_account.account_type = 'omnibus'
        
        original_share = Share()
        original_share.share_id = 'FR123'
        original_share.share_name = 'ETF201'
        original_share.share_state = 'open'
        
        original_order = Order()
        original_order.order_id = i
        original_order.pricing_date = datetime.today() - timedelta(days=1)
        original_order.amount = uniform(-100000.0, 100000.0)
        original_order.currency = 'EUR'
        original_order.client = original_client
        original_order.account = original_account
        original_order.share = original_share
        original_orders.append(original_order)
    
    original_portfolio = Portfolio()
    original_portfolio.orders = original_orders
    return original_portfolio
    

def encrypt(message):
    fernet = Fernet(key) 
    return fernet.encrypt(str(message).encode('utf'))
    
    
def decrypt(encode_message): 
    fernet = Fernet(key)
    return fernet.decrypt(encode_message).decode('utf')
    
        
if __name__ == '__main__':
    original_portfolio = get_original_portfolio()
    
    copy_portfolio_1 = original_portfolio.clone()
    # profound copies
    assert copy_portfolio_1.orders !=  original_portfolio.orders
    assert len(copy_portfolio_1.orders) ==  len(original_portfolio.orders)
    assert copy_portfolio_1.portfolio_id ==  original_portfolio.portfolio_id
    
    for (o_1, o_2) in zip(copy_portfolio_1.orders, original_portfolio.orders):
        # profound copies
        assert o_1.order_id == o_2.order_id
        assert o_1.pricing_date == o_2.pricing_date
        assert o_1.amount == o_2.amount
        assert o_1.currency == o_2.currency
        assert o_1.client != o_2.client
        assert o_1.account != o_2.account
        assert o_1.share != o_2.share 
        
        # shallow copies
        assert o_1.client.client_id == o_2.client.client_id
        assert o_1.client.client_name == o_2.client.client_name
        assert o_1.client.client_country == o_2.client.client_country
        assert o_1.account.account_id == o_2.account.account_id
        assert o_1.account.account_name == o_2.account.account_name
        assert o_1.account.account_type == o_2.account.account_type
        assert o_1.share.share_id == o_2.share.share_id
        assert o_1.share.share_name == o_2.share.share_name
        assert o_1.share.share_state == o_2.share.share_state
    
    for o in copy_portfolio_1.orders:
        copy_client = o.client.clone()
        copy_client.client_name = encrypt(copy_client.client_name)
        copy_client.client_country = encrypt(copy_client.client_country)
        o.client = copy_client
    
    for o in copy_portfolio_1.orders:
        assert o.client.client_name != 'Clement' 
        assert decrypt(o.client.client_name) == 'Clement'
        assert o.client.client_country != 'France'
        assert decrypt(o.client.client_country) == 'France'
    
    copy_portfolio_2 = original_portfolio.clone()
    for o in copy_portfolio_2.orders:
        assert o.client.client_name == 'Clement'
        assert o.client.client_country == 'France'

Les tests unitaires sont bien passés. En effet, on crée un portefeuille par la méthode « couteuse » get_original_portfolio, qui ne devra jamais être changé à la suite. La 1e duplication du portefeuille confirme d’abord que la copie profonde s’applique sur lui-même et ses ordres, et les autres objets sont clonés en guise de la copie superficielle. Ensuite on y chiffre les informations clientèles confidentielles, ce qui ne modifie que le duplicata chez les ordres, lorsque toutes les données dans le portefeuille original restent intactes et disponibles pour une utilisation suivante.

Par ailleurs, la méthode clone pourrait être réalisée d’une manière plus complexe dans le prototype, si l’on ne veut copier que certains attributs d’un objet lors de son appel. Par exemple, au lieu de chiffrer le nom et le pays chez un client, on pourrait enlever ces attributs secrets lors du clonage.

Le code suivant aborde ce sujet. La mise en œuvre de la classe PartialClone dérivant de l’interface IPrototype prend un ensemble de noms d’attribut en propriété (hidden_property_set) à enlever. Grace à l’héritage multiple en Python 3, la classe Client peut dériver de cette classe de prototype et d’une classe OriginalClient sans clone. Avant chaque clonage, on doit définir les propriétés à supprimer dans son hidden_property_set, lorsque l’on remet ce dernier à un ensemble vide, pour que la duplication superficielle redevienne totale.

# prototype_partial_clone_by_inheritance.py

from abc import ABC, abstractmethod
from copy import copy
from pytest import raises


class IPrototype(ABC):
    __slots__ = ()
    
    @abstractmethod
    def clone(self):
        raise NotImplemented

        
class PartialClone(IPrototype):
    __slots__ = ()
    
    @property
    def hidden_property_set(self):
        return self._hidden_property_set
    
    @hidden_property_set.setter
    def hidden_property_set(self, v):
        self._hidden_property_set = v
        
    def reset_hidden_property_set(self):
        self.hidden_property_set = set()
        
    def clone(self):
        result = self.__class__.__new__(self.__class__)
        for base in self.__class__.__mro__:
            for s in getattr(base, '__slots__', []):
                if s not in self.hidden_property_set:
                    setattr(result, s, getattr(self, s))
        return result
        

class OriginalClient(object):
    __slots__ = ('_client_id', '_client_name', '_client_country')
    
    def __init__(self):
        self._client_id = None
        self._client_name = None
        self._client_country = None
        
    @property
    def client_id(self):
        return self._client_id
        
    @property
    def client_name(self):
        return self._client_name
        
    @property
    def client_country(self):
        return self._client_country
        
    @client_id.setter
    def client_id(self, value):
        self._client_id = value
        
    @client_name.setter
    def client_name(self, value):
        self._client_name = value
        
    @client_country.setter
    def client_country(self, value):
        self._client_country = value
        
        
class Client(OriginalClient, PartialClone):
    __slots__ = ('_hidden_property_set', )


def create_orignal_client():
    original_client = Client()
    original_client.client_id = 100
    original_client.client_name = 'Clement'
    original_client.client_country = 'France'
    return original_client


if __name__ == '__main__':
    original_client = create_orignal_client()
    
    original_client.reset_hidden_property_set()
    copy_client_1 = original_client.clone()
    assert copy_client_1.client_id == 100
    assert copy_client_1.client_name == 'Clement'
    assert copy_client_1.client_country == 'France' 
    copy_client_1.client_id = 10
    assert original_client.client_id == 100
    assert original_client.client_name == 'Clement'
    assert original_client.client_country == 'France' 
    
    original_client.hidden_property_set = {'_client_name', '_client_country'}
    copy_client_2 =  original_client.clone()
    original_client.reset_hidden_property_set() # should reset the clone 
    assert copy_client_2.client_id == 100
    with raises(AttributeError):
        copy_client_2.client_name
    with raises(AttributeError):
        copy_client_2.client_country
    
    copy_client_2.client_id = 10
    assert original_client.client_id == 100
    assert original_client.client_name == 'Clement'
    assert original_client.client_country == 'France'

Les tests unitaires sont bien passés. Le client dérive des deux classes qui s’occupent de fabriquer et cloner l’objet de client respectivement. Quand l’on appelle sa méthode reset_hidden_property_set, la copie superficielle totale est remise pour son clonage. En revanche, dès que hidden_property_set est affecté par un ensemble de noms d’attribut définis dans __slots__, un filtre chez la méthode clone empêche les duplications des attributs concernés. Du coup, les attributs d’un objet sont bien enlevés en copie, lorsque les données originales sont intouchées.

En outre, on aimerait parfois demander le clonage qui se varie dynamiquement au gré du besoin durant l’exécution. A part le héritage multiple en Python 3, on peut s’appuyer sur la composition pour mettre en place le clone partiel dans le code suivant, où le client dérive directement de l’interface IPrototype et il encapsule un objet de clonage (par défaut superficiel total) qui s’occupe de copier son instance. Du coup, justement avant l’appel de la méthode clone chez le client, on pourrait changer cet objet de clonage comme on veut pendant l’exécution, lorsque l’on le remet au clonage initial après l’appel, ce qui rend notre utilisation de clone flexible.

# prototype_partial_clone_by_composition.py

from abc import ABC, abstractmethod
from copy import copy
from pytest import raises


class IPrototype(ABC):
    __slots__ = ()
    
    @abstractmethod
    def clone(self):
        raise NotImplemented


class ShallowClone(IPrototype):
    __slots__ = ('_instance', )
        
    @property
    def instance(self):
        return self._instance
    
    @instance.setter
    def instance(self, v):
        self._instance = v
    
    def clone(self):
        return copy(self._instance)
        
        
class PartialClone(IPrototype):
    __slots__ = ('_hidden_property_set', '_instance')
    
    @property
    def hidden_property_set(self):
        return self._hidden_property_set
        
    @property
    def instance(self):
        return self._instance
    
    @hidden_property_set.setter
    def hidden_property_set(self, v):
        self._hidden_property_set = v
    
    @instance.setter
    def instance(self, v):
        self._instance = v
    
    def clone(self):
        result = self._instance.__class__.__new__(self._instance.__class__)
        for base in self._instance.__class__.__mro__:
            for s in getattr(base, '__slots__', []):
                if s not in self._hidden_property_set:
                    setattr(result, s, getattr(self._instance, s))
        return result
        

class Client(IPrototype):
    
    __slots__ = ('_client_id', '_client_name', '_client_country',
                 '_clone_obj')
    
    def __init__(self):
        self._client_id = None
        self._client_name = None
        self._client_country = None
        self._clone_obj = ShallowClone()
        
    @property
    def client_id(self):
        return self._client_id
        
    @property
    def client_name(self):
        return self._client_name
        
    @property
    def client_country(self):
        return self._client_country
        
    @property
    def clone_obj(self):
        return self._clone_obj
        
    @client_id.setter
    def client_id(self, value):
        self._client_id = value
        
    @client_name.setter
    def client_name(self, value):
        self._client_name = value
        
    @client_country.setter
    def client_country(self, value):
        self._client_country = value
        
    @clone_obj.setter
    def clone_obj(self, value):
        self._clone_obj = value
        
    def clone(self):
        c = self._clone_obj
        c.instance = self
        return c.clone()
        

def create_orignal_client():
    original_client = Client()
    original_client.client_id = 100
    original_client.client_name = 'Clement'
    original_client.client_country = 'France'
    return original_client
    
    
if __name__ == '__main__':
    original_client = create_orignal_client()
    
    copy_client_1 = original_client.clone()
    assert copy_client_1.client_id == 100
    assert copy_client_1.client_name == 'Clement'
    assert copy_client_1.client_country == 'France'
    copy_client_1.client_id = 10
    assert original_client.client_id == 100
    assert original_client.client_name == 'Clement'
    assert original_client.client_country == 'France'
    
    partial_clone = PartialClone()
    partial_clone.hidden_property_set = {'_client_name', '_client_country'}
    initial_clone = original_client.clone_obj
    original_client.clone_obj = partial_clone
    assert original_client.client_id == 100
    assert original_client.client_name == 'Clement'
    assert original_client.client_country  == 'France' 
    
    copy_client_2 =  original_client.clone()
    original_client.clone_obj = initial_clone  # should reset to the original
    assert copy_client_2.client_id == 100
    with raises(AttributeError):
        copy_client_2.client_name
    with raises(AttributeError):
        copy_client_2.client_country
    
    copy_client_2.client_id = 10
    assert original_client.client_id == 100
    assert original_client.client_name == 'Clement'
    assert original_client.client_country == 'France'

Les tests unitaires sont bien passés. Le client dérivant de l’interface IPrototype met au point la méthode clone en déléguant son instance à un objet de clonage, qui est responsable de la duplication et fourni pendant l’exécution du programme avant l’appel de clone. L’objet de clonage superficiel par défaut chez le client va copier entièrement l’instance du client. Or, si un objet de clonage partiel est affecté au client, la duplication superficielle aura lieu partiellement. Car cet objet prend en compte l’ensemble de noms d’attribut à enlever. Sinon, les données originales sont toujours inchangées.

Quoi que ce soit implémenté par l’héritage ou la composition en Python 3, plusieurs prototypes sont désormais disponibles pour fabriquer les duplicatas des différents objets chez un portefeuille complexe selon les besoins. D’ailleurs, par l’héritage, il faudrait choisir en avance une meilleure méthode clone qui s’adapterait aux attributs de l’instance à la phase du développement, lorsque la composition permettrait d’instancier dynamiquement un clonage qui fait partie de l’objet à copier justement avant la demande du clone.

Du fait, le patron de conception Prototype découple la génération d’un objet et son clonage. D’ores et déjà, on ne pourrait construire qu’une seule fois les objets originaux complexes dont on profiterait pour diverses copies nécessaires à la suite.

IV. Conclusion

Dans cet article, on met en évidence la nécessité du patron de conception Prototype, qui répond à nos besoins de la réutilisation des instances coûteuses durant leur première fabrication de la source. Il respecte le principe de responsabilité unique en découplant la génération et le clonage. Les implémentations s’appuient sur l’héritage multiple ou la composition en Python 3, ce qui permet de mettre les divers types de duplication dehors les objets à cloner. Le patron de conception prototype est mis en place et testé pour les copies superficielles, profondes et partielles, ce qui pourrait facilement s’étendre aux autres façons du clonage.

Expertise Design & Code

$

Python, Java, C++, C# et Front-End

Découvrez nos formations

$

Parcourir le catalogue

Boostez votre carrière !

$

Nos offres pour Développeurs

Tous les mois recevez nos derniers articles !

Try X4B now !

Découvrez gratuitement XComponent for Business. Notre solution logicielle BizDevOps !

Écrit par Dr. Ruijing HU

0 Comments

Submit a Comment

Votre adresse e-mail ne sera pas publiée.