Cleaning output, adding queuing system, finilazing

Author: natewoods-wf

net/__main__.py

@@ -1,25 +1,33 @@
 from net import lib
 from sys import argv
+from time import time
+from json import dumps
 from SocketServer import TCPServer, BaseRequestHandler
 
 
 class Memory(object):
  score = None
  graph = None
- name = None
  weight = None
  complete = False
+ start = None
 
  def __repr__(self):
  return str(self.__dict__)
 
 
 class MyServer(TCPServer):
  data = dict()
+ processing = 1
 
  def save(self):
  # TODO: store data to disk
- pass
+ print dumps(
+ {
+ key: value.__dict__
+ for key, value in self.data.iteritems()
+ }, indent=4
+ )
 
 
 class MyTCPHandler(BaseRequestHandler):
@@ -30,16 +38,25 @@ def send(self, msg):
  lib.send(self.request, msg)
 
  def handle_start(self):
- name = argv[1] if len(argv) > 1 else None
+ name = None
+ if len(argv) > self.server.processing:
+ name = argv[self.server.processing]
  weight = 0
  if name:
  weights = [1.2, 1.1, 1.08, 1.04, 1]
  try:
  memory = self.server.data.setdefault(name, Memory())
+ if memory.complete:
+ # If we are done, move on
+ self.server.processing += 1
+ return self.handle_start()
+
  weight = max([
  w for w in weights
  if not memory.weight or memory.weight > w
  ])
+ if not memory.start:
+ memory.start = time()
  except Exception:
  name = None
  self.send((name, weight))
@@ -54,11 +71,12 @@ def handle_end(self):
  data.score = score
  data.graph = graph
  data.weight = weight
- data.name = name
  print 'New best score of {} for {}'.format(score, name)
  if weight <= 1:
  print 'Completed Search on {}'.format(name)
  data.complete = True
+ data.duration = time() - data.start
+ del data.start
  self.server.save()
  else:
  print 'Worse score of {} for {}'.format(score, name)
@@ -78,7 +96,10 @@ def handle(self):
  'P': self.handle_ping
  }
  command = self.request.recv(1)
- print 'Client {1}:{2} said "{0}"'.format(command, *self.client_address)
+ if command != 'P':
+ print 'Client {1}:{2} said "{0}"'.format(
+ command, *self.client_address
+ )
  if command in obj:
  obj.get(command, lambda: 0)()
  else:
@@ -87,4 +108,9 @@ def handle(self):
 if __name__ == "__main__":
  server = MyServer((lib.HOST, lib.PORT), MyTCPHandler)
  print 'Serving at {}:{}'.format(*server.server_address)
- server.serve_forever()
+ try:
+ server.serve_forever()
+ except KeyboardInterrupt:
+ print 'Killing server'
+ server.server_close()
+ server.shutdown()

src/__main__.py

@@ -15,14 +15,16 @@ def __init__(self, name, weight, monitor):
  self.score = None
 
  def run(self):
- score, graph = procedure(self.name, self.weight, self.monitor)
+ score, graph = procedure(
+ self.name, self.weight, self.monitor, debug=False
+ )
  if score:
  self.score = score
  lib.end(self.name, self.weight, score, graph)
 
 
 def network():
- delay = models.Delay()
+ delay = models.Delay(cap=5)
  while True:
  try:
  name, weight = lib.start()
@@ -35,7 +37,7 @@ def network():
  print 'Search "{}" with max weight of {:.6f}'.format(name, weight)
 
  # Fire up process threads with shared access to monitor
- monitor = Monitor()
+ monitor = Monitor(name)
  monitor.start()
  threads = []
  thread_count, base = cpu_count(), 1

src/base.py

@@ -5,23 +5,26 @@
 # from parents import ParentBuilder
 
 
-def procedure(name, weight=1, monitor=None):
- timer = Timer('Fetching Variables')
+def procedure(name, weight=1, monitor=None, debug=True):
+ if debug:
+ timer = Timer('Fetching Variables')
  data = BNSearch(name)
- print timer.stop()
-
- timer = Timer('Calculate Scores')
+ if debug:
+ print timer.stop()
+  timer = Timer('Calculate Scores')
  data.score = ScoreBuilder(data.data, data.variables)(data.name)
- print timer.stop()
+ if debug:
+ print timer.stop()
 
  # timer = Timer('Build Parent Graphs')
  # data.best_score = ParentBuilder(data)()
  # print timer.stop()
 
  if not monitor:
- monitor = Monitor()
+ monitor = Monitor(name)
 
- timer = Timer('Search')
+ if debug:
+ timer = Timer('Search')
  killed = False
  score = 1e99
  try:
@@ -32,13 +35,11 @@ def procedure(name, weight=1, monitor=None):
  )
  killed = True
  finally:
- print timer.stop()
+ if debug:
+ print timer.stop()
 
  if killed:
  return
 
- timer = Timer('Rebuild graph')
  graph = data.build_graph()
- print timer.stop()
-
  return score, graph

src/data/__init__.py

@@ -68,8 +68,8 @@ def __init__(self, name='scale'):
  new_data.append(new_item)
  self.data = new_data
  self.variables = sorts
- for variable in self.variables:
- print '{}: {}'.format(variable.name, repr(variable.domain))
+ # for variable in self.variables:
+ #  print '{}: {}'.format(variable.name, repr(variable.domain))
 
 
 def is_num(test):

src/monitor.py

@@ -3,8 +3,9 @@
 
 
 class Monitor(Thread):
- def __init__(self):
+ def __init__(self, name):
  super(Monitor, self).__init__()
+ self.name = name
  self.complete = False
  self.score = 1e9
  self.best = 2
@@ -20,6 +21,6 @@ def run(self):
  self.event.wait(10)
 
  def stop(self):
- print 'Killing monitor'
+ # print 'Killing monitor'
  self.event.set()
  self.join()

src/scores.py

@@ -52,7 +52,7 @@ def __call__(self, name):
  path.dirname(__file__), 'data', name, '{}.score.p'.format(name)
  ))
  if path.isfile(file_path):
- print 'Found Generated Scores - Loading'
+ # print 'Found Generated Scores - Loading'
  with open(file_path, 'rb') as f:
  self.score.cache = pickle.load(f)
  else:

src/search.py

@@ -31,16 +31,16 @@ def search(self, weight=1, monitor=False):
  open_set = PriorityQueue()
  closed_set = set()
 
- print 'Beginning Search'
+ # print 'Beginning Search'
  variables = set(self.variables)
  open_set.put((1, frozenset()))
  counter = 0
  while not open_set.empty() and not monitor.complete:
  counter += 1
  U = open_set.get()[1]
  if U == frozenset(self.variables):
- print 'Number of expansions:', counter
- print 'The best score is', self.base_score.get(U)
+ # print 'Number of expansions:', counter
+ # print 'The best score is', self.base_score.get(U)
  return self.base_score.get(U)
  closed_set.add(frozenset(U))
  for X in variables.difference(U):