def __init__(self, name, id_sd=-1):
LogThread.__init__(self, name)
id_sd = int(id_sd)
# Initializing architecture stuff
parser = Parser().getInstance()
try:
sd_instance = parser.read_smartdirections_instance(id_sd)
except:
print("ERROR: wrong SD ID")
raise Exception()
#building = list(filter(lambda b: b.id == idBuilding, parser.read_sd_buildings()))
#assert len(building) == 1, "Something wrong"
self.sd_instance = sd_instance
self.sd_instance.initRouting()
# Initializing mqtt protocol
self.client = mqtt.Client()
self.client.username_pw_set(username="******", password="******")
self.client.connect(BROKER_IP, 1884, 60)
self.client.on_connect = self.on_connect
self.client.on_message = self.on_message
# start timer executing localization thread
t1 = threading.Thread(target=self.run_timer)
t1.start()
def question_handler():
question = request.get_json()
user_input = question["user_input_value"]
parser = Parser(user_input)
parsed_question = parser.parse()
if parsed_question != "ignore":
try:
gmaps = GmapsFetcher(parsed_question)
gmaps_json_data = gmaps.get_json_data()
if gmaps_json_data != "ZERO_RESULTS":
mwiki = MwikiFetcher(gmaps_json_data[1])
info = mwiki.get_page_id_and_title()
extract = mwiki.get_extract(info[0], info[1])
print(extract)
return jsonify(gmaps_json_data[0], gmaps_json_data[1], extract)
else:
return jsonify(gmaps_json_data)
except (KeyError, ConnectionError):
return jsonify("error")
else:
return jsonify("ignore")
def __init__(self, sd_instance, model_name='kb', name='wifi_ble'):
self.parser = Parser().getInstance()
self.model_name, self.name = model_name, name
self.sd_instance = sd_instance
self.id_sd = self.sd_instance.id
try:
self.model_predict_building = self.parser.load_sd_model(self.id_sd)
except:
print("WARNING: init SD model from scratch")
self.model_predict_building = self.__train_sd_model(True)
try:
self.models_building_floor = self.parser.load_building_floor_models(
self.id_sd)
except:
print("WARNING: init building models from scratch")
self.models_building_floor = {
b.id: self.__train_building_floor_model(b.id, True)
for b in self.sd_instance.buildings
}
try:
self.models_building = self.parser.load_building_models(self.id_sd)
except:
print("WARNING: init building models from scratch")
self.models_building = self.__train_all_building_models(True)
def func():
parser = Parser()
client = self.mode['clients'][id - 1]
print(f'SERVER START receiving FROM CLIENT-{id}...')
while self.status['connected'][id]:
# receive and parse msg
try:
msg_strs = parser.parse(client['socket'].recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
print('\tJSON Decode Error!')
continue
# deal with msg
for msg_str in msg_strs:
msg = json.loads(msg_str)
if msg['tag'] == 'close':
self.status['connected'][id] = False
if msg['tag'] == 'move':
self.command.add(
(tuple(msg['move'][0]), tuple(
msg['move'][1]), msg['move'][2]), id)
elif msg['tag'] == 'clear':
self.command.clear_command(id)
print(f'SERVER END receiving FROM CLIENT-{id}...')
def start():
# initializing nodes
data_path = "../assets/"
parser = Parser(data_path).getInstance()
parking_container = parser.read_parking_container()
subscriberThread = MQTTSubscriber("MQTT", parking_container)
subscriberThread.start()
def receive(self):
parser = Parser()
print('CLIENT START receiving...')
while self.connected['connected']:
# receive messages
try:
msgs = parser.parse(
self.mode['connect']['socket'].recv(1 << 20))
except socket.timeout:
continue
except OSError:
break
# process the messages
for msg in msgs:
if msg == 'pause':
self.paused = not self.paused
# close socket
elif msg == 'close':
pass
# self.connected['connected'] = False
# update status
elif msg.startswith('time'):
self.time = msg[4:]
elif msg.startswith('info'):
info = json.loads(msg[4:])
self.score, self.time = info['score'], info['time']
elif msg.startswith('end'):
info = json.loads(msg[3:])
self.win, self.score, self.time = info['win'], info[
'score'], info['time']
else:
status = json.loads(msg)
self.set_status(status)
print('CLIENT END receiving...')
def receive(self):
parser = Parser()
print(f'CLIENT START receiving FROM SERVER...')
while self.status['connected']:
# receive and parse msg
try:
msg_strs = parser.parse(self.mode['socket'].recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
print('\tJSON Decode Error!')
continue
# deal with msg
for msg_str in msg_strs:
msg = json.loads(msg_str)
if msg['tag'] == 'close':
self.close()
elif msg['tag'] == 'status':
self.map.turn = msg['turn']
self.map.set_status(msg['status'])
self.command.trim(msg['cc'])
elif msg['tag'] == 'init':
self.map_status = msg['status']
elif msg['tag'] == 'conquer':
self.map.conquer(msg['players'][0], msg['players'][1])
self.status['winner'] = self.map.get_winner()
elif msg['tag'] == 'pause':
self.status['paused'] = not self.status['paused']
print(f'CLIENT END receiving FROM SERVER...')
def receive(self):
parser = Parser()
print('CLIENT START receiving...')
while self.connected['connected']:
# receive messages
try:
msgs = parser.parse(self.mode['connect']['socket'].recv(1 << 20))
except socket.timeout:
continue
except OSError:
break
# process the messages
for msg in msgs:
if msg == 'pause':
self.paused = not self.paused
# close socket
elif msg == 'close':
continue
# update status
else:
status = json.loads(msg)
self.set_status(status)
# refresh pan
self.refresh_pan()
print('CLIENT END receiving...')
def start():
# initializing nodes
data_path = "assets/"
parser = Parser(data_path).getInstance()
node = parser.read_node()
subscriberThread = MQTTPublisher("MQTT", node)
subscriberThread.start()
def load_graph(graph):
parser = Parser()
while True:
start = input('Unesite root dir: ')
if os.path.isdir(start):
for fname in os.listdir(start):
curr = os.path.join(start, fname)
if os.path.isdir(curr) or curr.endswith('.html'):
break
else:
err('Nije validna putanja')
break
else:
err('Nije validna putanja')
current = 0
for root, dirs, files in os.walk(start):
for file in files:
current = loading_rotation(current, 'Ucitavanje grafa...')
if file[-5:] == '.html':
path = root + os.path.sep + file
path_root = os.path.abspath(os.path.dirname(path))
filepath = path_root + os.path.sep + file
links, words = parser.parse(path)
# NOTE(Jovan): Informacije o stranici pretvaraju se u vertex
vertex = Vertex(filepath, words, links)
graph.add_vertex(vertex)
graph.gen_backlinks()
loading_rotation(current,
col.bold + col.green + 'Ucitavanje zavrseno' + col.rst)
print()
return graph.vertex_count()
def receive(self, ip, client_socket):
parser = Parser()
while self.status == 'accepting' and ip in self.ip_list():
# receive and parse msg
try:
msg_strs = parser.parse(client_socket.recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
print('JSON Decode Error!')
continue
# deal with msg
for msg_str in msg_strs:
msg = json.loads(msg_str)
if msg['tag'] == 'quit':
self.clients.remove([ip, client_socket])
print(f'THREAD ABORTS: server.receive(ip={ip})')
return
elif msg['tag'] == 'start-game':
self.status = 'game'
break
# check abort
if self.status == 'abort':
print(f'THREAD ABORTS: server.receive(ip={ip})')
return
while self.game is None:
pass
print(f'THREAD ENDS: server.receive(ip={ip})')
def start():
# initializing nodes
parser = Parser().getInstance()
id_sd = 0
sd_instance = parser.read_smartdirections_instance(id_sd)
subscriberThread = MQTTSubscriber("MQTT", sd_instance.id)
subscriberThread.start()
def test_parse_auto(self):
iterator = 0
for questions in mock_questions_list:
self.parser_test = Parser(questions)
test_result = self.parser_test.parse()
expected_result = expected_results[iterator]
self.assertEqual(test_result, expected_result)
iterator += 1
def saveBuildings(self, close_window = False):
self.sd_instance.name = self.nameEntry.get()
Parser().getInstance().write_sd_buildings(self.sd_instance)
if close_window:
if self.isUpdate:
self.master.edit_sd_instance(self.sd_instance)
else:
self.master.add_sd_instance(self.sd_instance)
self.sd_instance = None
self.destroy()
def test_parser_1(caplog):
p = Parser('examples/problem.yaml', 'examples/instance.yaml')
assert p.rawProblem.name == "labirinth"
assert p.rawInstance.size == 2
assert len(p.problem.types) == 2
p.problem.setTypes(p.rawProblem.types)
assert "position" in p.problem.types
instantiated_variables = p.problem.instantiateVar(p.rawProblem.variables,
p.rawInstance.variables)
assert "treasure_0" in instantiated_variables
assert "treasure_1" in instantiated_variables
assert len(instantiated_variables) == 8
def __init__(self, listen_port, path):
self._controller_listen_port = listen_port
# Root directory of the controller
self._sys_root = os.path.dirname(os.path.abspath(__file__))
# Load system configuration
self._system_conf = self._sys_root + "/" + path
self._federazione = None
self._customers = None
self._dp_to_customer = {
} # chiave :(id datapath, ingress_port) valore: customer
self._controller = None
# Create parser object
self._parser = Parser(self._controller_listen_port)
def func():
parser = Parser()
client = self.mode['connect']['clients'][i]
print(f'SERVER START receiving FROM C{i}...')
while self.connected['connected']:
try:
events_strs = parser.parse(client['socket'].recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
continue
for events_str in events_strs:
events = json.loads(events_str)
self.players[i + 1].process_pressed(
events['key-pressed'], events['key-down'])
print(f'SERVER END receiving FROM C{i}...')
def main():
# Initialize parser
parser = Parser()
# Get parsed arguments
hosts = parser.hosts
ports = parser.ports
discovery = parser.host_discovery
stype = parser.scan_type
rand_ips = parser.rand_ips
rand_ports = parser.rand_ports
# Initialize scanner with user defined settings
scanner = Scanner(discovery, stype, rand_ips, rand_ports)
# Scan and get output from scan
output = scanner.scan(hosts, ports)
# Print output
names = output['Host'].unique().tolist()
for name in names:
host_output = output.loc[output['Host'] == name]
summary = host_output.groupby(['Host', 'Status'])
summary = summary.agg({
'Status': ['count']
}).rename(columns={
'Status': '',
'count': ''
})
open_ports = host_output.loc[output['Status'] == 'open']
closed_ports = host_output.loc[output['Status'] == 'closed']
filtered_ports = host_output.loc[output['Status'] == 'filtered']
print(summary)
print('\n%s\t%s\t%s' % ('Port', 'Desc', 'Status'))
for _, row in open_ports.iterrows():
print('%d\t%s\topen' % (row['Port'], row['Description']))
if parser.show_closed:
for _, row in closed_ports.iterrows():
print('%d\t%s\tclosed' % (row['Port'], row['Description']))
for _, row in filtered_ports.iterrows():
print('%d\t%s\tfiltered' % (row['Port'], row['Description']))
# Save output file
if parser.output:
save_csv(output)
def receive(self):
parser = Parser()
end = False
while not end:
try:
msg_strs = parser.parse(self.client.recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
print('\tJSON Decode Error!')
continue
# deal with msg
for msg_str in msg_strs:
msg = json.loads(msg_str)
if msg['tag'] == 'status':
self.set_status(msg['status'])
elif msg['tag'] == 'end-game':
end = True
print(f'THREAD ENDS: player[{self.id}].sprites.game.receive()')
def main():
args = argv()
if args.replay:
replay(args.replay)
else:
# Create a TCP/IP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind the socket to the port
server_address = ('', int(args.port))
print(colors.Green + "Server Starting on: ", server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen(5)
while True:
# Wait for a connection
print(colors.Blue + 'waiting for a connection' + colors.White)
connection, client_address = server.accept()
try:
print(colors.Green + 'connection from ', client_address[0],
'on Port ', client_address[1])
# Receive the data in small chunks and retransmit it
while True:
data = connection.recv(1024)
if data:
p = Parser(data)
tlv_blob = p.parse()
p.print_parsed_data(tlv_blob, client_address)
JSON.write_json(tlv_blob, client_address)
# print('sending data back to the client')
connection.sendall(data)
else:
print(colors.Red + 'no more data from', client_address)
break
finally:
# Clean up the connection
connection.close()
def receive(self, player_id):
parser = Parser()
while self.players[player_id].alive:
# receive and parse msg
try:
msg_strs = parser.parse(self.clients[player_id][1].recv(1 << 20))
except socket.timeout:
continue
except json.decoder.JSONDecodeError:
print('\tJSON Decode Error!')
continue
# deal with msg
for msg_str in msg_strs:
msg = json.loads(msg_str)
if msg['tag'] == 'command':
self.execute(player_id, msg['command'])
elif msg['tag'] == 'pause':
if player_id == 0:
self.toggle_pause()
print(f'THREAD ENDS: game.game.receive(player_id={player_id})')
def loadFromFile(self):
path_directory = filedialog.askdirectory(
) #askopenfilename(initialdir = "assets/",title = "Select directory",filetypes = [("Txt files", ".txt")])
path_floors, path_mesh = join(path_directory, 'floors.txt'), join(
path_directory, 'mesh.txt')
if os.path.isfile(path_floors) and os.path.isfile(path_mesh):
parser = Parser("").getInstance()
floors = parser.read_floors_z(path_floors)
points = parser.read_points_from_txt(path_mesh, floors=floors)
self.set_building(
Building(id=self.id,
latitude=0,
longitude=0,
points=points,
floors=floors,
name="Nuovo edificio - {}".format(self.id)))
self.confirm_building()
else:
messagebox.showerror(
"error",
"Directory must contain floors.txt and mesh.txt in the correct format"
)
'type': float,
'default': 2.0,
'help': 'Regularization for the matrix sqrt algorithm'
}],
[('--reg2', ), {
'type': float,
'default': 1E-8,
'help': 'Regularization for the gradient of the bures metric'
}],
[('--log_period', '-lp'), {
'type': int,
'default': 50,
'help': 'Logging period'
}]]
argparser = Parser("Deep Elliptical Embeddings")
argparser.add_arguments(args)
opt = argparser.get_dictionary()
viz = Visdom(port=8098)
vm = VisualManager(viz, 'marco')
root = r'/mnt/DATA/Prob_IR/'
context_dataset_name = r'context_data'
encoded_docs_filename = r'encoded_docs_model'
word_index_filename = r'word_index'
emb_filename = r'embeddings_dim_' + str(opt['dim']) + '_margin_' + str(
opt['margin'])
emb_path = os.path.join(root, emb_filename)
context_dataset_path = os.path.join(root, context_dataset_name)
def saveSDInstances(self):
Parser().getInstance().write_sd_instances(self.sd_instances)
def getSDInstances(self):
return Parser().getInstance().read_smartdirections_instances()
def delete(self):
to_delete = self.sd_instances.pop(self.indexSelected)
Parser().getInstance().clear_sd(to_delete)
self.saveSDInstances()
self.showList()
def generator():
for soup in self.soup_list:
yield Parser(soup)
def load_and_verify(problem: str, instances: str):
p = Parser(problem, instances)
print(p.problem)
from utils.parser import Parser
if __name__ == "__main__":
data_path = "../assets/"
parser = Parser(data_path).getInstance()
parking_container = parser.read_parking_container()
def input_filename(self, P):
"""Check the content of the input widget to verify that it is valid
with the rules of the application.
Arguments:
- P (str): Value of the entry if the edit is allowed
Returns:
- str: Output text processed by application rules
"""
user_input = P
date_format, alert = self.view.get_format_date()
if alert:
self.view.statusbar.var_alert.set(alert)
self.view.statusbar.update()
else:
self.view.statusbar.var_alert.set("")
counter = int(self.view.params.start_sbox.get())
step = int(self.view.params.step_sbox.get())
digits = self.view.params.digits_sbox.get()
if sys.platform == "win32":
self.view.check_valid_characters_filename(user_input)
for index, initial in enumerate(self.initial_filenames):
dirname, filename = os.path.split(initial)
filename, ext = os.path.splitext(filename)
self.parser = Parser(self.changed_filenames, user_input, filename,
dirname)
# Name [n]
temp_input = self.parser.name_n(ext, index)
# Name from first character [nX]
temp_input = self.parser.name_truncate_x(temp_input, ext, index)
# Name from last character [n-X]
temp_input = self.parser.name_last_x(temp_input, ext, index)
# Name from n character [n,X]
temp_input = self.parser.name_start_x(temp_input, ext, index)
# Add counter
temp_input = self.parser.add_counter(temp_input, digits, counter,
ext, index)
counter += step
# Add date
try:
temp_input = self.parser.add_date(temp_input, date_format, ext,
index)
except TypeError:
pass
self.replace_filename = self.changed_filenames[:]
self.populate_treeview(self.replace_filename)
return True
