python:

- "2.7"

- "3.4"

- "3.5"

- "3.6"

- pip

install:

- pip install flake8 # eventually worth

script:

# Run tests

- PYTHONPATH=. nosetests -s -v --with-doctest --with-cov --cover-package . --logging-level=INFO -v .

# Actually run all the scripts, contributing to coverage

- PYTHONPATH=. ./run_all.sh

after_success:

- coveralls

A collection of design patterns and idioms in Python.

__Creational Patterns__:

| [3-tier](structural/3-tier.py) | data<->business logic<->presentation separation (strict relationships) |

| [adapter](structural/adapter.py) | adapt one interface to another using a white-list |

| [bridge](structural/bridge.py) | a client-provider middleman to soften interface changes |

| [decorator](structural/decorator.py) | wrap functionality with other functionality in order to affect outputs |

| [facade](structural/facade.py) | use one class as an API to a number of others |

| [flyweight](structural/flyweight.py) | transparently reuse existing instances of objects with similar/identical state |

| [blackboard](other/blackboard.py) | architectural model, assemble different sub-system knowledge to build a solution, AI approach - non gang of four pattern |

| [graph_search](other/graph_search.py) | graphing algorithms - non gang of four pattern |

| [hsm](other/hsm/hsm.py) | hierarchical state machine - non gang of four pattern |

class Catalog(object):

# dictionary that will be used to determine which static method is

# to be executed but that will be also used to store possible param

# value

# simple test to validate param value

if param in self._static_method_choices.keys():

def _instance_method_2(self):

print("Value {}".format(self.x2))

def main_method(self):

"""will execute either _instance_method_1 or _instance_method_2

def _class_method_2(cls):

print("Value {}".format(cls.x2))

def main_method(self):

"""will execute either _class_method_1 or _class_method_2

def _static_method_2():

print("executed method 2!")

def main_method(self):

"""will execute either _static_method_1 or _static_method_2

test = CatalogStatic('param_value_1')

test.main_method()

if __name__ == "__main__":

main()

from contextlib import contextmanager

import os

import sys

import time

class Handler(object):

def __init__(self, successor=None):

self._successor = successor

if not res:

self._successor.handle(request)

def _handle(self, request):

raise NotImplementedError('Must provide implementation in subclass.')

class ConcreteHandler1(Handler):

def _handle(self, request):

if 0 < request <= 10:

print('request {} handled in handler 1'.format(request))

return True

class ConcreteHandler2(Handler):

def _handle(self, request):

if 10 < request <= 20:

print('request {} handled in handler 2'.format(request))

return True

class ConcreteHandler3(Handler):

def _handle(self, request):

if 20 < request <= 30:

print('request {} handled in handler 3'.format(request))

return True

class DefaultHandler(Handler):

def _handle(self, request):

print('end of chain, no handler for {}'.format(request))

return True

class Client(object):

def __init__(self):

def delegate(self, requests):

for request in requests:

cr = func(*args, **kwargs)

next(cr)

return cr

return start

class ClientCoroutine:

def __init__(self):

self.target = coroutine1(coroutine3(coroutine2(default_coroutine())))

def timeit(func):

def count(*args, **kwargs):

start = time.time()

res = func(*args, **kwargs)

count._time = time.time() - start

return res

return count

with suppress_stdout():

client1_delegate(requests)

client2_delegate(requests)

print(client1_delegate._time, client2_delegate._time)

class Person(object):

def __init__(self, name, action):

self.name = name

self.action = action

class Action(object):

def __init__(self, name):

self.name = name

def stop(self):

print('then stop')

if __name__ == '__main__':

move = Action('move')

from __future__ import print_function

import os

from os.path import lexists

class MoveFileCommand(object):

def __init__(self, src, dest):

self.src = src

self.dest = dest

command_stack.append(MoveFileCommand('bar.txt', 'baz.txt'))

# verify that none of the target files exist

try:

with open("foo.txt", "w"): # Creating the file

pass

finally:

os.unlink("foo.txt")

if __name__ == "__main__":

main()

from __future__ import print_function

def count_to(count):

"""Counts by word numbers, up to a maximum of five"""

numbers = ["one", "two", "three", "four", "five"]

yield number

count_to_two = lambda: count_to(2)

count_to_five = lambda: count_to(5)