Merge pull request #1 from faif/master

cstrap · cstrap · commit 63dbcbff23a8 · 2013-02-19T06:33:07.000-08:00
Merge with original repository
diff --git a/borg.py b/borg.py
@@ -3,22 +3,34 @@ class Borg:
 
     def __init__(self):
         self.__dict__ = self.__shared_state
-        self.state = 'Running'
 
     def __str__(self):
         return self.state
 
+class YourBorg(Borg):
+    pass
+
 if __name__ == '__main__':
     rm1 = Borg()
     rm2 = Borg()
 
-    print('rm1 state: {}'.format(rm1))
-    print('rm2 state: {}'.format(rm2))
+    rm1.state = 'Idle'
+    rm2.state = 'Running'
+
+    print('rm1:', rm1)
+    print('rm2:', rm2)
+
+    rm2.state = 'Zombie'
+
+    print('rm1:', rm1)
+    print('rm2:', rm2)
+
+    print('rm1 id:', id(rm1))
+    print('rm2 id:', id(rm2))
 
-    rm2.state = 'Idle'
+    rm3 = YourBorg()
 
-    print('rm1 state: {}'.format(rm1))
-    print('rm2 state: {}'.format(rm2))
+    print('rm1:', rm1)
+    print('rm2:', rm2)
+    print('rm3:', rm3)
 
-    print('rm1 id: {}', id(rm1))
-    print('rm2 id: {}', id(rm2))
diff --git a/factory_method.py b/factory_method.py
@@ -1,29 +1,30 @@
+#encoding=utf-8
 '''http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/'''
 
-class GreekGetter:     
-    """A simple localizer a la gettext"""      
-    def __init__(self):         
+class GreekGetter:
+    """A simple localizer a la gettext"""
+    def __init__(self):
         self.trans = dict(dog="σκύλος", cat="γάτα")
-        
-    def get(self, msgid):         
+
+    def get(self, msgid):
         """We'll punt if we don't have a translation"""          
-        try:             
-            return str(self.trans[msgid])         
-        except KeyError:             
-            return str(msgid)  
+        try:
+            return self.trans[msgid]
+        except KeyError:
+            return str(msgid)
 
-class EnglishGetter:     
+class EnglishGetter:
     """Simply echoes the msg ids"""     
-    def get(self, msgid):         
-        return str(msgid)  
+    def get(self, msgid):
+        return str(msgid)
 
-def get_localizer(language="English"):     
-    """The factory method"""      
-    languages = dict(English=EnglishGetter,Greek=GreekGetter)      
-    return languages[language]()  
+def get_localizer(language="English"):
+    """The factory method"""
+    languages = dict(English=EnglishGetter, Greek=GreekGetter)
+    return languages[language]()
 
-# Create our localizers 
-e, j = get_localizer("English"), get_localizer("Greek")  
-# Localize some text 
-for msgid in "dog parrot cat bear".split():     
-    print(e.get(msgid), j.get(msgid))
+# Create our localizers
+e, g = get_localizer("English"), get_localizer("Greek")
+# Localize some text
+for msgid in "dog parrot cat bear".split():
+    print(e.get(msgid), g.get(msgid))
diff --git a/graph_search.py b/graph_search.py
@@ -0,0 +1,75 @@
+class GraphSearch:
+    """Graph search emulation in python, from source http://www.python.org/doc/essays/graphs/"""
+    
+    def __init__(self, graph):
+        self.graph = graph 
+    
+    def find_path(self, start, end, path=[]):
+        self.start = start
+        self.end = end
+        self.path = path
+        
+        self.path+=[self.start]
+        if self.start == self.end:
+            return self.path
+        if not self.graph.has_key(self.start):
+            return None
+        for node in self.graph[self.start]:
+            if node not in self.path:
+                newpath = self.find_path(node, self.end, self.path)
+                if newpath:
+                    return newpath
+        return None
+    
+    def find_all_path(self, start, end, path=[]):            
+        self.start = start
+        self.end = end
+        self.path = path
+        self.path+=[self.start]
+        if self.start == self.end:
+            return [self.path]
+        if not self.graph.has_key(self.start):
+            return []
+        paths=[]
+        for node in self.graph[self.start]:
+            if node not in self.path:
+                newpaths = self.find_all_path(node, self.end, self.path)
+                for newpath in newpaths:
+                    paths.append(newpath)                
+        return paths
+    
+    def find_shortest_path(self, start, end, path=[]):         
+        self.start = start
+        self.end = end
+        self.path = path
+        
+        self.path+=[self.start]
+        if self.start == self.end:
+            return self.path
+        if not self.graph.has_key(self.start):
+            return None
+        shortest = None
+        for node in self.graph[self.start]:
+            if node not in self.path:
+                newpath = self.find_shortest_path(node, self.end, self.path)
+                if newpath:
+                    if not shortest or len(newpath) < len(shortest):
+                        shortest = newpath
+        return shortest
+
+#example of graph usage
+graph = {'A':['B', 'C'],
+         'B': ['C', 'D'],
+         'C': ['D'],
+         'D': ['C'],
+         'E': ['F'],
+         'F': ['C']   
+            }
+
+#inistialization of new graph search object
+graph1 = GraphSearch(graph)
+
+
+print graph1.find_path('A', 'D')
+print graph1.find_all_path('A', 'D')
+print graph1.find_shortest_path('A', 'D')
diff --git a/iterator.py b/iterator.py
@@ -4,8 +4,8 @@
 def count_to(count):
     """Counts by word numbers, up to a maximum of five"""
     numbers = ["one", "two", "three", "four", "five"]
-    # The zip keeps from counting over the limit
-    for number, pos in zip(numbers, list(range(count))):
+    # enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over sequence
+    for pos, number in enumerate(numbers):
         yield number
 
 # Test the generator
diff --git a/pool.py b/pool.py
@@ -25,14 +25,17 @@ def __del__(self):
             self._q.put(self.o)           
             self.o = None   
 
-if __name__ == "__main__":   
-    import queue    
+if __name__ == "__main__":
+    try:
+        import queue as Queue
+    except:                     # python 2.x compatibility
+        import Queue
 
     def testObj(Q):       
         someObj = qObj(Q, True)        
         print('Inside func: {}'.format(someObj.o))    
 
-    aQ = queue.Queue()    
+    aQ = Queue.Queue()
     aQ.put("yam")    
 
     with qObj(aQ) as obj:       
diff --git a/proxy.py b/proxy.py
@@ -14,7 +14,7 @@ def __init__(self):
 
     def work (self):                         
         print("Proxy checking for Sales Manager availability")                         
-        if self.busy == 'Yes':                                      
+        if self.busy == 'No':                                      
             self.sales = SalesManager()                                      
             time.sleep(2);                                      
             self.sales.talk()                         
