def __init__(self,
cities,
gas_stations,
storage,
min_sleep_time=15,
max_sleep_time=60):
"""
Initializes a crawler.
Args:
cities: a list of "city, state"
gas_stations: a list of gas stations
sleep_time: number of seconds to sleep after web request
"""
# list of cities
self.cities = cities
# list of gas stations
self.gas_stations = gas_stations
# sleep time
self.min_sleep_time = min_sleep_time
self.max_sleep_time = max_sleep_time
# parser for the gas station blocks
self.parser = Parser()
# parameters to extract
self.params = [
'address', 'brand', 'lat', 'lon', 'price_1', 'price_2', 'price_3'
]
# storage medium
self.storage = storage
def compile_file(self, filename):
"""
"""
print("compile file...<<", filename)
idx = self.find_proto(filename)
if idx >= 0:
return idx
with codecs.open(filename, encoding='utf-8') as f:
print('=' * 100)
ast = Parser(filename, f.read()).parse_file()
print('=' * 100)
# print('ast.execute result: >>', ast.execute())
print('=' * 100)
proto = ProtoType(None, filename)
proto.name = filename
proto.env = self
ast.to_bin(proto)
print("proto-->>", proto)
idx = self.add_proto(filename, proto)
return idx
def process_node_create_html(self, nodeid):
if self.options.verbose:
print 'html', nodeid
errors = 0
infile = os.path.join('src', self.book.name, self.stage_name,
nodeid + '.txt')
success = True
try:
parser = Parser(self, self.options)
if not parser.parse(infile, nodeid, todo=True):
success = False
except Exception as e:
print 'Exception:', e
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
success = False
if not success:
print '%s' % nodeid
print 'Parse failure'
errors += 1
sys.exit(0)
parser.export_html(
os.path.join(self.book.name, self.stage_name, nodeid + '.html'))
return errors
def upload_files_from_storage_to_search(self):
print("uploading files from storage account to search")
vi_output_files = self.storage_client.list_files_in_container(
self.insights_container)
i = 0
for file in vi_output_files:
i += 1
try:
json_object = json.loads(
self.storage_client.get_blob_string(
self.insights_container, file.name).encode(
) # Encode as UTF-8 in case UTF-8 BOM
)
if json_object["state"] == "Processed":
parser = Parser()
intervals = parser.parse_vi_json(json_object)
intervals = list(intervals.values())
for item in intervals:
item["@search.action"] = "upload"
documents = {"value": intervals}
print(
str(i) +
f": uploading {str(file.name)} to search index")
self.upload_to_search(documents)
self.write_status_file(str(file.name),
self.ingest_log_filename)
except ValueError:
print("could not process " + str(file))
self.write_status_file(file, self.ingest_failure_log_filename)
def __init__(self):
code = (" var myset = set() \n var oo = set() n = 653")
p = Parser()
p.parse(code)
raw_input("Press Enter to continue...")
def process_html(self, infile, outfile, options):
"""
Process simple (non-node) src file and generate an HTML file.
"""
errors = 0
name = os.path.splitext(os.path.basename(infile))[0]
make_dir(os.path.dirname(outfile))
success = True
if options.verbose:
print ' %s -> html' % infile
try:
parser = Parser(None, options)
if not parser.parse(infile, name):
print 'Failure during parse_main'
success = False
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
success = False
if not success:
print '%s' % file
print 'Parse failure'
errors += 1
else:
parser.export_html(outfile)
return errors
def test_parses_succeessfully(self):
reader = CsvReader(os.path.join(TEST_DIR, '3.csv'))
formatter = WeekFormatter()
parser = Parser(reader, formatter)
actual = parser.parse()
expected = [{
'square': 9,
'day': 'mon',
'value': 3,
'description': 'third_desc 9'
}, {
'square': 9,
'day': 'tue',
'value': 3,
'description': 'third_desc 9'
}, {
'square': 4,
'day': 'wed',
'value': 2,
'description': 'third_desc 4'
}, {
'double': 4,
'day': 'thu',
'value': 2,
'description': 'third_desc 4'
}, {
'double': 2,
'day': 'fri',
'value': 1,
'description': 'third_desc 2'
}]
for dct1, dct2 in zip(expected, actual):
self.assertDictEqual(dct1, dct2)
def upload_local_files_to_search(self):
print("uploading local files to search")
files = self.read_files_from_directory(self.vi_output_directory)
i = 0
for file in files:
path = os.path.join(self.vi_output_directory, file)
i += 1
with open(path) as f:
try:
json_object = json.load(f)
if json_object["state"] == "Processed":
parser = Parser()
intervals = parser.parse_vi_json(json_object)
intervals = list(intervals.values())
for item in intervals:
item["@search.action"] = "upload"
documents = {"value": intervals}
print(
str(i) +
f": uploading {str(file)} to search index")
self.upload_to_search(documents)
self.write_status_file(file, self.ingest_log_filename)
except ValueError:
print("could not process " + str(file))
self.write_status_file(file,
self.ingest_failure_log_filename)
def test_gohugo_parser(title, desc, content, tags, date, clean):
expected_template = '''
---
title: ''' + title + '''
date: ''' + date + '''
draft: true
summary: ''' + desc + ''' ''' + content + '''
tags: ''' + str(tags) + '''
isfeed: true
id: 1
---
'''
parser = Parser()
template, post_id = parser.gohugo_parser(title,
desc,
content,
tags,
date,
post_id=1)
if clean:
assert_that(template).is_equal_to(expected_template) if title != '' \
else assert_that(len(template)).is_greater_than(len(expected_template))
assert_that(len(template)).is_equal_to(len(expected_template)) if title != '' \
else assert_that(template).is_not_equal_to(expected_template)
else:
assert_that(template).is_not_equal_to(expected_template)
assert_that(len(template)).is_less_than(len(expected_template)) if title != '' \
else assert_that(len(template)).is_not_equal_to(len(expected_template))
assert_that(post_id).is_not_none()
def test_parsing_infix_expressions(self):
tests = [
["5 + 5;", 5, "+", 5],
["5 - 5;", 5, "-", 5],
["5 * 5;", 5, "*", 5],
["5 / 5;", 5, "/", 5],
["5 > 5;", 5, ">", 5],
["5 < 5;", 5, "<", 5],
["5 == 5;", 5, "==", 5],
["5 != 5;", 5, "!=", 5],
["foobar + barfoo;", "foobar", "+", "barfoo"],
["foobar - barfoo;", "foobar", "-", "barfoo"],
["foobar * barfoo;", "foobar", "*", "barfoo"],
["foobar / barfoo;", "foobar", "/", "barfoo"],
["foobar > barfoo;", "foobar", ">", "barfoo"],
["foobar < barfoo;", "foobar", "<", "barfoo"],
["foobar == barfoo;", "foobar", "==", "barfoo"],
["foobar != barfoo;", "foobar", "!=", "barfoo"],
["true == true", True, "==", True],
["true != false", True, "!=", False],
["false == false", False, "==", False],
]
for tt in tests:
lexer = Lexer(tt[0])
parser = Parser(lexer)
program = parser.parse_program()
self.assert_parser_errors(parser)
self.assertEqual(1, len(program.statements))
exp = program.statements[0].expression
self.assert_infix_expression(tt[1], tt[2], tt[3], exp)
def make_track(self):
if not self.unstable:
random.seed(self.content)
track = Track()
track.add_event(TempoEvent(100)) #bpm
parser = Parser(self.content)
channel_stack = []
used_up_channels = []
key = self._generate_key()
last_note = self.select_note(key, None)
frame = StackFrame(track.new_channel(), key, last_note)
frame.channel.add_event(ProgramChangeEvent, 0, random.choice(instruments.values()))
frame.channel.add_event(SetVolumeEvent, 0, 0x32)
frame.channel.add_event(NoteOnEvent, 0, last_note, 0x42)
# for every function scope we enter, we want a new channel,
# and we want a new key for it, and we want to immediately start
# a note playing. In function scope, every assignment should end that note and start a new note
# on that channel. Every other scope starts another note that ends when that scope ends, and behaves similarly
# with assignments
# when a scope ends we end its current note
tok = parser.next_token()
max_depth = 0
while tok is not None:
if tok == Tokens.FUNCTION_START:
# create a new channel, a new key, and the last note put on this channel
# start that note playing
key = self._generate_key(depth=len(channel_stack))
last_note = self.select_note(key, None)
channel_stack.append(frame)
if len(channel_stack) > max_depth:
max_depth = len(channel_stack)
if used_up_channels:
frame = used_up_channels.pop()
else:
frame = StackFrame(track.new_channel(), key, last_note)
frame.channel.add_event(ProgramChangeEvent, 0, random.choice(instruments.values()))
frame.channel.add_event(SetVolumeEvent, 0, 0x32)
frame.channel.add_event(NoteOnEvent, 0, frame.last_note, 0x42)
self.maybe_update_stack(channel_stack)
elif tok == Tokens.FUNCTION_END:
frame.channel.add_event(NoteOffEvent, self.eighth_note, frame.last_note, 0x42)
used_up_channels.append(frame)
frame = channel_stack.pop()
elif tok == Tokens.ASSIGNMENT:
frame.channel.add_event(NoteOffEvent, self.eighth_note, frame.last_note, 0x42)
frame.last_note = self.select_note(frame.key, frame.last_note)
frame.channel.add_event(NoteOnEvent, 0, frame.last_note, 0x42)
self.maybe_update_stack(channel_stack)
elif tok == Tokens.OTHER_KEYWORD:
pass
elif tok == Tokens.INVALID_SOURCE:
print 'Error in %s on line %d' % (self.filename, parser.line_no)
tok = parser.next_token()
return track
def test_person():
Name = fact(
'Name',
['first', 'last'],
)
Person = fact(
'Person',
['position', 'name']
)
LAST = and_(
gram('Surn'),
not_(gram('Abbr')),
)
FIRST = and_(
gram('Name'),
not_(gram('Abbr')),
)
POSITION = morph_pipeline([
'управляющий директор',
'вице-мэр'
])
gnc = gnc_relation()
NAME = rule(
FIRST.interpretation(
Name.first
).match(gnc),
LAST.interpretation(
Name.last
).match(gnc)
).interpretation(
Name
)
PERSON = rule(
POSITION.interpretation(
Person.position
).match(gnc),
NAME.interpretation(
Person.name
)
).interpretation(
Person
)
parser = Parser(PERSON)
match = parser.match('управляющий директор Иван Ульянов')
assert match
assert match.fact == Person(
position='управляющий директор',
name=Name(
first='Иван',
last='Ульянов'
)
)
def test_const():
RULE = rule(
'a'
).interpretation(
const(1)
)
parser = Parser(RULE)
match = parser.match('a')
assert match.fact == 1
def setUpClass(cls):
logging.basicConfig(level=logging.INFO)
parser = Parser('../test_data', 'euro16_k2.txt')
parser = parser.get_scenario(2)
networkTopology = parser.networkTopology
cls.graph = graph_factory(networkTopology)
cls.candidate_path_fetcher = CandidatePathsFetcher(parser.candidatePaths,
networkTopology.n_nodes,
parser.pathsLengths)
def test_rule_custom():
RULE = rule(
'3', '.', '14'
).interpretation(
custom(float)
)
parser = Parser(RULE)
match = parser.match('3.14')
assert match.fact == 3.14
def text_normalized():
RULE = rule(
'московским'
).interpretation(
normalized()
)
parser = Parser(RULE)
match = parser.match('московским')
assert match.fact == 'московский'
def test_inflected():
RULE = rule(
'московским'
).interpretation(
inflected({'nomn', 'femn'})
)
parser = Parser(RULE)
match = parser.match('московским')
assert match.fact == 'московская'
def test_attribute_const():
F = fact('F', 'a')
RULE = rule(
'январь'
).interpretation(
F.a.const(1)
)
parser = Parser(RULE)
match = parser.match('январь')
assert match.fact == 1
def test_one(self):
l = Lexer('tests/sample.ps')
l.lex()
self.assertEqual([(t.name, t.value) for t in l.tokens], [('KEYWORD', 'program'), ('IDENTIFIER', 'hellowld'), ('SEMICOLON', ';'), ('KEYWORD', 'begin'), ('IDENTIFIER', 'writeln'), ('LP', '('), ('BASE10_NUM', '2'), ('RP', ')'), ('SEMICOLON', ';'), ('IDENTIFIER', 'readln'), ('SEMICOLON', ';'), ('KEYWORD', 'end')])
p = Parser(l.tokens)
try:
p.parse()
except SyntaxError:
self.fail()
def test_attribute():
F = fact('F', 'a')
RULE = rule(
'a'
).interpretation(
F.a
)
parser = Parser(RULE)
match = parser.match('a')
assert match.fact == 'a'
def main(args):
parser = Parser()
iface = parser.parse(args.specification.read())
for generator in args.generators:
for file_path, content in generator.generate(iface).items():
write_generated_file(path.join(generator.name, file_path),
content,
args.out_directory,
args.update)
def test_rule_custom_custom():
MAPPING = {'a': 1}
RULE = rule(
'A'
).interpretation(
custom(str.lower).custom(MAPPING.get)
)
parser = Parser(RULE)
match = parser.match('A')
assert match.fact == 1
def setUp(self):
parser = Parser('./data', 'euro16_k2.txt')
self.scenario = parser.get_scenario(0)
self.graph = graph_factory(self.scenario.networkTopology)
self.logger = logging.getLogger(str(self.__class__))
candidate_path_fetcher = CandidatePathsFetcher(self.scenario.candidatePaths,
self.scenario.networkTopology.n_nodes,
self.scenario.pathsLengths)
self.demand_factory = DemandsFactory(candidate_path_fetcher)
self.sa = SimulatedAnnealing()
def test_two(self):
l = Lexer('tests/sample2.ps')
l.lex()
self.assertEqual([(t.name, t.value) for t in l.tokens], [('KEYWORD', 'program'), ('IDENTIFIER', 'exFunction'), ('SEMICOLON', ';'), ('KEYWORD', 'var'), ('IDENTIFIER', 'a'), ('COMMA', ','), ('IDENTIFIER', 'b'), ('COMMA', ','), ('IDENTIFIER', 'ret'), ('COLON', ':'), ('KEYWORD', 'integer'), ('SEMICOLON', ';'), ('KEYWORD', 'function'), ('IDENTIFIER', 'max'), ('LP', '('), ('IDENTIFIER', 'num1'), ('COMMA', ','), ('IDENTIFIER', 'num2'), ('COLON', ':'), ('KEYWORD', 'integer'), ('RP', ')'), ('COLON', ':'), ('KEYWORD', 'integer'), ('SEMICOLON', ';'), ('KEYWORD', 'var'), ('IDENTIFIER', 'result'), ('COLON', ':'), ('KEYWORD', 'integer'), ('SEMICOLON', ';'), ('KEYWORD', 'begin'), ('KEYWORD', 'if'), ('LP', '('), ('IDENTIFIER', 'num1'), ('GT', '>'), ('IDENTIFIER', 'num2'), ('RP', ')'), ('KEYWORD', 'then'), ('IDENTIFIER', 'result'), ('ATTRIB', ':='), ('IDENTIFIER', 'num1'), ('KEYWORD', 'else'), ('IDENTIFIER', 'result'), ('ATTRIB', ':='), ('IDENTIFIER', 'num2'), ('SEMICOLON', ';'), ('IDENTIFIER', 'max'), ('ATTRIB', ':='), ('IDENTIFIER', 'result'), ('SEMICOLON', ';'), ('KEYWORD', 'end'), ('SEMICOLON', ';'), ('KEYWORD', 'begin'), ('IDENTIFIER', 'a'), ('ATTRIB', ':='), ('BASE10_NUM', '100'), ('SEMICOLON', ';'), ('IDENTIFIER', 'b'), ('ATTRIB', ':='), ('BASE10_NUM', '200'), ('SEMICOLON', ';'), ('IDENTIFIER', 'ret'), ('ATTRIB', ':='), ('IDENTIFIER', 'max'), ('LP', '('), ('IDENTIFIER', 'a'), ('COMMA', ','), ('IDENTIFIER', 'b'), ('RP', ')'), ('SEMICOLON', ';'), ('IDENTIFIER', 'writeln'), ('LP', '('), ('IDENTIFIER', 'ret'), ('RP', ')'), ('SEMICOLON', ';'), ('KEYWORD', 'end')])
p = Parser(l.tokens)
try:
p.parse()
except SyntaxError:
self.fail()
def setUpClass(cls):
logging.basicConfig(level=logging.INFO)
parser = Parser('../test_data', 'euro16_k2.txt')
scenario = parser.get_scenario(2)
networkTopology = scenario.networkTopology
cls.graph = graph_factory(networkTopology)
cls.candidate_path_fetcher = CandidatePathsFetcher(scenario.candidatePaths,
networkTopology.n_nodes,
scenario.pathsLengths)
cls.demands = unicast_demands_factory(scenario.unicastDemands, cls.candidate_path_fetcher)
def setUp(self):
parser = Parser("../test_data", "euro16_k2.txt")
scenario = parser.get_scenario(2)
graph = graph_factory(scenario.networkTopology)
candidatePathFetcher = CandidatePathsFetcher(scenario.candidatePaths, len(graph.nodes), scenario.pathsLengths)
# get path
list_of_paths1 = candidatePathFetcher.fetch_candidates(0, 1)
# 1, 6, 10
self.path = list_of_paths1[1]
self.edges = graph.edges
self.sa = SpectrumAllocator(graph)
def test_predicate_attribute():
F = fact('F', ['a'])
RULE = rule(
eq('a').interpretation(F.a)
).interpretation(F)
parser = Parser(RULE)
match = parser.match('a')
record = match.fact
assert record == F(a='a')
assert record.spans == [(0, 1)]
assert record.as_json == {'a': 'a'}
def test_parsing_empty_hash_literal(self):
lexer = Lexer("{}")
parser = Parser(lexer)
program = parser.parse_program()
self.assert_parser_errors(parser)
hash_literal = program.statements[0].expression
self.assertIsInstance(hash_literal, HashLiteral)
self.assertEqual(0, len(hash_literal.pairs))
def test_identifier_expression(self):
lexer = Lexer("foobar;")
parser = Parser(lexer)
program = parser.parse_program()
self.assert_parser_errors(parser)
self.assertEqual(1, len(program.statements))
ident = program.statements[0].expression
self.assertEqual("foobar", ident.value)
self.assertEqual("foobar", ident.token_literal())
def test_integer_literal_expression(self):
lexer = Lexer("5;")
parser = Parser(lexer)
program = parser.parse_program()
self.assert_parser_errors(parser)
self.assertEqual(1, len(program.statements))
literal = program.statements[0].expression
self.assertEqual(5, literal.value)
self.assertEqual("5", literal.token_literal())
def test_rule_attribute_custom():
F = fact('F', ['a'])
RULE = rule(
'1'
).interpretation(
F.a
).interpretation(
custom(int)
)
parser = Parser(RULE)
match = parser.match('1')
assert match.fact == 1
def test_operator_precedence_parsing(self):
tests = [
["-a * b", "((-a) * b)"],
["!-a", "(!(-a))"],
["a + b + c", "((a + b) + c)"],
["a + b - c", "((a + b) - c)"],
["a * b * c", "((a * b) * c)"],
["a * b / c", "((a * b) / c)"],
["a + b / c", "(a + (b / c))"],
["a + b * c + d / e - f", "(((a + (b * c)) + (d / e)) - f)"],
["3 + 4; -5 * 5", "(3 + 4)((-5) * 5)"],
["5 > 4 == 3 < 4", "((5 > 4) == (3 < 4))"],
["5 < 4 != 3 > 4", "((5 < 4) != (3 > 4))"],
[
"3 + 4 * 5 == 3 * 1 + 4 * 5",
"((3 + (4 * 5)) == ((3 * 1) + (4 * 5)))",
],
["true", "true"],
["false", "false"],
["3 > 5 == false", "((3 > 5) == false)"],
["3 < 5 == true", "((3 < 5) == true)"],
["1 + (2 + 3) + 4", "((1 + (2 + 3)) + 4)"],
["(5 + 5) * 2", "((5 + 5) * 2)"],
["2 / (5 + 5)", "(2 / (5 + 5))"],
["(5 + 5) * 2 * (5 + 5)", "(((5 + 5) * 2) * (5 + 5))"],
["-(5 + 5)", "(-(5 + 5))"],
["!(true == true)", "(!(true == true))"],
["a + add(b * c) + d", "((a + add((b * c))) + d)"],
[
"add(a, b, 1, 2 * 3, 4 + 5, add(6, 7 * 8))",
"add(a, b, 1, (2 * 3), (4 + 5), add(6, (7 * 8)))",
],
[
"add(a + b + c * d / f + g)",
"add((((a + b) + ((c * d) / f)) + g))",
],
[
"a * [1, 2, 3, 4][b * c] * d",
"((a * ([1, 2, 3, 4][(b * c)])) * d)",
],
[
"add(a * b[2], b[1], 2 * [1, 2][1])",
"add((a * (b[2])), (b[1]), (2 * ([1, 2][1])))",
],
]
for tt in tests:
lexer = Lexer(tt[0])
parser = Parser(lexer)
program = parser.parse_program()
self.assert_parser_errors(parser)
self.assertEqual(tt[1], str(program))
def test_inflected_custom():
MONTHS = {
'январь': 1
}
RULE = rule(
'январе'
).interpretation(
inflected({'nomn', 'sing'}).custom(MONTHS.get)
)
parser = Parser(RULE)
match = parser.match('январе')
assert match.fact == 1
def test_normalized_custom():
MONTHS = {
'январь': 1
}
RULE = rule(
'январе'
).interpretation(
normalized().custom(MONTHS.get)
)
parser = Parser(RULE)
match = parser.match('январе')
assert match.fact == 1
def test_tagger():
text = 'a b c d e f g'
A = tag('I').repeatable()
parser = Parser(A, tagger=MyTagger())
matches = parser.findall(text)
spans = [_.span for _ in matches]
substrings = [
text[start:stop]
for start, stop in spans
]
assert substrings == ['b c', 'e f']
def setUpClass(cls):
logging.basicConfig(level=logging.INFO)
parser = Parser('../test_data', 'euro16_k2.txt')
# 40.dem, 10.dea, 31.rep
cls.parser = parser.get_scenario(261)
networkTopology = cls.parser.networkTopology
cls.graph = graph_factory(networkTopology)
cls.candidate_path_fetcher = CandidatePathsFetcher(cls.parser.candidatePaths,
networkTopology.n_nodes,
cls.parser.pathsLengths)
cls.demand_factory = DemandsFactory(cls.candidate_path_fetcher)
cls.unicast_demands = cls.demand_factory.get_unicast_demands(cls.parser.unicastDemands)
cls.anycast_demands = cls.demand_factory.get_anycast_demands(cls.parser.anycastDemands, cls.parser.dataCenters)
def execute(program_container: ProgramContainer):
"""
Executes the given program.
:param program_container: the program container containing the program that shall be executed.
"""
try:
try:
parsed_program = ast_tree_of_intermediate_code(program_container)
except IntermediateCodeError as b:
logger.error(b.message())
parsed_program = Parser.parse(program_container)
generate_tree_based_intermediate_code(parsed_program, program_container)
logger.debug('Parsed AST for %s: %s' % (program_container.origin, parsed_program))
global_env = GlobalEnvironment(name='__main__', file_path=program_container.origin)
parsed_program.execute(global_env, None)
logger.debug('Environment after execution: %s' % global_env)
except (ParserErrors, ExecutionError) as p:
print(p.message(), file=sys.stderr)
def main():
parser = Parser()
cities = parser.parse_cities("data/city.json")
flights = parser.parse_flights("data/flight.json")
customers = parser.parse_customers("data/customer.json")
articles = parser.parse_articles("data/article.json")
tags = parser.parse_tags("data/tags.json")
engine = Engine(customers, articles, tags, flights, cities)
print_customers(customers, parser.customer_schema)
cid = dialog_customer(customers, parser.customer_schema)
ar = engine.articlerating_customer(cid)
show_best_articles(ar, articles, parser.article_schema)
return True
class ParserTests(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def testCorrectSquareBrackets(self):
self.assertTrue(self.parser.read("[]"))
def testFalseSquareBrackets(self):
self.assertFalse(self.parser.read("[]]"))
def testCorrectMixedBrackets(self):
self.assertTrue(self.parser.read("{<>}()[{}]"))
def testFalseMixedBrackets(self):
self.assertFalse(self.parser.read("{<}()[{}]"))
def testTokenExistsButOrderIsWrong(self):
self.assertFalse(self.parser.read("{[}]"))
def testLargeString(self):
eval_this = """
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
"""
self.assertTrue(self.parser.read(eval_this))
def testFalseLargeString(self):
# SyntaxError in line 41
eval_this = """
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]{}<>()[]
"""
self.assertFalse(self.parser.read(eval_this))
def run_interpreter(stream):
token_stream = Lexer.start(stream)
parsed_stream = Parser.start(token_stream)
return Interpreter.simulate_statements(parsed_stream)
def setUpClass(cls):
logging.basicConfig(level=logging.INFO)
parser = Parser('../test_data', 'euro16_k2.txt')
parser = parser.get_scenario(0)
cls.networkTopology = parser.networkTopology
cls.graph = graph_factory(cls.networkTopology)
import socket
from subprocess import call
from plugins.cameraled import CameraLED
from parser.parser import Parser
# Accept requests from any IP address on port 50000
TCP_IP = '0.0.0.0'
TCP_PORT = 50000
BUFFER_SIZE = 4096
# Create socket and bind it to TCP address & port
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP, TCP_PORT))
led = CameraLED()
parser = Parser();
# Infinite loop
while 1:
# Listen for a connection
s.listen(1)
# Connection found. Accept connection
conn, addr = s.accept()
data = conn.recv(BUFFER_SIZE).rstrip()
tokens = parser.parse(data);
#print tokens
l = len(tokens)
if l > 0 and tokens[0] == "led":
if l > 1 and tokens[1] == "on":
# print "Turn LED on"
def test_direct_input_stream(self):
tokenstream_oracle = TokenStream([InputNumDirect(Integer(0, 111), InputNumCell(3))])
actual_tokenstream = Parser.start(TokenStream([Integer(0, 111), InputNumCell(3)]))
self.assertSequenceEqual(actual_tokenstream, tokenstream_oracle)
# for each edge add its index to corresponding node
for key, edge in edges.items():
nodes[edge.source].add_edge(key)
return nodes
logger = logging.getLogger(graph_factory.__name__)
assert isinstance(network_topology, parser.parser.NetworkTopology)
graph = Graph()
logger.debug("filling edges")
graph.edges = generate_edges(network_topology.matrix_of_net_links)
logger.debug("filling nodes")
graph.nodes = generate_nodes(network_topology.matrix_of_net_links, graph.edges)
logger.info("graph created")
return graph
if __name__ == "__main__":
from parser.parser import Parser
test_parser = Parser('../test/test_data', 'euro16_k2.txt')
test_parser = test_parser.get_scenario(2)
test_graph = graph_factory(test_parser.networkTopology)
for edge in test_graph.edges:
print test_graph.edges[edge]
for node in test_graph.nodes:
print test_graph.nodes[node]
def test_nested_condition_stream(self):
tokentream_oracle = TokenStream([IncrementCell(0), ConditionalStatement(Condition(3), [PointerRight(6), ConditionalStatement(Condition(9), [PointerLeft(12)])]), OutputNumCell(21)])
actual_tokenstream = Parser.start(TokenStream([IncrementCell(0), Condition(3), PointerRight(6), Condition(9), PointerLeft(12), JumpBack(15), JumpBack(18), OutputNumCell(21)]))
self.assertSequenceEqual(actual_tokenstream, tokentream_oracle)
def test_direct_output_stream(self):
tokenstream_oracle = TokenStream([OutputNumDirect(Integer(0, 2223), OutputNumCell(4))])
actual_tokenstream = Parser.start(TokenStream([Integer(0, 2223), OutputNumCell(4)]))
self.assertSequenceEqual(actual_tokenstream, tokenstream_oracle)
return False
def cool_temperature(self):
self.temperature *= 1 - self.cooling_rate
def is_not_cold(self):
return self.temperature > self.minimal_temperature
if __name__ == "__main__":
from parser.parser import Parser
from graph.graph import graph_factory
from graph.path import CandidatePathsFetcher
from demand.demand import DemandsFactory
logging.basicConfig(level=logging.INFO)
test_parser = Parser('../test/test_data', 'euro16_k2.txt')
scenario = test_parser.get_scenario(100)
graph = graph_factory(scenario.networkTopology)
candidate_path_fetcher = CandidatePathsFetcher(scenario.candidatePaths,
scenario.networkTopology.n_nodes,
scenario.pathsLengths)
demand_factory = DemandsFactory(candidate_path_fetcher)
sa = SimulatedAnnealing()
uni_demands = demand_factory.get_unicast_demands(scenario.unicastDemands)
any_demands = demand_factory.get_anycast_demands(scenario.anycastDemands, scenario.dataCenters)
demands = uni_demands + any_demands
sa.run(graph, demands)
print sa.best_energy
# for demand in sa.best_solution:
# if isinstance(demand, UnicastDemand):
# print demand.get_selected_path()
def main(args):
parser = Parser()
print parser.read("<{}<>()")
def setUp(self): self.parser = Parser()
