Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/tylerlaberge/PyPattyrn

A simple library for implementing common design patterns.
https://github.com/tylerlaberge/PyPattyrn

design-patterns library python

Last synced: about 2 months ago
JSON representation

A simple library for implementing common design patterns.

Lists

README 

        
# PyPattyrn



```python

from pypattyrn.creational.singleton import Singleton



class DummyClass(object, metaclass=Singleton):  #  DummyClass is now a Singleton!

    ...

```



PyPattyrn is a python package aiming to make it easier and faster to implement design patterns into your own projects.



Design patterns by nature cannot be directly translated into code as they are just a description of how to solve a particular problem. However, many of the common design patterns have boilerplate code that is common throughout all implementations of the pattern. This package captures that common code and makes it easy to use so that you dont have to write it yourself in all your projects.

___



### Contents

___

* [Installation](https://github.com/tylerlaberge/PyPattyrn#installation)

* [Examples](https://github.com/tylerlaberge/PyPattyrn#examples)

  * [Behavioral Patterns](https://github.com/tylerlaberge/PyPattyrn#behavioral-patterns)

    * [Chain of Responsibility](https://github.com/tylerlaberge/PyPattyrn#chain-of-responsibility-pattern)

    * [Command](https://github.com/tylerlaberge/PyPattyrn#command-pattern)

    * [Iterator](https://github.com/tylerlaberge/PyPattyrn#iterator-pattern)

    * [Mediator](https://github.com/tylerlaberge/PyPattyrn#mediator-pattern)

    * [Memento](https://github.com/tylerlaberge/PyPattyrn#memento-pattern)

    * [Null Object](https://github.com/tylerlaberge/PyPattyrn#null-object-pattern)

    * [Observer](https://github.com/tylerlaberge/PyPattyrn#observer-pattern)

    * [Visitor](https://github.com/tylerlaberge/PyPattyrn#visitor-pattern)

  * [Creational Patterns](https://github.com/tylerlaberge/PyPattyrn#creational-patterns)

    * [Builder](https://github.com/tylerlaberge/PyPattyrn#builder-pattern)

    * [Factory](https://github.com/tylerlaberge/PyPattyrn#factory-pattern)

    * [Abstract Factory](https://github.com/tylerlaberge/PyPattyrn#abstract-factory-pattern)

    * [Object Pool](https://github.com/tylerlaberge/PyPattyrn#object-pool-pattern)

    * [Prototype](https://github.com/tylerlaberge/PyPattyrn#prototype-pattern)

    * [Singleton](https://github.com/tylerlaberge/PyPattyrn#singleton-pattern)

  * [Structural Patterns](https://github.com/tylerlaberge/PyPattyrn#structural-patterns)

    * [Adapter](https://github.com/tylerlaberge/PyPattyrn#adapter-pattern)

    * [Composite](https://github.com/tylerlaberge/PyPattyrn#composite-pattern)

    * [Decorator](https://github.com/tylerlaberge/PyPattyrn#decorator-pattern)

    * [Flyweight](https://github.com/tylerlaberge/PyPattyrn#flyweight-pattern)

* [Resources](https://github.com/tylerlaberge/PyPattyrn#resources)



___

### Installation

___

```

pip install pypattyrn

```



or



```

git clone https://github.com/tylerlaberge/PyPattyrn.git

cd PyPattyrn

python setup.py install

```



___

### Examples

___



#### Behavioral Patterns



Patterns which deal with communication between objects.

___

##### Chain of Responsibility Pattern



Pass a request along a chain of objects until the request is handled.



```python

from pypattyrn.behavioral.chain import Chain, ChainLink



class ConcreteChainLinkThree(ChainLink): # This object is a ChainLink



    def handle(self, request): # Implement the handle method.

        if request == 'handle_three':

            return "Handled in chain link three"

        else:

            return self.successor_handle(request) # If this ChainLink can't handle the request, 

                                                  # ask its successor to handle it. 

                                                  # (Has no successor so will raise AttributeError)

                                                  # (This exception is caught and will call a Chains fail method)



class ConcreteChainLinkTwo(ChainLink): # This object is a ChainLink



    def __init__(self): # Override init to set a successor on initialization.

        super().__init__() # first call ChainLinks init

        self.set_successor(ConcreteChainLinkThree()) # Set the successor of this chain link 

                                                     # to a ConcreteChainLinkThree instance.



    def handle(self, request): # Implement the handle method.

        if request == 'handle_two':

            return "Handled in chain link two"

        else:

            return self.successor_handle(request) # If this ChainLink can't handle a request 

                                                  # ask its successor to handle it 

                                                  # (the ConcreteChainLinkThree instance).



class ConcreteChainLinkOne(ChainLink): # This object is a ChainLink



    def __init__(self): 

        super().__init__()

        self.set_successor(ConcreteChainLinkTwo()) # Set the successor of this ChainLink

                                                   # to a ConcreteChainLinkTwo instance.



    def handle(self, request): # Implement the handle method.

        if request == 'handle_one':

            return "Handled in chain link one"

        else:

            return self.successor_handle(request) # If this ChainLink can't handle a request 

                                                  # ask its successor to handle it 

                                                  # (the ConcreteChainLinkTwo instance).



class ConcreteChain(Chain): # This object is a Chain



    def __init__(self): # Override init to initialize a Chain with the starting chain link.

        super().__init__(ConcreteChainLinkOne()) # Initialize this Chain with a start chain link.

                                                 # (a ConcreteChainLinkOne instance)



    def fail(self): # Implement the fail method, this is called if no chain links could handle a request.

        return 'Fail'



chain = ConcreteChain()



assert "Handled in chain link one" == chain.handle("handle_one")

assert "Handled in chain link two" == chain.handle("handle_two")

assert "Handled in chain link three" == chain.handle("handle_three")

assert "Fail" == chain.handle('handle_four')

```

##### Command Pattern



Encapsulate information for performing an action into an object.



```python

from pypattyrn.behavioral.command import Receiver, Command, Invoker



class Thermostat(Receiver): # This object is a Receiver. 

                            # Contains methods for commands to use.



    def raise_temp(self, amount):

        return "Temperature raised by {0} degrees".format(amount)



    def lower_temp(self, amount):

        return "Temperature lowered by {0} degrees".format(amount)



class RaiseTempCommand(Command): # This object is a Command.



    def __init__(self, receiver, amount=5): # Override init to include a temperature amount argument.

        super().__init__(receiver)

        self.amount = amount



    def execute(self): # Implement the execute method.

        return self._receiver.action('raise_temp', self.amount) # Call on the Receiver's action method  with 

                                                                # the name of the method to call and args.

                                                                # (Raises the temperature by 5 degrees.)



    def unexecute(self): # Implement the unexecute method.

        return self._receiver.action('lower_temp', self.amount) # Calls on the Receiver to lower 

                                                                # the temperature by 5 degrees.

                                                     



class LowerTempCommand(Command): # This object is a Command.

 

   def __init__(self, receiver, amount=5):

        super().__init__(receiver)

        self.amount = amount



    def execute(self):

        return self._receiver.action('lower_temp', self.amount) # Call on the receiver to lower the

                                                                # temperature by 5 degrees.



    def unexecute(self):

        return self._receiver.action('raise_temp', self.amount) # Call on the receiver to raise the 

                                                                # temperature by 5 degrees.



class Worker(Invoker): # This object is the Invoker



    def __init__(self): # Override init to initialize an Invoker with Commands to accept.

        super().__init__([LowerTempCommand, RaiseTempCommand]) # Initialize the Invoker with the

                                                               # LowerTempCommand and RaiseTempCommand classes.



thermostat = Thermostat() # Create a Receiver.

worker = Worker() # Create an Invoker.



assert "Temperature lowered by 5 degrees" == worker.execute(LowerTempCommand(thermostat)) # Have the Invoker execute a LowerTempCommand

                                                                                          # which uses the thermostat Receiver.

assert "Temperature raised by 5 degrees" == worker.execute(RaiseTempCommand(thermostat)) # Have the Invoker execute a RaiseTempCommand

                                                                                          # which uses the thermostat Receiver.

assert "Temperature lowered by 5 degrees" == worker.undo() # Undo the previous command (Calls the RaiseTempCommand unexecute method.)

```



##### Iterator Pattern



A way of sequentially accessing elements in a collection.



```python

from pypattyrn.behavioral.iterator import Iterable, Iterator



class Counter(Iterable): # This object is an Iterable



    def __init__(self, max):

        self.count = 0

        self.max = max



    def __next__(self): # Implement the __next__ method.

        self.count += 1 # Increment the count

        if self.count > self.max:

            raise StopIteration() # make sure to raise StopIteration at the appropriate time.

        else:

            return self.count - 1 # Return the count



class CounterIterator(Iterator): # This object is an Iterator



    def __init__(self): # Override init to initialize an Iterator with the Counter object.

        super().__init__(Counter(10)) # Initialize the iterator with a Counter that goes to 10.



counter_iterator = CounterIterator() # Create a CounterIterator.



for count in counter_iterator: # You can loop through it how you would expect.

    print(count)  # 0, 1, 2, 3, ..., 9

```



##### Mediator Pattern



An intermediary for managing communications between many objects.



```python

from pypattyrn.behavioral.mediator import Mediator



class Dog(object):

    sound = ''



    def set_sound(self, sound):

        self.sound = sound



class Cat(object):

    sound = ''



    def set_sound(self, sound):

        self.sound = sound



dog = Dog()

cat = Cat()



mediator = Mediator() # Create a Mediator object.



mediator.connect('set_dog_sound', dog.set_sound) # Connect the signal 'set_dog_sound' to the dog.set_sound method.

mediator.connect('set_cat_sound', cat.set_sound) # Connect the signal 'set_cat_sound' to the cat.set_sound method.



mediator.connect('set_sound', dog.set_sound) # Also connect the signal 'set_sound' to the dog.set_sound method.

mediator.connect('set_sound', cat.set_sound) # Also connect the signal 'set_sound' to the cat.set_sound method.



mediator.signal('set_sound', 'foo') # Send out the signal 'set_sound' 

                                    # with an argument to be passed to the connected methods.

                                    # (Sets dog.sound and cat.sound to 'foo')



assert 'foo' == dog.sound 

assert 'foo' == cat.sound



mediator.signal('set_dog_sound', 'woof') # Send out the signal 'set_dog_sound'

                                         # (Sets dog.sound to 'woof')

mediator.signal('set_cat_sound', 'meow') # Send out the signal 'set_cat_sound'

                                         # (Sets cat.sound to 'meow')



assert 'woof' == dog.sound

assert 'meow' == cat.sound



mediator.disconnect('set_sound', dog.set_sound) # Disconnect the method dog.sound from the signal 'set_sound'



mediator.signal('set_sound', 'bar') # Send out the signal 'set_sound'

                                    # (Only sets cat.sound to 'bar' because we disconnected dog.sound)



assert 'woof' == dog.sound

assert 'bar' == cat.sound

```



##### Memento Pattern



Save the state of an object and rollback to it at a later time.



```python

from pypattyrn.behavioral.memento import Originator



class Cat(Originator): # This object is an Originator

    def __init__(self, name):

        self.name = name



cat = Cat('Tom') # Initialize a Cat with the name 'Tom'

assert cat.name == 'Tom'



cat_memento = cat.commit() # Save the cats current state to a Memento object.

cat.name = 'jerry' # Change the cats name to 'jerry'

assert cat.name == 'jerry'



cat.rollback(cat_memento) # Restore the cats state to the memento object we saved.

assert 'Tom' == cat.name # The cats name was changed back to 'Tom' as expected.

```



##### Null Object Pattern



Encapsulate the absence of an object into an object with neutral behavior.



```python

from pypattyrn.behavioral.null import Null



# You can initialize a Null object with any parameters.

try:

    Null()

    Null('value')

    Null('value', param='value')

except:

    raise AssertionError()



null = Null()



# Attempting to set parameters won't do anything and won't error

try:

    null.foo = 'foo' 

    null.foo.bar = 'bar'

except:

    raise AssertionError()



# Calling on a null object in any way will just return that null object.



assert null == null()

assert null == null('value')

assert null == null('value', param='value')

assert null == null.foo

assert null == null.foo.bar

assert null == null.foo.bar.method1()

assert null == null.foo.bar.method1().method2('foo', bar='bar').attr3



assert str(null) == '' # Null objects string representation is the empty string.

assert repr(null) == '' # Null objects repr is the empty string.

assert bool(null) is False # Null object evaluates to False as a boolean.



# Trying to delete attributes doesn't do anything and won't error.

try:

    del null.foo 

    del null.foo.bar

except:

    raise AssertionError()

```



##### Observer Pattern



Notify many objects when a single object's state changes.



```python

from pypattyrn.behavioral.observer import Observable, Observer



class ConcreteObservable(Observable): # This object is an Observable.

    _kinda_private_var = 'I am kinda private'

    __private_var = 'I am more private'



    def change_state(self, **kwargs): # Some method to change this objects state and notify observers.

        for key, value in kwargs.items():

            setattr(self, key, value) # Change the objects state.



        self.notify() # Notify all observers of the change in state.

                      # Will call the update method of each attached observer with kwargs that come

                      # from this objects __dict__ attribute, minus any private variables (starts with __ or _)



class ConcreteObserver(Observer): # This object is an Observer.

    updated_state = None



    def update(self, **state): # Implement the update method. 

                               # Called when an attached observable calls its notify method.

        self.updated_state = state



observable = ConcreteObservable() # Create an Observable

observer_1 = ConcreteObserver() # Create Observers

observer_2 = ConcreteObserver()

observer_3 = ConcreteObserver()



observable.attach(observer_1) # Attach each of the Observers to the Observable

observable.attach(observer_2)

observable.attach(observer_3)



observable.change_state(foo='foo', bar='bar') # Change the Observable's state.

                                              # Also calls notify which will call each Observers update method.



expected_state = {'foo': 'foo', 'bar': 'bar'} 



# Make sure each Observers state was changed accordingly when the notify method was called by the Observable.



assert sorted(expected_state.keys()) == sorted(observer_1.updated_state.keys()) and \

       sorted(expected_state.values()) == sorted(observer_1.updated_state.values())



assert sorted(expected_state.keys()) == sorted(observer_2.updated_state.keys()) and \

       sorted(expected_state.values()) == sorted(observer_2.updated_state.values())



assert sorted(expected_state.keys()) == sorted(observer_3.updated_state.keys()) and \

       sorted(expected_state.values()) == sorted(observer_3.updated_state.values())



observable.detach(observer_1) # Detach Observer 1 from the Observable

observable.change_state(bar='foobar') # Change the Observables state.

expected_state_2 = {'foo': 'foo', 'bar': 'foobar'}



# Make sure each Observers state was changed accordingly when notify was called by the Observable,

# Except for observer_1 because we detached that Observer from the Observable.



assert sorted(expected_state_2.keys()) != sorted(observer_1.updated_state.keys()) or \

       sorted(expected_state_2.values()) != sorted(observer_1.updated_state.values())



assert sorted(expected_state_2.keys()) == sorted(observer_2.updated_state.keys()) and \

       sorted(expected_state_2.values()) == sorted(observer_2.updated_state.values())



assert sorted(expected_state_2.keys()) == sorted(observer_3.updated_state.keys()) and \

       sorted(expected_state_2.values()) == sorted(observer_3.updated_state.values())

```



##### Visitor Pattern



Add new operations to an existing class without modifying it.



```python

from pypattyrn.behavioral.visitor import Visitee, Visitor



class A(Visitee): # This object is a Visitee

    pass



class B(A): # This object is an A, which also makes this a Visitee.

    pass



class C(B): # This object is a B, which also makes this a Visitee.

    pass



class D(Visitee): # This object is a Visitee

    pass



class NodeVisitor(Visitor): # This object is a Visitor



    def generic_visit(self, node, *args, **kwargs): # Implement the generic visit method.

                                                    # This is called when there is no visit_ method

                                                    # implemented for a particular visitee.



        return 'generic_visit ' + node.__class__.__name__



    def visit_b(self, node, *args, **kwargs): # Called when this object visits a Visitee of class 'B'.

        return 'visit_b ' + node.__class__.__name__



    def visit_d(self, node, *args, **kwargs): # Called when this object visits a Visitee of class 'D'.

        return 'visit_d {0} args: {1} kwargs: {2}'.format(node.__class__.__name__, args, kwargs)



# Create Visitee's

node_a = A()

node_b = B()

node_c = C()

node_d = D()



# Create Visitor

node_visitor = NodeVisitor()



assert 'generic_visit A' == node_a.accept(node_visitor) # Visit node_a with the Visitor.

                                                        # Since the visitor does not have a visit_a method,

                                                        # generic_visit is called.

assert 'visit_b B' == node_b.accept(node_visitor) # Visit node_b with the Visitor.

                                                  # Calls the visitors visit_b method.

assert 'visit_b C' == node_c.accept(node_visitor) # Visit node_c with the Visitor.

                                                  # Even though the visitor does not have a visit_c method, 

                                                  # since node_c inherits B, the Visitors visit_b method is called.



# Visit node_d with the Visitor. Calls the visitors visit_d method.

assert "visit_d D args: ('foo', 'bar') kwargs: {'foobar': 'foobar'}" == node_d.accept(node_visitor,

                                                                                      'foo', 'bar',

                                                                                      foobar='foobar')

```



___

#### Creational Patterns



Patterns which deal with object creation.

___



##### Builder Pattern



Separate object construction from its representation.



```python

from pypattyrn.creational.builder import Builder, Director



class Building(object):  # The object being constructed.



    def __init__(self):

        self.floor = None

        self.size = None



    def __repr__(self):

        return 'Floor: {0.floor} | Size: {0.size}'.format(self)



class HomeBuilder(Builder):  # A base Builder class for constructing homes.



    def __init__(self):

        super().__init__(Building())  # Initialize the Builder class with a Building instance.

        self._register('floor', self._build_floor)  # Register the keyword 'floor' with the _build_floor method.

        self._register('size', self._build_size)  # Register the keyword 'size' with the _build_size method.



    def _build_floor(self):

        pass



    def _build_size(self):

        pass



class HouseBuilder(HomeBuilder):  # A concrete HomeBuilder class for constructing houses



    def _build_floor(self):

        self.constructed_object.floor = 'One'  # Alter the Building's floor attribute.



    def _build_size(self):

        self.constructed_object.size = 'Big'  # Alter the Building's size attribute.



class FlatBuilder(HomeBuilder):  # A concrete HomeBuilder class for constructing flats



    def _build_floor(self):

        self.constructed_object.floor = 'More than one'  # Alter the Building's floor attribute.



    def _build_size(self):

        self.constructed_object.size = 'Small'  # Alter the Building's size attribute.



class HomeDirector(Director):  # A Director class for managing home construction.



    def construct(self):

        self.builder.build('floor')  # Build the floor part of the Building by using the keyword 'floor'

        self.builder.build('size')  # Build the size part of the Building by using the keyword 'size'



home_director = HomeDirector()



home_director.builder = HouseBuilder()  # Use the house builder.

home_director.construct()  # Construct the house.

house = home_director.get_constructed_object()  # Get the constructed house.

print(repr(house))    #Floor: One | Size: Big

    

home_director.builder = FlatBuilder()  # Use the flat builder.

home_director.construct()  # Construct the flat.

house = home_director.get_constructed_object()  # Get the constructed flat.

print(repr(house))    #Floor: More than one | Size: Small

```



##### Factory Pattern



An interface for creating an object.



```python

from pypattyrn.creational.factory import Factory  # This is just an interface



class Cat(object):



    def speak(self):

        print('meow')



class Dog(object):



    def speak(self):

        print('woof')



class AnimalFactory(Factory):  # A factory class for creating animals.



    def create(self, animal_type):  # Implement the abstract create method.

        if animal_type == 'cat':

            return Cat()

        elif animal_type == 'dog':

            return Dog()

        else:

            return None



animal_factory = AnimalFactory()



cat = animal_factory.create('cat')

dog = animal_factory.create('dog')



cat.speak()  # 'meow'

dog.speak()  # 'woof'

```



##### Abstract Factory Pattern



Create an instance from a family of factories.



```python

from pypattyrn.creational.factory import Factory, AbstractFactory



class Cat(object):



    def speak(self):

        print('meow')



class Dog(object):



    def speak(self):

        print('woof')



class Ant(object):



    def march(self):

        print('march')



class Fly(object):



    def fly(self):

        print('fly')



class AnimalFactory(Factory):  # A factory class for creating animals.



    def create(self, animal_type):  # Implement the abstract create method.

        if animal_type == 'cat':

            return Cat()

        elif animal_type == 'dog':

            return Dog()

        else:

            return None



class InsectFactory(Factory):  # A factory class for creating insects.



    def create(self, insect_type):  # Implement the abstract create method.

        if insect_type == 'ant':

            return Ant()

        elif insect_type == 'fly':

            return Fly()

        else:

            return None



class CreatureFactory(AbstractFactory):  # A Factory class for creating creatures.



    def __init__(self):

        super().__init__()

        self._register('insect_factory', InsectFactory())  # Register an InsectFactory with a keyword.

        self._register('animal_factory', AnimalFactory())  # Register an AnimalFactory with a keyword.



    def create(self, creature_type):  # Implement the Abstract create method.

        if creature_type == 'cat' or creature_type == 'dog':

            return self._factories['animal_factory'].create(creature_type)  # Use the AnimalFactory

        elif creature_type == 'ant' or creature_type == 'fly':

            return self._factories['insect_factory'].create(creature_type)  # Use the InsectFactory

        else:

            return None



creature_factory = CreatureFactory()



cat = creature_factory.create('cat')

dog = creature_factory.create('dog')

ant = creature_factory.create('ant')

fly = creature_factory.create('fly')



cat.speak()  # 'meow'

dog.speak()  # 'woof'

ant.march()  # 'march'

fly.fly()  # 'fly'

```



##### Object Pool Pattern



Provide a pool of instantiated objects which can be checked out and returned rather than creating new objects all the time.



```python

from pypattyrn.creational.pool import Reusable, Pool



class Dog(Reusable):

    def __init__(self, sound):

        self.sound = sound

        super().__init__()



class DogPool(Pool):

    def __init__(self):

        super().__init__(Dog, 'woof')



dog_pool = DogPool()



dog_one = dog_pool.acquire()

dog_two = dog_pool.acquire()

dog_two.sound = 'meow'



dog_pool.release(dog_one)

dog_three = dog_pool.acquire()



dog_pool.release(dog_two)

dog_four = dog_pool.acquire()



assert id(dog_one) == id(dog_three)

assert id(dog_two) == id(dog_four)

assert dog_one.sound == dog_two.sound

assert dog_three.sound == dog_four.sound

assert dog_one.sound == dog_four.sound

```



##### Prototype Pattern



Clone an object to produce new objects.



```python

from pypattyrn.creational.prototype import Prototype



class Point(Prototype):

    def __init__(self, x, y):

        self.x = x

        self.y = y



    def move(self, x, y):

        self.x += x

        self.y += y



point_one = Point(15, 15)

point_two = point_one.prototype(z=20)

point_three = point_two.prototype()



assert point_one.x == point_two.x

assert point_one.y == point_two.y

assert not hasattr(point_one, 'z')

assert hasattr(point_two, 'z')

assert point_two.z == 20

assert point_three.__dict__ == point_two.__dict__



from math import sqrt

def distance_to(this, other):

    return sqrt((this.x - other.x) ** 2 + (this.y - other.y) ** 2)



point_four = point_three.prototype(distance_to=distance_to)



assert hasattr(point_four, 'distance_to')

assert point_four.distance_to(point_three) == 0

```



##### Singleton Pattern



Ensure that only a single instance of a class exists.



```python

from pypattyrn.creational.singleton import Singleton



class DummySingletonOne(object, metaclass=Singleton):



    def __init__(self):

        pass



class DummySingletonTwo(object, metaclass=Singleton):



    def __init__(self):

        pass



dummy_class_one_instance_one = DummySingletonOne()

dummy_class_one_instance_two = DummySingletonOne()



dummy_class_two_instance_one = DummySingletonTwo()

dummy_class_two_instance_two = DummySingletonTwo()



assert id(dummy_class_one_instance_one) == id(dummy_class_one_instance_two)

assert id(dummy_class_two_instance_one) == id(dummy_class_two_instance_two)



assert id(dummy_class_one_instance_one) != id(dummy_class_two_instance_one)

assert id(dummy_class_one_instance_two) != id(dummy_class_two_instance_two)

```

___



#### Structural Patterns



Patterns which deal with object composition

___



##### Adapter Pattern



Wrap an object into an interface which the client expects. 



```python

from pypattyrn.structural.adapter import Adapter



class Dog(object):

    def __init__(self):

        self.name = "Dog"



    def bark(self):

        return "woof!"



class Cat(object):

    def __init__(self):

        self.name = "Cat"



    def meow(self):

        return "meow!"



cat = Cat()

dog = Dog()



cat_adapter = Adapter(cat, make_noise=cat.meow)

dog_adapter = Adapter(dog, make_noise=dog.bark)



assert cat_adapter.make_noise == cat.meow

assert dog_adapter.make_noise == dog.bark



assert cat_adapter.make_noise() == 'meow!'

assert dog_adapter.make_noise() == 'woof!'



assert cat_adapter.name == 'Cat'

assert dog_adapter.name == 'Dog'



assert cat_adapter.meow() == 'meow!'

assert dog_adapter.bark() == 'woof!'



assert cat_adapter.original_dict() == cat.__dict__

assert dog_adapter.original_dict() == dog.__dict__



bad_cat_adapter = Adapter(cat, foo=cat.name)



try:

    bad_cat_adapter.foo

except AttributeError:

    pass

else:

    raise AssertionError()



bad_dog_adapter = Adapter(dog, make_noise=cat.meow)



try:

    bad_dog_adapter.make_noise()

except AttributeError:

    pass

else:

    raise AssertionError()

```



##### Composite Pattern



Compose objects into a tree structure of objects that can be treated uniformly.



```python

from pypattyrn.structural.composite import Composite



class Component(object):



    def do_something(self):

        pass



class Leaf(Component):



    def __init__(self):

        self.did_something = False



    def do_something(self):

        self.did_something = True



leaf_one = Leaf()

leaf_two = Leaf()

leaf_three = Leaf()



composite_one = Composite(Component)

composite_two = Composite(Component)

composite_three = Composite(Component)



composite_one.add_component(leaf_one)

composite_two.add_component(leaf_two)

composite_three.add_component(leaf_three)



composite_two.add_component(composite_three)

composite_one.add_component(composite_two)



assert set() == {leaf_one, composite_two}.symmetric_difference(composite_one.components)

assert set() == {leaf_two, composite_three}.symmetric_difference(composite_two.components)

assert set() == {leaf_three}.symmetric_difference(composite_three.components)



composite_two.remove_component(composite_three)



assert set() == {leaf_two}.symmetric_difference(composite_two.components)



assert not leaf_one.did_something

assert not leaf_two.did_something

assert not leaf_three.did_something



composite_one.do_something()



assert leaf_one.did_something

assert leaf_two.did_something

assert not leaf_three.did_something

```



##### Decorator Pattern



Attach additional functionality to functions.



```python

import time

from pypattyrn.structural.decorator import DecoratorSimple, DecoratorComplex, CallWrapper



class TimeThis(DecoratorSimple):



    def __call__(self, *args, **kwargs):

        start = time.time()

        result = self.func(*args, **kwargs)

        end = time.time() - start

        return result, end



class SlowClass(object):



    @TimeThis

    def slow_function(self, n):

        time.sleep(n)

        return 'foo'



slow_class = SlowClass()

result = slow_class.slow_function(1)

assert result[0] == 'foo'

assert 1 <= result[1] <= 2



class Alert(DecoratorComplex):



    def __init__(self, alert_time):

        self.alert_time = alert_time



    @CallWrapper

    def __call__(self, func, *args, **kwargs):

        start = time.time()

        return_val = func(*args, **kwargs)

        end = time.time() - start

        if end > self.alert_time:

            return return_val, True

        return return_val, False



class SlowClass(object):



    @Alert(1)

    def slow_function_true(self, n):

        time.sleep(n)

        return n



    @Alert(1)

    def slow_function_false(self, n):

        return n



slow_class = SlowClass()

assert (2, True) == slow_class.slow_function_true(2)

assert (10, False) == slow_class.slow_function_false(10)

```



##### Flyweight Pattern



Share data with other similar objects to increase efficiency.



```python

from pypattyrn.structural.flyweight import FlyweightMeta



class Card(object, metaclass=FlyweightMeta):



    def __init__(self, suit, value):

        self.suit = suit

        self.value = value



three_of_spades = Card('Spade', 3)

four_of_spades = Card('Spade', 4)

three_of_spades_two = Card('Spade', 3)



assert id(three_of_spades) == id(three_of_spades_two)

assert id(three_of_spades) != id(four_of_spades)

```

___



#### Resources

___



* [API Documentation](https://tylerlaberge.github.io/PyPattyrn/)

* [General Design Pattern Information](https://sourcemaking.com/design_patterns)



___