def Program(self):
functions = []
if self.peek().type == "FUNCTION":
functions = self.Functions()
aslist = self.Assignments()
return Program(assignments=aslist, functions=functions)
def convert_to_ast(node):
program = Program()
program.set_name(node.get_name())
program.set_type(node.get_type())
dclr_child = node.get_child_nodes()[0]
dclr_list = DclrList()
while True:
if dclr_child is not None and dclr_child.get_name() == 'var':
ident_name = dclr_child.get_child_nodes()[0]
declaration = Declaration(ident_name.get_name())
declaration.set_name(ident_name.get_name())
declaration.set_type(symbol_table.get(ident_name.get_name()))
dclr_list.add_declaration_to_list(declaration)
AST.dot.edge(dclr_list.get_gv_name(), declaration.get_gv_name())
length = len(dclr_child.get_child_nodes())
dclr_child = dclr_child.get_child_nodes()[length - 1]
else:
break
program.set_dclr_list(dclr_list)
AST.dot.edge(program.get_gv_name(), dclr_list.get_gv_name())
stmt_child = node.get_child_nodes()[2]
stmt_list = generate_statement_list(stmt_child)
if stmt_list.get_type_error():
AST.dot.edge(program.get_gv_name(),
stmt_list.get_gv_name(),
color='red')
else:
AST.dot.edge(program.get_gv_name(), stmt_list.get_gv_name())
program.set_stmt_list(stmt_list)
return program
def fromTextFile(self, path):
with open(path, 'r') as f:
appString = f.read()
appString = appString.split(',')
appString = [x for x in appString if x.strip()]
appList = [Program(x) for x in appString]
return self(apps=appList)
def start(self, version):
"""Display the menu, wait for user input and then run the program
Parameters:
version - version number
"""
# display menu and ask for input file path
filePath = None
cwdpath = ''
while not filePath:
cwdpath, filePath = self.displayMenu(version)
# merge working directory and file path
totalPath = os.path.join(cwdpath, filePath)
# call program selector
program = Program(cwdpath, totalPath)
timer = Timer()
timer.tic()
try:
program.run()
except NoInputFileException as e:
print e.message
timer.toc()
self.logger.info(timer.string('\n' 'iFlow run time'))
# upon closing, ask input before ending. This to keep plot windows open.
# self.askClose()
return
def main():
tokenizer = create_tokenizer("input.txt")
open_output_file("output.txt")
program = Program()
program.parse()
program.evaluate()
close_output_file()
tokenizer.destroy()
def get_links(self, text):
# download_links = []
#
# found = self.download_regex.findall(text)
# #found2 = self.download2_regex.findall(text)
#
# info_links = self.get_info_links(self, text)
#
# #print(found2)
#
# #sys.exit()
#
# counter = 0
#
# for url in found:
#
# # Configura o link de download
# url = url[13:-1]
#
# #links.append(Program(url, self.get_version(self, text), downloads[counter]))
# download_links.append(Program(url, info_links[counter], None, 0, 0))
#
# counter += 1
#
# counter = 0
# for url in found2:
#
# # Configura o link de download
# url = url[13:-1]
#
# url = "http://www.reporting-download.com/download/?appid=" + url[42:]
#
# #links.append(Program(url, self.get_version(self, text), downloads[counter]))
# download_links.append(Program(url, info_links[counter], None, 0, 0))
#
# counter += 1
links = []
found = self.page_regex.findall(text)
#_, last_week = self.get_downloads(self, "", text, False)
counter = 0
for url in found:
l = self.create_links_list(self, url[:-2]) # Remove space and " chars
if l is not None:
l = html.unescape(l)
links.append(Program(l, url[:-8], "", 0, None))#last_week[counter]))
counter += 1
return links
def main():
app = Program(DB)
choise = ''
while True:
print(UI)
choise = input('Choise (1 - 6): ')
if choise.isdigit():
choise = int(choise)
print('-' * WIDTH)
# show
if choise == 1:
app.show()
# add
elif choise == 2:
app.add()
# change
elif choise == 3:
changeable_name = input("Name for change: ")
app.change(name=changeable_name)
# delete
elif choise == 4:
deletable_name = tuple (input(\
"Name for delete: (1 or more names)\n"
"example: 'Name2 Name2 Name3 ... ' "\
).replace(',',' ').split())
print('-' * WIDTH)
app.delete(*deletable_name)
# search
elif choise == 5:
searchable_name = input("Search: ")
app.search(searchable_name)
# reset all
elif choise == 6:
sure_reset = input(
"Are you sure you want reset all contacts? (Y/n): ")
if sure_reset.lower() == 'y':
app.reset_all()
print('Done.')
elif sure_reset.lower() == 'n':
print('Reset canceled')
else:
print('Wrong choise!')
# exit
elif choise == 7:
answer = input("Are you sure? ('Y/n')")
if answer.lower() == 'y':
break
else:
print("Wrong choise!!!")
def main():
print("dasm: Simple dcpu assembler\n")
l = lark.Lark(grammar.grammar, start="start")
parser = argparse.ArgumentParser(description='dcpu assembler')
parser.add_argument("-i",
help="Assembly input file",
action="store",
metavar="<input file>",
type=str,
required=True,
dest="input_filename")
parser.add_argument(
"-o",
help="Binary output file basename (without file extension)",
metavar="<output file base name>",
action="store",
type=str,
required=False,
dest="output_filebase")
args = parser.parse_args()
try:
fn = args.input_filename
with open(fn) as f:
lines = f.readlines()
except:
print(f"ERROR: Cannot open file {fn}")
return 2
contents = "".join(lines)
t = l.parse(contents)
# print(t.pretty())
# print(t)
n = dcpuTransformer().transform(t)
program = Program(n.children)
(path, name) = os.path.split(fn) # remove path
if args.output_filebase == None:
outfn_noext = os.path.splitext(name)[0] # remove extension
else:
outfn_noext = args.output_filebase
program.write_as_bin(outfn_noext + ".bin")
program.write_as_memfile(outfn_noext + ".mem")
program.write_as_cfile(outfn_noext + ".c")
program.write_as_listing(outfn_noext + ".list", lines)
program.write_symbols(outfn_noext + ".symbols")
program.write_as_simdata(outfn_noext + ".sim", lines)
size = program.end_address - program.start_address + 1
print(f"File '{name}' assembled\nOutput size: {size} words")
def test_compute_minimum_area(self):
from Drone import Drone
drone_list = [
Drone('test1', 30.0, 18.0, (3840, 2160), 12, 104),
Drone('test2', 30.0, 18.0, (3840, 2160), 12, 104),
Drone('test3', 30.0, 18.0, (3840, 2160), 6, 104)
]
obtained = Program().compute_minimum_area(drone_list)
self.assertEqual(obtained, (15.359299586316945, 8.639606017303281))
self.assertEqual(obtained[0] * obtained[1], 132.6982971275077)
def testLimitFiles(self):
program = Program()
with open("fileTest.txt", "r") as file:
for line in file:
program.open(line[0:-1])
self.assertEqual(program.getRecentFiles(), [
'peixe.txt', 'santanche.txt', 'osu.exe', 'cyberpunk.txt',
'rambo.py', 'foo.txt', 'igor.py', 'sugoidesu.txt', 'bakamitai.mp3',
'kurisu.txt'
])
def main():
mode, length, width, file_path = load_data()
program = Program(length, width, mode)
program.read_file(file_path)
if mode == 1:
program.load_data()
program.simulate1(length, width)
elif mode == 2:
program.simulate2(length, width)
def compile(self, code):
codeStream = InputStream(code)
lexer = cargobotLexer(codeStream)
stream = CommonTokenStream(lexer)
parser = cargobotParser(stream)
tree = parser.start()
program = Program()
listener = CargoBotListenerImpl(program)
walker = ParseTreeWalker()
walker.walk(listener, tree)
return program
def part_one():
# Setup
program = Program(1024 * 1024)
program.load_code("testInput.txt")
# Run
#program.load_input([1])
program.run()
print(program.is_done())
output = program.get_output()
print(output)
def parse(self):
'''Postcondition: Implements program -> function ID ( ) -> <block>'''
self.match(self.lex.getNextTok(), TokenType.METHOD_TOK)
self.match(self.lex.getNextTok(), TokenType.ID_TOK)
self.match(self.lex.getNextTok(), TokenType.INPUTSTRT_TOK)
self.match(self.lex.getNextTok(), TokenType.INPUTEND_TOK)
program = Program(self.getBlock())
self.match(self.lex.getNextTok(), TokenType.END_TOK)
self.match(self.lex.getNextTok(), TokenType.EOS_TOK)
return program
def __init__(self, x, y, edge, start, goal, executable, auto):
self.x, self.y = x, y
self.edge = edge
self.auto = auto
self.goal = complex(*self[goal])
self.bot_pos = self.start = complex(*self[start])
self.bot_angle = complex(0, 1)
self.window = Window(self.x, self.y)
self.c_program = Program(executable)
#self.c_program=IO()
Thread(target=self.refresh, daemon=False).start()
self.window.launch()
def generateCallTree(sourceFiles, options):
firstFile = open(sourceFiles, "r") # Open first given file for reading
callTree = []
while True:
try:
line = firstFile.next().strip() # Read next line.
except: # End of file
break
if isProgram(line): # Is this a line containing "program" statement?
callTree.append(Program(firstFile, line))
else: # Ordinary statement
recognizeSourceLineAndUpdateTree(callTree, line)
return callTree
def parse(self):
tok = self.get_next_token()
self.match(tok, TokenType.MAIN_TOK)
tok = self.get_next_token()
self.match(tok, TokenType.LEFT_PAREN_TOK)
tok = self.get_next_token()
self.match(tok, TokenType.RIGHT_PAREN_TOK)
tok = self.get_next_token()
self.match(tok, TokenType.EOLN_TOK)
block = self.get_statement_block()
tok = self.get_next_token()
if tok.Token.get_token_type() != TokenType.EOS_TOK:
raise ParserException("invalid end of file")
return Program(block)
def parse(self):
tok = self.lex.get_next_token()
Parser.match(tok, TokenType.FUNCTION_TOK)
functionName = self.get_id()
tok = self.lex.get_next_token()
Parser.match(tok, TokenType.LEFT_PAREN_TOK)
tok = self.lex.get_next_token()
Parser.match(tok, TokenType.RIGHT_PAREN_TOK)
blk = self.get_block()
tok = self.lex.get_next_token()
Parser.match(tok, TokenType.END_TOK)
tok = self.lex.get_next_token()
if tok.get_tok_type() != TokenType.EOS_TOK:
raise Exception("garbage at end of file")
return Program(blk)
def parse(self):
tok = self.getNextToken()
self.match(tok, TokenType.FUNCTION_TOK)
functionName = self.getId()
tok = self.getNextToken()
self.match(tok, TokenType.LEFT_PAREN_TOK)
tok = self.getNextToken()
self.match(tok, TokenType.RIGHT_PAREN_TOK)
blk = self.getBlock()
tok = self.getNextToken()
self.match(tok, TokenType.END_TOK)
tok = self.getNextToken()
if tok.getTokType() != TokenType.EOS_TOK:
raise Exception("garbage at end of file")
return Program(blk)
def parse(self):
token = self.lex.get_next_token()
Parser.match(token, TokenType.FUNCTION_TOK)
function_Name = self.get_id()
token = self.lex.get_next_token()
Parser.match(token, TokenType.LEFT_PAREN_TOK)
token = self.lex.get_next_token()
Parser.match(token, TokenType.RIGHT_PAREN_TOK)
block = self.get_block()
token = self.lex.get_next_token()
Parser.match(token, TokenType.END_TOK)
token = self.lex.get_next_token()
if token.get_tok_type() != TokenType.EOS_TOK:
raise Exception("File has Garbage")
print("There is extra information on the julia")
return Program(block)
def test_run_invalid_input(self):
program = Program()
program.transport = mock.create_autospec(Transport)
program.parser = mock.create_autospec(Parser)
program.interpolator = mock.create_autospec(Interpolator)
program.transport.read.return_value = 'input'
program.parser.parse.side_effect = ValueError('Error')
program.interpolator.interpolate.return_value = 'output'
actual = program.run()
program.transport.read.assert_called()
program.parser.parse.assert_called()
program.parser.parse.assert_called_with('input')
program.interpolator.interpolate.assert_not_called()
program.transport.write.assert_called_with('Invalid matrix!')
def test_run(self):
program = Program()
program.transport = mock.create_autospec(Transport)
program.parser = mock.create_autospec(Parser)
program.interpolator = mock.create_autospec(Interpolator)
program.transport.read.return_value = 'input'
program.parser.parse.return_value = 'parsed_input'
program.interpolator.interpolate.return_value = 'output'
actual = program.run()
program.transport.read.assert_called()
program.parser.parse.assert_called()
program.parser.parse.assert_called_with('input')
program.interpolator.interpolate.assert_called_with('parsed_input')
program.transport.write.assert_called_with('output')
def __init__(self, action = None, learner = None):
"""Initialize new Learner. This can either be done from scratch or
as a copy of a previous Learner, maintaining that Learner's action,
which may be a pointer to a Team.
Be wary of using deepcopy! The temptation to copy Learners via deepcopy
was there, but this is a mistake since it will create copies of any Team
pointed to by self.action. On the other hand, copying Programs via
deepcopy is correct and a conveneient way to ensure that the new Program
gets its own copy of the list of instructions.
"""
# Set default value. This is so that setAction() will function properly
# when checking the current self.action type. In general, the action
# should always be set via setAction()
self.action = 0
# This counter keeps track of how many Teams hold a pointer to
# this Learner, ie. how many Teams this Learner is a member of.
self.num_referencing_teams = 0
if learner is None:
# Create Program associated with Learner
self.program = Program()
self.setAction(action)
if action is None:
print("WARNING - Learner::init - No Learner and no Action")
# Assign Learner's action value
self.setAction(randint(0, Learner.ATOMIC_ACTION_RANGE))
else:
# Make a copy of the other Learner's Program
self.program = deepcopy(learner.program)
# Copy the other Learner's action, whether it's atomic or not
self.setAction(learner.action)
# If new action is a Team pointer, update that Team's number of
# referencing Learners
if not self.isActionAtomic():
self.action.incrementNumReferencingLearners()
def part_two():
# Setup program
program = list()
for i in range(5):
program.append(Program())
program[i].load_code("thrusterProgram.txt")
# Try all phase setting permutations
phase_configuration_permutations = itertools.permutations([5, 6, 7, 8, 9])
max_output = 0
for phase_configuration in phase_configuration_permutations:
# Start each program
output = 0
for i, phase in enumerate(phase_configuration):
program[i].load_input([output, phase])
program[i].run()
output = program[i].get_output()
#print("Output: %d from %d with phase %d" % (output, i, phase))
# Run until done
i = 0
while not program[4].is_done():
program[i].load_input([output])
program[i].run()
output = program[i].get_output()
i = (i + 1) % 5
#print([x.is_done() for x in program])
#print("Output: %d from %d" % (output, i))
if output > max_output:
max_output = output
print("Max output is: %d" % max_output)
def load_data():
wb = load_workbook(CBOutreachFile)
ws = wb['Outreach Events']
findLastRowInput(ws)
for i in range(firstRowInput, lastRowInput + 1):
global data
row = str(i)
initiative = ws[cInitiative + row].value
strategy = ws[cStrategy + row].value
activity = ws[cActivity + row].value
program = ws[cProgram + row].value
if program is None:
continue
else:
program = program.strip()
date = ws[cDate + row].value # type: datetime
numPeople = ws[cNumPeople + row].value
numPeopleUnique = ws[cNumPeopleUnique + row].value
if initiative not in data:
data[initiative] = {}
if strategy not in data[initiative]:
data[initiative][strategy] = {}
if activity not in data[initiative][strategy]:
data[initiative][strategy][activity] = {}
if program not in data[initiative][strategy][activity]:
data[initiative][strategy][activity][program] = Program(
initiative, strategy, activity, program)
programInstance = data[initiative][strategy][activity][
program] # type: Program
programInstance.addEvent(date, numPeople, numPeopleUnique)
getLastMonthAndYearWithEntries()
def get_links(self, text):
links = []
found = self.page_regex.findall(text)
_, last_week = self.get_downloads(self, "", text, False)
counter = 0
for url in found:
l = self.create_links_list(self, url)
if l is not None:
l = html.unescape(l)
links.append(Program(l, url[:-8], "", 0, last_week[counter]))
counter += 1
return links
def part_one():
# Setup program
program = Program()
program.load_code("thrusterProgram.txt")
# Try all phase setting permutations
phase_configuration_permutations = itertools.permutations([0, 1, 2, 3, 4])
max_output = 0
for phase_configuration in phase_configuration_permutations:
output = 0
for phase in phase_configuration:
program.load_input([output, phase])
program.reset()
program.run()
output = program.get_output()
if output > max_output:
max_output = output
print("Highest signal to thrusters is: %d" % max_output)
def get_program(username):
con = sql.connect('classes2.db')
cur = con.cursor()
cur.execute("SELECT major FROM Users WHERE username = ?", username)
user = cur.fetchone()
#have the user, now build their program
courses = loadCourses.load()
if user == "Computer Science":
CS = Program("Computer Science")
csBuild = programBuilder(2017, 0, 3, CS)
return csBuild.planCourses()
elif user == "Information Systems - Standard":
IS0 = Program("Information Systems - Standard")
is0Build = programBuilder(2017, 0, 3, IS0)
return is0Build.planCourses()
elif user == "Information Systems - Business Analysis/Systems Analysis":
IS1 = Program(
"Information Systems - Business Analysis/Systems Analysis")
is1Build = programBuilder(2017, 0, 3, IS1)
return is1Build.planCourses()
elif user == "Information Systems - Business Intelligence":
IS2 = Program("Information Systems - Business Intelligence")
is2Build = programBuilder(2017, 0, 3, IS2)
return is2Build.planCourses()
elif user == "Information Systems - DB Administration":
IS3 = Program("Information Systems - DB Administration")
is3Build = programBuilder(2017, 0, 3, IS3)
return is3Build.planCourses()
elif user == "Information Systems - IT Enterprise Management":
IS4 = Program("Information Systems - IT Enterprise Management")
is4Build = programBuilder(2017, 0, 3, IS4)
return is4Build.planCourses()
def part_one_and_two():
program = Program()
program.load_code("input.txt")
program.run()
children_string = match.group(3)
# omit programs without children - they can't be root
if children_string is not None:
children_of_current_program = children_string.split(", ")
possible_roots_names.append(name)
for child in children_of_current_program:
parent_of[child] = name
else:
children_of_current_program = []
children_of[name] = children_of_current_program
program_with_name[name] = Program(name, weight, [])
root_name = None
for program in possible_roots_names:
if program not in parent_of:
root_name = program
break
print("Root: ")
print(root_name)
# build tree
def build(node_name):
