def __init__(self, host, user, password="", database="zbd_project"): """Initialize database object""" # Initialize logger self.logger = Logger(__name__, loggingLevel="debug") self.logger.debug("Database logger has started.") self.connection = None # Initialize database connection try: self.logger.debug("Trying to attempt connection with database.") self.connection = pymysql.connect(host=host, user=user, passwd=password, database=database) except Exception as e: self.logger.critical(f"Could not connect to database! Error = {e}") raise ConnectionRefusedError(f"Could not connect to database! Error = {e}") self.logger.info("Database connection is stable.") self.config = dict() try: with open("config.json") as f: self.config = {**self.config, **json.load(f)} except IOError as e: self.logger.error(f"Error occured while reading config from .json file!. Error = {e}") exit(-1) self.logger.debug("Config has been read.") # Initialize global cursor self.logger.debug("Creating global cursor.") self.cursor = self.connection.cursor() self.logger.debug("Global cursor created.")
def fill_blanks(self, fill): response = copy.deepcopy(self.template) for i in range(len(self.dependent_nodes)): to_insert = "" Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i]) print(self.relation[i]) if self.dependent_nodes[i] is not None: curr_index = response.index(self.dependent_nodes[i]) if self.blanks[i] == 'Object' or self.blanks[i] == 'Character': to_insert = self.relations_blanks[0][i].name Logger.log_dialogue_model_basic( str(self.relations_blanks[0][i].name)) elif self.blanks[i] == 'IsA': to_insert = self.relations_blanks[0][i].first Logger.log_dialogue_model_basic( str(self.relations_blanks[0][i].first)) # <2 UsedFor 3> elif int(self.relation[i][0]) < int(self.relation[i][2]): to_insert = self.relations_blanks[0][i].second Logger.log_dialogue_model_basic( str(self.relations_blanks[0][i].second)) # <3 CreatedBy 2> else: to_insert = self.relations_blanks[0][i].first Logger.log_dialogue_model_basic( str(self.relations_blanks[0][i].first)) response[curr_index] = to_insert return response
def create_connection(): host = config.get_config("database-settings", "host") if host is False or host is None: logger = Logger.get_instance() logger.err("Value \"host\" must not be None") return False user = config.get_config("database-settings", "user") if user is False or user is None: logger = Logger.get_instance() logger.err("Value \"user\" must not be None") return False password = config.get_config("database-settings", "password") if password is False: logger = Logger.get_instance() logger.err("Value \"password\" has not been declared in file.config") return False database = config.get_config("database-settings", "database") if database is False or database is None: logger = Logger.get_instance() logger.err("Value \"database\" must not be None") return False return DBConnection(host, user, password, database)
def fill_blanks(self, dialogue_history): print("KA STUFF") # for x in range(len(dialogue_history)): # print(dialogue_history[x].dialogue_type) response = self.template if len(dialogue_history) < 3: return None else: print(dialogue_history[len(dialogue_history) - 3].dialogue_type) suggestion_blanks = dialogue_history[len(dialogue_history) - 3].word_relation subject = "" for x in range(len(suggestion_blanks)): print(suggestion_blanks[x]) if suggestion_blanks[x].second_token == "character": if self.blanks[0] == 'Character': subject = suggestion_blanks[x].first_token elif suggestion_blanks[x].second_token == "object": if self.blanks[0] == 'Object': subject = suggestion_blanks[x].first_token Logger.log_dialogue_model_basic("Subject: " + subject) response = [x.replace("1", subject) for x in response] return response
def __init__(self, argv): QtGui.QMainWindow.__init__(self) self.MainWindow = Ui_MainWindow self.ui = Ui_MainWindow self.MainWindow.__init__(self.window) self.setupUi(self) self.show() self.logger = Logger(self.logPanel) self.device = EthernetDevice(self.logger) self.device.disconState = QtGui.QPixmap( _fromUtf8('../res/disconnected')) self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected')) self.device.currentState = 0 self.device.power = 0 self.device.direction = 0 self.addWidgets() self.updater = DataUpdateThread(self) # create a thread self.updater.trigger.connect( self.updateState) # connect to it's signal self.updater.start() self.cam = Camera(self)
def __init__(self, agent, temp_it=CFG.temp_thresh + 1, player_name=None): self.agent = agent self.game = self.agent.game self.logger = Logger() self.temp_it = temp_it self.player_name = player_name self.tree = State(None, 1, self.game(), prior=1.0)
def listen(self): try: self.listeningSocket.bind(("127.0.0.1", 0)) except socket.error as msg: Logger.error('[GAME] Bind failed. Error : ' + str(sys.exc_info())) return (False) self.listeningSocket.listen(1)
def __init__(self, auction_id, test=False): self.auction_id = auction_id self.highest_bid = 0 self.highest_bidder = None self.bid_time = 0 self.no_bids = 0 self.test = test # suppress logging in tests self.log = Logger(id=auction_id, test=self.test) self.log.init_logfile()
def run(self): self.socket.connect((self.serverIp, self.serverPort)) self.connected = True recvData = self.socket.recv(4096) while recvData: self.parser.feed(recvData) if self.processPackets() == False: return (False) recvData = self.socket.recv(4096) self.connected = False Logger.info("[GAME] Server disconnected")
def run(self): self.socket.connect(("34.251.172.139", 443)) self.connected = True recvData = self.socket.recv(4096) while recvData: self.parser.feed(recvData) if self.processPackets() == False: return (False) recvData = self.socket.recv(4096) self.connected = False Logger.info("[REALM] Server disconnected")
def run(self): self.connected = True self.remoteServer = RealmRemoteClient(self) self.remoteServer.start() recvData = self.fd.recv(4096) while recvData: self.parser.feed(recvData) if self.processPackets() == False: return (False) recvData = self.fd.recv(4096) self.connected = False Logger.info("[REALM] Client " + self.ip + ":" + self.port + " disconnected")
def processPackets(self): newPacket = self.parser.getPacket() while newPacket: Logger.debug("[GAME] << " + newPacket) DatabaseManager().addPacket(0, newPacket) data = bytearray(newPacket.encode("utf-8")) data += b'\x00' if self.localClient.send(data) == False: self.socket.close() Logger.info("[GAME] Server disconnected") return (False) newPacket = self.parser.getPacket() return (True)
def fill_blanks(self, fill): dBOConceptGlobalImpl = DBOConceptGlobalImpl() rand_concept = dBOConceptGlobalImpl.get_random_concept() response = copy.deepcopy(self.template) for i in range(len(self.nodes)): to_insert = rand_concept.first Logger.log_dialogue_model_basic(str(to_insert)) curr_index = response.index(self.nodes[i]) response[curr_index] = to_insert return response
def processPackets(self): newPacket = self.parser.getPacket() while newPacket: Logger.debug("[REALM] >> " + newPacket) DatabaseManager().addPacket(1, newPacket) data = bytearray(newPacket.encode("utf-8")) data += b'\x00' if self.remoteServer.send(data) == False: self.fd.close() Logger.info("[REALM] Client " + self.ip + ":" + self.port + " disconnected") return (False) newPacket = self.parser.getPacket() return (True)
def fill_blanks(self, event): print(self.full_string()) # response = self.template # response = DialogueTemplateBuilder.build(*self) response = copy.deepcopy(self.template) for i in range(len(self.nodes)): to_insert = "" curr_index = response.index(self.nodes[i]) Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i]) if self.blanks[i] == 'Repeat': to_insert = self.check_subject(event.subject.name) + " " # to_insert = event.subject.name + " " if event.get_type() == EVENT_ACTION: to_insert = to_insert + str(event.verb) Logger.log_dialogue_model_basic( str(to_insert + str(event.verb))) elif event.get_type() == EVENT_CREATION: to_insert = event.subject.name Logger.log_dialogue_model_basic(str(event.subject.name)) elif event.get_type() == EVENT_DESCRIPTION: #Iterate through attributes for X in event.attributes: to_insert = to_insert + X.keyword + " " + str( X.description.lemma_) Logger.log_dialogue_model_basic( str(to_insert + X.keyword + " " + str(X.description.lemma_))) response[curr_index] = to_insert return response
def takeoff(self): try: print("takeoff") self.toggleButtonEnabled() self.drone.takeoff() except: print('Not connected to a drone') return if self.drone.navdata: self.toggleButtonEnabled() self.logger = Logger() self.begin_log() print("taking off")
def run(self): Logger.info("[DB] Starting the database...") self.db = sqlite3.connect('data.db') self.createDb() Logger.info("[DB] Waiting for data") while True: with self.condition: self.condition.wait() cursor = self.db.cursor() while self.tasks.empty() == False: task = self.tasks.get() cursor.execute( "INSERT INTO packets(direction, packet, date) VALUES(?, ?, ?);", (task[0], task[1], datetime.datetime.now())) self.db.commit()
def __init__(self): super().__init__() self.title = 'GameOfDrones Test GUI' self.left = 100 self.top = 100 self.width = 1024 self.height = 768 self.initUI() self.logger = Logger() self.drone = ARDrone(connect=True) self.drone.send(at.CONFIG('general:navdata_demo', True)) font = QFont() font.setBold(True) font.setPixelSize(18) self.setFont(font)
def __init__(self, argv): QtGui.QMainWindow.__init__(self) self.MainWindow=Ui_MainWindow self.ui=Ui_MainWindow self.MainWindow.__init__(self.window) self.setupUi(self) self.show() self.logger = Logger(self.logPanel) self.device = EthernetDevice(self.logger) self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected')) self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected')) self.device.currentState = 0 self.device.power=0 self.device.direction=0 self.addWidgets() self.updater = DataUpdateThread(self) # create a thread self.updater.trigger.connect(self.updateState) # connect to it's signal self.updater.start() self.cam = Camera(self)
class FunctionController: def __init__(self, rootWindow, database, backEvent, year): self.rootWindow = rootWindow self.backEvent = backEvent self.database = database self.year = year # Start logger self.logger = Logger(__name__, loggingLevel="debug") self.logger.debug("FunctionController logger has started.") self.functionWindow = Toplevel(self.rootWindow) self.functionWindow.title("Check a book.") self.functionWindow.protocol('WM_DELETE_WINDOW', self.goBack) self.functionWindow.bind("<<back>>", lambda _: self.backEvent()) self.data = self.database.findBestBook(self.year) values = self.database.executeStatement( f"SELECT * FROM `ksiazki` WHERE `tytul` = '{self.data[0][0][0]}'") self.finalData = dict() self.finalData["Title"] = values[0][1] self.finalData["Date"] = str(values[0][2]) self.finalData["Genre"] = values[0][3] self.finalData["Amount"] = self.data[1][0][0] self.mainFrame = Frame(self.functionWindow, bd=4, relief=RAISED, width=self.functionWindow.winfo_width(), height=self.functionWindow.winfo_height()) self.mainFrame.pack(fill='both', side=TOP) titleLabel = Label(self.mainFrame, text=f"Most hired book in year {year} is..", font=("Arial Bold", 18)) titleLabel.grid(row=0, column=0, columnspan=3, padx=40, pady=20) rowNo = 1 for no, val in self.finalData.items(): l1 = Label(self.mainFrame, text=f"{no}: {val}", font=("Arial Bold", 14)) l1.grid(row=rowNo, column=0, columnspan=3, padx=10, pady=10) rowNo += 1 def goBack(self): self.functionWindow.event_generate("<<back>>")
def get_config(setting_name, key_name): with open(config_file, "r") as file: text = file.read() pattern = re.compile("\"" + setting_name + "\":\s*\{\s*([\n \"a-zA-Z0-9.:_-]*)\s*\}") settings = pattern.finditer(text) for e in settings: settings = e.group(1).replace("\t", "").replace(" ", "").split("\n") settings = list(filter(None, settings)) # returns False if "settings_name" was not found if settings == []: logger = Logger.get_instance() logger.err("Could not find \"" + setting_name + "\" in file .config") return False # transform settings into dictionary settings_dict = {} for e in settings: # key pattern = re.compile("\"([^.*\"]*)\":") key = pattern.finditer(e) for i in key: key = i.group(1) # value pattern = re.compile("\:\s*\"([^.*\"]*)\"") value = pattern.finditer(e) for i in value: value = i.group(1) settings_dict.update({key: value}) # returns False if "key_name" was not found if settings_dict.__contains__(key_name) == False: logger = Logger.get_instance() logger.err("Could not find \"" + key_name + "\" in object \"" + setting_name + "\" in file .config") return False return settings_dict[key_name]
def parsePacket(self, packet): if len(packet) > 3 and packet[0] == 'A' and packet[ 1] == 'X' and packet[2] == 'K': Logger.debug("[REALM] onSelectServer packet detected!") encryptedIp = packet[3:11] encryptedPort = packet[11:14] ticket = packet[14:] decryptedIp = CipherManager.decryptIp(encryptedIp) decryptedPort = CipherManager.decryptPort(encryptedPort) newGameClient = GameLocalClient(decryptedIp, decryptedPort) newGameClient.listen() newEncryptedIp = CipherManager.encryptIp( newGameClient.getListeningIp()) newEncryptedPort = CipherManager.encryptPort( newGameClient.getListeningPort()) newPacket = "AXK" + newEncryptedIp + newEncryptedPort + ticket Logger.debug("[REALM] Replacing packet '" + packet + "' with packet '" + newPacket + "'") newGameClient.start() return (newPacket) return (packet)
def __init__(self, configPath, width=640, height=480): # Initialize logger self.logger = Logger(__name__, loggingLevel="debug") self.logger.debug( "===================================================================" ) self.logger.debug("Application logger has started.") self.config = dict() try: with open(configPath) as f: self.config = {**self.config, **json.load(f)} except IOError as e: self.logger.error( f"Error occured while reading config from .json file!. Error = {e}" ) exit(-1) self.logger.debug("Config has been read.") # Initialize app window self.logger.debug("Initializing application window.") self.window = Tk() self.window.title("Database Application.") self.logger.debug("Application window has been initialized.") self.window.geometry(f"{int(width)}x{int(height)}+0+0") self.window.resizable(0, 0) self.window.attributes("-topmost", True) # Setting a theme picture self.theme = Canvas(width=width, height=height, bg='black') self.theme.grid(column=0, row=0) self.imagesDict = dict() self.imagesDict["themeC"] = PhotoImage(file="theme.gif") self.imagesDict["themeG"] = PhotoImage(file="grayscale_theme.gif") self.logger.debug("Images has been loaded.") self.imageOnCanvas = self.theme.create_image( 0, 0, image=self.imagesDict["themeG"], anchor=NW) self.logger.debug("Setting grayscale theme.")
def fill_blanks(self, event): response = self.template for i in range(len(self.nodes)): to_insert = "" curr_index = response.index(self.nodes[i]) Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i]) if self.blanks[i] == 'Character': to_insert = self.check_subject( event.get_characters_involved()[0].name) # if event.get_characters_involved()[0].name.lower() == 'i': # to_insert = 'you' # else: # to_insert = event.get_characters_involved()[0].name elif self.blanks[i] == 'Object' or self.blanks[i] == 'Item': to_insert = event.get_objects_involved()[0].name Logger.log_dialogue_model_basic( str(event.get_objects_involved()[0].name)) elif self.blanks[i] == 'Event': to_insert = self.check_subject(event.subject.name) + " " + str( event.verb.lemma_) # to_insert = event.subject.name + " " + str(event.verb.lemma_) elif self.blanks[i] == 'Repeat': to_insert = self.check_subject(event.subject.name) + " " # to_insert = event.subject.name + " " if event.get_type() == EVENT_ACTION: to_insert = to_insert + str(event.verb) elif event.get_type() == EVENT_CREATION: to_insert = event.subject.name elif event.get_type() == EVENT_DESCRIPTION: #Iterate through attributes for X in event.attributes: to_insert = to_insert + X.keyword + " " + str( X.description.lemma_) response[curr_index] = to_insert return response
def setup(self): self.log = Logger('./%s.log') # import the two players from src.Players.Dave2Player import Dave2Player from src.Players.Dave2Player_old import Dave2Player_old self.bot1 = Dave2Player() # your player! self.bot2 = Dave2Player_old() test_map = 'M 1 0 0 0\n'\ + 'P 10 10 1 1 119 4\n'\ + 'P 10 20 2 0 100 5\n'\ + 'P 20 10 3 0 100 5\n'\ + 'P 20 20 4 2 119 4\n' self.pw = PlanetWars(test_map, logger=self.log.turn)
def __init__(self, host, user, password, database): self.logger = Logger.get_instance() try: self.connection = mysql.connector.connect( host=host, user=user, password=password, database=database, ) self.cursor = self.connection.cursor() self.logger.log('connection to database established') except: self.logger.err('failed to establish a connection to the database') exit(2)
def flow_handler(args): if len(args) == 1: print("1 positional argument missing!") print("\tuse_captured_video: detection on captured video\n\tuse_onboard_camera: detection on real-time video " "from tx2 camera\n\tuse_local_rtsp: detection on captured video with rtsp server") return father_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) log = Logger(father_dir + '/results/log/smart_parking.log', 'info') if args[1] == 'use_captured_video' or args[1] == 'use_onboard_camera' or args[1] == 'use_local_rtsp': detection_pipeline(log, args=args) else: print("\tuse_captured_video: detection on captured video\n\tuse_onboard_camera: detection on real-time video " "from tx2 camera\n\tuse_local_rtsp: detection on captured video with rtsp server") return
def get_rel_list(self, init_list, relation): # TODO: Randomizer should not be here temp_list = [] for X in init_list: if len(X) > int(relation[0]) - 1: print("X len is: ", len(X)) curr_refer = X[int(relation[0]) - 1] # idk if dapat may randomizer dito # curr_refer = np.random.choice(curr_refer_list) if type(curr_refer) == Character or type(curr_refer) == Object: print("testing: ", curr_refer.name) temp_list.append( self.dbo_concept.get_concept_by_first_relation( curr_refer.name, relation[1])) else: print("testing: ", curr_refer.first) temp_list.append( self.dbo_concept.get_concept_by_first_relation( curr_refer.first, relation[1])) else: for items in range(len(X)): if isinstance(X[items], LocalConcept): curr_refer = X[items] print("testing: ", curr_refer.second) temp_list.append( self.dbo_concept.get_concept_by_second_relation( curr_refer.second, relation[1])) Logger.log_dialogue_model_basic_example( "List of all Valid Relations: ") if (len(temp_list)) > 0: for x in range(len(temp_list[0])): Logger.log_dialogue_model_basic_example(str(temp_list[0][x])) updated_list = [] if (len(temp_list)) > 0: if (len(temp_list[0])) > 0: updated_list.append(np.random.choice(temp_list[0])) Logger.log_dialogue_model_basic_example("Chosen Relation: ") Logger.log_dialogue_model_basic_example(str(updated_list[0])) return updated_list
def get_backup_files_list(): with open(config_file, "r") as file: config_text = file.read() match = __get_contents__("match", config_text) include = __get_contents__("include", config_text) exclude = __get_contents__("exclude", config_text) # returns False if no files were found if match == [] and include == []: logger = Logger.get_instance() logger.err("Could not find any files to back-up in file .config\nPlease include the object \"include\" or \"match\" in file .config") return False # gets a list of all the files which require a back-up files_path = "files" files = [f for f in listdir(files_path) if isfile(join(files_path, f))] files_to_backup = [] # match for e in match: for file in files: if file.__contains__(e): files_to_backup.append(file) # include for e in include: for file in files: if file == e: files_to_backup.append(e) files_to_backup = list(dict.fromkeys(files_to_backup)) # exclude for e in exclude: for file in files: if file == e: files_to_backup.remove(e) files_to_backup = [files_path + "/" + f for f in files_to_backup] return files_to_backup
def start(self): try: self.socket.bind(("127.0.0.1", 12345)) except socket.error as msg: Logger.error('[REALM] Bind failed. Error : ' + str(sys.exc_info())) return (False) self.socket.listen(16) Logger.info("[REALM] Listening on port 12345...") while True: fd, addr = self.socket.accept() ip, port = str(addr[0]), str(addr[1]) Logger.info('[REALM] New incomming connection: ' + ip + ':' + port) newClient = RealmLocalClient(fd, addr, ip, port) newClient.start() self.socket.close()
def run(self): Logger.info("[GAME] Listening on " + self.getListeningIp() + ":" + str(self.getListeningPort()) + "...") self.fd, self.addr = self.listeningSocket.accept() self.ip, self.port = str(self.addr[0]), str(self.addr[1]) Logger.info('[GAME] New incomming connection: ' + self.ip + ':' + self.port) self.listeningSocket.close() self.connected = True self.remoteServer = GameRemoteClient(self, self.serverIp, self.serverPort) self.remoteServer.start() recvData = self.fd.recv(4096) while recvData: self.parser.feed(recvData) if self.processPackets() == False: return (False) recvData = self.fd.recv(4096) self.connected = False Logger.info("[GAME] Client " + self.ip + ":" + self.port + " disconnected")
class ControlApp(QtGui.QMainWindow, Ui_MainWindow): #def values camDirectionAngle=0 keylist = [] cam = None updater = None def __init__(self, argv): QtGui.QMainWindow.__init__(self) self.MainWindow=Ui_MainWindow self.ui=Ui_MainWindow self.MainWindow.__init__(self.window) self.setupUi(self) self.show() self.logger = Logger(self.logPanel) self.device = EthernetDevice(self.logger) self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected')) self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected')) self.device.currentState = 0 self.device.power=0 self.device.direction=0 self.addWidgets() self.updater = DataUpdateThread(self) # create a thread self.updater.trigger.connect(self.updateState) # connect to it's signal self.updater.start() self.cam = Camera(self) def addWidgets(self): """ В этом методе мы добавляем виджеты и wприсоединяем обработчики сигналов. Обработчик сигнала для виджета так же называется "слотом" """ #camview setup #path="C:\\Users\\SCB\\Downloads\\test.avi" path=QtCore.QUrl("rtsp://192.168.2.100:7070/") media = Phonon.MediaSource(path) self.videoPlayer.load(media) self.videoPlayer.play() #set maps properties url = "res.gmap.html" page = QtCore.QUrl("../res/gmap.html") self.mapView.load(page) #thumper pic myPixmap = QtGui.QPixmap(_fromUtf8('../res/thumper_top.jpg')) self.thumperImage.setPixmap(myPixmap) self.thumperImage.setScaledContents(True) #camDirection myPixmap = QtGui.QPixmap(_fromUtf8('../res/cam.png')) myPixmap = myPixmap.transformed(QtGui.QTransform().rotate(self.camDirectionAngle)) self.camDirection.setPixmap(myPixmap) self.camDirection.setScaledContents(True) #logger self.actionSaveLog.triggered.connect(self.saveLog) self.actionSaveLog.setShortcut('Ctrl+S') #define menu actions self.actionExit.triggered.connect(self.exitApp) self.actionExit.setShortcut('Ctrl+Q') #device state #self.connectStateIndicator.connect(self.connectStateIndicator, QtCore.SIGNAL("") self.connectStateIndicator.setPixmap(self.device.disconState) self.connectStateIndicator.setScaledContents(True) self.actionConnect.triggered.connect(self.changeConnectionState) self.actionConnect.setShortcut('F5') self.resetTelemetry() #get state self.actionBattery.triggered.connect(self.addMarkerWithLabel) #init direction level (altitude direction indicator) #init battery state #self.actionBattery.setShortcut('R') def keyPressEvent(self, event): if event.key() not in self.keylist: self.keylist.append(event.key()) self.processmultikeys(self.keylist) def keyReleaseEvent(self, event): if event.key() in self.keylist: if not event.isAutoRepeat(): self.keylist.remove(event.key()) self.processmultikeys(self.keylist) def processmultikeys(self, keyspressed): #TODO send eth control print(self.keylist) Key_G = QtCore.Qt.Key_G in self.keylist Key_J = QtCore.Qt.Key_J in self.keylist Key_Y = QtCore.Qt.Key_Y in self.keylist Key_H = QtCore.Qt.Key_H in self.keylist Key_Q = QtCore.Qt.Key_Q in self.keylist Key_E = QtCore.Qt.Key_E in self.keylist Key_R = QtCore.Qt.Key_R in self.keylist Key_W = QtCore.Qt.Key_W in self.keylist Key_S = QtCore.Qt.Key_S in self.keylist self.device.power = 0 + Key_W - Key_S Key_A = QtCore.Qt.Key_A in self.keylist Key_D = QtCore.Qt.Key_D in self.keylist Key_I = QtCore.Qt.Key_I in self.keylist self.device.direction = 0 + Key_A - Key_D Key_SPACE = QtCore.Qt.Key_Space in self.keylist if(self.device.isConnected()): self.device.movePD(1 + Key_W - Key_S, 1 + Key_A - Key_D) print("ololololololo"+str(Key_W) +"|"+ str(QtCore.Qt.Key_W)) self.cam.zdirection = 0 + Key_Q - Key_E self.cam.hdirection = 0 + Key_G - Key_J self.cam.vdirection = 0 + Key_Y - Key_H if(Key_I): self.cam.moveReset(); else: if(Key_R): self.cam.home(); else: self.cam.move(); def closeEvent(self, event): # do stuff self.updater.stop() self.updater.wait() self.device.destroy() print("Goodby, World!") sys.exit() def exitApp(self): self.updater.stop() self.updater.wait() self.device.destroy() print("Goodby, World!") sys.exit() def saveLog(self): self.logger.save() def updateState(self): BatteryState = self.device.getBatteryState() self.leftBatteryState.setValue(int(BatteryState[0])) self.rightBatteryState.setValue(int(BatteryState[1])) self.obstacleLeftTop.setValue(10) self.obstacleRightTop.setValue(10) self.obstacleTop.setValue(10) self.obstacleBottom.setValue(10) #if BatteryState[0] <= 7000: # self.logger.append("Low left battery level") #if BatteryState[1] <= 7000: # self.logger.append("Low right battery level") def addMarkerWithLabel(self): doc = self.mapView.page().mainFrame().documentElement() #user = doc.findFirst("div[id=map_canvas]") #user.evaluateJavaScript("panTo(new google.maps.LatLng(51.98646, 81.90669));") def resetTelemetry(self): self.obstacleLeftTop.setValue(0) self.obstacleRightTop.setValue(0) self.obstacleTop.setValue(0) self.obstacleBottom.setValue(0) def changeConnectionState(self): if(self.device.isConnected()): self.device.disconnect() self.connectStateIndicator.setPixmap(self.device.disconState) self.actionConnect.setText("Connect") self.actionConnect.setShortcut('F5') self.device.currentState = 0 self.resetTelemetry() else: if self.device.connect() == 0: self.connectStateIndicator.setPixmap(self.device.conState) self.actionConnect.setText("Disconnect") self.actionConnect.setShortcut('Ctrl+D')