Python and strategy pattern

[tanc]

Hi There,

I need your help to understand how to use Strategy pattern properly in Python.
Indeed i don't know how to transfer a result coming from a strategy to another.
Structure is : (files are at the bottom of this post)

• App.py
  
• AStrategyAbstract.py
  
• BStrategyAbstract.py
  
• CStrategyAbstract.py
  

Running the app below, App.py is giving me the following :

A1 Strategy applied
Give me your name
Foo !
B3 Strategy applied
C2 Strategy applied
___
A2 Strategy applied
Give me your name
Bar !
B1 Strategy applied
C2 Strategy applied

I would like to get the following, but I don't understand how.
Should i declare a getter/setter within app class but how to access it ?
Any other way ?

A1 Strategy applied
Give me your name
Foo !
B3 Strategy applied
Name given was Foo!
C2 Strategy applied
___
A2 Strategy applied
Give me your name
Bar !
B1 Strategy applied
Name given was Bar !
C2 Strategy applied

Can please someone point me on the right direction ?
Regards,
Pierre

Filename : App.py

from AStrategyAbstract import A1Strategy,A2Strategy,A3Strategy
from BStrategyAbstract import B1Strategy,B2Strategy,B3Strategy
from CStrategyAbstract import C1Strategy,C2Strategy,C3Strategy


a1_strategy = A1Strategy()
a2_strategy = A2Strategy()
a3_strategy = A3Strategy()


b1_strategy = B1Strategy()
b2_strategy = B2Strategy()
b3_strategy = B3Strategy()


c1_strategy = C1Strategy()
c2_strategy = C2Strategy()
c3_strategy = C3Strategy()

class App(object):
    def __init__(self, a_strategy, b_strategy, c_strategy):
        self._a_strategy = a_strategy
        self._b_strategy = b_strategy
        self._c_strategy = c_strategy
        self.name = None

    def do_sth(self):
        self._a_strategy.do_sth()
        self._b_strategy.do_sth()
        self._c_strategy.do_sth()

class AApp(App):
    def __init__(self):
        super(AApp, self).__init__(a1_strategy, b3_strategy, c2_strategy)

    def start(self):
        self.do_sth()

class BApp(App):
    def __init__(self):
        super(BApp, self).__init__(a1_strategy, b1_strategy, c2_strategy)

    def start(self):
        self.do_sth()

if __name__ == '__main__':
    myaapp = AApp()   
    myaapp.start()
    print("___")
    mybapp = BApp()   
    mybapp.start()

Filename : AStrategyAbstract.py

import abc 

class AStrategyAbstract(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def do_sth(self):
        """Required Method"""

class A1Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A1 Strategy applied")
        print("Give me your name")
        name = input()

class A2Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A2 Strategy applied")
        print("Give me your name")
        name = input()

class A3Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A3 Strategy applied")
        print("Give me your name")
        name = input()

Filename : BStrategyAbstract.py

import abc 

class BStrategyAbstract(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def do_sth(self):
        """Required Method"""

class B1Strategy(BStrategyAbstract):
    def do_sth(self):
        print("B1 Strategy applied")

class B2Strategy(BStrategyAbstract):
    def do_sth(self):
        print("B2 Strategy applied")

class B3Strategy(BStrategyAbstract):
    def do_sth(self):
        print("B3 Strategy applied")

Filename : CStrategyAbstract.py

import abc 

class CStrategyAbstract(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def do_sth(self):
        """Required Method"""

class C1Strategy(CStrategyAbstract):
    def do_sth(self):
        print("C1 Strategy applied")

class C2Strategy(CStrategyAbstract):
    def do_sth(self):
        print("C2 Strategy applied")

class C3Strategy(CStrategyAbstract):
    def do_sth(self):
        print("C3 Strategy applied")

[Gribouillis]

You could simply write

name = self._a_strategy.do_sth()

and have the do_sth() method of the A strategies return the name.

[tanc]

Thank you for this quick reply, and sorry for this dumb question.
Btw why the abstract method B for example doesn't care of param ?
Was more expecting

@abc.abstractmethod
    def do_sth(self, nom):
        """Required Method"""

than

@abc.abstractmethod
    def do_sth(self):
        """Required Method"""

I did update App.py to be

from AStrategyAbstract import A1Strategy,A2Strategy,A3Strategy
from BStrategyAbstract import B1Strategy,B2Strategy,B3Strategy
from CStrategyAbstract import C1Strategy,C2Strategy,C3Strategy


a1_strategy = A1Strategy()
a2_strategy = A2Strategy()
a3_strategy = A3Strategy()


b1_strategy = B1Strategy()
b2_strategy = B2Strategy()
b3_strategy = B3Strategy()


c1_strategy = C1Strategy()
c2_strategy = C2Strategy()
c3_strategy = C3Strategy()

class App(object):
    def __init__(self, a_strategy, b_strategy, c_strategy):
        self._a_strategy = a_strategy
        self._b_strategy = b_strategy
        self._c_strategy = c_strategy
        self.name = None
        
    def do_sth(self,name):
        self.name = self._a_strategy.do_sth()
        self._b_strategy.do_sth(self.name)
        self._c_strategy.do_sth(self.name)

class AApp(App):
    def __init__(self):
        super(AApp, self).__init__(a1_strategy, b3_strategy, c2_strategy)
         
    def start(self):
        self.do_sth(self.name)

class BApp(App):
    def __init__(self):
        super(BApp, self).__init__(a2_strategy, b1_strategy, c2_strategy)
         
    def start(self):
        self.do_sth(self.name)

if __name__ == '__main__':
    myaapp = AApp()   
    myaapp.start()

    mybapp = BApp()   
    mybapp.start()

AStrategyAbstract.py

import abc 

class AStrategyAbstract(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def do_sth(self):
        """Required Method"""

class A1Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A1 Strategy applied")
        print("Give me your name")
        name = input()
        return name

class A2Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A2 Strategy applied")
        print("Give me your name")
        name = input()
        return name

class A3Strategy(AStrategyAbstract):
    def do_sth(self):
        print("A3 Strategy applied")
        print("Give me your name")
        name = input()
        return name

BStrategyAbstract.py

import abc 

class BStrategyAbstract(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def do_sth(self):
        """Required Method"""

class B1Strategy(BStrategyAbstract):
    def do_sth(self, name):
        print("B1 Strategy applied {}".format(name))

class B2Strategy(BStrategyAbstract):
    def do_sth(self, name):
        print("B2 Strategy applied {}".format(name))

class B3Strategy(BStrategyAbstract):
    def do_sth(self, name):
        print("B3 Strategy applied {}".format(name))

[Gribouillis]

Python functions cannot be overloaded. One can only override functions in subclasses. I guess python doesn't even look at the parameters, even in the case of abstract methods. That said, I'm breaking a zen of python's rule: "In the face of ambiguity, refuse the temptation to guess." :) The answer is probably in abc's documentation.

[tanc]

I'll print this rule. Thanks a ton for this clarification !

[Gribouillis]

If you come from the Java world, don't think ABCMeta plays a similar role in Python as interfaces do in Java. I would have written these classes with a base class, but without using the abc module. You're adding an unnecessary complexity in the code. I think python's abc is only useful for extremely general functionalities, such as in collections.abc, otherwise it will come in your way rather than help you. Without ABCMeta, you can simply raise NotImplementedError in the base class' method. Last but not least, use python 3!