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()
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
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()
