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