def test3(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | B3 | { "D": str(D), "radius": str(radius)} with reaction_rules(): A1 == A2 | (1.0, 1.0) B1 == B2 | (1.0, 1.0) A2 + B2_ > B3 | 1.0 / 30.0 B3 > A2 + B2 | 1.0 m = get_model() w1 = gillespie.GillespieWorld(edge_lengths) w1.bind_to(m) sim1 = gillespie.GillespieSimulator(w1) # w2 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) # w2.bind_to(m) # sim2 = meso.MesoscopicSimulator(w2) # w2 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) # w2.bind_to(m) # sim2 = spatiocyte.SpatiocyteSimulator(w2) # w2 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) # w2.bind_to(m) # sim2 = egfrd.EGFRDSimulator(w2) w2 = ode.ODEWorld(edge_lengths) w2.bind_to(m) sim2 = ode.ODESimulator(w2) sim2.set_dt(0.01) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2')) ev1.borrow('B2', 'B2_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2', 'B3')) owner.set_value(Species("A1"), 60) owner.set_value(Species("B1"), 60) owner.initialize() logger = Logger(owner, ("A1", "A2", "B1", "B2", "B3")) logger.add("B2_", w1) logger.log() while owner.step(10): # while owner.step(50): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
def start_servers(): coord = Coordinator(('', 10000)) coord.serve_forever() srv1 = Server(('', 10001)) srv1.serve_forever() srv2 = Server(('', 10002)) srv2.serve_forever()
def test5(): edge_lengths = Real3(1, 1, 1) with reaction_rules(): A1 == A2 | (1.0, 1.0) B1 == B2 | (1.0, 1.0) A1 == B1 | (1.0, 1.0) A2 + B2_ > C1 | 1.0 / 30.0 C1 > A2 + B2 | 1.0 m = get_model() w1 = meso.MesoscopicWorld(edge_lengths, Integer3(3, 3, 3)) w1.bind_to(m) sim1 = meso.MesoscopicSimulator(w1) w2 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w2.bind_to(m) sim2 = meso.MesoscopicSimulator(w2) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2', 'C1')) ev1.borrow('B2', 'B2_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2')) owner.set_value(Species("A1"), 120) # owner.set_value(Species("A1"), 60) # owner.set_value(Species("B1"), 60) owner.initialize() logger = Logger(owner, ("A1", "A2", "C1", "B1", "B2")) logger.add('B2_', w1) logger.log() while owner.step(5): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.savefig() logger.savetxt()
def test2(): edge_lengths = Real3(1, 1, 1) with reaction_rules(): A1 == A2 | (1.0, 1.0) E1 == E2 | (1.0, 1.0) A1 == E1 | (1.0, 1.0) m = get_model() w1 = gillespie.GillespieWorld(edge_lengths) w1.bind_to(m) sim1 = gillespie.GillespieSimulator(w1) w2 = ode.ODEWorld(edge_lengths) w2.bind_to(m) sim2 = ode.ODESimulator(w2) owner = Coordinator() owner.add_event(simulator_event(sim1)).add(('A1', 'A2')) owner.add_event(ODEEvent(sim2, 0.01)).add(('E1', 'E2')) owner.set_value(Species("A1"), 120) # owner.set_value(Species("A1"), 60) # owner.set_value(Species("E1"), 60) owner.initialize() logger = Logger(owner, ("A1", "A2", "E1", "E2")) logger.add("A1", w2) logger.log() while owner.step(50): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.savefig() logger.savetxt()
def test4(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | {"D": str(D), "radius": str(radius)} with reaction_rules(): A1 + B1_ > B2 | 0.04483455086786913 > B1 + A2 | 1.35 B2 > B1 + A1 | 1.5 m = get_model() w1 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w1.bind_to(m) sim1 = meso.MesoscopicSimulator(w1) # w2 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) # w2.bind_to(m) # sim2 = spatiocyte.SpatiocyteSimulator(w2) w2 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) w2.bind_to(m) sim2 = egfrd.EGFRDSimulator(w2) w1.add_molecules(Species("A1"), 120) w2.add_molecules(Species("B1"), 60) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2')) ev1.borrow('B1', 'B1_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2')) owner.initialize() logger = Logger(owner, ("A1", "A2", "B1", "B2")) logger.add("B1_", w1) logger.log() while owner.step(1): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
def test4(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | B3 | C1 | C2 | C3 | { "D": str(D), "radius": str(radius) } with reaction_rules(): A1 + B1_ > B2 | 0.04483455086786913 > A1 + B1 | 1.35 B2 > A2 + B1 | 1.5 A2 + B1_ > B3 | 0.09299017957780264 > A2 + B1 | 1.73 B3 > A3 + B1 | 15.0 A3 + C1 > C2 | 0.04483455086786913 > A3 + C1 | 1.35 C2 > A2 + C1 | 1.5 A2 + C1 > C3 | 0.09299017957780264 > A2 + C1 | 1.73 C3 > A1 + C1 | 15.0 m = get_model() w1 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w1.bind_to(m) sim1 = meso.MesoscopicSimulator(w1) w2 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) w2.bind_to(m) sim2 = spatiocyte.SpatiocyteSimulator(w2) # w2 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) # w2.bind_to(m) # sim2 = egfrd.EGFRDSimulator(w2) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2', 'A3')) ev1.add(('C1', 'C2', 'C3')) ev1.borrow('B1', 'B1_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2', 'B3')) owner.set_value(Species("A1"), 120) owner.set_value(Species("B1"), 30) owner.set_value(Species("C1"), 30) owner.initialize() logger = Logger(owner, ("A1", "A2", "A3", "B1", "B2", "B3", "C1", "C2", "C3")) logger.add("B1_", w1) logger.log() while owner.step(1): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
import os import sys current_path = os.getcwd() sys.path.append(current_path) from coordinator import Coordinator from config import tuned_config model = Coordinator(tuned_config, 'name') model.train() model.restore('name-step')
import os import sys import time from threading import Thread from utils.api_handler import APIHandler from utils.socket_connection import ServerSocketConnection import config.config as config from controller import Controller from coordinator import Coordinator from game import DQGame from server_renderer import ServerRenderer socket = ServerSocketConnection(8000) api_handler = APIHandler() controller = Controller(socket) dq_game = DQGame() renderer = ServerRenderer() coordinator = Coordinator(controller, renderer, dq_game, api_handler) def start_game(): coordinator.start() game_thread = Thread(target=start_game) game_thread.start() renderer.initialize()
def main(): coordinator = Coordinator() exit_criteria = coordinator.solve(max)
class Robot: """ Robot class. Represents the virtual robot. Orientation refers to where the robot is facing: 0. Top 1. Right 2. Bottom 3. Left Attributes: pos: a 15x20 array. Contains None, 0 or 1 as values. orientation: Centre of 3x3 start area. Default = [1,1] explore: if True, update map after every movement. Explorer sets this to False after finishing exploration. map: Map object. Refer to Map.py sensors: Sensors object. Refer to sensors.py coordinator: Coordinator object. Refer to coordinator.py pathfinder: Pathfinder object. Refer to pathfinder.py explorer: Explorer Object. Refer to explorer.py """ pos = [1, 1] orientation = 0 explore = True map = Map() android = None sensors = None coordinator = Coordinator() pathfinder = None explorer = None imagefinder = None images = [] camera_counter = 0 sendimages = False sendreport_counter = 0 fakeRun = False def __init__(self, arduino=None, android=None, fakeRun=False, fakeMap=None, stepsPerSec=1, **kwargs): """ Constructor. Accepts attributes as kwargs. Args: fakeRun: set True if running simulation. Remember to give fake map as input. I.e: fakeMap = fakemap fakeMap: set simulation map. If left empty, creates an empty arena. pos: a 15x20 array. Contains None, 0 or 1 as values. orientation: Centre of 3x3 start area. Default = [1,1] map: Map object. Refer to Map.py sensors: Sensors object. Refer to sensors.py coordinator: Coordinator object. Refer to coordinator.py """ if fakeRun: self.fakeRun = True from sensors_fake import Sensors self.sensors = Sensors(self, fakeMap) #fake sensors for simulation self.coordinator.fakeRun = True self.coordinator.stepsPerSec = stepsPerSec self.imagefinder = Imagefinder(fakeRun=True) elif arduino is None: raise Exception("Real run requires arduino to be present") elif android is None: raise Exception("Real run requires arduino to be present") else: from sensors import Sensors self.android = android self.sensors = Sensors(self, arduino) self.coordinator.arduino = arduino self.imagefinder = Imagefinder() #update map self.updatemap() goalTiles = [ #set goal as explored [12, 19], [13, 19], [14, 19], [12, 18], [13, 18], [14, 18], [12, 17], [13, 17], [14, 17], ] valuelist = [0] * len(goalTiles) self.map.setTiles(goalTiles, valuelist) #initialise pathfinder self.pathfinder = Pathfinder(self.map) #initialise explorer self.explorer = Explorer(self) def backward(self): """ Moves the robot backward. """ self.coordinator.backward() x, y = self.pos newpos_dict = { 0: "[x, y-1]", 1: "[x-1,y]", 2: "[x, y+1]", 3: "[x+1,y]" } self.pos = eval(newpos_dict[self.orientation]) if self.explore: self.updatemap() if settings.logging: print("Movement: Robot goes backward") def checkPhantomBlock(self, checkpos): print("Checking {} for phantom block".format(checkpos)) x, y = checkpos neighbours = [ "[x+1,y]", "[x,y-1]", "[x-1,y]", "[x,y+1]", ] for n in neighbours: tile = eval(n) if self.map.getTile(tile) is None: print("Unexplored terrain detected, changing {} to unexplored". format(checkpos)) self.map.setTile(checkpos, None) self.removeImage( checkpos) #check whether removed block has image return #no unexplored neighbours print("No unexplored terrain detected. Keeping {} as is.".format( checkpos)) def decodeSensors(self, terrain, tiles_array, sensors_range): newTiles = [] valuelist = [] skipUpdate = False for row in tiles_array: terr = terrain.pop(0) if terr == -1: continue for i in range(0, terr): pos = row[i] #check phantom block if self.map.getTile(pos) == 1: if terr > 1: """Not tested""" print( "Warning: Sensor attemped to wipe previous obstacle. But we are skipping reading." ) skipUpdate = True break print( "Warning: Phantom block detected and removed. Tile is {}" .format(pos)) self.removeImage( pos) #check whether removed block has image newTiles.append(pos) valuelist += [0] """Not tested""" if skipUpdate: skipUpdate = False continue if terr < sensors_range: pos = row[terr] newTiles.append(pos) valuelist += [1] #obstacle detected. Add to map #check phantom block if self.map.getTile(pos) == 0: print( "Warning: Phantom block appeared on explored tile, {}." .format(pos)) if terr < sensors_range - 1: checkpos = row[terr + 1] self.checkPhantomBlock(checkpos) self.map.setTiles(newTiles, valuelist) def explore(self, timer=None, exploreLimit=None): """ Starts exploration. Args: timer: Integer. Time in seconds. Total time for robot to explore. Includes time to return exploreLimit: Float. Between 0.0 to 1.0. Percentage of map to explore before exploration is declared done. """ self.explorer.setTime(timer) self.explorer.setExploreLimit(exploreLimit) self.explorer.start() #update android exploration done if not self.fakeRun: self.writeImages() time.sleep(0.5) self.android.write('{"action": "exploreCompleted"}') def faceDirection(self, orient): """ Turns the robot to face the given direction. Args: orient: Integer. Direction for robot to face. """ if orient == self.orientation: return elif orient == (self.orientation + 1) % 4: self.turnRight() elif orient == (self.orientation + 3) % 4: self.turnLeft() else: self.turnRight() self.turnRight() def detectImage(self, reset_counter=False): if reset_counter: self.camera_counter = 0 if self.isDetectImageCancelled(): return #only check tiles that have obstacles checktiles = [] baseline_vert = self.getBaseLineVert() for i in range(3): if self.map.getTile(baseline_vert[i]) == 1: checktiles.append(i) results = self.imagefinder.find(checktiles=checktiles) if results is None: return id, location = results pos = baseline_vert[location] for img in self.images: if pos == img[1]: print( "WARNING. Found image {} at {} but position already has an image" .format(id, pos)) return print("images found") self.images.append([id, pos]) self.sendimages = True #write to android self.writeImages() def isDetectImageCancelled(self): """method to minimise image recognition calls""" #cancelled because settings is find no image if settings.findallimages == 0: return True #cancelled because all images found if len(self.images) == settings.images_threshold: return True #reduce camera usage by only taking once every 3 steps if self.camera_counter != 0: self.camera_counter = (self.camera_counter + 1) % 3 return True else: self.camera_counter = (self.camera_counter + 1) % 3 #if next to arena walls, cancel image recognition #format is [x,y,orientation] conditions = [[1, -1, 0], [-1, 18, 1], [13, -1, 2], [-1, 1, 3]] for cond in conditions: x, y, orient = cond if (self.pos[0] == x or self.pos[1] == y) and self.orientation == orient: return True return False def findpath(self, start=None, goal=[13, 18], waypoint=None, move=True, rowgoal=None): """ Method for robot to find shortest path. Args: start: [x,y] coordinates. Defaults to current robot position. goal: [x,y] coordinates. Defaults to [13,18]. waypoint: [x,y] coordinates. Defaults to None. move: Boolean. Defaults True. If True, moves robot after finding shortest path. rowgoal: Integer. y-axis. Defaults None. Ends findpath() early if y-axis is reached. """ if start is None: start = self.pos orientation = self.orientation path, directions = self.pathfinder.findpath(start, goal, waypoint, orientation) if move: instructions = self.readDirections(directions) for i in instructions: if rowgoal and self.pos[1] == rowgoal: break exec(i) if settings.logging: print("Movement: findpath() to " + str(goal) + " with rowgoal " + str(rowgoal)) return [path, directions] def forward(self, steps=1, findImage=False): """ Moves the robot forward. Args: steps: Integer. Defaults to 1. Number of steps forward to take """ if not self.coordinator.forward(steps): #phantom block detected. Check sensors again wipeTiles = self.getBaseLine() valuelist = [None] * len(wipeTiles) self.map.setTiles(wipeTiles, valuelist) #remove tiles front_terrain = self.sensors.getFront() tiles_array = self.getBaseLineRange( length=self.sensors.front_sensors_range) self.decodeSensors(terrain=front_terrain, tiles_array=tiles_array, sensors_range=self.sensors.front_sensors_range) return x, y = self.pos newpos_dict = { 0: "[x, y+steps]", 1: "[x+steps,y]", 2: "[x, y-steps]", 3: "[x-steps,y]" } self.pos = eval(newpos_dict[self.orientation]) if self.explore: self.updatemap() if findImage: self.detectImage() if settings.logging: print("Movement: Robot goes forward " + str(steps) + " steps") #send update to android self.writeReport() def getBaseLine(self): """ Baseline refers to the left,middle & right (from the robot's perspective) tiles immediately in front of robot and the 3x3 space the robot is occupying. Returns a string compatible for eval(). Expects [x,y] to be declared beforehand. Example string: "[[x-1,y+2],[x,y+2],[x+1,y+2]]" Example usage: x,y = self.pos baseline = getBaseLine() tilelist = eval(baseline) """ #baseline_dict contains the tiles to search. For example, if facing right, search top, middle & bottom tiles x, y = self.pos baseline_dict = { 0: "[[x-1,y+2],[x,y+2],[x+1,y+2]]", 1: "[[x+2,y+1],[x+2,y],[x+2,y-1]]", 2: "[[x+1,y-2],[x,y-2],[x-1,y-2]]", 3: "[[x-2,y-1],[x-2,y],[x-2,y+1]]" } baseline = eval(baseline_dict[self.orientation]) return baseline def getBaseLineRange(self, length=1): baseline = self.getBaseLine() tileRange = self.getTileRange() results = [] for tile in baseline: x, y = tile tiles = [] for i in range(length): tiles.append([x, y]) x, y = eval(tileRange) results.append(tiles) return results def getBaseLineVert(self, right=False): """ baseline_vert refers to baseline, but vertical. Refer to getBaseLine() above. """ x, y = self.pos if right: baseline_vert_dict = { 0: "[[x+2,y+1], [x+2,y], [x+2,y-1]]", 1: "[[x+1,y-2], [x,y-2], [x-1,y-2]]", 2: "[[x-2,y-1], [x-2,y], [x-2,y+1]]", 3: "[[x-1,y+2], [x,y+2], [x+1,y+2]]" } else: baseline_vert_dict = { 0: "[[x-2,y+1], [x-2,y], [x-2,y-1]]", 1: "[[x+1,y+2], [x,y+2], [x-1,y+2]]", 2: "[[x+2,y-1], [x+2,y], [x+2,y+1]]", 3: "[[x-1,y-2], [x,y-2], [x+1,y-2]]" } baseline_vert = eval(baseline_vert_dict[self.orientation]) return baseline_vert def getBaseLineVertRange(self, length=1, exclude_mid=True, toRight=False): baseline_vert = self.getBaseLineVert(right=toRight) if exclude_mid: baseline_vert.pop(1) tileRange_vert = self.getTileRangeVert(toRight=toRight) results = [] for tile in baseline_vert: x, y = tile tiles = [] for i in range(length): tiles.append([x, y]) x, y = eval(tileRange_vert) results.append(tiles) return results def getTileRange(self): """ Range of tiles to search. If facing right, search range of tiles right of robot. Returns a string compatible for eval(). Expects [x,y] to be declared beforehand. Example string: "[x,y+1]" Example usage: x,y = self.pos tilerange=getTileRange for i in range(0,5): nextTile = eval(tilerange) """ tileRange_dict = { 0: "[x,y+1]", 1: "[x+1,y]", 2: "[x,y-1]", 3: "[x-1,y]", } tileRange = tileRange_dict[self.orientation] return tileRange def getTileRangeVert(self, toRight=False): """ Search range of tiles to left of robot. Refer to getTileRange() above. """ if toRight: tileRange_vert_dict = { 0: "[x+1,y]", 1: "[x,y-1]", 2: "[x-1,y]", 3: "[x,y+1]", } else: tileRange_vert_dict = { 0: "[x-1,y]", 1: "[x,y+1]", 2: "[x+1,y]", 3: "[x,y-1]", } tileRange_vert = tileRange_vert_dict[self.orientation] return tileRange_vert def isLeftBlocked(self): """ Checks whether left side is blocked by reading map. """ x, y = self.pos tiles = self.getBaseLineVert() for pos in tiles: if self.map.getTile(pos) == 1: return True return False def readDirections(self, directions): """ Reads a list of directions and converts it into instructions like forward, turn left, etc. Args: directions: list of directions/integers. """ prev = self.orientation steps = 0 instructions = [] for d in directions: if d == prev: steps += 1 prev = d elif d == (prev + 1) % 4: #turn right if steps > 0: instructions.append("self.forward(" + str(steps) + ")") instructions.append("self.turnRight()") steps = 1 elif d == (prev + 2) % 4: #U-turn if steps > 0: instructions.append("self.forward(" + str(steps) + ")") instructions.append("self.turnRight()") instructions.append("self.turnRight()") steps = 1 else: #turn right if steps > 0: instructions.append("self.forward(" + str(steps) + ")") instructions.append("self.turnLeft()") steps = 1 prev = d if steps > 0: instructions.append("self.forward(" + str(steps) + ")") if settings.logging: print("=======Read Instructions Output========") print(instructions) return instructions def removeImage(self, tile): for im in self.images: id, pos = im if pos == tile: print( "WARNING: Image detected at removed phantom block. Removing image as well. Consider block may not be phantom?" ) self.images.remove(im) def setAttributes(self, **kwargs): """ Set class attributes. Accepts kwargs of robot attributes. """ for key, value in kwargs: concat = "self." + key + " = " + value eval(concat) #Set attributes. Evaluate self.key = value def turnLeft(self, findImage=False): """ Turns the robot left. """ self.coordinator.turnLeft() self.orientation = (self.orientation + 3) % 4 if self.explore: self.updatemap() if findImage: self.detectImage() if settings.logging: print("Movement: Robot Turns Left") #send update to android self.writeReport() def turnRight(self, findImage=False): """ Turns the robot right. """ if findImage: self.detectImage( reset_counter=True) #called before and after movement self.coordinator.turnRight() self.orientation = (self.orientation + 1) % 4 if self.explore: self.updatemap() if findImage: self.detectImage(reset_counter=True) if settings.logging: print("Movement: Robot Turns Right") #send update to android self.writeReport() def updatemap(self): """ Updates map by reading sensors. """ #update robot's position as free space on map x, y = self.pos freeTiles = [ [x - 1, y + 1], [x, y + 1], [x + 1, y + 1], [x - 1, y], [x, y], [x + 1, y], [x - 1, y - 1], [x, y - 1], [x + 1, y - 1], ] valuelist = [0] * len(freeTiles) self.map.setTiles(freeTiles, valuelist) #update map with front sensors terrain = self.sensors.getLeastSensors() front_terrain = terrain[:3] tiles_array = self.getBaseLineRange( length=self.sensors.front_sensors_range) self.decodeSensors(terrain=front_terrain, tiles_array=tiles_array, sensors_range=self.sensors.front_sensors_range) #update map with left sensors left_terrain = terrain[3:5] tiles_array = self.getBaseLineVertRange( length=self.sensors.left_sensors_range) self.decodeSensors(terrain=left_terrain, tiles_array=tiles_array, sensors_range=self.sensors.left_sensors_range) #update map with right sensors right_terrain = terrain[-1] if right_terrain == -1: tiles_array = self.getBaseLineVertRange( length=self.sensors.front_sensors_range, #use front sensors exclude_mid=False, toRight=True) row = tiles_array.pop(self.sensors.right_sensors_position) isRightExplored = True for tile in row: if self.map.getTile(tile) == 1: #explored and found obstacle break if self.map.getTile(tile) is None: isRightExplored = False if not isRightExplored: #update map by turning right and using front sensors self.turnRight() front_terrain = self.sensors.getFront() tiles_array = self.getBaseLineRange( length=self.sensors.front_sensors_range) self.decodeSensors( terrain=front_terrain, tiles_array=tiles_array, sensors_range=self.sensors.front_sensors_range) self.turnLeft() else: #update using right sensors. tiles_array = self.getBaseLineVertRange( length=self.sensors.right_sensors_range, exclude_mid=False, toRight=True) row = tiles_array.pop(self.sensors.right_sensors_position) self.decodeSensors(terrain=[right_terrain], tiles_array=[row], sensors_range=self.sensors.right_sensors_range) if self.map.is_explored(): self.explore = False def writeImages(self): img_list = [] for img in self.images: x, y = img[1] id = img[0] img_list.append([x, y, id]) output = {"imageDisplay": img_list} output = json.dumps(output) self.android.write(output) def writeReport(self): if self.fakeRun: return self.sendreport_counter = (self.sendreport_counter + 1) % 10 if self.sendreport_counter == 0: self.writeImages() else: results = "" for item in self.map.convert(): results += item[2:].upper() + ',' for coords in self.pos: results += str(coords) + ',' orientation = 90 * self.orientation results += str(orientation) dict = {"robot": results} report = json.dumps(dict) self.android.write(report)
import sys from ratelimitedapi import RateLimitedApi from coordinator import Coordinator if __name__ == "__main__": # Working dir needs to have config.json file at the root. Coordinator will create subfolders for storing the # backtest results. working_dir = Path(r"path/to/data/dir") with (working_dir / "config.json").open() as f: config = json.load(f) loglevel = config.get("loglevel", logging.INFO) logging.basicConfig( # configures root logger, more succinct than wiring up handlers on object directly level=loglevel, format="%(asctime)s %(name)s [%(threadName)s] [%(levelname)-5.5s]: %(message)s", stream=sys.stdout ) logger = logging.getLogger() # root logger logger.info(str(config)) try: mod = importlib.import_module(config["module"]) testset = getattr(mod, config["testset"]) api = RateLimitedApi(config["user_id"], config["token"], debug=False) coordinator = Coordinator(testset, api, working_dir, config["project_name"], config["concurrency"]) asyncio.run(coordinator.run(), debug=True) except Exception as e: logger.error("Unhandled error", exc_info=e) sys.exit(1)
import slack import specificvars import re import threading import queue from time import sleep slack_events_adapter = SlackEventAdapter(specificvars.slack_signing_secret, endpoint="/slack/events") webclient = slack.WebClient(token=specificvars.bot_user_token) rtmclient = slack.RTMClient(token=specificvars.bot_user_token) respond_msg_queue = queue.Queue() output_queue = queue.Queue() coord = Coordinator(output_queue) @slack_events_adapter.on("app_mention") def app_mention(event_data): event = event_data['event'] text = event['text'] clean_text = re.sub(r'<@.*>', '', text) event['text'] = clean_text event['dubious'] = False respond_msg_queue.put(event) @slack.RTMClient.run_on(event='message') def channel_msg(**payload): data = payload['data']
class TapiocaBot(sc2.BotAI): def __init__(self, verbose=False, visual_debug=False): self.verbose = verbose self.visual_debug = visual_debug ipdb.launch_ipdb_on_exception() # Control Stuff self.researched_warpgate = False # Remove me later # Managers and controllers self.worker_controller = WorkerController(bot=self, verbose=self.verbose) self.army_controller = ArmyController(bot=self, verbose=self.verbose) self.scouting_controller = ScoutingController(bot=self, verbose=self.verbose) self.upgrades_controller = UpgradesController(bot=self, verbose=self.verbose) self.robotics_facility_controller = RoboticsFacilitiyController( bot=self, verbose=self.verbose, ) self.gateway_controller = GatewayController( bot=self, verbose=self.verbose, auto_morph_to_warpgate=True) self.building_controller = BuildingController(bot=self, verbose=self.verbose) self.event_manager = EventManager() self.build_order_controller = BuildOrderController( verbose=self.verbose, bot=self) self.coordinator = Coordinator(bot=self, verbose=self.verbose, build_order='three_gate_blink_all_in') self.order_queue = [] def on_start(self): self.army_controller.init() self.event_manager.add_event(self.worker_controller.step, 0.1, jitter=0) self.event_manager.add_event( self.building_controller.update_nexus_list, 2.5) self.event_manager.add_event(self.build_order_controller.step, 0.5) self.event_manager.add_event(self.army_controller.step, 0.1, jitter=0) self.event_manager.add_event(self.coordinator.step, 1) self.coordinator.on_start() async def on_step(self, iteration): if iteration == 0: # Do nothing on the first iteration to avoid # everything being done at the same time if self.verbose: print('\n------------------------\n') print('%8.2f %3d Rise and Shine' % (self.time, self.supply_used)) await self.chat_send( "Cry 'havoc', and let slip the Tapiocas of war!") return events = self.event_manager.get_current_events(self.time) for event in events: await event() await self.debug() await self.execute_order_queue() if self.verbose: sys.stdout.flush() async def do(self, action): self.order_queue.append(action) async def execute_order_queue(self): await self._client.actions(self.order_queue, game_data=self._game_data) self.order_queue = [] async def debug(self): if not self.visual_debug: return # Setup and info font_size = 14 total_units = 0 for unit_type in self.army_controller.units_available_for_attack.keys( ): total_units += self.units(unit_type).idle.amount # Text messages = [ ' n_workers: %3d' % self.units(UnitTypeId.PROBE).amount, ' n_stalkers: %3d' % self.units(UnitTypeId.STALKER).amount, ' militia_size: %3d' % len(self.worker_controller.militia_controller.militia), '', 'ememy_structures_nearby: %3d' % len(self.worker_controller.militia_controller. nearby_enemy_structures_found), ' ememy_workers_nearby: %3d' % len(self.worker_controller.militia_controller. nearby_enemy_workers_found), ' ememy_units_nearby: %3d' % len(self.worker_controller.militia_controller. nearby_enemy_units_found), '', ' know_enemy_structures: %3d' % len(self.known_enemy_structures) ] y = 0 inc = 0.018 for message in messages: self._client.debug_text_screen(message, pos=(0.001, y), size=font_size) y += inc # 3D text debug_army_state = False if debug_army_state: for tag in self.army_controller.soldiers: unit = self.units.find_by_tag(tag) if unit is not None: message = self.army_controller.soldiers[tag]['state'] self._client.debug_text_world(message, pos=unit.position3d, size=font_size) # Spheres debug_army_groups = False if debug_army_groups: leader_tag = self.army_controller.leader for soldier_tag in self.army_controller.soldiers: soldier_unit = self.units.find_by_tag(soldier_tag) if soldier_unit is not None: if soldier_tag == leader_tag: self._client.debug_sphere_out(soldier_unit, r=1, color=(255, 0, 0)) else: self._client.debug_sphere_out(soldier_unit, r=1, color=(0, 0, 255)) # Lines if debug_army_groups: if self.army_controller.army_size() > 0: leader_tag = self.army_controller.leader leader_unit = self.units.find_by_tag(leader_tag) for soldier_tag in self.army_controller.soldiers: if soldier_tag == leader_tag: continue soldier_unit = self.units.find_by_tag(soldier_tag) if soldier_unit is not None: leader_tag = self.army_controller.leader leader_unit = self.units.find_by_tag(leader_tag) if leader_unit is not None: self._client.debug_line_out(leader_unit, soldier_unit, color=(0, 255, 255)) # Attack Lines debug_army_attack = False if debug_army_attack: if self.army_controller.army_size() > 0: for soldier_tag in self.army_controller.soldiers: soldier_unit = self.units.find_by_tag(soldier_tag) if soldier_unit is not None and \ self.army_controller.soldiers[soldier_tag]['state'] == 'attacking' and \ self.army_controller.attack_target is not None: self._client.debug_line_out( soldier_unit, self.army_controller.attack_target, color=(255, 127, 0)) # Sens the debug info to the game await self._client.send_debug() def get_unit_info(self, unit, field="food_required"): assert isinstance(unit, (Unit, UnitTypeId)) if isinstance(unit, Unit): unit = unit._type_data._proto else: unit = self._game_data.units[unit.value]._proto if hasattr(unit, field): return getattr(unit, field) else: return None
# Prepare Loop # ==== loop = asyncio.get_event_loop() # Create agents # ==== # coordinator agents are the entities that can become coordinators. etcd_config = EtcdConfig(etcd_ip, etcd_port) # coordinator agent 1 uuid = "1" coordinator_configuration = CoordinatorConfiguration( uuid, group_prefix, workers_subprefix, global_task_prefix, coordinator_subprefix, worker_queue_subprefix, coordinator_time_to_renew) agent_one = Coordinator(coordinator_configuration, etcd_config, loop, logger) # coordinator agent 2 uuid = "2" coordinator_configuration = CoordinatorConfiguration( uuid, group_prefix, workers_subprefix, global_task_prefix, coordinator_subprefix, worker_queue_subprefix, coordinator_time_to_renew) agent_two = Coordinator(coordinator_configuration, etcd_config, loop, logger) def operation_on_task(etcd, task_id, operation): key = global_task_prefix + "." + task_id if operation == "delete": etcd.delete(key) elif operation == "put": etcd.put(key, task_id)
test_x = make_image_scale(test_x) train_y = make_onehot(train_y) test_y = make_onehot(test_y) # Set model parameters model_parameter = ModelDNN(train_x=train_x, train_y=train_y, test_x=test_x, test_y=test_y, codec=codec, psgd_type=arg.psgd, server_codec=arg.server_codec, learn_rate=arg.lr, epoches=arg.epochs, optimizer_type=arg.op) core = Coordinator(model_parameter, logger) with open(arg.workers, 'r') as f: workers = json.load(f) core.set_workers(workers, arg.n) try: if not arg.do_retrieve_only: core.resources_dispatch() else: core.require_client_log() except ConnectionAbortedError: print('All Done.')
network_topology=network_config, learning_rate_decay_step=int(total_training_step / 30), update_tar_period=1000, epsilon=1, epsilon_Min=0.1, epsilon_decay_period=total_training_step * replay_period / 5, memory_size=500 * batch_size, batch_size=batch_size, history_length=window_length, log_freq=50, save_period=save_period, save=save, name=name, GPU=GPU) coo = Coordinator(agent) env = PortfolioEnv(df_train, steps=256, trading_cost=0.00007, window_length=window_length, scale=False, random_reset=False) ob = env.reset() for i in range(5): print(coo.action_values(ob)) ob, a, r, ob_ = env.step(np.ones(5)) coo.train(env, total_training_step=total_training_step,
''' DO WHAT THE F**K YOU WANT TO PUBLIC LICENSE Version 2, December 2004 Copyright (C) 2014 bcdev <*****@*****.**> Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed. DO WHAT THE F**K YOU WANT TO PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. You just DO WHAT THE F**K YOU WANT TO. ''' import sys if sys.version_info < (3, 0): sys.stdout.write("Node requires Python 3.x\n") sys.exit(1) import config import time from coordinator import Coordinator coordinator = Coordinator() coordinator.start()
import socket import json from coordinator import Coordinator # Create a TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Bind the socket to the port server_address = ('localhost', 4444) print('Starting up on {} port {}'.format(*server_address)) sock.bind(server_address) # Listen for incoming connections sock.listen(5) c = Coordinator() while True: connection, client_address = sock.accept() #print('connection from', client_address) # Receive the data data_string = connection.recv(4096) #print('received {!r}'.format(data_string)) if data_string: #Parsed Json p = json.loads(data_string) #connection.sendall(str(p)) #print(p) if (p['open'] == True): print('open_trans') r = c.open_trans() print('open_trans data', r) connection.sendall(str(r))
def main(): service = Coordinator() longDelay = service.deadPings * 2 srv1 = ("localhost", 10001) srv2 = ("localhost", 10002) srv3 = ("localhost", 10003) currentView = 0 try: # no ready servers if service.master() is not None: raise TestFailedException("no ready servers") sys.stderr.write("Test passed: no ready servers\n") # first master for i in range(longDelay): info = service.ping(0, srv1) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv1, None, currentView, "first master") # first backup for i in range(longDelay): service.ping(currentView, srv1) info = service.ping(0, srv2) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv1, srv2, currentView, "first backup") # master fails, backup should take over service.ping(2, srv1) for i in range(longDelay): info = service.ping(2, srv2) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv2, None, currentView, "backup takes over") # first server restarts, should become backup for i in range(longDelay): service.ping(currentView, srv2) info = service.ping(0, srv1) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv2, srv1, currentView, "restarted server becomes backup") # master fails, third server appears, # backup should become master, new server - backup service.ping(currentView, srv2) for i in range(longDelay): service.ping(currentView, srv1) info = service.ping(0, srv3) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv1, srv3, currentView, "spare server becomes backup") # master quickly restarts, should not be master anymore service.ping(currentView, srv1) for i in range(longDelay): service.ping(0, srv1) info = service.ping(currentView, srv3) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv3, srv1, currentView, "master reboots") # set up a number with just 3 as master, # to prepare for the next test. for i in range(longDelay): info = service.ping(currentView, srv3) service.tick() currentView += 1 test(info, srv3, None, currentView, "master only") # backup appears but master does not ack for i in range(longDelay): service.ping(0, srv1) info = service.ping(currentView, srv3) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv3, srv1, currentView, "master doesn't ack") # master didn't ack and dies # check that backup is not promoted for i in range(longDelay): info = service.ping(currentView, srv1) if info.number == currentView + 1: break service.tick() test(info, srv3, srv1, currentView, "do not promote backup") # master finally acks for i in range(longDelay): service.ping(currentView, srv3) info = service.ping(currentView, srv1) if info.number == currentView + 1: break service.tick() test(info, srv3, srv1, currentView, "master acks") # backup suddenly restarts # should become backup anew for i in range(longDelay): service.ping(currentView, srv3) info = service.ping(0, srv1) if info.number == currentView + 1: break service.tick() currentView += 1 test(info, srv3, srv1, currentView, "backup reboots") except TestFailedException as e: sys.stderr.write("Test failed: %s\n" % e)
def test1(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | C1 | C2 | D1 | D2 | E1 | E2 | { "D": str(D), "radius": str(radius)} with reaction_rules(): A1 == A2 | (1.0, 1.0) B1 == B2 | (1.0, 1.0) C1 == C2 | (1.0, 1.0) D1 == D2 | (1.0, 1.0) E1 == E2 | (1.0, 1.0) A1 == B1 | (1.0, 1.0) A1 == C1 | (1.0, 1.0) A1 == D1 | (1.0, 1.0) A1 == E1 | (1.0, 1.0) B1 == C1 | (1.0, 1.0) B1 == D1 | (1.0, 1.0) B1 == E1 | (1.0, 1.0) C1 == D1 | (1.0, 1.0) C1 == E1 | (1.0, 1.0) D1 == E1 | (1.0, 1.0) m = get_model() w1 = gillespie.GillespieWorld(edge_lengths) w1.bind_to(m) sim1 = gillespie.GillespieSimulator(w1) w2 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w2.bind_to(m) sim2 = meso.MesoscopicSimulator(w2) w3 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) w3.bind_to(m) sim3 = spatiocyte.SpatiocyteSimulator(w3) w4 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) w4.bind_to(m) sim4 = egfrd.EGFRDSimulator(m, w4) w5 = ode.ODEWorld(edge_lengths) w5.bind_to(m) sim5 = ode.ODESimulator(w5) sim5.set_dt(0.01) owner = Coordinator() owner.add_event(simulator_event(sim1)).add(('A1', 'A2')) owner.add_event(simulator_event(sim2)).add(('B1', 'B2')) owner.add_event(simulator_event(sim3)).add(('C1', 'C2')) owner.add_event(simulator_event(sim4)).add(('D1', 'D2')) owner.add_event(simulator_event(sim5)).add(('E1', 'E2')) owner.set_value(Species("A1"), 300) # owner.set_value(Species("A1"), 60) # owner.set_value(Species("B1"), 60) # owner.set_value(Species("C1"), 60) # owner.set_value(Species("D1"), 60) # owner.set_value(Species("E1"), 60) owner.initialize() logger = Logger(owner, ("A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2", "E1", "E2")) logger.log() while owner.step(3): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
def main(): parser = argparse.ArgumentParser(description=None) parser.add_argument("-v", "--verbose", action="store_true", help="show detailed logs") parser.add_argument("-vv", action="store_true", dest="vv", help="show debug logs") parser.add_argument("--version", dest="version", action="store_true", help="show version number") parser.add_argument( '-kg', '--keygen', dest="kg", action="store_true", help="Generate a key string and quit, overriding other options") parser.add_argument( '--get-meek', dest="dlmeek", action="store_true", help="Download meek to home directory, overriding normal options") parser.add_argument( '-c', '--config', dest="config", default=None, help="specify a configuration files, required for ArkC to start") parser.add_argument("-t", action="store_true", dest="transmit", help="use transmit server") parser.add_argument( '-ep', "--use-external-proxy", action="store_true", help= """use an external proxy server or handler running locally,e.g. polipo, for better performance. Use this option to support other types of proxy other than HTTP, or use authentication at client-end proxy. Fall back to in-built python proxy server otherwise.""") print("""ArkC Server V""" + VERSION + """ by ArkC Technology. The programs is distributed under GNU General Public License Version 2. """) args = parser.parse_args() if args.version: print("ArkC Server Version " + VERSION) sys.exit() elif args.kg: print("Generating 2048 bit RSA key.") print("Writing to home directory " + os.path.expanduser('~')) generate_RSA( os.path.expanduser('~') + os.sep + 'arkc_pri.asc', os.path.expanduser('~') + os.sep + 'arkc_pub.asc') print( "Please save the above settings to client and server side config files." ) sys.exit() elif args.dlmeek: if sys.platform == 'linux2': link = "https://github.com/projectarkc/meek/releases/download/v0.2.2/meek-client" localfile = os.path.expanduser('~') + os.sep + "meek-client" elif sys.platform == 'win32': link = "https://github.com/projectarkc/meek/releases/download/v0.2.2/meek-client.exe" localfile = os.path.expanduser('~') + os.sep + "meek-client.exe" else: print( "MEEK for ArkC has no compiled executable for your OS platform. Please compile and install from source." ) print( "Get source at https://github.com/projectarkc/meek/tree/master/meek-client" ) sys.exit() print("Downloading meek plugin (meek-client) from github to " + localfile) urllib.urlretrieve(link, localfile) if sys.platform == 'linux2': st = os.stat(localfile) os.chmod(localfile, st.st_mode | stat.S_IEXEC) print("File made executable.") print( "Finished. If no error, you may change obfs_level and update pt_exec to " + localfile + " to use meek.") sys.exit() elif args.config is None: logging.fatal("Config file (-c or --config) must be specified.\n") parser.print_help() sys.exit() # mapping client public sha1 --> (RSA key object, client private sha1) certs = dict() data = {} # Load json configuration file try: data_file = open(args.config) data = json.load(data_file) data_file.close() except Exception as err: logging.error("Fatal error while loading configuration file.") print(err) # TODO: improve error processing sys.exit() try: for client in data["clients"]: with open(client[0], "r") as f: remote_cert_txt = f.read() remote_cert = RSA.importKey(remote_cert_txt) remote_cert_txt = remote_cert_txt.strip(' ').lstrip('\n') certs[sha1(remote_cert_txt).hexdigest()] =\ [remote_cert, client[1]] except KeyError: pass except Exception as err: print("Fatal error while loading client certificate.") print(err) sys.exit() try: certsdbpath = data["clients_db"] except KeyError: certsdbpath = None try: certs_db = certstorage(certs, certsdbpath) except Exception as err: print("Fatal error while loading clients' certificate.") print(err) sys.exit() if args.transmit: try: with open(data["central_cert"], "r") as f: central_cert_txt = f.read() central_cert = RSA.importKey(central_cert_txt) except Exception as err: print("Fatal error while loading client certificate.") print(err) sys.exit() else: central_cert = None try: with open(data["local_cert_path"], "r") as f: local_cert = RSA.importKey(f.read()) if not local_cert.has_private(): print("Fatal error, no private key included in local certificate.") except IOError as err: print("Fatal error while loading local certificate.") print(err) sys.exit() if args.vv: logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="%(levelname)s: %(asctime)s; %(message)s") elif args.verbose: logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(levelname)s: %(asctime)s; %(message)s") else: logging.basicConfig(stream=sys.stdout, level=logging.WARNING, format="%(levelname)s: %(asctime)s; %(message)s") if not args.use_external_proxy: if "proxy_port" not in data: data["proxy_port"] = 8100 start_proxy(data["proxy_port"]) else: if "proxy_port" not in data: data["proxy_port"] = 8123 if "udp_port" not in data: if args.transmit: data["udp_port"] = 8000 else: data["udp_port"] = 53 if "socks_proxy" not in data: data["socks_proxy"] = None if "delegated_domain" not in data: data["delegated_domain"] = "public.arkc.org" if "self_domain" not in data: data["self_domain"] = "freedom.arkc.org" if "pt_exec" not in data: data["pt_exec"] = "obfs4proxy" if "obfs_level" not in data: data["obfs_level"] = 0 elif 1 <= int(data["obfs_level"]) <= 2: logging.error( "Support for obfs4proxy is experimental with known bugs. Run this mode at your own risk." ) if "meek_url" not in data: data["meek_url"] = "https://arkc-reflect1.appspot.com/" # Start the loop try: reactor.listenUDP( data["udp_port"], Coordinator(data["proxy_port"], data["socks_proxy"], local_cert, certs_db, central_cert, data["delegated_domain"], data["self_domain"], data["pt_exec"], data["obfs_level"], data["meek_url"], args.transmit)) except CannotListenError as err: print(err.socketError) if data["udp_port"] <= 1024 and str(err.socketError) == "[Errno 13] \ Permission denied": print("root privilege may be required to listen to low ports") exit() try: reactor.run() except KeyboardInterrupt: pass
def test4(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | B3 | C1 | C2 | C3 | {"D": str(D), "radius": str(radius)} with reaction_rules(): A1 + B1_ > B2 | 0.04483455086786913 > A1 + B1 | 1.35 B2 > A2 + B1 | 1.5 A2 + B1_ > B3 | 0.09299017957780264 > A2 + B1 | 1.73 B3 > A3 + B1 | 15.0 A3 + C1 > C2 | 0.04483455086786913 > A3 + C1 | 1.35 C2 > A2 + C1 | 1.5 A2 + C1 > C3 | 0.09299017957780264 > A2 + C1 | 1.73 C3 > A1 + C1 | 15.0 m = get_model() w1 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w1.bind_to(m) sim1 = meso.MesoscopicSimulator(w1) w2 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) w2.bind_to(m) sim2 = spatiocyte.SpatiocyteSimulator(w2) # w2 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) # w2.bind_to(m) # sim2 = egfrd.EGFRDSimulator(w2) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2', 'A3')) ev1.add(('C1', 'C2', 'C3')) ev1.borrow('B1', 'B1_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2', 'B3')) owner.set_value(Species("A1"), 120) owner.set_value(Species("B1"), 30) owner.set_value(Species("C1"), 30) owner.initialize() logger = Logger(owner, ("A1", "A2", "A3", "B1", "B2", "B3", "C1", "C2", "C3")) logger.add("B1_", w1) logger.log() while owner.step(1): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
def test3(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | B3 | {"D": str(D), "radius": str(radius)} with reaction_rules(): A1 == A2 | (1.0, 1.0) B1 == B2 | (1.0, 1.0) A2 + B2_ > B3 | 1.0 / 30.0 B3 > A2 + B2 | 1.0 m = get_model() w1 = gillespie.GillespieWorld(edge_lengths) w1.bind_to(m) sim1 = gillespie.GillespieSimulator(w1) # w2 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) # w2.bind_to(m) # sim2 = meso.MesoscopicSimulator(w2) # w2 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) # w2.bind_to(m) # sim2 = spatiocyte.SpatiocyteSimulator(w2) # w2 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) # w2.bind_to(m) # sim2 = egfrd.EGFRDSimulator(w2) w2 = ode.ODEWorld(edge_lengths) w2.bind_to(m) sim2 = ode.ODESimulator(w2) sim2.set_dt(0.01) owner = Coordinator() ev1 = simulator_event(sim1) ev1.add(('A1', 'A2')) ev1.borrow('B2', 'B2_') owner.add_event(ev1) owner.add_event(simulator_event(sim2)).add(('B1', 'B2', 'B3')) owner.set_value(Species("A1"), 60) owner.set_value(Species("B1"), 60) owner.initialize() logger = Logger(owner, ("A1", "A2", "B1", "B2", "B3")) logger.add("B2_", w1) logger.log() while owner.step(10): # while owner.step(50): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
def create_logger(level=logging.INFO): logging.basicConfig(level=logging.INFO, stream=sys.stderr, format='%(asctime)s %(levelname)s %(message)s') return logging.getLogger() if __name__ == '__main__': opt = option.parse(__doc__, ['port=', 'interface='], ['port'], {'interface': ''}) log = create_logger() log.info('hello') # TODO # pre-fork hub # http://groups.google.com/group/gevent/browse_thread/thread/44b756976698503b env = {'rain.log': log, 'rain.coordinator': Coordinator(log)} server = wsgi_httpserver.create(opt['interface'], opt['port'], log, env) try: server.serve_forever() except KeyboardInterrupt: print log.info('recd KeyboardInterrupt; shutting down') server.stop() log.info('bye')
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from coordinator import Coordinator if __name__ == '__main__': c = Coordinator() c.run_tasks()
def test1(): D, radius = 1, 0.005 edge_lengths = Real3(1, 1, 1) with species_attributes(): A1 | A2 | B1 | B2 | C1 | C2 | D1 | D2 | E1 | E2 | { "D": str(D), "radius": str(radius) } with reaction_rules(): A1 == A2 | (1.0, 1.0) B1 == B2 | (1.0, 1.0) C1 == C2 | (1.0, 1.0) D1 == D2 | (1.0, 1.0) E1 == E2 | (1.0, 1.0) A1 == B1 | (1.0, 1.0) A1 == C1 | (1.0, 1.0) A1 == D1 | (1.0, 1.0) A1 == E1 | (1.0, 1.0) B1 == C1 | (1.0, 1.0) B1 == D1 | (1.0, 1.0) B1 == E1 | (1.0, 1.0) C1 == D1 | (1.0, 1.0) C1 == E1 | (1.0, 1.0) D1 == E1 | (1.0, 1.0) m = get_model() w1 = gillespie.GillespieWorld(edge_lengths) w1.bind_to(m) sim1 = gillespie.GillespieSimulator(w1) w2 = meso.MesoscopicWorld(edge_lengths, Integer3(9, 9, 9)) w2.bind_to(m) sim2 = meso.MesoscopicSimulator(w2) w3 = spatiocyte.SpatiocyteWorld(edge_lengths, radius) w3.bind_to(m) sim3 = spatiocyte.SpatiocyteSimulator(w3) w4 = egfrd.EGFRDWorld(edge_lengths, Integer3(4, 4, 4)) w4.bind_to(m) sim4 = egfrd.EGFRDSimulator(m, w4) w5 = ode.ODEWorld(edge_lengths) w5.bind_to(m) sim5 = ode.ODESimulator(w5) sim5.set_dt(0.01) owner = Coordinator() owner.add_event(simulator_event(sim1)).add(('A1', 'A2')) owner.add_event(simulator_event(sim2)).add(('B1', 'B2')) owner.add_event(simulator_event(sim3)).add(('C1', 'C2')) owner.add_event(simulator_event(sim4)).add(('D1', 'D2')) owner.add_event(simulator_event(sim5)).add(('E1', 'E2')) owner.set_value(Species("A1"), 300) # owner.set_value(Species("A1"), 60) # owner.set_value(Species("B1"), 60) # owner.set_value(Species("C1"), 60) # owner.set_value(Species("D1"), 60) # owner.set_value(Species("E1"), 60) owner.initialize() logger = Logger( owner, ("A1", "A2", "B1", "B2", "C1", "C2", "D1", "D2", "E1", "E2")) logger.log() while owner.step(3): if owner.last_event.event_kind == EventKind.REACTION_EVENT: logger.log() logger.log() logger.savefig() logger.savetxt()
import time from http import HTTPStatus from flask import Flask, request, json from flask import Response from coordinator import Coordinator app = Flask(__name__) coordinator = Coordinator() cache = {} @app.route('/') def index(): resp = Response() resp.set_data('Key Value Store') return resp @app.route('/put', methods=['PUT']) def put(): r = Response(mimetype="application/json") r.headers["Content-Type"] = "text/json; charset=utf-8" data = request.values if 'key' not in data or 'val' not in data: r.status_code = HTTPStatus.BAD_REQUEST r.response = json.dumps({ 'code': "1",