def RemoveUnused(dictionary, indictator):
newDict = {}
ListoKeys = []
for guy in dictionary.keys():
ListoKeys.append(guy)
# print(ListoKeys)
for h in ListoKeys:
fitVal = dictionary[h]
# print("line 203")
# print(fitVal)
deleteList = []
for i in range(len(h._strategies)):
if h._counter_calls[i] == 0:
deleteList.append(h._strategies[i])
# print("210")
# print(deleteList)
for bad in deleteList:
# print('213')
# print(h._strategies)
h._strategies.remove(bad)
# print(h._strategies)
if len(h._strategies) != 0:
Ok = Script(h._strategies, h._id + indictator + 70)
Ok.saveFile(path)
module = importlib.import_module("Population.Script" +
str(Ok.getId()))
class_ = getattr(module, "Script" + str(Ok.getId()))
inst = class_()
newDict[inst] = fitVal
# print("IN IF")
# print(fitVal)
# print(newDict)
# print(inst)
else:
Try = DSL()
OK = Script(Try.initializeNumerous(3, 3), h._id + 70 + indictator)
OK.saveFile(path)
module = importlib.import_module("Population.Script" +
str(OK.getId()))
class_ = getattr(module, "Script" + str(OK.getId()))
inst = class_()
newDict[inst] = 0
# print("IN ELSE")
return newDict
def test_getTotalRows(self):
data = self.getData()
script = Script()
expectedResult = 1
result = script.get_total_rows(data)
self.assertEqual(expectedResult, result)
def setup_test(self):
script = Script()
script_config = ScriptConfig()
when(script_config).get_location().thenReturn("./testFiles/")
script.script_config = script_config
return script
def do_POST(self):
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
parsed_path = urlparse.urlparse(self.path)
params = urlparse.parse_qs(parsed_path.query)
ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))
if ctype == 'multipart/form-data':
postvars = cgi.parse_multipart(self.rfile, pdict)
elif ctype == 'application/x-www-form-urlencoded':
length = int(self.headers.getheader('content-length'))
postvars = cgi.parse_qs(self.rfile.read(length), keep_blank_values=1)
else:
postvars = {}
print parsed_path
if parsed_path.path == '/heartbeat' :
returnJson = {'status': 'ok'}
elif parsed_path.path == '/completions':
script = Script(postvars)
script.display()
returnJson = prophet.speak(script)
else:
returnJson = {'error': 'command ' + parsed_path.path + ' does not exist'}
print "Returning", len(returnJson), "items"
print
self.wfile.write(json.dumps(returnJson, encoding = 'latin1'))
def loadScripts(self, dir):
import sys
sys.path.insert(0, "./scripts")
from Script import Script
s = Script(self, "test")
from loading import Loading
l = Loading(self.segments[0])
self.scripts.append(l)
from TheaterChase import TheaterChase
t = TheaterChase(self.segments[0])
self.scripts.append(t)
from rainbow import Rainbow
r = Rainbow(self.segments[0])
self.scripts.append(r)
from LeftToRightRandom import LeftToRightRandom
lr = LeftToRightRandom(self.segments[0])
self.scripts.append(lr)
from RandomLed import RandomLed
r = RandomLed(self.segments[0])
self.scripts.append(r)
from Light import Light
self.scripts.append(Light(self.segments[0]))
from Test import Test
self.scripts.append(Test(self.segments[0]))
from Cycle import Cycle
self.scripts.append(Cycle(self.segments[0]))
from SingleColor import SingleColor
self.scripts.append(SingleColor(self.segments[0]))
def script(self, **kwds):
from Script import Script
script = Script(**kwds)
self.contents.append(script)
return script
def sign_input(self, input_index, private_key):
z = self.sig_hash(input_index)
der = private_key.sign(z).der()
sig = der + SIGHASH_ALL.to_bytes(1, 'big')
sec = private_key.point.sec()
self.tx_ins[input_index].script_sig = Script([sig, sec])
return self.verify_input(input_index)
def test_getFileExtension(self):
data = self.getData()
script = Script()
expectedResult = "py"
result = script.get_file_extension(data)
self.assertEqual(expectedResult, result)
def test_getEigenschap(self):
data = self.getData()
script = Script()
expectedResult = "Tokenize.py"
result = script.get_property_from_data(data)
self.assertEqual(expectedResult, result)
def __init__(self, prev_tx, prev_index, script_sig=None, sequence=0xffffffff):
self.prev_tx = prev_tx
self.prev_index = prev_index
if script_sig is None: # <1>
self.script_sig = Script()
else:
self.script_sig = script_sig
self.sequence = sequence
def continue_saved_game(self):
f = open("save.dat")
data = f.read().split("\n")
f.close()
self.scripts = [Script(self, data[0])]
if len(data) > 1:
self.main.music.load_music(data[1])
self.main.music.begin()
self.main.music.cue(int(data[2]), True)
self.main.music.play_next()
def initializePopulation(self, size, depth):
list1 = []
for i in range(size):
choose = random.randint(1, 5)
Try = DSL()
OK = Script(Try.initializeNumerous(choose, depth), i)
list1.append(OK)
OK.saveFile(path)
return list1
def initializePopulation(size, generation, depth):
list1 = []
# The following line is the directory on Rohan's computer, change
# this to the directory where you would like to store your scripts.
for i in range(size):
choose = random.randint(1, 5)
Try = DSL()
OK = Script(Try.initializeNumerous(choose, depth), i)
list1.append(OK)
OK.saveFile(path)
return list1
class VisualizeVariablesController(object):
file = File()
script = Script()
def load(self, path):
return self.file.load(path)
def get_criteria(self):
return self.file.get_filter_criteria()
def filter(self, levels_and_variables):
return self.file.filter(json.loads(levels_and_variables))
def get_properties(self):
return self.script.get_properties()
def execute(self, data):
return self.script.execute(data)
def __init__(self, glob):
self.glob = glob
self.symbols = {
# Use one globalId for global vars.
#
'globalId': glob.get_id_mgr(),
# These keywords have run method to handle exec calls.
#
'import' : Import(self.glob),
'script' : Script(self.glob),
'exec' : Exec(self.glob),
'replace': Replace(self.glob)
}
# Assign keywords for items in the table.
#
for key, value in self.symbols.iteritems():
value.assign_keyword(key)
def mutate(script, j):
Try = DSL()
new = []
for i in range(len(script._strategies)):
if random.randint(0, 1) == 0:
new.append(Try.initialize('S', 3))
if random.randint(0, 1) == 0:
new.append(Try.initialize('S', 3))
else:
new.append(script._strategies[i])
if random.randint(0, 1) == 0:
new.append(Try.initialize('S', 3))
# print('p')
# print(new)
Ok = Script(new, script._id + j)
Ok.saveFile(path)
return Ok
def runConverting():
tup = dialog.getPaths()
folder = dialog.getFolderName()
# Удаляем сообщения если есть
lb.clearMessages()
lb.destroyLables()
# Проверяем выбран ли файлы
if len(tup) == 0:
return messagebox.showerror("Ошибка", "Необходимо выбрать файлы")
script = Script(tup, folder)
filename = script.run()
# Удаляем сообщения об успешном выполнении и выводим сообщение об успешном завершении процесса
lb.destroyLables()
lb.addMessageToList(
f'{filename} готов.\n Если в консоле нет ошибок, то все ок.', 6)
lb.createLables(background='#2e8b57')
interaction.interact(lcond, lcons)
interactionQ.remove(interaction)
gp = piece.gridposition()
piece.position = piece.space.grid.g[gp[X]][gp[Y]].center()
if ((piece.gridposition()[Y] == WHITEEDGE
and piece.team.name == 'blacks')
or (piece.gridposition()[Y] == BLACKEDGE
and piece.team.name == 'whites')):
piece.promotion()
piece.latency = (max(piece.latency - 1, 0) if piece.latency != -1 else -1)
p = piece.gridposition()
lp = piece.lastgridposition
if p != lp:
GameObject.game.space.grid.g[lp[X]][lp[Y]].removeObject(piece)
GameObject.game.space.grid.g[p[X]][p[Y]].addObject(piece)
piece.lastgridposition = p
def onInteraction(piece, interaction):
if interaction.interactionid in piece.interactiondomain:
piece.addInteraction(interaction, None, piece, piece)
return True
return False
piecebehavior = lambda owner: Script(owner, onCreate, onUpdate, onCollision,
onInteraction)
import sys
import r2pipe
from Script import Script
r2 = r2pipe.open("./a.out")
display = "variables"
analysis = Script()
analysis.analyzeFile(r2, display)
if __name__ == '__main__':
# ------ File name: diamond.dag--------
# JOB A A.condor
# JOB B B.condor
# JOB C C.condor
# JOB D D.condor
# SCRIPT PRE B pre.csh $JOB .gz
# SCRIPT POST C pre.csh $JOB .gz
# PARENT A CHILD B C
# PARENT B C CHILD D
dag = DAG('diamond.dag')
#create jobs
j1 = Job('job1', 'a.sh')
s1 = Script('a.sh', 'j1', 'PRE')
s2 = Script('a.sh', 'j1', 'POST', argu='$JOB .gz')
node1 = Node('A')
node1.job = j1
node1.scripts = [s1]
node2 = Node('B')
node2.job = j1
node2.scripts = [s2]
node3 = Node('C')
node4 = Node('D')
e1 = Edge(['A'], ['B', 'C'])
e2 = Edge(['A'], ['B'])
global gPilotListInJSON
global gFrameTime # Frame per second
global gMsgCtrl
global gMapSize
global gObjCtrl
global gScript
global gMapCtrl
try:
gObjList = {}
gFrameTime = 0.05
gPilotListInJSON = {}
gMsgCtrl = myFunc.MsgCtrl()
gMapSize = []
gObjCtrl = ObjCtrl()
gScript = Script()
gMapCtrl = myFunc.MapCtrl()
# 建立執行緒並執行
t = threading.Thread(target=loopAll)
t.start()
handlers = [[r'/signup', SignUpHandler], [r'/index', IndexHandler],
[r'/ws', WebSocketHandler],
[
r'/favicon.ico', tornado.web.StaticFileHandler, {
'path': './static/favicon.ico'
}
]]
webApp = tornado.web.Application(
def load_startup_script(self):
#This is the script that's loaded when the program is started.
if self.check_for_save():
self.scripts.insert(0, Script(self, "startscreen/continue_screen"))
else:
self.scripts.insert(0, Script(self, "startscreen/newgame_screen"))
def start_new_game(self):
self.scripts.insert(0, Script(self, "level1/main_script"))
def crossover(parent1, parent2, i):
childStrat = generateSplit(parent1, parent2)
Ok = Script(childStrat, i)
Ok.saveFile(path)
return Ok
