def handle_connection(conn, addr):
message_data = ""
while True:
new_data = conn.recv(1)
message_data += new_data
if new_data == parser.message_separator:
break
message = parser.parse(message_data)
if message is None:
print "Unknown message received in connection to " + addr[0]
conn.close()
return
if isinstance(message, GetFilelistMessage):
for f in peerlist.self_peer.files:
m = FileMessage(f.sha_hash.lower(),
-1 if f.ttl == float("inf") else f.ttl,
f.length,
f.name,
f.meta)
conn.sendall(parser.build(m))
conn.close()
return
elif isinstance(message, GetFileMessage):
try:
file_to_send = filter(lambda f: f.sha_hash == message.sha.lower(),
peerlist.self_peer.files)[0]
except:
conn.sendall(parser.build(
FileTransferResponseMessage(FileTransferResponseMessage
.NEVER_TRY_AGAIN_STATUS, 0)
))
conn.close()
return
if message.offset + message.length > file_to_send.length:
conn.sendall(parser.build(
FileTransferResponseMessage(
FileTransferResponseMessage.NEVER_TRY_AGAIN_STATUS,
0)
))
conn.close()
return
conn.sendall(parser.build(
FileTransferResponseMessage(FileTransferResponseMessage
.OK_STATUS, message.length)
))
f = open(file_to_send.local_path)
f.seek(message.offset)
length_remaining_to_send = message.length
while length_remaining_to_send > 0:
length_to_send = min(length_remaining_to_send, 4096)
length_remaining_to_send -= length_to_send
conn.sendall(f.read(length_to_send))
conn.close()
def get_file(peer, f):
f.local_path = os.path.join(settings.DOWNLOAD_PATH,
os.path.split(f.name)[1])
print "Downloading to " + f.local_path
if os.path.exists(f.local_path):
print("File {filename} already exists.".format(filename=f.name))
return
sock = socket.create_connection((peer.address, peer.tcp_port))
sock.sendall(parser.build(GetFileMessage(f.sha_hash, 0, f.length)))
message_data = ""
while True:
new_data = sock.recv(1)
message_data += new_data
if new_data == parser.message_separator:
message = parser.parse(message_data)
if message.status != FileTransferResponseMessage.OK_STATUS:
print("File Request denied by peer.")
sock.close()
return
else:
break
fd = file(f.local_path, "wb")
while True:
new_data = sock.recv(1024)
if new_data:
fd.write(new_data)
else:
break
fd.close()
sock.close()
def test_events(self):
station, timetable = build("timetable_example.txt")
state = StationState(station)
state.add_timetable(timetable)
self.check_events(state, 2, [TrainEvent(2, "1437", TrainState.BeingFormed, "4", "C")])
self.check_events(state, 12, [TrainEvent(12, "1437", TrainState.Scheduled, "4", "C")])
self.check_events(state, 20, [TrainEvent(20, "1437", TrainState.Railed, "4", "C"),
TrainEvent(20, "7382", TrainState.Scheduled, "2", "B")])
self.check_events(state, 23, [TrainEvent(23, "8493", TrainState.Scheduled, "1", "A")])
def bindParser(self, name, what=""): name = name.upper() if what is None: if name in self.parsers: del self.parsers[name] else: if callable(what): fun = what else: fun = parser.build(str(what)) self.parsers[name] = new.instancemethod(fun, self, Client)
def compile(pattern, dfa=True):
"""compile a pattern to RegEx"""
from parser import build
try:
graph = build(pattern)
if not graph:
raise SyntaxError()
except SyntaxError, error:
if not error.args:
raise SyntaxError("pattern `%s` cannot be parsed" % pattern)
else:
raise error
def get_file_list(peer):
sock = socket.create_connection((peer.address, peer.tcp_port))
sock.sendall(parser.build(GetFilelistMessage()))
message_data = ""
while True:
new_data = sock.recv(1)
if not new_data:
break
message_data += new_data
if new_data == parser.message_separator:
message = parser.parse(message_data)
if message:
peerlist.update_with_file_announcement_message(message, peer)
message_data = ""
sock.close()
if __name__ == '__main__':
try:
filename = sys.argv[1] if len(
sys.argv) > 1 else "examples/example5_1.m"
file = open(filename, "r")
except IOError:
print("Cannot open {0} file".format(filename))
sys.exit(0)
lexer = scanner.Scanner()
lexer.build()
parser = parser.Parser(lexer)
parser.build()
text = file.read()
typeChecker = typechecker.TypeChecker()
try:
ast = parser.parse(text, lexer=lexer)
except:
print("Syntax error(s) occured")
else:
return_code = typeChecker.visit(ast)
if return_code == 0:
ast.accept(interpreter.Interpreter())
else:
print("Semantic errors occured ({} error(s))".format(return_code))
import sys
import parser as parser
# función de error
def error(message):
print("Error: " + message)
sys.exit()
if len(sys.argv) > 1:
# se manda el arhivo al parser
file = sys.argv[1]
parser.build(file)
else:
error("No file provided")
# se lee el resultado de los quadruplos, la tabla de ctes y symboltable
f2 = open('datos.txt', 'r', newline='\n')
data = eval(f2.read())
f2.close()
# obtiene la lista de cuádruplos
quadruples = data['quadruples']
# obtiene la tabla de símbolos
symbol_table = data['symbol_table']
# obtiene la tabla de constantes
ctes_table = data['ctes']
# int, float, char, bool
cont_vars = [0, 0, 0, 0]
path = config.data_path
# obtain the yaml skelton
with open(config.yaml_skelton_path) as f:
default_string = f.read()
# for each sample that will be generated from search space space
for i in xrange(20):
timestamp = get_timestamp()
print t.bold_red('ITERATION:'), t.bold_red(str(i)), "started at: ", timestamp
samp = sample(spa) # generate sample (will give a description of a model)
print t.bold_cyan('SAMP'), samp
mod = build(samp) # based on description generated build an object that will fit into yaml_parser
print t.bold_blue('MODEL'), mod
# define weight decay parameters. They depend on the number of layers (there is one parameter fo each layer)
weight_decay_coeffs = yp.parse_weight_decay(mod)
# generate a filename to store the best model
pkl_filename = join(config.path_for_storing, timestamp+"best_"+str(i)+'_'+".pkl")
# create dictionary with hyper parameters
hyper_params = {'model': yp.parse_to_yaml(mod), 'path': yp.parse_to_yaml(path),
'weight_decay_coeffs': weight_decay_coeffs, 'pkl_filename': pkl_filename}
# fill the yaml skelton with hyperparameters
yaml_string = default_string % hyper_params
r = ['%s%s [' % (node.name, '^' * node.plain),
",\n".join(attrs),
']'
]
return "\n".join(r)
def visit_Attr(self, node, children):
return node
if __name__ == '__main__':
lexer = spec_lexer.build()
parser = spec_parser.build()
with open('base.cfg', 'r') as f:
code = f.read()
spec_ast = parser.parse(code)
b = Indenter()
r = b.traverse(spec_ast)
with open('~base.cfg.bak', 'w') as f:
f.write(code)
with open('base.cfg', 'w') as f:
f.write(r)
def data(self):
import parser
return parser.build(self)
