def _parse_metrics(self, message):
"""
Given a raw message of metrics split by newline characters, this will
parse the metrics and return an array of metric objects.
This will raise a :exc:`ValueError` if any metrics are invalid, unless
``ignore_errors`` is set to True.
"""
results = []
for line in message.split("\n"):
# If the line is blank, we ignore it
if len(line) == 0: continue
# Parse the line, and skip it if its invalid
try:
(key, value, metric_type, flag) = parser.parse_line(line)
except ValueError:
self.logger.error("Invalid line syntax: %s" % line)
continue
# Create the metric and store it in our results
if metric_type in metrics.METRIC_TYPES:
# Create and store the metric object
metric = metrics.METRIC_TYPES[metric_type](key, value, flag)
results.append(metric)
else:
# Ignore the bad invalid metric, but log it
self.logger.error("Invalid metric '%s' in line: %s" % (metric_type, line))
return results
def _parse_metrics(self, message):
"""
Given a raw message of metrics split by newline characters, this will
parse the metrics and return an array of metric objects.
This will raise a :exc:`ValueError` if any metrics are invalid, unless
``ignore_errors`` is set to True.
"""
results = []
for line in message.split("\n"):
# If the line is blank, we ignore it
if len(line) == 0: continue
# Parse the line, and skip it if its invalid
try:
(key, value, metric_type, flag) = parser.parse_line(line)
except ValueError:
self.logger.error("Invalid line syntax: %s" % line)
continue
# Create the metric and store it in our results
if metric_type in metrics.METRIC_TYPES:
# Create and store the metric object
metric = metrics.METRIC_TYPES[metric_type](key, value, flag)
results.append(metric)
else:
# Ignore the bad invalid metric, but log it
self.logger.error("Invalid metric '%s' in line: %s" % (metric_type, line))
return results
def check(cls, paths):
'''Will check if there are keys available there, as in --path
paths can be a string (one address), or a list of
'''
#TODO: more solid check: something like
if type(paths) is not str:
out = []
for p in paths:
try:
res = cls.check(p)
except:
continue
else:
if res:
out.extend(res)
return out
buf = NamedTemporaryFile()
try:
subprocess.check_call(
[cls.undertakerexec, paths, '--batch', '--path'], stderr=buf)
except subprocess.CalledProcessError as exc:
return False
out = []
buf.seek(0)
for line in buf:
ret = parser.parse_line(line)
if ret and ret['type'] == 'found':
out.append(ret['content'])
return out
def check(cls, paths):
'''Will check if there are keys available there, as in --path
paths can be a string (one address), or a list of
'''
#TODO: more solid check: something like
if type(paths) is not str:
out = []
for p in paths:
try:
res = cls.check(p)
except:
continue
else:
if res:
out.extend(res)
return out
buf = NamedTemporaryFile()
try:
subprocess.check_call([cls.undertakerexec, paths, '--batch',
'--path'], stderr=buf)
except subprocess.CalledProcessError as exc:
return False
out = []
buf.seek(0)
for line in buf:
ret = parser.parse_line(line)
if ret and ret['type'] == 'found':
out.append(ret['content'])
return out
def command():
content = request.get_json(silent=True)
game_id = content.get('game_id')
team_id = content.get('team_id')
line = content.get('line')
result = parse_line(game_id, team_id, line, parser_cursor)
cnx.commit()
return result
def repl():
from sys import exit, stdout
def prompt():
print("\x1B[2mdq>\x1B[22m ", end='')
line = input()
if line in ['exit', 'quit']:
exit()
return line + "\n"
stream = TokenStream("", prompt)
try:
while True:
tree = parse_line(stream)
if tree is None:
continue
if isinstance(tree, ParseError):
tree.display(stream.log)
continue
if isinstance(tree, ParseTree) and tree.kind == 'assignment':
name = tree.children[0].val
q = makeQueue(tree.children[1])
GLOBALS[name] = q
elif isinstance(tree, ParseTree) and tree.kind == 'output':
cmd = tree.children[0].val
q = makeQueue(tree.children[1])
if cmd == 'print':
smartPrint(q, stdout)
elif cmd == 'printNum':
printNum(q, stdout)
elif cmd == 'printStr':
printStr(q, stdout)
elif cmd == 'printRepr':
printRepr(q, stdout)
else:
raise Exception("this should never happen")
else:
q = makeQueue(tree)
fq = Take(q, 1024 * 1024)
smartPrint(fq, stdout)
if fq.halted:
print("\x1B[93mwarning\x1B[39m: output truncated")
except KeyboardInterrupt:
print("\b\b")
except EOFError:
print('exit')
def run_controller(circuit, instruction: str, flags=""):
parsed, _ = parser.parse_line(instruction)
print(instruction, parsed)
clock = circuit_module.Clock()
with scope("IR"):
ir = bus()
with scope("FLAGS"):
flags_in = Lines("CAEZ")
with scope("STEPPER"):
stepper = bus(6)
inputs = clock.clk >> clock.clk_s >> clock.clk_e >> ir >> flags_in >> stepper
output = inputs >> circuit_module.controller
simulation = {}
es = tag_outputs(circuit, ["CONTROL", "ENABLER"])
ss = tag_outputs(circuit, ["CONTROL", "SELECTOR"])
rounds = []
for step in range(6):
e_found = set()
s_found = set()
for clock_round in range(4):
f = clock.step()
f.update({stepper[j]: int(j == step) for j in range(6)})
f.update({ir[j]: k for j, k in enumerate(parsed)})
f.update(
{flags_in[j]: int(letter in flags) for j, letter in enumerate("CAEZ")}
)
simulation.update(simulate(f, circuit, simulation))
new_es = set(e for e in es if simulation[e])
new_ss = set(s for s in ss if simulation[s])
if clock_round == 3:
assert (
len(
[
line
for line in new_es
if line not in Lines(new_es).typed(("E", "B1"))
and line not in Lines(new_es).typed(("ALU", "OP"))
]
)
== 0
)
if clock_round != 1:
assert len(new_ss) == 0
e_found.update(new_es)
s_found.update(new_ss)
rounds.append({"e": Lines(e_found), "s": Lines(s_found)})
return rounds
def on_input (self, reactor):
""" Yield incoming `Message` objects """
super(IRCClient, self).on_input()
while self.buffer:
line = self.buffer.pop(0)
# Skip the line if it is a PING
if line.startswith('PING :'):
self.socket.send("PONG :" + line[6:] + "\r\n")
break
# Handler disconnections
if line.startswith('ERROR :'):
reactor.disconnect(self)
break
yield self.parse(handler=self, **parse_line(line))
def test_parser():
tests = [("NOP", Instr("NOP", Operand(IMPL, None))),
("ADC #16", Instr("ADC", Operand(IMM, 16))),
("ADC $FF", Instr("ADC", Operand(ZP_ABS, 255))),
("ADC 16, X", Instr("ADC", Operand(ABS_X, 16))),
("ADC ($100)", Instr("ADC", Operand(INDIR, 256))),
("ADC (120)", Instr("ADC", Operand(ZP_INDIR, 120))),
("ADC (120, X)", Instr("ADC", Operand(INDEXED_INDIR_X, 120))),
("ADC (120), X", Instr("ADC", Operand(INDIR_INDEXED_X, 120))),]
succeeded = 0
failed = 0
for i in range(len(tests)):
test = tests[i]
result = parser.parse_line(test[0], i)[0]
if result == test[1]:
succeeded += 1
else:
print("Failed: " + test[0] + " => " + str(result) + "( expected " + str(test[1]) + " )")
failed += 1
print(str(succeeded) + " succeeded, " + str(failed) + " failed")
def test_parse_line_begin_freq(self):
actual = parser.parse_line(freq)
expected = ('core', 'blockchain', parser.parse_parameters(parameters),
480000, freq_measure)
self.assertEqual(actual, expected)
def test_parse_line_begin_stats(self):
actual = parser.parse_line(stats)
expected = ('topology', 'messages-ping',
parser.parse_parameters(parameters), 1080000,
stats_measure)
self.assertEqual(actual, expected)
This file is part of NecroDancer Stat Tracker.
NecroDancer Stat Tracker is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
NecroDancer Stat Tracker is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with NecroDancer Stat Tracker. If not, see <http://www.gnu.org/licenses/>.
"""
import config
config.open_() # Open config file so logctl doesn't error
import logctl
import parser
import runctl
run = runctl.Run()
log = logctl.open_latest()
while True:
current_line = logctl.readline(log)
parser.parse_line(current_line, run)
