class Scanner():
def __init__(self, direction, puzzle, wordsToFind):
self.observable = Observable()
self.direction = direction
self.puzzle = puzzle
self.puzzleRows = len(puzzle)
self.puzzleColumns = len(puzzle[0])
self.wordsToFind = wordsToFind
def scan_for_words(self):
for row, letters in enumerate(self.puzzle):
for column, letter in enumerate(letters):
for word in self.__get_first_letter_matches(letter):
if self.__enough_room_for_word(len(word), row, column):
foundWordCoordinates = self.__search_for_word(
word, row, column)
if len(foundWordCoordinates) != 0:
self.observable.update_observers(
foundWordCoordinates)
def register(self, observer):
self.observable.register(observer)
def __enough_room_for_word(self, lengthOfWord, row, column):
if row + lengthOfWord * self.direction[1] > self.puzzleColumns:
return False
elif column + lengthOfWord * self.direction[0] > self.puzzleRows:
return False
else:
return True
def __get_first_letter_matches(self, letter):
matches = []
for word in self.wordsToFind:
if word[0] == letter:
matches.append(word)
return matches
def __search_for_word(self, word, row, column):
wordCoordinates = [(column, row)]
for position, letter in enumerate(word[1:]):
rowOffset = (position + 1) * self.direction[1]
columnOffset = (position + 1) * self.direction[0]
if not self.puzzle[row + rowOffset][column +
columnOffset] == letter:
return []
else:
wordCoordinates.append(
(column + columnOffset, row + rowOffset))
return wordCoordinates
from observable import Observable
from observer import Observer
class AmericanStockMarket(Observer):
def update(self, *args, **kwargs):
print("American stock market recevied: {0}\n{1}".format(args, kwargs))
class EuropeanStockMarket(Observer):
def update(self, *args, **kwargs):
print("European stock market recevied: {0}\n{1}".format(args, kwargs))
if __name__ == '__main__':
observable = Observable()
american_observer = AmericanStockMarket()
observable.register(american_observer)
european_observer = EuropeanStockMarket()
observable.register(european_observer)
observable.update_observers('Market Rally', something='hello world')
from keyboard import KeyBoard
from observable import Observable
from observer import Observer
from actor import Actor
if __name__ == '__main__':
observable = Observable()
keyBoard = KeyBoard()
actor = Actor()
observable.register(actor)
while 1:
observable.update_observers(c=keyBoard.get_ch())
#!/usr/bin/python
# imports for observer pattern and scrapping stdout
from observable import Observable
from observer import Observer
import os
# imports for type-observer-view
from testobserverview import TestObserverView
import subprocess, time, os, sys
cmd = ["sudo", "tcpdump", "-c", "5"]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
observable = Observable()
test_observer = TestObserverView()
observable.register(test_observer)
for line in iter(p.stdout.readline, b''):
observable.update_observers(line.rstrip())
print("program ended")
class BasePool(object):
def __init__(self, N, food_size):
self.reaction_computed = Observable()
self.step_computed = Observable()
self.generation_computed = Observable()
self.expressions = Multiset(N)
self.tmp_removed_expressions = []
self.food_size = food_size
def register_step_observer(self, obs):
self.step_computed.register(obs.on_step_computed)
def register_reaction_observer(self, obs):
self.reaction_computed.register(obs.on_reaction_computed)
def deregister_observers(self):
self.reaction_computed.deregister_all()
self.step_computed.deregister_all()
def pop_reactive(self):
assert len(self.expressions) > 0
t = self.expressions.sample()
self.tmp_remove(t)
return t
def rollback(self, t):
self.tmp_removed_expressions.remove(t)
self.append(t)
def get_total_size(self):
return sum(len(expr) for expr in self.expressions) + \
sum(len(expr) for expr in self.tmp_removed_expressions)
def __len__(self):
return len(self.expressions) + len(self.tmp_removed_expressions)
def __iter__(self):
return iter(self.expressions)
def unique(self):
return self.expressions.unique()
def __contains__(self, t):
return t in self.expressions or self.can_make(t)
def load(self, fn):
raise NotImplementedError()
def append(self, t):
self.expressions.add(t)
def tmp_remove(self, t):
self.tmp_removed_expressions.append(t)
self.expressions.remove(t)
def remove(self, t):
if t in self.tmp_removed_expressions:
self.tmp_removed_expressions.remove(t)
return True
else:
if t in self.expressions:
self.expressions.remove(t)
return True
else:
return False
#if t == Expression.parse('SII'):
# print('food# ' ,self.get_multiplicity(t))
def remove_all(self, ts):
for t in ts:
if not self.remove(t):
return False
return True
def apply_reaction(self, reaction):
if self.has_or_make_reactives(reaction):
for r in reaction.reactives:
self.remove(r)
for p in reaction.products:
self.append(p)
self.reaction_computed(self, reaction)
return True
else:
return False
def has_or_make_reactives(self, reaction):
reactives = reaction.reactives
missing = self.count_missing(reactives)
if any(r not in self and r not in self.tmp_removed_expressions
for r in reactives):
assert missing[r] > 0
#if missing:
# print(reaction, {str(k): v for k,v in missing.items()})
for compound, count in missing.items():
if count > 0:
made = self.make(compound, count)
#NOTE: a compound can be made before noticing than another
# cannot be made, but it should never happen with these
# binary reactions.
if not made:
return False
return True
def count_missing(self, reactives):
missing = Counter(self.expressions.count_missing(reactives))
in_tmp = Counter(self.tmp_removed_expressions)
return Counter({k: v - in_tmp[k] for k, v in missing.items()})
def make(self, compound, count):
for i in range(count):
if not self.can_make(compound):
return False
if self.remove_all(compound.atoms()):
self.append(compound)
return True
def can_make(self, ts):
if self.food_size is None or len(ts) > self.food_size:
return False
return self.expressions.has_all(ts.atoms())
def get_multiplicity(self, t):
return self.expressions[t] - self.tmp_removed_expressions.count(t)
def __getitem__(self, t):
return self.get_multiplicity(t)
def __str__(self):
pool_strs = []
for k in sorted(set(self.expressions),
key=lambda k: self.expressions[k]):
pool_strs.append(f"{k} {self.expressions[k]}")
return "\n".join(pool_strs)
def serializable(self):
return {x.serializable(): self[x] for x in self.unique()}
def evolve(self, num_reactions, timeout_time=1):
for i in range(num_reactions):
#with timeout(timeout_time):
self.step()
self.step_computed(self, i)
def evolve_generations(self, num_generations):
tick = 0
for i in range(num_generations):
for j in range(len(self)):
self.step()
self.step_computed(self, tick)
tick += 1
self.generation_computed(i)
class observable_test(unittest.TestCase):
def setUp(self):
self.observable = Observable()
self.observer1 = AnObserver()
self.observer2 = AnObserver()
self.observer3 = AnObserver()
def test_remove_all(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister_all()
# Should be zero registered
self.assertEqual(len(self.observable.observers), 0)
def test_register(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
# Should be three registered
self.assertEqual(len(self.observable.observers), 3)
self.observable.unregister_all()
def test_unregister(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister(self.observer2)
self.observable.unregister(self.observer3)
# Should be 1 registered
self.assertEqual(len(self.observable.observers), 1)
self.observable.unregister_all()
def test_update_observers(self):
self.observable.register(self.observer1)
self.observable.update_observers('abc', msg='123')
self.assertEqual(self.observer1.args[0], 'abc')
self.assertEqual(self.observer1.kwargs['msg'], '123')
self.observable.unregister_all()
from observer import Subscriber1, Subscriber2
from observable import Observable
# test code
sports_magazine = Observable()
lofty = Subscriber1()
sports_magazine.register(lofty)
mier = Subscriber2()
sports_magazine.register(mier)
sports_magazine.update("Important update",
msg="Micheal Jordan will join Lakers team")
sports_magazine.unregister(mier)
sports_magazine.update("Latest update",
msg="Mier unregistered to sports magazine")
from observable import Observable
from observer import Observer
class AmericanStockMarket(Observer):
def update(self, *args, **kwargs):
print("American stock market received: {0}\n{1}".format(args,
kwargs))
class EuropeanStockMarket(Observer):
def update(self, *args, **kwargs):
print("European stock market received: {0}\n{1}".format(args,
kwargs))
if __name__ == "__main__":
observable = Observable()
american_observer = AmericanStockMarket()
observable.register(american_observer)
european_observer = EuropeanStockMarket()
observable.register(european_observer)
observable.update_observers('Market Rally', something='Hello World')
class observerable_test(unittest.TestCase):
def setUp(self):
self.observable = Observable()
self.observer1 = AnObserver()
self.observer2 = AnObserver()
self.observer3 = AnObserver()
def test_remove_all(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister_all()
# Should be zero registered
self.assertEqual(len(self.observable.observers), 0)
def test_register(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
# Should be three registered
self.assertEqual(len(self.observable.observers), 3)
self.observable.unregister_all()
def test_unregister(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister(self.observer2)
self.observable.unregister(self.observer3)
# Should be one registered
self.assertEqual(len(self.observable.observers), 1)
self.observable.unregister_all()
'''
class observerable_test(unittest.TestCase):
def setUp(self):
self.observable = Observable()
self.observer1 = AnObserver()
self.observer2 = AnObserver()
self.observer3 = AnObserver()
def test_remove_all(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister_all()
# Should be zero registered
self.assertEqual(len(self.observable.observers), 0)
def test_register(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
# Should be three registered
self.assertEqual(len(self.observable.observers), 3)
self.observable.unregister_all()
def test_unregister(self):
self.observable.register(self.observer1)
self.observable.register(self.observer2)
self.observable.register(self.observer3)
self.observable.unregister(self.observer2)
self.observable.unregister(self.observer3)
# Should be one registered
self.assertEqual(len(self.observable.observers), 1)
self.observable.unregister_all()
def test_update_observers(self):
self.observable.register(self.observer1)
self.observable.update_observers('abc', msg='123')
self.assertEqual(self.observer1.args[0], 'abc')
self.assertEqual(self.observer1.kwargs['msg'], '123')
self.observable.unregister_all()
# Example of how to use the Observable and Observer abstract classes
from observable import Observable
from observer import Observer
class AmericanStockMarket(Observer):
def update(self, *args, **kwargs):
print("American stock market received: {0}\n{1}".format(args, kwargs))
class JapaneseStockMarket(Observer):
def update(self, *args, **kwargs):
print("Japanese stock market received: {0}\n{1}".format(args, kwargs))
if __name__ == "__main__":
observable = Observable()
american_observer = AmericanStockMarket()
observable.register(american_observer)
japanese_observer = JapaneseStockMarket()
observable.register(japanese_observer)
observable.update_observers('Market Rally', something='hello Scott')
from keyboard import KeyBoard
from observable import Observable
from observer import Observer
from input_handler import InputHandler#Actor
from view import View
import curses
if __name__ == '__main__':
observable = Observable()
screen = curses.initscr()
curses.noecho()
curses.cbreak()
keyBoard = KeyBoard(screen)
input_handler = InputHandler()
view = View(screen)
observable.register(input_handler)
observable.register(view)
while 1:
try:
observable.update_observers(c=keyBoard.get_ch())
except KeyboardInterrupt:
curses.endwin()
exit()