import model

 import pickle

 import hashlib

 from operator import attrgetter

 commands = {}

 def help(socket, client, worker):

 	socket.sendto("\n".join([key + ": " + value[1] 

 		for key, value in commands.iteritems()]) + "\n", client)

 def createModel(socket, client, worker, (name,)):

 	model.createModel(name)

 	socket.sendto("model %s created\n" % name, client)

 def deleteModel(socket, client, worker, (name,)):

 	if model.deleteModel(name):

 		socket.sendto("model %s deleted\n" % name, client)

 def saveModel(socket, client, worker, (name,)):

 	model = lookupModel(socket, client, name)

 	if model:

 		pickle.dump(model, open(name + ".model", "w"))

 		socket.sendto("model %s saved\n" % name, client)

 def loadModel(socket, client, worker, (name,)):	

 	model.addModel(pickle.load(open(name + ".model", "r")))

 	socket.sendto("model %s loaded\n" % name, client)		

 def getModel(name):

 	if name in model.models:

 		return model.models[name]

 def lookupModel(socket, client, name):

 	if name not in model.models:

 		socket.sendto("model %s not found\n" % name, client)

 		return None

 	else:

 		return model.models[name]

 def addObserver(socket, client, worker, (modelName, eventType)):

 	model = lookupModel(socket, client, modelName)

 	if model:

 		model.register(socket, client, eventType)

 		socket.sendto("observer for event type %s added: " % eventType 

 			+ str(client) + "\n", client)

 def setResolution(socket, client, worker, (modelName, x, y)):

 	model = lookupModel(socket, client, modelName)

 	if model:

 		model.setResolution(int(x), int(y))

 		socket.sendto("model %s resolution set to %s, %s\n" % 

 			(modelName, x, y), client)

 def setRange(socket, client, worker, (modelName, begin, end)):

 	model = lookupModel(socket, client, modelName)

 	if model:

 		model.setRange(complex(begin), complex(end))

 		socket.sendto("model %s range set to %s, %s\n" % 

 			(modelName, begin, end), client)

 def update(socket, client, worker, (modelName, iterations)):

 	model = lookupModel(socket, client, modelName)

 	if model:

 		old_res = model.resolution

 		begin_y = model.range[0].imag

 		end_y = model.range[1].imag

 		begin_x = model.range[0].real

 		end_x = model.range[1].real

 		step_x = (end_x - begin_x) / len(worker)

 		model.resolution = (old_res[0] / len(worker), old_res[1])

 		for i, w in enumerate(worker):

 			new_begin_x = begin_x + step_x * i

 			new_end_x = begin_x + step_x * (i + 1)

 			model.range = (complex(new_begin_x, begin_y), 

 							complex(new_end_x, end_y))

 			print model.range

 			print model.resolution

 			model.cells = {}

 			dump = pickle.dumps(model)

 			socket.sendto("%010i%s%010i" % (len(dump), dump, 

 				int(iterations)), w) 

 		socket.sendto("model %s updated with max %s iterations\n" 

 			% (modelName, iterations), client)

 		model.range = (complex(begin_x, begin_y), complex(end_x, end_y))

 		model.resolution = old_res

 def view(socket, client, worker, (name,)):

 	model = lookupModel(socket, client, name)

 	if model:

 		keys = model.cells.keys()

 		keys.sort(key=attrgetter("real", "imag"))

 		cells = {}

 		for k in keys:

 			cells[k] = model.cells[k]

 		print "size: %i hash: %s" % (len(cells), 

 				hashlib.sha256(str(cells)).hexdigest())

 commands = {"help": (help, "help"),

 	"create model": (createModel, "creates a new model"),

 	"delete model": (deleteModel, "deletes a model"),	

 	"save model": (saveModel, "makes a persistent copy of the model"),

 	"load model": (loadModel, "loads a persistent model"),

 	"set resolution": (setResolution, "sets the model resolution"),

 	"set range": (setRange, "sets the model range"),

 	"update": (update, "updates the model data"),

 	"view": (view, "shows the model data"),

 	"add observer": (addObserver, "adds an observer to a model's events"),}