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 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 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 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",
