def extractZip(zipFile, password): try: zipFile.extractall(pwd=password) stdout.write('[+] Pass : %s' % password.decode()) Thread._stop() except: pass
def index(): if request.method == 'POST': id = request.form['uid'] n = request.form['n'] text = request.form['feedback'] print id, n, text time = int(n) * 1500 #theek hai? print time if checkAll(uid=str(id), n=int(n), text=str(text)): print "OK" try: thread = Thread(target=fayat, args=(str(id), int(n), str(text))) thread.start() # fayat(userid=str(id),n=int(n),text=str(text)) return render_template('rocket.html', time=time, uid=str(id)) except: try: thread._stop() except: pass return '<script>alert("error");</script>' else: print "err?" return '''<script>alert("We had a problem processing your request! Possible reasons - User does not exist, feedback text length is greater than 200 or total flood rate is greater than 200. ;)"); var meta = document.createElement('meta'); meta.httpEquiv = "REFRESH"; meta.content = "0;URL=https://www.floodsayat.me"; document.getElementsByTagName('head')[0].appendChild(meta); </script>''' return render_template('index.html')
def FastDownload(filename, url): t = Thread(target=ImageDownload, args=( filename, url, )) t.setDaemon(False) t.start() t.join() t._stop()
def abort_executing_thread(thread: threading.Thread): """Abort the thread execution. Args: thread (threading.Thread): The thread to abort. """ # FIXME: Not recommended since _stop might be removed. thread._reset_internal_locks(False) thread._stop()
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self, *args, obj=None, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.setupUi(self) # Button callbacks self.rekeyButton.clicked.connect(self.rekeyButtonCallback) self.runClientButton.clicked.connect(self.runClientCallback) self.sendButton.clicked.connect(self.sendCommandCallback) self.client = None self.isClientUp = False def rekeyButtonCallback(self): # self.textBrowser.append("Rekey issued from client") self.sendEncryptedCommand("rekey") self.rekey() # TODO (Erkut): Implement rekey def rekey(self): if(self.isClientUp): self.textBrowser.append("Rekeying ...") self.client.rekey() else: self.textBrowser.append("Client not running") def sendCommandCallback(self): text = self.commandPlainTextEdit.toPlainText() # self.textBrowser.append(text + " message sent to client") self.sendEncryptedCommand(text) def runClientCallback(self): if(not self.isClientUp): self.client = Client(self) self.clientThread = Thread(target = self.client.run, args =()) self.clientThread.start() if(self.client.isConnected): self.textBrowser.append("Client stated") self.isClientUp = True self.runClientButton.setStyleSheet("background-color : green") self.runClientButton.setText("Client Running") else: self.textBrowser.append("Client already running") def sendEncryptedCommand(self, msg): self.textBrowser.append("Sending encrypted message: " + msg) if(self.isClientUp): self.client.sendData(msg) else: self.textBrowser.append("Client not connected cannot send message") def closeEvent(self, event): if(self.isClientUp): self.client.terminate() # TODO (Vatan): Fix assertion error self.clientThread._stop()
def run(self): server = Thread(target=self._start_server) server.daemon = True server.start() try: while True: frames = self._get_frames() if not self.requests.empty(): self._process_requests(frames) finally: self.pipeline.stop() server._stop()
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self, *args, obj=None, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.setupUi(self) # Button callbacks self.rekeyButton.clicked.connect(self.rekeyButtonCallback) self.runServerButton.clicked.connect(self.runServerCallback) self.sendButton.clicked.connect(self.sendCommandCallback) # Server self.serverRunning = False self.server = None def rekeyButtonCallback(self): self.sendEncryptedCommand("rekey") self.rekey() def rekey(self): if(self.serverRunning == True): self.textBrowser.append("Rekeying ...") self.server.rekey() else: self.textBrowser.append("Server not running") def sendCommandCallback(self): text = self.commandPlainTextEdit.toPlainText() self.sendEncryptedCommand(text) def runServerCallback(self): if(not self.serverRunning): self.server = Server(self) self.serverThread = Thread(target = self.server.run, args =()) self.serverThread.start() # ? Check if server started self.serverRunning = True self.textBrowser.append("Server started") self.runServerButton.setStyleSheet("background-color : green") self.runServerButton.setText("Server Running") else: self.textBrowser.append("Server already running") def sendEncryptedCommand(self, msg): self.textBrowser.append("Sending encrypted message: " + msg) if(self.serverRunning): self.server.sendData(msg) else: self.textBrowser.append("Server not running") def closeEvent(self, event): if(self.serverRunning): self.server.terminate() self.serverRunning = False # TODO (Vatan): Fix assertion error self.serverThread._stop()
def FastGetSoup(url): q = Queue() t = Thread(target=GetSoup, args=(q, url, )) t.start() soupObj = q.get() t.join() t._stop() return soupObj
def run(self): user_input = input('Informe a operação: ') self.user_input = user_input while True: responses = Queue() main_thread = Thread(target=self.req_handle, args=(responses,)) main_thread.start() main_thread.join(timeout=2) main_thread._stop() if responses.qsize() > 0: break
def run(self): server = Thread(target=self._start_server) server.daemon = True server.start() try: while True: sample = self._get_sample() self.buffer.append(sample) if not self.requests.empty(): self._process_requests() finally: self.stream.stop_stream() self.stream.close() self.audio.terminate() server._stop()
def executar(self): entrada = input('Operacao: ') self.entrada = entrada while True: responses = Queue() main_thread = Thread(target=self.request, args=(responses, )) main_thread.start() main_thread.join(timeout=2) main_thread._stop() if responses.qsize() > 0: break
class WebSocket: def __init__(self, host, port, maxWebsockets, socketsTTL, processor): self.sockets=TTLCache(maxsize=maxWebsockets, ttl=socketsTTL) self.t=None self.host=host self.port=port self.processor=processor def start(self): self.t=Thread(target=self.serve_forever) self.t.start() logging.info("WEBSOCKET STARTED IN "+self.host+":"+str(self.port)) def stop(self): self.t._stop() def serve_forever(self): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) start_server = websockets.serve(self.handler, self.host, self.port) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever() async def handler(self, websocket, path): while True: data = await websocket.recv() logging.info("WEBSOCKET RECEIVED "+data) jsonData=json.loads(data) token=jsonData["token"] if token in self.sockets: self.sockets[token].close() self.sockets[token]=websocket self.processor.checkPermissions(token) async def send(self, data, token): socket = self.sockets.get(token) if socket: await socket.send(data) def getUsers(self): return self.sockets.keys() def delToken(self, token): if token in self.sockets: self.sockets[token].close() del self.sockets[token]
def spawn_crawl_processes(self, html2txt, metas, proc, wait_courtesy): processes = [] for i in range(0, proc): e = Event() p = Process(None, self._sub_crawl, None, (), {"queue": self.seed.q, "storage": self.storage, "end_event": e, \ "wait": wait_courtesy, "html2txt": html2txt, "metas": metas}) p.start() processes.append({"proc": p, "event": e, "id": i}) monitor = Thread(group=None, target=self._monitore_processes, name=None, args=(), kwargs={"processes": processes}) monitor.start() while not self.crawling_process_over: # If all processes are over, or if getting an element # from queue takes more than timeout seconds (which seems empirically abnormal) # then crawl is finished. c = 0 for p in processes: if not p["proc"].is_alive(): c += 1 if c >= len(processes): self.logger.warning("All processes are dead !") break try: el = self.storage.get(block=True, timeout=5) yield el except Empty: if self.storage.empty(): pass self.logger.debug("joining processes...") for p in processes: if p["proc"].is_alive(): p["proc"].terminate() p["proc"].join() # Finally, joining monitoring thread monitor.join(3) if monitor.is_alive(): monitor._stop()
def send(): print(os.listdir('downloads/')) filepath = 'downloads/' filename = input("\nInserisci il nome del file da inviare: ") destSend = input("Inserisci l'indirizzo base 32 a cui connettersi: ") server_address = destSend print('connessione a {}'.format(*server_address)) #Crea un socket TCP/IP per peer sendS = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sendS.setblocking(True) sendS.settimeout(10) port = i2pSupporter.getFreePort() th = Thread(target=i2pSupporter.i2pClientTunnel, args=(port, destSend)) th.start() time.sleep(5) try: sendS.connect(("127.0.0.1", port)) except: th._stop() print("Host non raggiungibile oppure momentaneamente occupato\n") main() sendS.settimeout(None) print("Connessione a {} riuscita".format(*server_address)) if os.path.exists(filepath) and os.path.isfile(filepath + filename): sendS.sendall(filename.encode('utf-8')) time.sleep(2) f = open(filepath + filename, 'rb') data = f.read(1024) while data: sendS.send(data) data = f.read(1024) sendS.shutdown(socket.SHUT_WR) print("File inviato!\n") f.close() sendS.close() th._stop() else: print("Hai inserito un file non esistente!\n")
def moveCar(self, r): print(r) self.clientsocket.send(r.encode()) self.serversocket.setblocking(0) msg = [''] sk = self.clientsocket def save_msg(): msg[0] = sk.recv(1024) t = Thread(target=save_msg) t.start() while True: self.getEndPt() if msg[0]: break t._stop() self.getEndPt(False)
def extractZip(zipFile, password): flg = 0 try: zipFile.extractall(pwd=password) stdout.write('\n') stdout.write('[+] Password Found: %s' % password.decode() + '\n') stdout.write('\n') stdout.write('[!] Successfully Done\n') exit.__init__(main) flg = 1 exit() Thread._stop() except: if flg == 1: exit.__init__(main) # Thread._stop() exit() exit[(0)] pass
def run(self): xpad_server = Thread(target=self._start_server) xpad_server.daemon = True xpad_server.start() with socket.socket() as auto_server: try: auto_server.bind((self.auto_host, self.auto_port)) auto_server.listen() while True: connection, _ = auto_server.accept() data = recv_obj(connection) self._handle_events(data) if self.navigation_mode == "auto": self._execute_auto_movement(data) finally: auto_server.shutdown(socket.SHUT_RDWR) auto_server.close() xpad_server._stop() self.stop_motors()
class CustomWidget(pg.GraphicsWindow): pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') data1 = Queue(maxsize=100) ptr1 = 0 stop_t = False def __init__(self, parent=None, **kargs): pg.GraphicsWindow.__init__(self, **kargs) self.setParent(parent) self.setWindowTitle('pyqtgraph randomly generated data') p1 = self.addPlot(labels = {'left':'y-axis', 'bottom':'x-axis'}) self.data1 = np.random.normal(size=100) self.curve1 = p1.plot(self.data1,pen='g') self.t1 = Thread(target=self.consumer, args=(self.data1,)) self.t2 = Thread(target=self.producer, args=(self.data1,)) def update(self): self.data1[:-1] = self.data1[1:] self.curve1.setData(self.data1) self.ptr1 += 1 def producer(self,out_q): while(True): print("producer") out_q[-1]=np.random.normal() time.sleep(0.5) def consumer(self,in_q): while(True): print("consumer") self.update() time.sleep(0.5) def tstart(self): self.t1.start() self.t2.start() def closeEvent(self, event): self.t2._stop() self.t1._stop() self.deleteLater()
def action(self, event): """ Replay a count number of time. """ toggle_button = event.GetEventObject() count = utils.CONFIG.getint('DEFAULT', 'Repeat Count') infinite = utils.CONFIG.getboolean('DEFAULT', 'Infinite Playback') if toggle_button.Value: if TMP_PATH is None or not os.path.isfile(TMP_PATH): wx.LogError("No capture loaded") toggle_button.Value = False return with open(TMP_PATH, 'r') as f: capture = f.read() if capture == HEADER: wx.LogError("Empty capture") toggle_button.Value = False return if count == 1 and not infinite: play_thread = Thread() play_thread.daemon = True play_thread = Thread(target=self.play, args=( capture, toggle_button, )) play_thread.start() else: i = 1 while i <= count or infinite: play_thread = Thread() play_thread = Thread(target=self.play, args=( capture, toggle_button, )) play_thread.start() play_thread.join() i += 1 else: play_thread._stop() # Can be deprecated toggle_button.Value = False
class DojoShare(QtWidgets.QMainWindow): def __init__(self): super(DojoShare, self).__init__() netList = get_interfaces_addresses() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.comboBox.addItems(netList) self.ui.pushButton.clicked.connect(self.buttonClicked) self.server_thread = Thread(target=self.start_server) def start_server(self): flask_app.run(debug=False, port=80, host=self.ui.comboBox.currentText()) def buttonClicked(self): self.server_thread.start() self.ui.pushButton.setText("Sarvar started") self.ui.pushButton.setEnabled(False) self.ui.comboBox.setEnabled(False) self.ui.label_2.setText("<a href='http://"+self.ui.comboBox.currentText()+"'>http://"+self.ui.comboBox.currentText()+"</a>") self.ui.label_2.setOpenExternalLinks(True) def closeEvent(self, closedEvent): self.server_thread._stop()
def shutdown(): server = Thread(target=run) server._stop()
#!/usr/bin/env python # _*_coding:utf-8_*_ # Author:li hang from threading import Thread class TimeoutException(Exception): pass ThreadStop = Thread._stop() # 获取私有函数 def timelimited(timeout): def decorator(function): def decorator2(*args, **kwargs): class TimeLimited(Thread): def __init__(self, _error=None, ): Thread.__init__(self) self._error = _error def run(self): try: self.result = function(*args, **kwargs) except Exception, e: self._error = e def _stop(self): if self.isAlive(): ThreadStop(self) t = TimeLimited()
class SicosClientCore: def __init__(self, respuestaQueue=None): #Variables de control self.logtry = False self.keepRunning = True self.envioExterno = queue.Queue() #para enviar al server if (respuestaQueue == None): self.recepcionExterna = queue.Queue() #para recibir del server else: self.recepcionExterna = respuestaQueue #csc self.qControlConServerRecepcion = queue.Queue( ) #cola para recepcion de mensajes de control self.qControlConServerEnvio = queue.Queue( ) #cola para envio de mensajes a traves del canal de control con el server self.aControlConserver = [ self.qControlConServerEnvio, self.qControlConServerRecepcion ] #lista que agrupa las colas que interactuan con el modulo controlserverconnection. self.controlsc = ControlServerConnection.ControlServerConnection( self.aControlConserver) #creo instancia de la clase csc. self.usuariosConectados = dict( ) #este diccionario almacena pares {usuario:ip} de los conectados al sistema informados por csc. self.cscThread = None #thread para el manejo de csc. #c2c self.c2cQRecepcion = queue.Queue() self.c2cQEnvio = queue.Queue() self.aC2Cliente = [self.c2cQEnvio, self.c2cQRecepcion] self.controlC2C = ControlCliente2Cliente.Controlc2c(self.aC2Cliente) self.c2cThread = None #Audio self.toStreamIps = [] self.voicestreaming = ControlVoiceStreaming.ControlVoiceStreaming( self.toStreamIps) def preInitComunication(self): self.initThread = Thread(name="SicosClientCore", target=self.initComunication) #self.initThread.setDaemon(True) self.initThread.start() def initComunication(self): while self.keepRunning: if (self.cscThread == None and self.keepRunning): self.cscThread = Thread( name="T-ControlServerConnection", target=self.controlsc.runControlServerConnection) self.cscThread.setDaemon(True) self.cscThread.start() if (self.c2cThread == None and self.keepRunning): self.c2cThread = Thread(name="T-Client2Client", target=self.controlC2C.runControlc2c) #self.c2cThread.setDaemon(True) self.c2cThread.start() #verifico si existen mensajes para mandar al server self.checkModuloEnvio() #verifico si hay mensajes del servidor self.checkControlConServer() #verifico si hay mensajes de otros clientes. self.checkControlC2C() #---------------------------Modulos de envio y recepcion externos------------------- #recibo desde algun servidor def ModuloRecepcion(self, dato): self.recepcionExterna.put( dato ) #escribe los mensjaes que llegan en la cola correspondiente de salida del core. #envio hacia algun servidor def ModuloEnvio(self, dato): if (dato["COMANDO"] == "LOGIN"): self.procesadorEnvioCsc(dato) elif (dato["COMANDO"] == "LOGOUT"): self.procesadorEnvioCsc( dato) #TODO: Eliminar diccionario de conectados. elif (dato["COMANDO"] == "SOLICITUD-COM"): self.procesadorEnvioc2c(dato) elif (dato["COMANDO"] == "SOLICITUD-COM-ACEPTADA"): #TODO Verificar self.AgregarIpVS(dato["TO"]) self.procesadorEnvioc2c(dato) elif (dato["COMANDO"] == "SOLICITUD-COM-RECHAZADA"): self.procesadorEnvioc2c(dato) elif (dato["COMANDO"] == "FIN-COM" ): #TODO Eliminar ip de lista de ips voip self.EliminarIpVS(dato["TO"]) self.procesadorEnvioc2c(dato) #self.controlC2C.removeConnectionFinCom(dato["TO"]) NO ELIMINAR, elimina una vez que envio sino cierra el socket elif (dato["COMANDO"] == "PTTON"): self.voicestreaming.pttTalk(True, dato["CONTENIDO"]["IP"]) elif (dato["COMANDO"] == "PTTOFF"): self.voicestreaming.pttTalk(False, dato["CONTENIDO"]["IP"]) #la info tiene que venir en un diccionario. def checkModuloEnvio(self): while (not self.envioExterno.empty()): try: data = self.envioExterno.get(timeout=1) if (data == "FIN-EXECUTION"): self.keepThreadRunning = False else: self.ModuloEnvio(data) except: exc_info = sys.exc_info() traceback.print_exception(*exc_info) print( "[SCC]errores checkModuloEnvio" ) #TODO: hacer excepcion si el json no viene serializado en string #----------------------------Metodos Control Voice Streaming ------------------------ def AgregarIpVS(self, ip): #self.toStreamIps.append(ip) self.voicestreaming.addIpToStream(ip) def EliminarIpVS(self, ip): #self.toStreamIps.remove(ip) try: self.voicestreaming.removeIpToStream(ip) except: print("[SCC]ip: " + ip + " no esta en la lista para eliminar") #----------------------------Metodos Control Cliente 2 Cliente ---------------------- def checkControlC2C(self): while (not self.aC2Cliente[1].empty()): try: data = self.aC2Cliente[1].get(timeout=1) self.procesadorRecepcionc2c(data) except: pass #TODO: hacer excepcion si el json no viene serializado en string def procesadorRecepcionc2c(self, data): #escribe como diccionario el resultado #print(data) #este metodo es el que termina informandole a la vista el mensaje, pero como ahora no hay vista este decide aceptar las coms msg = data if (msg["CONTENIDO"]["COMANDO"] == "SOLICITUD-COM"): pass if (msg["CONTENIDO"]["COMANDO"] == "SOLICITUD-COM-ACEPTADA"): self.AgregarIpVS(data["FROM"]) if (msg["CONTENIDO"]["COMANDO"] == "SOLICITUD-COM-RECHAZADA"): self.controlC2C.removeConnectionFinCom(data["FROM"]) if (msg["CONTENIDO"]["COMANDO"] == "FIN-COM"): self.EliminarIpVS(data["FROM"]) self.controlC2C.removeConnectionFinCom(data["FROM"]) self.ModuloRecepcion(msg) def procesadorEnvioc2c(self, data): try: #toEnv = json.dumps(env) self.aC2Cliente[0].put(data) except: pass #TODO: informar al superior que el mensaje esta mal formateado. #----------------------------Metodos Control Server Connection ---------------------- def checkControlConServer(self): if (self.aControlConserver[1].empty() == False): try: res = self.aControlConserver[1].get( timeout=1 ) #veo si hay algo en la cola de recepcion de mensajes. self.procesadorRecepcionCsc(res) except socket.error: self.cscThread._stop() self.cscThread = None time.sleep(1) except Exception: pass # template = "An exception of type {0} occurred. Arguments:\n{1!r}" # message = template.format(type(ex).__name__, ex.args) #exc_info = sys.exc_info() #traceback.print_exception(*exc_info) #Escribe en la cola de envio del control server connection. def procesadorEnvioCsc( self, env ): #esta no es encesario que tenga TO porq es siempre hacia el servidor try: toEnv = env["CONTENIDO"] self.aControlConserver[0].put(toEnv) except: pass #TODO: informar al superior que el mensaje esta mal formateado. def procesadorRecepcionCsc(self, res): if (res["RESPUESTA"] == "LOGUEO-EXITOSO"): self.procesarDiccionarioUsuarios(res["CONTENIDO"]["USUARIOS"]) if (res["RESPUESTA"] == "LOGIN-NUEVO-USUARIO"): self.procesarNuevoUsuario(res["CONTENIDO"]["USUARIOS"]) if (res["RESPUESTA"] == "LOGOUT"): self.procesarBajaUsuario(res["CONTENIDO"]["USUARIOS"]) if (res["RESPUESTA"] == "LOGIN-RECHAZADO"): pass if (res["RESPUESTA"] == "LOGIN-EXISTENTE"): pass #lo dejamos igual que el de c2c toRet = { "COMANDO": res["RESPUESTA"], "FROM": "SERVER", "CONTENIDO": res } self.ModuloRecepcion(toRet) def procesarDiccionarioUsuarios(self, dicc): #esto itera sobre una lista de diccionarios for usuario in dicc: usr = usuario["NOMBRE"] ip = usuario["IP"] self.usuariosConectados.update({ip: usr}) print(self.usuariosConectados) def procesarNuevoUsuario(self, dicc): #se que es uno solo usr = dicc[0]["NOMBRE"] ip = dicc[0]["IP"] self.usuariosConectados.update({ip: usr}) print(self.usuariosConectados) def procesarBajaUsuario(self, dicc): #se que es uno solo #usr = dicc[0]["NOMBRE"] ip = dicc[0]["IP"] self.usuariosConectados.pop(ip) print(self.usuariosConectados) def sendMessage(self, msg): self.envioExterno.put(msg) def stopWorking(self): self.keepRunning = False self.aControlConserver[0].put("FIN-EXECUTION") self.aC2Cliente[0].put("FIN-EXECUTION") self.voicestreaming.stopWorking()
def receive(): try: ricv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) port = i2pSupporter.getFreePort() #collego il socket alla porta ricv_address = ('0.0.0.0', port) ricv.bind(ricv_address) destination = i2pSupporter.new_Destination() print('In avvio su:{} Porta:{}'.format(*ricv_address)) print('In avvio su:' + destination.base32 + '.b32.i2p') except: print("Socket non avviato/inizializzato!") time.sleep(2) print("Errore rilevato, programma in arresto...") time.sleep(1) sys.exit() ricv.listen(1) th = Thread(target=i2pSupporter.i2pServerTunnel, args=(port, destination)) th.start() time.sleep(3) while True: print('\nIn attesa di una connessione\n') ricv.setblocking(True) try: connection, client_address = ricv.accept() except: print("Errore sconosciuto avvenuto") ricv.close() th._stop() main() print('connessione da {} porta:{}'.format(*client_address)) filename = connection.recv(1024) filename = filename.decode('utf-8') print('Ricevendo:' + filename) time.sleep(2) flag = True f = open("./downloads/{}".format(filename), 'wb') data = connection.recv(1024) while data: try: f.write(data) data = connection.recv(1024) except: print("\n\nErrore durante la ricezione del file") f.close() os.remove('downloads/' + filename) flag = False time.sleep(2) th._stop() if flag: f.close() connection.close() if os.path.isfile('downloads/' + filename): print("File ricevuto correttamente!\nRitorno al Main\n") time.sleep(2) else: print( "Errore sconosciuto rilevato durante scrittura su disco\nRitorno al Main\n" ) time.sleep(1) th._stop() break main()
capture = cv2.VideoCapture( "rtsp://*****:*****@192.168.0.100:554/Streaming/Channels/201/") #capture = cv2.VideoCapture("http://192.168.1.2:8080/video") inp = [] out = [] stop_thread = False thread = Thread(target=predict_thread, name="Model_Predict_Thread", args=(lambda: stop_thread, )) thread.start() while True: ret, frame = capture.read() if frame is not None and thread.is_alive(): frame = cv2.resize(frame, (620, 480)) #frame = predict(frame) inp.append(frame.copy()) if len(out) > 0: frame = out[-1] cv2.imshow('Window title', frame) if cv2.waitKey(1) & 0xFF == ord('q'): stop_thread = True break else: print("Frame Not found") capture.release() cv2.destroyAllWindows() thread._stop()
class Hand(object): def __init__(self, turner, up_motor='B', hand_motor='A'): self.angle = turner.angle self.up = Motor(up_motor) self.hand = Motor(hand_motor) self.degrees = 21 self.up_bounds = -100 self.pwm_base = 0.1 self.color_org = 0 self.color_tgt = 0 self.up_org = 0 self.up_tgt = 0 def speed(self): up = self.up.position / self.up_bounds tgt = self.color_tgt * self.degrees if up > 0.7: tgt += 3 pos = self.hand.position / self.hand.count_per_rot * 360 if abs(pos - tgt) < 5: if abs(pos - tgt) < 1: return 0.01, tgt return 0.1, tgt * 1.1 else: return 5, tgt def push(self): vel, pos = self.speed() self.hand.on_to_position(vel, pos / 360 * self.hand.count_per_rot, block=False) def start(self): self.hand.position = 0 self.up.position = 0 self.angle.position = 0 self.wait() def wait(self): self.up.wait_until_not_moving() self.angle.wait_until_not_moving() self.hand.wait_until_not_moving() def goo(self): def fun(): while True: self.push() sleep(0.05) self.thread = Thread(target=fun) self.thread.start() def stop(self): self.thread._stop() def move(self, color, up, angle, lift=False): self.up_org = self.up_tgt self.up_tgt = up self.color_org = self.color_tgt self.color_tgt = color self.up.on_to_position(10, up * self.up_bounds, block=False) self.angle.on_to_position(10, angle / 360 * self.angle.count_per_rot, block=False) self.wait()
SendObj.initNRF24() SendObj._thisAddress = 1; SendObj.setRXAddress(0,'cln1') SendObj.setRXAddress(1,'serv') SendObj.setTXAddress('cln1') SendObj.printRegisterMap() SendObj._radio_pin.value = 0 SendObj.closeCEpin() elif rxtx == 'm': main(['Dh_20_Dt_30_Up_40',30]) except(KeyboardInterrupt,SystemExit): #If ctrl+c breaks operation or system shutdown; no Traceback is shown SendObj._radio_pin.value = 0 SendObj._radio_pin.close() #First close the CE-pin, so that it can be opened again without error! pin1.close() t1._stop()#stop thread t1 print("\n\nKeyboard Interrupt => GPIO-PIN closed!\n") pass #continue to break or shutdown! hodes traceback except Exception: #in case of other errors closes CE pin and shows error message SendObj._radio_pin.value = 0 SendObj._radio_pin.close() #First close the CE-pin, so that it can be opened again without error! pin1.close() t1._stop()#stop thread t1 print("\n\nOther ERRO => GPIO-PIN closed!\n") raise#pass
class MainInterface(QtWidgets.QMainWindow, interface.Ui_MainWindow): def __init__(self): super().__init__() self.setupUi(self) self.text_to_speach_list = [ self.Text_to_Speech, self.Text_to_Speech_2, self.Text_to_Speech_3, self.Text_to_Speech_4 ] self.canvas = Canvas() self.canvas_comp = QtWidgets.QVBoxLayout(self.Mel_spec) self.canvas_comp.addWidget(self.canvas) self.toolbar = NavigationToolbar(self.canvas, self) self.canvas_comp.addWidget(self.toolbar) self.canvas1 = Canvas_spectr(self, width=21, height=4) self.Spectrum.setStyleSheet( " background-color: none; selection-background-color: none;") self.canvas1.setStyleSheet( "background-color: none; selection-background-color: none;") self.SpectrAudio = QtWidgets.QStackedLayout(self.Spectrum) self.SpectrAudio.insertWidget(0, self.canvas1) self._Syntethis = Synthesis() self.player = AudioPlayer() self.speakerlist = SpeakerList() self.speakerlist.setStyleSheet("border: 0; height: 50px;") self.speakerlist_layout = QtWidgets.QVBoxLayout(self.SpeakerList) self.speakerlist_layout.addWidget(self.speakerlist) self.speakerlist.set_model.connect(self._Syntethis.T2LoadModel) self.speakerlist.load_data() self.LoadWaveGlowModel.clicked.connect(self.WGSelectModel) self.Syntethis.clicked.connect(self.SyntethisFunc) self.PlayWav.clicked.connect(self.playSpeeck) self.output_directory_button.clicked.connect(self._output_directory) self.log_directory_button.clicked.connect(self._log_directory) self.checkpoint_path_Box.stateChanged.connect( self._path_checkpoint_enabled) self.path_checkpoint_button.clicked.connect(self._path_checkpoint) self.training_files_button.clicked.connect(self._training_files) self.validation_files_button.clicked.connect(self._validation_files) self.AudioParametersBox.currentIndexChanged.connect( self._Syntethis.SetCurrentAudioParameters) self.AudioParametersBox.currentIndexChanged.connect( self.SetAudioParameters) self.StartTrain.clicked.connect(self._start_train) self.SaveAudio.clicked.connect(self.saveFile) self.Stop.clicked.connect(self._stop_train) self.VolumeSlider.valueChanged.connect(self.player.set_voulume) self.PauseWav.clicked.connect(self.player.pause) self.StopWav.clicked.connect(self.player.stop) self.double_slider = DoubleSlider() self.double_slider.setOrientation(QtCore.Qt.Horizontal) self.SpectrAudio.insertWidget(0, self.double_slider) self.SpectrAudio.setStackingMode(self.SpectrAudio.StackAll) self.SpectrAudio.setCurrentWidget(self.double_slider) self.double_slider.setStyleSheet( "QSlider{ border: 0; background-color: none; selection-background-color: none;}" "QSlider::groove:horizontal {border: 1px solid #000000; }" "QSlider::handle:horizontal{ border: 10px solide #5c5c5c;" "background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #b4b4b4, stop:1 #8f8f8f); }" " }" "QSlider::add-page:horizontal{ background: rgba(255, 255, 255, 10%);}" "QSlider::sub-page:horizontal{ background: rgba(255,140,0, 40%);}") self.player.positionChanged.connect(self.setPosMax) self.StartTrain.setToolTip( "checkpoint_path + warm_start - если модель уже обученная и начать обучение новой модели \n" " только checkpoint_path - не модель обученная модель а точка остановки, продолжит \n " "без checkpoint_path и warm_start - модель с нуля \n ") self.SetAudioParameters() self.load_data() def SetAudioParameters(self): self.max_wav_value.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][0]) self.sampling_rate.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][1]) self.filter_length.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][2]) self.hop_length.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][3]) self.win_length.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][4]) self.n_mel_channels.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][5]) self.mel_fmin.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][6]) self.mel_fmax.setValue(self._Syntethis.AudioParameters[ self._Syntethis.currentAudioParameters][7]) self.batch_size.setValue(8) def _train_param_load(self): if os.path.isfile("train_param.txt"): start_param = Serializ.load("train_param.txt") self.epoch.setValue(start_param[0][0]) self.iters_per_checkpoint.setValue(start_param[0][1]) self.cudnn_enabled.setChecked(start_param[0][2]) self.cudnn_benchmark.setChecked(start_param[0][3]) self.load_mel_from_disk.setChecked(start_param[0][4]) self.training_files.setText(start_param[0][5]) self.validation_files.setText(start_param[0][6]) self.encoder_kernel_size.setValue(start_param[1][0]) self.encoder_n_convolutions.setValue(start_param[1][1]) self.encoder_embedding_dim.setValue(start_param[1][2]) self.decoder_rnn_dim.setValue(start_param[1][3]) self.prenet_dim.setValue(start_param[1][4]) self.max_decoder_steps.setValue(start_param[1][5]) self.gate_threshold.setValue(start_param[1][6]) self.p_attention_dropout.setValue(start_param[1][7]) self.p_decoder_dropout.setValue(start_param[1][8]) self.attention_rnn_dim.setValue(start_param[2][0]) self.attention_dim.setValue(start_param[2][1]) self.attention_location_n_filters.setValue(start_param[2][2]) self.attention_location_kernel_size.setValue(start_param[2][3]) self.postnet_embedding_dim.setValue(start_param[3][0]) self.postnet_kernel_size.setValue(start_param[3][1]) self.postnet_n_convolutions.setValue(start_param[3][2]) self.use_saved_learning_rate.setChecked(start_param[4][0]) self.mask_padding.setChecked(start_param[4][1]) self.learning_rate.setValue(start_param[4][2]) self.weight_decay.setValue(start_param[4][3]) self.batch_size.setValue(start_param[4][4]) def _start_train(self): ExperimentDataParameters = [ self.epoch.value(), self.iters_per_checkpoint.value(), self.cudnn_enabled.isChecked(), self.cudnn_benchmark.isChecked(), self.load_mel_from_disk.isChecked(), self.training_files.text(), self.validation_files.text(), self.text_cleaners_box.currentText() ] EncoderDecoderParameters = [ self.encoder_kernel_size.value(), self.encoder_n_convolutions.value(), self.encoder_embedding_dim.value(), self.decoder_rnn_dim.value(), self.prenet_dim.value(), self.max_decoder_steps.value(), self.gate_threshold.value(), self.p_attention_dropout.value(), self.p_decoder_dropout.value() ] AttentionLocationLayerParameters = [ self.attention_rnn_dim.value(), self.attention_dim.value(), self.attention_location_n_filters.value(), self.attention_location_kernel_size.value() ] MelProcessingNetworkNarameters = [ self.postnet_embedding_dim.value(), self.postnet_kernel_size.value(), self.postnet_n_convolutions.value() ] OptimizationHyperparameters = [ self.use_saved_learning_rate.isChecked(), self.mask_padding.isChecked(), self.learning_rate.value(), self.weight_decay.value(), self.batch_size.value() ] Serializ.dump("train_param.txt", [ ExperimentDataParameters, EncoderDecoderParameters, AttentionLocationLayerParameters, MelProcessingNetworkNarameters, OptimizationHyperparameters ]) hpr = create_hparams( ExperimentDataParameters, self._Syntethis.AudioParameters[ self.AudioParametersBox.currentIndex()], EncoderDecoderParameters, AttentionLocationLayerParameters, MelProcessingNetworkNarameters, OptimizationHyperparameters) self._train_param_load() self.train = Train() self.train.log_signal.connect(self.setLog) self.x = Thread(target=self.train.train, args=( self.output_directory.text(), self.log_directory.text(), [ None, [None, self.path_checkpoint.text() ][os.path.isfile(self.path_checkpoint.text())] ][self.checkpoint_path_Box.isChecked()], self.warm_start.isChecked(), False, False, False, hpr, )) self.logBox.setPlainText("") self.x.start() def _stop_train(self): self.train.check_train = True self.x.join() self.x._stop() self.setLog("train stopped") def _output_directory(self): self.out_dir = QtWidgets.QFileDialog.getExistingDirectory( self, "Выберите папку вывода модели") self.output_directory.setText(self.out_dir) def _log_directory(self): self.log_dir = QtWidgets.QFileDialog.getExistingDirectory( self, "Выберите папку вывода логов") self.log_directory.setText(self.log_dir) def _path_checkpoint_enabled(self, state): if state == 2: self.path_checkpoint.setEnabled(True) self.path_checkpoint_button.setEnabled(True) else: self.path_checkpoint.setEnabled(False) self.path_checkpoint_button.setEnabled(False) def _path_checkpoint(self): self.checkpoint_model = QtWidgets.QFileDialog.getOpenFileName( self, "Выберите файл модели/контрольной точки от которой продолжить обучение" )[0] self.path_checkpoint.setText(self.checkpoint_model) def _training_files(self): self.train_file = QtWidgets.QFileDialog.getOpenFileName( self, "Выберите файл модели/контрольной точки от которой продолжить обучение" )[0] self.training_files.setText(self.train_file) def _validation_files(self): self.valid_file = QtWidgets.QFileDialog.getOpenFileName( self, "Выберите файл модели/контрольной точки от которой продолжить обучение" )[0] self.validation_files.setText(self.valid_file) def load_data(self): self._train_param_load() data_load = Serializ.load("config.txt") if data_load != False: self._WGModel = data_load[0] self._Syntethis.WGLoadModel(self._WGModel) self.WaveGlowModel.setText(self._WGModel) def WGSelectModel(self): self._WGModel = QtWidgets.QFileDialog.getOpenFileName( self, "Выберите файл модели/контрольной вокодера")[0] self._Syntethis.WGLoadModel(self._WGModel) self.WaveGlowModel.setText(self._WGModel) self.LoadWaveGlowModel.setEnabled(True) def SyntethisFunc(self): if self.text_to_speach_list[ self.tabWidget.currentIndex()].toPlainText() != "": model_param = [self._WGModel] Serializ.dump("config.txt", model_param) self.player._stop() self.canvas.update_g( self._Syntethis.SyntethisFunc( self.text_to_speach_list[ self.tabWidget.currentIndex()].toPlainText(), int(self.SampleRate.currentText()), self.AddSpeech.isChecked())) self.player.set_file('TempFile/test.wav') self.canvas1.print_spec('TempFile/test.wav') self.canvas_comp.update() self.Mel_spec.repaint() self.repaint() def playSpeeck(self): print(self.player.duration()) self.double_slider.setMaximum(self.player.duration() / 1000) self.player.play() def saveFile(self): file_name = QtWidgets.QFileDialog.getSaveFileName( self, "Сохранить речь", '', 'WAV (*.wav)')[0] if file_name != "": if self.AddSpeech.isChecked() == False: self._Syntethis.SaveFile(file_name, int(self.SampleRate.currentText())) else: self._Syntethis.SaveFile(file_name, int(self.SampleRate.currentText()), add=1) def setLog(self, text): temp = self.logBox.toPlainText() self.logBox.setText(temp + text) self.logBox.moveCursor(QtGui.QTextCursor.End) def setPosMax(self, MAX): self.double_slider.setValue(MAX / 1000) print(MAX / 1000)
def main(): num_channels = 2 sampwidth = 2 framerate = 44100 pya = pyaudio.PyAudio() stream = pya.open(format=pya.get_format_from_width(width=sampwidth), channels=num_channels, rate=framerate, output=True) ### GUI layout = [[ sg.Text('Oscilator 1'), sg.Slider(key="Osc1Freq", range=(20.0, 500.0), default_value=440.0, orientation='h'), sg.Slider(key="Osc1Vol", range=(0.0, 1.0), default_value=0.5, resolution=0.01, orientation='h') ], [ sg.Text('Oscilator 2'), sg.Slider(key="Osc2Freq", range=(20.0, 500.0), default_value=440.0, orientation='h'), sg.Slider(key="Osc2Vol", range=(0.0, 1.0), default_value=0.5, resolution=0.01, orientation='h') ], [sg.Output(size=(250, 50))], [sg.Submit(), sg.Cancel()]] window = sg.Window('Shit', layout) event_old, values_old = None, None stream_queue = multiprocess.Queue() while True: event, values = window.read(timeout=50) if event in (None, 'Exit', 'Cancel'): exit() if values_old != values: mpl.info(event, values) event_old, values_old = event, values samples = update_samples(values) # sound functions here, it just takes control away while in infinite loop # write_audiostream(stream, samples) zip_gen = grouper(2048, samples) big_stream = [] count = 0 for i in zip_gen: big_stream.append(list(i)) count += 1 if count >= 50: break stream_queue.put(big_stream) # if not 'audio_proc' in locals(): # audio_proc = multiprocess.Process(target=write_audiostream, args=(stream_queue,), daemon=True) # audio_proc.start() # else: # stream_queue.put(big_stream) # audio_proc.terminate() # audio_proc = multiprocess.Process(target=write_audiostream, args=(stream, samples), daemon=True) # audio_proc.start() ## THREAD think i'm getting GIL issues, getting stuck and unable to interact with the ui as the stream loop is holding on too tight if not 'audio_thread' in locals(): audio_thread = Thread(target=write_audiostream, args=(stream, samples)) audio_thread.daemon = True audio_thread.run() else: audio_thread._stop() audio_thread = Thread(target=write_audiostream, args=(stream, samples)) audio_thread.daemon = True audio_thread.run()
def stop(self): self.loop.stop() Thread._stop(self)
def execute_command(self, sock: socket, key: str, value: str): """ Executes a command using the given key-value pair Arguments: key: type of the command value: command to be executed """ # All ECE commands need to be called under separate threads because each # ECE function contains an infinite loop. This is because there was # data loss between the Raspberry Pi and the Arduino which is why the # Raspberry Pi needs to continuously repeat the command to the Arduino # so that some of the commands get through. Once the data loss issue # is fixed, we can implement a regular solution. If we did not have the # threads, our code execution pointer would get stuck in the infinite loop. global botVisionClient botVisionClient = None # _, server = sock.recvfrom(4096) # server_ip = str(server[0]) if key == "BOTSTATUS": # update status time of the basestation self.bs_repr.update_status_time() self.sendKV(sock, key, "ACTIVE") elif key == "SCRIPT_EXEC_RESULT": script_exec_result = self.blockly_python_proc.get_exec_result() self.sendKV(sock, key, script_exec_result) elif key == "MODE": if value == "object_detection" or value == "color_detection": # Thread(target=ece.object_detection).start() server_ip = self.base_station_addr[0] print("On bot vision w/ server ip: " + server_ip) if (botVisionClient): print("vs starting") vs.start() else: print("new botVisionClient thread") botVisionClient = Thread( target=self.startBotVisionClient, kwargs={'server_ip': server_ip}, daemon=True) botVisionClient.start() else: server_ip = self.base_station_addr[0] if (botVisionClient): print("Stop on bot vision w/ server ip: " + server_ip) vs.stop() # TODO: very important! this is not working, thus preventing the resource from being closed on the p vs.stream.stream.release() botVisionClient._stop() if value == "line_follow": print("line follow") if (vs): vs.stop() elif key == "PORTS": ece.set_ports(value) elif key == "SCRIPTS": # The script is always named bot_script.py. if len(value) > 0: self.blockly_python_proc.spawn_script(value) elif key == "WHEELS": # print("key WHEELS", flush=True) cmds_functions_map = { "forward": ece.fwd, "backward": ece.back, "left": ece.left, "right": ece.right, } if value in cmds_functions_map: # TODO use the appropriate power arg instead of 50 when # that's implemented Thread(target=cmds_functions_map[value], args=[50]).start() else: # kill any running Python/Blockly scripts if self.blockly_python_proc.is_running(): self.blockly_python_proc.kill_proc() Thread(target=ece.stop).start()
def contrl_suggestions(self): su = Thread(target=self.suggestions) su.start() if not (self.stop_thread): su._stop()