def __init__(self):
self.startCalc = -400
self.startAddData = -400
self.startUpdateWallet = -3
self.parser_ = Parser()
# === Update model === #
self.updateModel_ = False
self.reDoModel_ = False
# ==================== #
# TODO Implémenter ça depuis les données envoyées
self.trainPair_ = ('USDT', 'ETH')
self.strategy_ = Strategy(trainPair=self.trainPair_, updateModel=self.updateModel_)
self.reference_ = 'USDT'
self.wallet_ = Wallet(None, self.reference_)
self.reDoModel_ = self.updateModel_ if self.updateModel_ is False else self.reDoModel_
if self.reDoModel_ is True:
self.strategy_.removeTrainedModel()
# === CONSTANT === #
self.save_ = os.dup(1)
self.trainTime_ = True
self.startIter = None
self.currentIter = 0
self.saveStdout = os.dup(1)
os.dup2(2, 1)
def runmain():
from src.Semantic_Analyzer import SemanticAnalyzer
from src.Parser import Parser
while True:
try:
text = \
"""PROGRAM Test;
VAR
a : INTEGER;
BEGIN
a := 1
END.
"""
#input('calc> ')
except EOFError:
break
if not text:
continue
lexer = Lexer(text)
parser = Parser(lexer)
tree = parser.parse()
semantic_analyzer = SemanticAnalyzer()
try:
semantic_analyzer.visit(tree)
except SystemError as sys_error:
print(sys_error)
for token in lexer.tokens:
print(token)
break
def testMarkdownTags():
def nbFilesWithTag(parser, tag):
return len([file for file in parser.mdFiles if tag in file.tags])
parser = Parser('./test/testVault')
for tag in ['tag2', 'tag1', 'inexistent']:
files = parser.searchFilesWithTag(tag)
assert len(files) == nbFilesWithTag(parser, tag)
def main():
parser = Parser()
args = parser.get_parsed_args()
ip_parser = IP_Parser()
node_ip = ip_parser.parse(args.ip)
peer_search = Peer_search()
peer_search.init(Network_utils.get_udp_socket(node_ip.ip, int(node_ip.port)))
peer_search.join_network(args.bootstrap)
peer_search.search(["reddit"]) # needs to be a list
peer_search.search(["hackernews"]) # needs to be a list
def makeInterpreter(self, text):
from src.Lexer import Lexer
from src.Parser import Parser
from src.Interpreter import Interpreter
from src.SymbolTable import SymbolTableBuilder
lexer = Lexer(text)
parser = Parser(lexer)
tree = parser.parse()
symtab_builder = SymbolTableBuilder()
symtab_builder.visit(tree)
interpreter = Interpreter(tree)
return interpreter
def main():
parser = Parser()
args = parser.get_parsed_args()
ip_parser = IP_Parser()
node_ip = ip_parser.parse(args.ip)
peer_search = Peer_search()
peer_search.init(Network_utils.get_udp_socket(node_ip.ip, int(node_ip.port)))
peer_search.join_network(args.bootstrap)
peer_search.index_page("reddit.com", ["reddit", "frontpage", "of", "the", "internet"])
peer_search.index_page("reddit.com", ["reddit", "cats", "lots", "of", "cats"])
peer_search.index_page("reddit.com", ["reddit", "hackernews", "internet", "of", "cats"])
peer_search.index_page("news.ycombinator.com", ["reddit", "hackernews", "internet", "of", "cats"])
peer_search.index_page("google.com", ["reddit", "frontpage", "of", "the", "internet"])
def test_write_output_file(parsed_data, delimiter_symbol, output_file,
output_format, expected_file):
outputted_file = open(output_file, "w")
parser = Parser()
parser.write_output_file(parsed_data, delimiter_symbol, outputted_file,
output_format)
res_file = open(output_file, 'r')
exp_file = open(expected_file, 'r')
assert res_file.read() == exp_file.read()
def main(argv=sys.argv):
parser = Parser()
# Generate training data
lexStr = parser.getLexFromXML("../docs/samePopularnonaukowe/uczace/")
result = parser.parseLex(lexStr)
parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/train.data",
result)
#lexStr = parser.xxx("../docs/samePopularnonaukowe/uczace/")
#parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/train.data", lexStr)
# Generate testing data
lexStr = parser.getLexFromXML("../docs/samePopularnonaukowe/testowe/kap")
result = parser.parseLex(lexStr)
parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/test.data",
result)
def test_infinitive_solutions1():
equation = "5 * X^2 = 5 * X^2"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def test_big_degree1():
equation = "4 * X^0 + 4 * X^1 - 9.3 * X^2 = 1 * X^3"
try:
parser = Parser(equation)
Polynom(parser)
except:
pass
def test_no_solutions1():
equation = "6 * X^0 + 0 * X^2 = 1 * X^0"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def test_no_solutions2():
equation = "5 * X^0 = 8 * X^0"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def test_big_degree3():
equation = "1 * X^5 = 0 * X^0"
try:
parser = Parser(equation)
Polynom(parser)
except:
pass
def test_big_degree2():
equation = "4 * X^0 + 4 * X^4 - 9.3 * X^2 = 0 * X^2"
try:
parser = Parser(equation)
Polynom(parser)
except:
pass
def test_big_degree4():
equation = "6 * X^0 + 4 * X^18 - 9.3 * X^3 = 1 * X^0"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def main(argv):
file_name = argv[0]
path = os.path.join(os.getcwd(), 'instances', file_name + '.col')
graph = Parser().get_graph_from_file(path)
start_time = datetime.now()
if len(argv) >= 2:
# choose algorithm from command line
solution = globals()[argv[1]](graph)
else:
solution = ga1(graph)
if solution:
result_str = '\n\r'.join(['Coloring: %s' % solution.coloring,
'# Bad edges: %s' % number_bad_edges(solution),
'# Colors: %s' % number_colors(solution)])
else:
result_str = 'No solution found!'
result_str += '\n\rSeconds: %s' % (datetime.now() - start_time).total_seconds()
print(result_str)
script_dir = os.path.dirname(__file__)
directory = os.path.join(script_dir, 'results')
if not os.path.exists(directory):
os.makedirs(directory)
with open(os.path.join(directory, '%s_%s.txt' % (file_name, datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))), 'w') as f:
f.write(result_str)
def test_error_equal1():
equation = "5 * X + 3 * X"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def test_error_characters():
equation = "5glezjjngv = 1 * X^0"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def test_error_negative():
equation = "6 * X^0 + -4 * X^2 = 1 * X^0"
try:
parser = Parser(equation)
polynom = Polynom(parser)
except:
pass
def makeInterpreter(self, text):
from src.Lexer import Lexer
from src.Parser import Parser
from src.Interpreter import Interpreter
lexer = Lexer(text)
parser = Parser(lexer)
interpreter = Interpreter(parser)
return interpreter
def load_file(self, file_name):
with open(file_name) as file:
self.data = file.readlines()
self.data = [x.strip() for x in self.data]
parser = Parser()
self.data = parser.parse_iris_data(self.data)
x = 0
for i in range(len(self.data)):
normalize_data = list(
map(normalize, self.data[i][0:len(self.data[i]) - 1]))
normalize_data.append(self.data[i][-1])
self.data[i] = normalize_data
if x % 2 == 0:
self.test_data.append(self.data[i])
else:
self.train_data.append(self.data[i])
x += 1
def main(argv=sys.argv):
parser = Parser()
# Generate training data
lexStr = parser.getLexFromXML("../docs/samePopularnonaukowe/uczace/")
result = parser.parseLex(lexStr)
parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/train.data", result)
#lexStr = parser.xxx("../docs/samePopularnonaukowe/uczace/")
#parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/train.data", lexStr)
# Generate testing data
lexStr = parser.getLexFromXML("../docs/samePopularnonaukowe/testowe/kap")
result = parser.parseLex(lexStr)
parser.printToFile("../docs/samePopularnonaukowe/parsingOutput/test.data", result)
def test_parsing_correct_configurations(self):
subfolder = "correct_configs"
# Test original example
test_config_path = os.path.join(test_configs_folder, subfolder,
"base_example")
parser = Parser(test_config_path)
lawn_size, mowers = parser.parse_config_file()
assert lawn_size == (5, 5)
assert mowers == [
((1, 2, "N"), ["L", "F", "L", "F", "L", "F", "L", "F", "F"]),
((3, 3, "E"), ["F", "F", "R", "F", "F", "R", "F", "R", "R", "F"])
]
# Test with a big rectangle lawn
test_config_path = os.path.join(test_configs_folder, subfolder,
"with_big_rectangle_lawn")
parser = Parser(test_config_path)
lawn_size, mowers = parser.parse_config_file()
assert lawn_size == (300, 500)
assert mowers == [((80, 236, "W"), ["L", "F", "L", "F"]),
((300, 378, "S"), ["F", "F", "R", "F"])]
# Test with many mowers
test_config_path = os.path.join(test_configs_folder, subfolder,
"with_many_mowers")
parser = Parser(test_config_path)
lawn_size, mowers = parser.parse_config_file()
assert lawn_size == (10, 10)
assert mowers == [
((6, 4, "N"), ["L", "F"]), ((3, 3, "S"), ["R", "F", "F", "R"]),
((1, 2, "S"), ["L", "F", "L", "F", "L", "F", "L", "F", "F"]),
((2, 3, "E"), ["R", "F", "R", "L", "L", "R", "F"]),
((1, 8, "W"), ["L", "F", "L", "F"]),
((4, 3, "E"), ["F", "F", "R", "L"]),
((1, 4, "N"), ["L", "F", "L", "F", "L", "F", "L", "F", "F"]),
((4, 5, "N"), ["F", "F", "R", "F"]), ((1, 1, "N"), ["F", "F"]),
((3, 4, "E"), ["F", "R", "R", "F"]),
((8, 8, "W"), ["F", "L", "F", "F"]),
((3, 9, "E"), ["F", "F", "R", "F"]),
((10, 2, "S"), ["L", "F", "L", "F", "L", "F", "L", "F", "F"]),
((3, 5, "W"), ["L", "L", "L", "R", "R"]),
((6, 2, "N"), ["L", "F", "L", "F", "L", "F", "L", "F", "F"]),
((3, 7, "E"), ["F", "F", "L", "L", "R", "R", "L", "R", "R", "F"])
]
def find_solutions(self, query_text):
query = Parser(query_text).parse_query()
query_variable_map = {}
variables_in_query = False
# Find any variables within the query and return a map containing the variable name to actual
# Prolog variable mapping we can later use to query our database.
for argument in query.arguments:
if isinstance(argument, Variable):
variables_in_query = True
query_variable_map[argument.name] = argument
# Return a generator which iterates over the terms matching our query
matching_query_terms = [item for item in self.database.query(query)]
if matching_query_terms:
if query_variable_map:
# If our query has variables and we have matching query terms/items, we iterate over the query items
# and our list of query variables and construct a map containing the matching variable names
# and their values
solutions_map = defaultdict(list)
for matching_query_term in matching_query_terms:
matching_variable_bindings = query.match_variable_bindings(
matching_query_term)
# Itarate over the query variables and bind them to the matched database bindings
for variable_name, variable in query_variable_map.items():
solutions_map[variable_name].append(
matching_variable_bindings.get(variable))
return solutions_map
else:
# If we have matching query items / terms but no variables in our query, we simply return true
# to indicate that our query did match our goal. Otherwise, we return None
return True if not variables_in_query else None
else:
# If we have no variables in our query, it means our goal had no matches, so we return False.
# Otherwisewe simply return None to show no variable bindings were found.
return False if not variables_in_query else None
def main():
parser = Parser()
file_path = input("Insert file path: ")
file_data = parser.read_input_file(file_path)
delimiter_symbol = input("Insert delimiter symbol: ")
delimiter_symbol = parser.delimiter_character(delimiter_symbol)
directory = input("Type output directory to be outputted: ")
outputted_file = parser.output_file(directory, basename(file_path))
output_format = input("Type output file format(linhas[l] | colunas[c]): ")
output_format = parser.file_format(output_format)
parsed_data = parser.parse_file_data(file_data)
parser.write_output_file(
parsed_data, delimiter_symbol, outputted_file, output_format)
def _test(n):
input_path = pathlib.Path(current_dir / input_paths[n])
expected_path = pathlib.Path(current_dir / expected_paths[n])
solution = Solver(Parser(input_path)).solve()
expected = Solver.to_string(
[line for line in open(str(expected_path), 'r').read().splitlines()])
assert solution == expected, 'Failed test_' + str(
n) + ' -> ' + 'Expected:' + expected + ' != ' + 'Actual:' + solution
print('Passed test_' + str(n) + ' -> ' + 'Expected:' + expected + ' == ' +
'Actual:' + solution)
def paintshop_ide():
import pathlib
input_paths = [
'input_0.txt', 'input_1.txt', 'input_2.txt', 'input_3.txt',
'input_messy_formatting.txt'
]
for input_path in input_paths:
path = pathlib.Path(
pathlib.Path(__file__).parent / 'test' / input_path)
solution = Solver(Parser(path)).solve()
print(solution)
def main():
argparser = argparse.ArgumentParser(
description='Generate an AST DOT file.')
argparser.add_argument('fname', help='Pascal source file')
args = argparser.parse_args()
fname = args.fname
text = open(fname, 'r').read()
lexer = Lexer(text)
parser = Parser(lexer)
viz = ASTVisualizer(parser)
content = viz.gendot()
print(content)
class Preprocessor:
def __init__(self, path, target):
self.path = path
self.target = target
self.lexer = Lexer()
self.parser = Parser()
self.builder = Builder()
def compile(self, minify):
print(f'Compiling {self.path}')
with open(self.path, 'r') as file:
raw = file.read()
self.lexer.tokenize(raw)
self.parser.parse(self.lexer.tokens)
html = self.builder.build(self.parser.dom)
if minify: html = self.builder.minify(html)
with open(self.target, 'w', newline='\n') as file:
file.write(html)
def watch(self, minify):
print(f'Watching {self.path}')
path = self.getSanitizedPath()
eventHandler = EventHandler(path.fn, self.compile, [minify])
observer = Observer()
observer.schedule(eventHandler, path.dir, recursive=False)
observer.start()
try:
while True:
sleep(.1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def getSanitizedPath(self):
pathChunks = self.path.replace('\\', '/').split('/')
return Namespace(dir='/'.join(pathChunks[:-1]), fn=pathChunks[-1])
def test_parsing_incorrect_syntax(self):
subfolder = "incorrect_syntax"
# Test with an empty config
test_config_path = os.path.join(test_configs_folder, subfolder,
"empty_config")
parser = Parser(test_config_path)
with pytest.raises(ValueError):
parser.parse_config_file()
# Test with incorrect number of lines in the file
test_config_path = os.path.join(test_configs_folder, subfolder,
"incorrect_number_of_lines")
parser = Parser(test_config_path)
with pytest.raises(ValueError):
parser.parse_config_file()
def main():
commands_table = CommandsTable()
code_writer = CodeWriter(commands_table)
for argument in sys.argv[1:]:
code_writer.set_file(argument)
parser = Parser(argument, commands_table)
while parser.has_more_commands():
parser.advance()
command_type = parser.command_type()
argument1 = parser.arg1()
argument2 = parser.arg2()
if command_type == "C_ARITHMETIC":
code_writer.write_arithmetic(argument1)
if command_type == "C_PUSH":
code_writer.write_push_pop("C_PUSH", argument1, argument2)
if command_type == "C_POP":
code_writer.write_push_pop("C_POP", argument1, argument2)
code_writer.close()
def test_parsing_incorrect_mower_instructions(self):
subfolder = "incorrect_mower_instructions"
# Test with an incorrect direction
test_config_path = os.path.join(test_configs_folder, subfolder,
"incorrect_direction")
parser = Parser(test_config_path)
with pytest.raises(ValueError):
parser.parse_config_file()
# Test with a lower case direction
test_config_path = os.path.join(test_configs_folder, subfolder,
"lower_case_direction")
parser = Parser(test_config_path)
with pytest.raises(ValueError):
parser.parse_config_file()
def main(fname):
# argparser = argparse.ArgumentParser(
# description='Generate an AST DOT file.'
# )
# argparser.add_argument(
# 'fname',
# help='Pascal source file'
# )
# args = argparser.parse_args()
# fname = args.fname
text = open(fname, 'r').read()
lexer = Lexer(text)
parser = Parser(lexer)
viz = ASTVisualizer(parser)
content = viz.gendot()
print(content)
w = open('ast.dot', 'w')
w.write(content)
'''
@author: Jwang135
'''
from src.Parser import Parser
from flask import render_template
from flask import Flask
app = Flask(__name__)
projects = Parser.svn_list_parser('Data/svn_list.xml')
Parser.svn_log_parse('Data/svn_log.xml',projects)
# Learn from https://github.com/mukichou/cs242-1
@app.route('/')
def home_page():
return render_template('index.html',projects=projects)
@app.route('/mp1')
def assignment_page(name=None):
return render_template('projects.html',
projects=projects,
name=name)
@app.route('/mp2')
def assignment_page2(name=None):
return render_template('projects_2.html',
projects=projects,
name=name)
@app.route('/<name>/files')
from src.LexicalException import LexicalException
from src.Memory import Memory
from src.Parser import Parser
from src.ParserException import ParserException
__author__ = 'thamilton'
if __name__ == "__main__":
try:
parser = Parser("/Users/thamilton/PycharmProjects/Project_2/test_data/test3.e")
parser.feature().execute()
memory = Memory()
memory.display_memory()
except (OSError, IOError, ValueError, Exception, LexicalException, ParserException) as e:
print(e)
