def process_phase_sequence(self, phase_sequence):
program_a = Program(self.program, default_inputs=[phase_sequence[0], 0])
program_b = Program(self.program, default_inputs=[phase_sequence[1], program_a.outputs.pop()])
program_c = Program(self.program, default_inputs=[phase_sequence[2], program_b.outputs.pop()])
program_d = Program(self.program, default_inputs=[phase_sequence[3], program_c.outputs.pop()])
program_e = Program(self.program, default_inputs=[phase_sequence[4], program_d.outputs.pop()])
return program_e.outputs.pop()
def calc(log, values, mode, debug=False, draw=False):
from program import Program
if mode == 1:
prog = Program(values, log if debug else None)
while not prog.seen_pc():
prog.step()
return prog.acc
else:
prog = Program(values)
swap = {"jmp": "nop", "nop": "jmp"}
to_test = []
for i in range(len(values)):
if prog.instructions[i].op in swap:
to_test.append(i)
for i in to_test:
prog = Program(values)
prog.instructions[i].op = swap[prog.instructions[i].op]
backup = prog.clone()
hit_end = True
while prog.step():
if prog.seen_pc():
hit_end = False
break
if hit_end:
if draw:
while True:
print(f"Drawing frame {backup.steps} of {prog.steps}")
backup.show()
if not backup.step():
break
return prog.acc
return 0
def main():
logging.basicConfig(level=logging.DEBUG)
logging.info('Started')
lv = LoadValues()
lines = lv.strip_lines()
instr = get_instructions(lines)
prog = Program(instr)
(_, ip, acc) = prog.does_terminate()
print("Star 1 : ", acc)
finished = None
for (i, cur_instr) in enumerate(instr):
if cur_instr[0] == 'nop' or cur_instr[0] == 'jmp':
instr2 = instr.copy()
if cur_instr[0] == 'nop':
instr2[i] = ('jmp', cur_instr[1])
else:
instr2[i] = ('nop', cur_instr[1])
(res, ip, acc) = Program(instr2).does_terminate()
if res:
finished = (ip, acc)
break
print("Star 2 : ", acc)
logging.info('Finished')
def test_profit_04_notProfit(self):
Nackadmein = School("Nackademin")
iot = Program("IoT")
java = Program("Java")
Nackadmein.addProgram(iot)
Nackadmein.addProgram(java)
studentx = Student("john", "gatan 12", "iot", 17, 50)
studenty = Student("peter", "gatan 2", "iot", 17, 50)
studentz = Student("peter", "gatan 2", "iot", 17, 40)
iot.addStudent(studentx)
iot.addStudent(studenty)
java.addStudent(studentz)
staff1 = Staff("Mark", "Tomteboda 1", "Nackademin", 50)
staff2 = Staff("Pike", "Tomteboda 3", "Nackademin", 50)
staff3 = Staff("Moa", "Tomteboda 1", "Nackademin", 50)
Nackadmein.addStaff(staff1)
Nackadmein.addStaff(staff2)
Nackadmein.addStaff(staff3)
self.assertEqual(
Nackadmein.getProfit(Nackadmein.sumOfPay(), Nackadmein.totalFee()),
False)
def test_failed_build(self):
vert = VertexShader("A")
frag = FragmentShader("B")
program = Program(verts = vert)
with self.assertRaises(ValueError):
program.activate()
program = Program(frags = frag)
with self.assertRaises(ValueError):
program.activate()
def test_load_inter_fpga_connections():
program = Program([])
mapping = ProgramMapping([program], {
"n1:f1": program,
"n1:f2": program,
"n2:f1": program
})
connections = {
("n1:f1", 0): ("n1:f2", 0),
("n1:f2", 1): ("n2:f1", 1),
("n2:f1", 0): ("n1:f1", 1),
}
graph = networkx.Graph()
fpgas = load_inter_fpga_connections(graph, connections, mapping)
assert len(fpgas) == 3
fpgas = sorted(fpgas, key=lambda f: f.key())
assert fpgas[0].program is program
assert list(graph.edges(fpgas[0].channels[0])) == [(fpgas[0].channels[0],
fpgas[1].channels[0])]
assert list(graph.edges(fpgas[0].channels[1])) == [(fpgas[0].channels[1],
fpgas[2].channels[0])]
assert list(graph.edges(fpgas[1].channels[1])) == [(fpgas[1].channels[1],
fpgas[2].channels[1])]
assert list(graph.edges(fpgas[2].channels[0])) == [(fpgas[2].channels[0],
fpgas[0].channels[1])]
def P15():
p = Program(num_prog_inputs=2)
p.create_add_component()
p.create_and_component()
p.create_xor_component()
p.create_bitshiftright_component(1)
return ProgramSynthesis(p, BVT.P15, 'P15')
def run_program(action, name):
global p_running, s, p
ret = {
"type": "program",
"response": {
"action": action,
"name": name,
"status": ""
}
}
if action == "run":
for program in s.setup['programs']:
if program['name'] == name:
logger.debug(f"runProgram({name})")
p = Program(program, s.setup, t.hist, program_complete)
p.start()
ret['response']['status'] = "success"
return ret, 200
elif action == "cancel":
if p.running:
p.cancel()
ret['response']['status'] = "success"
return ret, 200
ret['response'][
'status'] = f"error: program[{name}] does not exist or no program running"
return ret, 200
def youtubeProgram():
# Creating Youtube Keword
yt = Program('snowboy.umdl')
def yt_callback(x): # called before recorder
print("-----OPEN YOUTUBE CALLBACK-----")
def recorder_callback(fname): # recieves recorded file
print("Proccessing request...")
r = sr.Recognizer()
with sr.AudioFile(fname) as source:
audio = r.record(source) # read the entire audio file
try:
# can use gdp
text = r.recognize_google(audio)
webbrowser.open('https://www.youtube.com/results?search_query=' +
"+".join(text.split(' ')))
except sr.UnknownValueError:
print("No query recieved. Going to home page -->")
webbrowser.open('https://www.youtube.com/') # default / home page
except sr.RequestError as e:
print(
"Could not request results from Google Speech Recognition service; {0}"
.format(e))
os.remove(fname)
yt.callback = yt_callback
return yt, recorder_callback
def rspdownload(args):
datadir = getDataDir(args)
log = Logger('Program')
direction = S3Operation.Direction.DOWN
program = Program(args.program)
log.title('STARTING PYTHON DOWNLOADER', "=")
downloadPath = menuwalk(program)
assert downloadPath, "No Product chosen. Exiting"
keyprefix = '/'.join(downloadPath)
conf = {
"delete": args.delete,
"force": args.force,
"direction": direction,
"localroot": path.join(datadir, keyprefix),
"keyprefix": keyprefix,
"bucket": program.Bucket
}
s3ops = s3BuildOps(conf)
log.title('Please Confirm that you wish to proceed?')
result = query_yes_no("Begin?")
if result:
for key in s3ops:
s3ops[key].execute()
else:
log.info("\n<EXITING> No sync performed\n")
def send_program():
json_data = request.args.get('json_data')
print("======>>>json_data" + json_data)
program = Program(json_data)
prog_name = program.send_program()
print("send program:" + prog_name)
return {"code": "200", "program_name": prog_name}
def test_allocation_get_channel():
program = Program([Push(0), Pop(0), Push(1), Push(2), Pop(2)])
assert program.get_channel_for_port_key(0, KEY_CKS_DATA) == 0
assert program.get_channel_for_port_key(0, KEY_CKS_CONTROL) == 3
assert program.get_channel_for_port_key(1, KEY_CKR_DATA) is None
assert program.get_channel_for_port_key(2, KEY_CKS_DATA) == 2
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-t', action='store_true')
parser.add_argument('-d', action='store_true')
arg = parser.parse_args()
program = Program()
cap = program.init_cap()
if arg.t:
program.show_trackbars()
ret = True
cnt = 0
while ret:
ret, img = cap.read()
if cnt > 10000:
break
cnt += 1
yellow_mask, x_yellow, y_yellow = program.filter_color(img, 'YELLOW')
print(cnt, x_yellow, y_yellow)
if arg.d:
cv.circle(img, (x_yellow, y_yellow), 5, (0, 255, 0), -1)
cv.putText(img, f"x : {int(x_yellow)} y : {int(y_yellow)}", (10, 100 - 25),
cv.FONT_HERSHEY_COMPLEX_SMALL, 0.8, (10, 255, 10))
cv.imshow("image", img)
cv.imshow("mask", yellow_mask)
k = cv.waitKey(1) & 0xFF
if k == 27:
program._setting.write()
cv.destroyAllWindows()
break
def parse(tokens):
tkGen = TokenStream(tokens)
program = Program()
while tkGen.index < len(tokens):
token = tkGen.peek()
if token.type == "CLASS_SYMBOL":
nextToken(tkGen)
nextTk = nextToken(tkGen)
if nextTk.type != "IDENT":
throwErr(SOURCE_FILE, nextTk.pos, "Expected IC name", 2)
curIC = IC(nextTk.value)
nextTk = nextToken(tkGen)
if nextTk.type != "OPEN_BRACE":
throwErr(SOURCE_FILE, nextTk.pos, "Expected IC defintion", 2)
while tkGen.peek().type != "CLOSE_BRACE":
local, op, arg = parseExpr(tkGen)
curIC.addTreeExpr(local, op, arg)
nextToken(tkGen)
program.addIC(curIC)
else:
_global, op, arg = parseExpr(tkGen)
program.addTreeExpr(_global, op, arg)
return program
def main():
INSTRUCTION = """
0 - exit
1 - sort by name in non-decreasing order
2 - sort by name in non-increasing order
3 - sort by destination in non-decreasing order
4 - sort by destination in non-increasing order
5 - sort by flight number in non-decreasing order
6 - sort by flight number in non-increasing order
7 - sort by price in non-decreasing order
8 - sort by price in non-increasing order
9 - find aeroflots with provided destination
10 - find aeroflots with provided name
11 - find aeroflots with provided departure day
12 - add new aeroflot
13 - delete aeroflot by index
14 - edit aeroflot(enter index and field which you want to change)
15 - print aeroflots
"""
print(INSTRUCTION)
path_read = input("enter path_read: ")
path_write = input("enter path_write: ")
reader = ReadFromFile(path_read)
file = FileEditor(path_write)
collection = reader.read()
menu = Program(collection)
while True:
try:
menu.menu(file)
except Exception as s:
print(s)
def learn_ASP_constraints(self,
script_name,
config=None,
print_results=False):
if self.config["debug"]:
print("DEBUGGING MODE IS ON")
asp_output_program_name = "tmp_asp_script.asp"
program = Program(script_name, config=self.config)
generator = Generator(program, asp_output_program_name)
generator.include_original_sketch()
generator.generate_program()
self.asp_engine.run(asp_output_program_name)
before_dominance_check = self.asp_engine.get_number_of_solutions()
print("before dominance models:", before_dominance_check)
# bp()
self.asp_engine.remove_dominated(program)
if print_results:
self.asp_engine.print_result()
solutions = self.asp_engine.get_set_of_atoms()
print('after dominance models:', len(solutions))
if self.config.get("debug", False):
print("DEBUGGING MODE: END OF THE OUTPUT")
return solutions, before_dominance_check
def test_cks_table_double_rail2():
program = Program([Push(0), Pop(0), Push(1), Pop(1)])
ctx = get_routing_ctx(
program, {
("N:F0", 1): ("N:F1", 0),
("N:F0", 3): ("N:F1", 2),
("N:F1", 1): ("N:F2", 0),
("N:F1", 3): ("N:F2", 2),
("N:F2", 1): ("N:F3", 0),
("N:F2", 3): ("N:F3", 2),
("N:F3", 1): ("N:F4", 0),
("N:F3", 3): ("N:F4", 2),
("N:F4", 1): ("N:F5", 0),
("N:F4", 3): ("N:F5", 2),
("N:F5", 1): ("N:F0", 0),
("N:F5", 3): ("N:F0", 2),
})
graph, routes, fpgas = (ctx.graph, ctx.routes, ctx.fpgas)
fpga = get_fpga(fpgas, "N:F4")
tables = cks_routing_tables(fpga, fpgas, routes)
check_fpga_tables(fpga, tables,
[[['0->1', '0->1'], ['QSFP', 'QSFP'], ['QSFP', 'QSFP'],
['0->2', 'QSFP'], ['CKR', 'CKR'], ['0->3', '0->1']],
[['QSFP', 'QSFP'], ['QSFP', '1->0'], ['1->0', '1->0'],
['1->0', '1->2'], ['CKR', 'CKR'], ['QSFP', 'QSFP']],
[['2->1', '2->1'], ['QSFP', 'QSFP'], ['QSFP', 'QSFP'],
['QSFP', 'QSFP'], ['CKR', 'CKR'], ['2->3', '2->1']],
[['QSFP', 'QSFP'], ['QSFP', 'QSFP'], ['3->0', '3->0'],
['3->0', '3->0'], ['CKR', 'CKR'], ['QSFP', 'QSFP']]])
def test_cks_table_double_rail():
program = Program([Push(0), Pop(0), Push(1), Pop(1)])
ctx = get_routing_ctx(
program, {
("N1:F0", 1): ("N1:F1", 0),
("N1:F0", 3): ("N1:F1", 2),
("N1:F1", 1): ("N2:F0", 0),
("N1:F1", 3): ("N2:F0", 2),
("N2:F0", 1): ("N2:F1", 0),
("N2:F0", 3): ("N2:F1", 2),
("N2:F1", 1): ("N1:F0", 0),
("N2:F1", 3): ("N1:F0", 2),
})
graph, routes, fpgas = (ctx.graph, ctx.routes, ctx.fpgas)
fpga = get_fpga(fpgas, "N1:F0")
tables = cks_routing_tables(fpga, fpgas, routes)
check_fpga_tables(fpga, tables, [
[["CKR", "CKR"], ["0->1", "0->1"], ["QSFP", "QSFP"], ["0->2", "QSFP"]],
[["CKR", "CKR"], ["QSFP", "1->3"], ["QSFP", "1->0"], ["1->0", "1->0"]],
[["CKR", "CKR"], ["2->1", "2->1"], ["QSFP", "QSFP"], ["QSFP", "QSFP"]],
[["CKR", "CKR"], ["QSFP", "QSFP"], ["QSFP", "QSFP"], ["3->0", "3->0"]]
])
fpga = get_fpga(fpgas, "N1:F1")
tables = cks_routing_tables(fpga, fpgas, routes)
check_fpga_tables(fpga, tables, [
[["QSFP", "QSFP"], ["CKR", "CKR"], ["0->1", "0->1"], ["QSFP", "QSFP"]],
[["1->0", "1->2"], ["CKR", "CKR"], ["QSFP", "1->3"], ["QSFP", "QSFP"]],
[["QSFP", "QSFP"], ["CKR", "CKR"], ["2->1", "2->1"], ["QSFP", "QSFP"]],
[["3->0", "3->0"], ["CKR", "CKR"], ["QSFP", "QSFP"], ["QSFP", "QSFP"]]
])
def get_programs(dir,
tmpdir,
pattern='.*',
allow_validation_scripts=False,
includedir=None,
error_handler=logging):
if not os.path.isdir(dir):
return []
ret = []
for f in sorted(os.listdir(dir)):
path = os.path.join(dir, f)
added = False
if allow_validation_scripts:
try:
ret.append(ValidationScript(path))
continue
except ProgramWarning as e:
pass
try:
if re.match(pattern, f):
ret.append(Program(path, tmpdir, includedir=includedir))
else:
error_handler.info("Ignoring '%s'; invalid filename" % f)
except ProgramError as e:
error_handler.error('%s: %s' % (f, e))
except ProgramWarning as e:
error_handler.warning('%s: %s' % (f, e))
except Exception as e:
raise
return ret
def test_detach(self):
vert = VertexShader("A")
frag = FragmentShader("B")
program = Program(vert, frag)
program.detach(frag)
assert len(program.shaders) == 1
assert program.shaders[0].code == "A"
def __init__(self, test_utility, model, serial_manager, report):
super().__init__()
self.abort_btn = QPushButton("Abort")
self.abort_btn.clicked.connect(self.abort)
self.setButton(QWizard.CustomButton1, self.abort_btn)
self.button(QWizard.FinishButton).clicked.connect(self.finish)
qbtn_layout = [
QWizard.Stretch, QWizard.NextButton, QWizard.FinishButton,
QWizard.CustomButton1
]
self.setButtonLayout(qbtn_layout)
self.button(QWizard.NextButton).setEnabled(False)
# This fixes a bug in the default style which hides the QWizard
# buttons until the window is resized.
self.setWizardStyle(0)
setup_id = self.addPage(
Setup(self, test_utility, serial_manager, model, report))
program_id = self.addPage(
Program(self, test_utility, serial_manager, model, report))
interfaces_id = self.addPage(
Interfaces(self, test_utility, serial_manager, model, report))
final_id = self.addPage(FinalPage(self, test_utility, report))
self.setup_page = self.page(setup_id)
self.program_page = self.page(program_id)
self.interfaces_page = self.page(interfaces_id)
self.final_page = self.page(final_id)
self.tu = test_utility
self.report = report
def build():
inputFileName = sys.argv[1]
inputFile = open(inputFileName, 'r', encoding='UTF-8')
program = Program()
for lineNumber, line in enumerate(inputFile, 1):
line = clean(line)
if line:
try:
if (line.startswith(common.PREFIX_LABEL)):
program.addLabel(parseLabel(line))
else:
program.addInstruction(parseInstruction(line))
except (ParserException, ProgramException) as e:
print('Error on line: %s' % lineNumber)
print('Content: %s' % line)
print('Message: %s' % e)
sys.exit(1)
if re.search(r'\.asm$', inputFileName):
outputFileName = re.sub(r'\.asm$', '.hack', inputFileName)
else:
outputFileName = inputFileName + '.hack'
outputFile = open(outputFileName, 'w')
outputFile.write(program.getBinary())
outputFile.write('\n')
def test_codegen_device(file_tester):
program = Program([
Push(0, "short", 8),
Pop(0),
Push(1),
Pop(2, "char", 8),
Broadcast(3, "float", 64),
Broadcast(4, "int"),
Push(5, "double", 32),
Reduce(6, "float", 16, "add"),
Scatter(7, "double"),
Gather(8, "char")
])
mapping = ProgramMapping([program], {
"n1:f1": program,
"n1:f2": program,
"n2:f1": program,
"n3:f1": program
})
connections = {
("n1:f1", 0): ("n1:f2", 0),
("n1:f2", 1): ("n2:f1", 1),
("n1:f2", 2): ("n3:f1", 1),
("n2:f1", 0): ("n1:f1", 1),
}
ctx = create_routing_context(connections, mapping)
file_tester.check(
"smi-device-1.h",
generate_program_device(ctx.fpgas[0], ctx.fpgas, ctx.graph, 4))
def search_next(cur, program, fo_remain, ho_remain, target_len):
if len(program) == target_len:
p = Program()
for s in program:
p.append_step(Step(*s))
PROGRAMs.append(p)
# print p
return
else:
valid_fo_funcs = filter(lambda x: FUNCs['FO'][x][1][0] == cur[2] \
if len(FUNCs['FO'][x][1]) == 1 \
else FUNCs['FO'][x][1][1] == cur[2], fo_remain)
# len(FUNCs['HO'][x][1]) == 2 \ and
valid_ho_funcs = filter(lambda x: FUNCs['HO'][x][1][1] == cur[2],
ho_remain)
for func in valid_fo_funcs:
search_next(FUNCs['FO'][func], \
program+[(func,)], \
filter(lambda x: x!=func, valid_fo_funcs), \
valid_ho_funcs, \
target_len)
for func in valid_ho_funcs:
for lambs in filter(lambda x: (Lambdas[x][3], Lambdas[x][2])\
==FUNCs['HO'][func][1][0], \
[l for l in Lambdas]):
search_next(FUNCs['HO'][func], \
program+[(func, lambs)], \
valid_fo_funcs, \
filter(lambda x: x!=func, valid_ho_funcs), \
target_len)
def __init__(self, name, command, positions, verbose):
Thread.__init__(self)
self._name = name
self._positions = positions
self._verbose = verbose
command = command + " --logfile-name=" + name + ".log"
self._program = Program(command, verbose)
def test_incrementer(self):
p = Program()
p.add("R0+ -> L1")
p.add("HALT")
state = p.execute([0])
self.assertEqual(state, [1])
def read_file(self):
"""Populate the simulation attrubutes"""
with open(self.filename, encoding='utf-8') as file:
json_file = json.load(file)
cache_dict = json_file["Cache"]
cache_params = get_param_list(cache_dict, CACHE_PARAMS)
self.cache = Cache(*cache_params)
tlb_dict = json_file["TLB"]
tlb_params = get_param_list(tlb_dict, TLB_PARAMS)
self.tlb = TLB(*tlb_params)
memory_dict = json_file["MemoriaFisica"]
memory_params = get_param_list(memory_dict, MEM_PARAMS)
self.memory = Memory(*memory_params)
disk_write = self.memory.write_speed * 10
disk_read = self.memory.read_speed * 10
self.disk = Disk(disk_write, disk_read)
self.page_table_size = self.memory.frames * 2
self.virtual_size = self.memory.size * 2
self.bits_address = int(log(self.virtual_size, 2))
self.bits_page = int(log(self.page_table_size, 2))
programs = json_file["Programas"]
for program_dic in programs:
program_parameters = get_param_list(program_dic,
["Nombre", "Secuencia"])
new_program = Program(*program_parameters, self.page_table_size)
self.programs.append(new_program)
self.program_map[new_program.id] = new_program
self.stats[new_program.id] = ProgramStats()
def main():
app = None
try:
from program import Program
app = Program()
app.run()
except Exception as exc:
traceback.print_exc(file=open(ERROR_LOG, "w"))
class Error(App):
theme_cls = kivymd.theming.ThemeManager()
def report_callback(self, *args):
try:
import webbrowser
webbrowser.open(PROJ_REPO + "/issues/new?body=" + str(exc))
except Exception:
traceback.print_exc(file=open(ERROR_LOG, "w"))
sys.exit(1)
def build(self):
return BugReporter(report_callback=self.report_callback)
Error().run()
def main():
glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH)
glutInitWindowSize(1000, 800)
glutInitContextVersion(4, 1)
glutInitContextProfile(GLUT_CORE_PROFILE)
wnd = glutCreateWindow('OpenGL 4')
# model = Model(*icosphere(6))
model = Model(*sphere(480, 240))
cam = Camera(sensivity=0.1)
program = Program(vertex='vertex.glsl',
tess_control='tess_control.glsl',
tess_eval='tess_eval.glsl',
geometry='geometry.glsl',
fragment='fragment.glsl')
engine = Engine(wnd, program, model, cam)
glutDisplayFunc(engine.display)
glutIdleFunc(glutPostRedisplay)
glutReshapeFunc(engine.reshape)
glutKeyboardFunc(engine.keyDown)
glutKeyboardUpFunc(engine.keyUp)
glutMouseFunc(engine.mouse)
glutMotionFunc(engine.motion)
glEnable(GL_DEPTH_TEST)
glutMainLoop()
def test_setitem(self):
vert = VertexShader("")
frag = FragmentShader("")
program = Program(vert,frag)
with self.assertRaises(ValueError):
program["A"] = 1
