Added new files.

Author: gennad

abstractfactory.py

@@ -0,0 +1,61 @@
+class Klass1:
+    """ a very simple obj """
+    def __init__(self):
+        pass
+    def hi(self):
+        print 'hi'
+
+class Factory:
+    """ base factory that can construct objects in a variety of ways:
+            * modules ['package1.subpackage',] to be searched for klass
+            * search global namespace
+            * create takes a arguement of what type of class to return
+            * return a default implementation - subclass must define createDefault()
+    """
+    def __init__(self, modules=[]):
+        self.modules=modules
+
+    def createDefault(self):
+        print dir()
+        raise NotImplementedError
+
+    def create(self, klass=None):
+        import string
+        if klass in globals().keys():
+            if type(globals()[klass]).__name__=='class':
+                return globals()[klass]()
+        for module in self.modules:
+            try:
+                fromlist = []
+                if string.find(module, '.'): fromlist = string.split(module, '.')[:-1]
+                module = __import__(module, globals(), locals(), fromlist)
+                if hasattr(module, klass): return getattr(module, klass)()
+            except AttributeError: pass
+        return self.createDefault()
+
+class MyFactory(Factory):
+    """ concrete factory that specifies:
+        * what modules to search for
+        * implements a createDefault() - which is used if class isnt found
+    """
+    def __init__(self, modules=[]):
+        Factory.__init__(self,modules)
+    def createDefault(self):
+        return Klass1()
+
+
+#--------much simpler one by mark lutz, http://shell.rmi.net/~lutz/talk.html
+def factory(aClass, *args):        # varargs tuple
+    return apply(aClass, args)     # call aClass
+
+class Spam:
+    def doit(self, message):
+        print message
+
+class Person:
+    def __init__(self, name, job):
+        self.name = name
+        self.job  = job
+
+object1 = factory(Spam)
+object2 = factory(Person, "Guido", "guru")

adapter.py

@@ -0,0 +1,20 @@
+class Barfooer:
+    def barfoo(self, bar, foo):
+        pass
+
+# Per instance, by wrapping and delegation
+class FoobaringWrapper:
+    def __init__(self, wrappee):
+        self.w = wrappee
+    def foobar(self, foo, bar):
+        return self.w.barfoo(bar, foo)
+
+foobarer = FoobaringWrapper(barfooer)
+
+# Per-classs by subclassing and self-delegation
+class Foobarer(Barfooer):
+    def foobar(self,foo, bar):
+        return self.barfoo(bar, foo)
+
+foobarer = Foobarer(some, init, params)
+

adapter2.py

@@ -0,0 +1,13 @@
+class Adaptee:
+    def specific_request(self):
+        return 'Adaptee'
+
+class Adapter:
+    def __init__(self, adaptee):
+        self.adaptee = adaptee
+
+    def request(self):
+        return self.adaptee.specific_request()
+
+client = Adapter(Adaptee())
+print client.request()

adaptermartelli.py

@@ -0,0 +1,9 @@
+class UppercasingFile:
+    def __init__(self, *a, **k):
+        self.f = file(*a, **k)
+
+    def write(self, data):
+        self.f.write(data.upper())
+
+    def __getattr__(self, name):
+        return getattr(self.f, name)

bridge.py

@@ -0,0 +1,9 @@
+class AbstractParser:
+    def __init__(self, scanner):
+        self.scanner = scanner
+
+class ExprParser(AbstractParser):
+    def expr(self):
+        t = self.scanner.next()...
+        self.scanner.push_back(t)...
+

bridge2.py

@@ -0,0 +1,54 @@
+# Implementor
+class DrawingAPI:
+        def drawCircle(x, y, radius):
+                pass
+
+# ConcreteImplementor 1/2
+class DrawingAPI1(DrawingAPI):
+        def drawCircle(self, x, y, radius):
+                print "API1.circle at %f:%f radius %f" % (x, y, radius)
+
+# ConcreteImplementor 2/2
+class DrawingAPI2(DrawingAPI):
+        def drawCircle(self, x, y, radius):
+                print "API2.circle at %f:%f radius %f" % (x, y, radius)
+
+# Abstraction
+class Shape:
+        # low-level
+        def draw(self):
+                pass
+
+        # high-level
+        def resizeByPercentage(self, pct):
+                pass
+
+# Refined Abstraction
+class CircleShape(Shape):
+        def __init__(self, x, y, radius, drawingAPI):
+                self.__x = x
+                self.__y = y
+                self.__radius = radius
+                self.__drawingAPI = drawingAPI
+
+        # low-level i.e. Implementation specific
+        def draw(self):
+                self.__drawingAPI.drawCircle(self.__x, self.__y, self.__radius)
+
+        # high-level i.e. Abstraction specific
+        def resizeByPercentage(self, pct):
+                self.__radius *= pct
+
+def main():
+        shapes = [
+                CircleShape(1, 2, 3, DrawingAPI1()),
+                CircleShape(5, 7, 11, DrawingAPI2())
+        ]
+
+        for shape in shapes:
+                shape.resizeByPercentage(2.5)
+                shape.draw()
+
+if __name__ == "__main__":
+        main()
+

chainofresp2.py

@@ -0,0 +1,41 @@
+class Car:
+    def __init__(self):
+        self.name = None
+        self.km = 11100
+        self.fuel = 5
+        self.oil = 5
+
+def handle_fuel(car):
+    if car.fuel < 10:
+        print "added fuel"
+        car.fuel = 100
+
+def handle_km(car):
+    if car.km > 10000:
+        print "made a car test."
+        car.km = 0
+
+def handle_oil(car):
+    if car.oil < 10:
+        print "Added oil"
+        car.oil = 100
+
+class Garage:
+    def __init__(self):
+        self.handlers = []
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+
+    def handle_car(self, car):
+        for handler in self.handlers:
+            handler(car)
+
+if __name__ == '__main__':
+    handlers = [handle_fuel, handle_km, handle_oil]
+    garage = Garage()
+
+    for handle in handlers:
+        garage.add_handler(handle)
+    garage.handle_car(Car())
+

command.py

@@ -0,0 +1,121 @@
+# -*- coding: utf8 -*-
+
+from sys import stdout as console
+
+# Обработка команды exit
+class SessionClosed(Exception):
+	def __init__(self, value):
+		self.value = value
+
+# Интерфейс команды
+class Command:
+	def execute(self):
+		raise NotImplementedError()
+
+	def cancel(self):
+		raise NotImplementedError()
+
+	def name():
+		raise NotImplementedError()
+
+# Команда rm
+class RmCommand(Command):
+	def execute(self):
+		console.write("You are executed \"rm\" command\n")
+
+	def cancel(self):
+		console.write("You are canceled \"rm\" command\n")
+
+	def name(self):
+		return "rm"
+
+# Команда uptime
+class UptimeCommand(Command):
+	def execute(self):
+		console.write("You are executed \"uptime\" command\n")
+
+	def cancel(self):
+		console.write("You are canceled \"uptime\" command\n")
+
+	def name(self):
+		return "uptime"
+
+# Команда undo
+class UndoCommand(Command):
+	def execute(self):
+		try:
+			cmd = HISTORY.pop()
+			TRASH.append(cmd)
+			console.write("Undo command \"{0}\"\n".format(cmd.name()))
+			cmd.cancel()
+
+		except IndexError:
+			console.write("ERROR: HISTORY is empty\n")
+
+	def name(self):
+		return "undo"
+
+# Команда redo
+class RedoCommand(Command):
+	def execute(self):
+		try:
+			cmd = TRASH.pop()
+			HISTORY.append(cmd)
+			console.write("Redo command \"{0}\"\n".format(cmd.name()))
+			cmd.execute()
+
+		except IndexError:
+			console.write("ERROR: TRASH is empty\n")
+	def name(self):
+		return "redo"
+
+# Команда history
+class HistoryCommand(Command):
+	def execute(self):
+		i = 0
+		for cmd in HISTORY:
+			console.write("{0}: {1}\n".format(i, cmd.name()))
+			i = i + 1
+	def name(self):
+		print "history"
+
+# Команда exit
+class ExitCommand(Command):
+	def execute(self):
+		raise SessionClosed("Good bay!")
+
+	def name(self):
+		return "exit"
+
+# Словарь доступных команд
+COMMANDS = {'rm': RmCommand(), 'uptime': UptimeCommand(), 'undo': UndoCommand(), 'redo': RedoCommand(), 'history': HistoryCommand(), 'exit': ExitCommand()}
+
+HISTORY = list()
+TRASH = list()
+
+# Шелл
+def main():
+
+	try:
+		while True:
+			console.flush()
+			console.write("pysh >> ")
+
+			cmd = raw_input()
+
+			try:
+
+				command = COMMANDS[cmd]
+				command.execute()
+
+				if not isinstance(command, UndoCommand) and not isinstance(command, RedoCommand) and not isinstance(command, HistoryCommand):
+					TRASH = list()
+					HISTORY.append(command)
+
+			except KeyError:
+				console.write("ERROR: Command \"%s\" not found\n" % cmd)
+
+	except SessionClosed as e:
+		console.write(e.value)
+
+if __name__ == "__main__": main()

composite2.py

@@ -0,0 +1,33 @@
+class Component(object):
+    def __init__(self, *args, **kw):
+        pass
+
+    def component_function(self): pass
+
+class Leaf(Component):
+    def __init__(self, *args, **kw):
+        Component.__init__(self, *args, **kw)
+
+    def component_function(self):
+        print "some function"
+
+class Composite(Component):
+    def __init__(self, *args, **kw):
+        Component.__init__(self, *args, **kw)
+        self.children = []
+
+    def append_child(self, child):
+        self.children.append(child)
+
+    def remove_child(self, child):
+        self.children.remove(child)
+
+    def component_function(self):
+        map(lambda x: x.component_function(), self.children)
+
+c = Composite()
+l = Leaf()
+l_two = Leaf()
+c.append_child(l)
+c.append_child(l_two)
+c.component_function()

compositechain.py

@@ -0,0 +1,28 @@
+>>> class DevelopmentPerformanceMonitor():
+...   def getPerformanceMonitorHandlers():
+...     return []
+...
+>>> class ProductionPerformanceMonitor():
+...   def getPerformanceMonitorHandlers():
+...     return [check_cpu_under_load, check_available_hd]
+...
+>>> class DevelopmentExceptionMonitor():
+...   def getExceptionHandlers():
+...     return [email_local_root, log_exception]
+...
+>>> class ProductionExceptionMonitor():
+...   def getExceptionHandlers():
+...     return [emails_system_admin, log_exception, create_ticket]
+...
+>>> class SomeSystem:
+...    pm = None # Performance Monitor
+...    em = None # Exception Monitor
+...    def __init__(self, performance_monitor, exception_monitor):
+...      pm = performance_monitor
+...      em = exception_monitor
+...    def on_exception(e):
+...      for handler in em.getExceptionHandlers():
+...        handler(e)
+...    def perform_performance_monitoring(s):
+...      for handler in pm.getPerformanceMonitorHandlers():
+...        handler(s)