def __init__(self):
Thread.__init__(self)
self.vision_state = {}
self.last = None
self.go_forward = 0
self.stop = True
self.distances = {229: 1280, 169: 1300, 162: 1320, 132: 1380, 113: 1500, 410: 2150}
class Triangulation:
"""
A service for determining the relative location of a device with respect to
nearby Wifi access points.
"""
def __init__(self, wifi: Wifi, mqtt: MqttConnection,
messaging: MessagingService, oled):
self.table = RssiTable()
self.wifi = wifi
self.mqtt = mqtt
self.messaging = messaging
self.thread = Thread(self.__run, "LocationThread")
self.oled = oled
self.previous_snapshot = []
def start(self):
self.thread.start()
def __unique_sets(self, a, b):
for (a_elem, _, _) in a:
for (b_elem, _, _) in b:
if a_elem == b_elem:
return False
return True
def __run(self, thread: Thread):
while thread.active:
if self.messaging.package_id:
# We cannot scan if we are connected to an access point
self.wifi.disconnect()
self.wifi.acquire()
try:
stations = self.wifi.scan()
print("Got {}".format(stations))
finally:
self.wifi.release()
self.wifi.deactivate(False)
for station in stations:
# Filter out mobile network used while testing
if station[0] != b"AndroidAP":
self.table.add(ubinascii.hexlify(station[1]),
station[3])
self.table.clean_table()
new_snapshot = self.table.snapshot(2)
if len(stations) >= 2 and self.__unique_sets(
new_snapshot, self.previous_snapshot):
self.previous_snapshot = new_snapshot
payload = ujson.dumps(self.previous_snapshot)
self.mqtt.publish(
TOPIC_MACLOCATION_PUBLISH.format(
self.messaging.package_id), payload)
self.messaging.notify()
self.oled.push_line("Got location")
utime.sleep(27)
def __init__(self, ):
Thread.__init__(self)
self.pipeline = rs.pipeline()
self.config = rs.config()
self.config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 60)
self.config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8,
60)
self.frame = None
try:
dev = self.find_camera()
advnc_mode = rs.rs400_advanced_mode(dev)
while not advnc_mode.is_enabled():
advnc_mode.toggle_advanced_mode(True)
time.sleep(2)
# The 'dev' object will become invalid and we need to initialize it again
dev = self.find_camera()
advnc_mode = rs.rs400_advanced_mode(dev)
with open('camera.json', 'r') as f:
distros_dict = json.load(f)
as_json_object = json.loads(str(distros_dict).replace("'", '\"'))
json_string = str(as_json_object).replace("'", '\"')
advnc_mode.load_json(json_string)
except Exception as e:
pass
self.profile = self.pipeline.start(self.config)
def now(bot, update, args):
if str(update.message.chat_id) in allowed_id:
try:
usernames = [ a['username'].lower() for a in users ]
if not args[1].lower() in usernames:
update.message.reply_text("Sorry, username <b>{}</b> is not saved.".format(args[1]), parse_mode='HTML')
return
if not args[0] in scripts:
update.message.reply_text("Sorry, script named <b>{}</b> is not in your scripts file.".format(args[0]), parse_mode='HTML')
return
job_name = "{}_temp_{}".format(args[0], time.time())
for user in users:
if user['username'].lower() == args[1].lower():
break
temp_thread = Thread(
job_name,
args[0],
update.message.chat_id,
bot,
user['username'],
user['password'],
user['proxy']
)
temp_thread.start()
except (IndexError, ValueError):
update.message.reply_text('Usage: /now <script_name> <username>')
else:
message = 'You have not the permission to use this bot.\nFor more details visit [Telegram-InstaPy-Scheduling](https://github.com/Tkd-Alex/Telegram-InstaPy-Scheduling)'
update.message.reply_text(message, parse_mode='Markdown')
def __init__(self):
Thread.__init__(self)
# Open serial port
# self.serial = pyserial.open or something
# Last command from AI, initially no command
self.last_command = None
def execute(self):
thread = Thread(self.handler)
self.handler.create_modal()
while(thread.alive()):
while Gtk.events_pending():
Gtk.main_iteration_do(True)
self.handler.delete_modal()
async def on_ready():
print(f"Ready in {time.time() - start} seconds.")
# used for uptime
client.start_time = datetime.now()
await client.change_presence(status=discord.Status.online, activity=discord.Game(auth.game))
print('Successfully logged in.')
Thread.start(block=False)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
if not os.path.exists("DOWNLOADS_PATH"):
os.makedirs("DOWNLOADS_PATH")
if not os.path.exists("TORRENTS_PATH"):
os.makedirs("TORRENTS_PATH")
r = self.geometry()
r.moveCenter(QApplication.desktop().availableGeometry().center())
self.setGeometry(r)
if ("DO_LOGIN"):
self.show_login_form()
self.actions = {
PACKAGE_SENT_ACT: self.on_package_sent_act,
PACKAGE_RECEIVED_ACT: self.on_package_received_act,
SERVER_ADDED_ACT: self.on_server_added_act,
CLIENT_ADDED_ACT: self.on_client_added_act,
SERVER_REMOVED_ACT: self.on_server_removed_act,
CLIENT_REMOVED_ACT: self.on_client_removed_act,
ANSWER_ACT: self.on_answer_act,
FILE_RECEIVED_ACT: self.on_file_received_act,
}
self.cli_thread = Thread(CLI_SOCK_PATH)
self.srv_thread = Thread(SRV_SOCK_PATH)
self.cli_thread.msg_came.connect(self.handle_cli_backend_message)
self.srv_thread.msg_came.connect(self.handle_srv_backend_message)
self.cli_thread.error_came.connect(self.handle_cli_error)
self.srv_thread.error_came.connect(self.handle_srv_error)
self.cli_thread.start()
self.srv_thread.start()
self.tableView_main.rowSelected.connect(self.on_main_table_row_changed)
self.tableView_main.rowDoubleClicked.connect(self.on_row_double_clicked)
self.timer = QTimer(self)
self.connect(self.timer, SIGNAL("timeout()"), self.on_timer)
self.timer.start(100)
self.timer_iteration = 0
self.transmissions = {}
self.expected_response = 0
Logger.log("Старт приложения")
if ("DAEMONIZE"):
self.run_daemons()
self.load_torrents()
def test(self):
self.textEdit.setText("我是按钮点击事件，设置文本值")
self.thread = Thread()
self.thread.start()
#使用自定义信号
self.thread.show_text.connect(self.show_text)
#使用系统信号
self.thread.finished.connect(self.done)
def __init__(self, wifi: Wifi, mqtt: MqttConnection,
messaging: MessagingService, oled):
self.table = RssiTable()
self.wifi = wifi
self.mqtt = mqtt
self.messaging = messaging
self.thread = Thread(self.__run, "LocationThread")
self.oled = oled
self.previous_snapshot = []
def main():
"""
Main method to control the program flow
"""
# set runtime name
Vault.set_runtime_name(Util.datetime_to_string())
# create runtime directory
mkdir(f"{SESSION_CACHE_PATH}/{Vault.get_runtime_name()}")
# set up threading
Thread.set_interrupt(False)
event = threading.Event()
# start threads
manager_thread = manager(event)
Escapy.async_sniff(custom_action)
# menu
info_data = [
f"{RED}Sniffer is running but not saving anything locally{RESET}",
f"{GREEN}Sniffer is running saving packets locally{RESET}"
]
option = [
"Type \"start\" to start saving: ", "Type \"stop\" to stop saving: "
]
while True:
print(info_data[0 if not Vault.get_saving() else 1], end="\n")
print(
f"Dashboard: {YELLOW}http://127.0.0.1:8000{RESET} | \'q\' to stop")
user_input = input(option[0 if not Vault.get_saving() else 1])
if not Vault.get_saving() and user_input == "start":
Util.start_saving()
elif Vault.get_saving() and user_input == "stop":
Util.stop_saving()
elif user_input == "q":
break
else:
print(f"{YELLOW}Invalid option{RESET}", end="\n\n")
# SAVE TO FILE IF PROGRAM ENDED AND SAVING IS TRUE
if Vault.get_saving():
Util.stop_saving()
# interrupt threads
Thread.set_interrupt(True)
event.set()
Escapy.stop()
# wait for threads to complete
manager_thread.join()
def __init__(self, wifi: Wifi, oled):
self.wifi = wifi
self.channels = []
self.oled = oled
self.package_id = config.get_string("package_id")
self.thread = Thread(self.__messaging_loop, "MessageThread")
# Semaphore for signaling the messaging service
self._message_semaphore = _thread.allocate_lock()
# Lock for protecting critical regions
self._sync_lock = ReentrantLock()
def switch_thread(self, user):
threads = [
thread for thread in self.threads
if thread.id == user["AttrStatus"]
]
if len(threads) > 0:
self.current_thread = threads[0]
else:
self.current_thread = Thread(user)
self.threads.append(self.current_thread)
self.current_thread.mark_read()
return self.current_thread.dump()
def __init__(self, com):
#self.repl = pyb.USB_VCP()
self.uart = pyb.UART(com, 9600,bits=8, parity=None, stop=1,read_buf_len=15024,timeout=10) # ,bits=8, parity=None, stop=1,read_buf_len=64
#self.pin = pyb.Pin('X18', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE)
#self.pin.low()
self.data=None
self.read_n='DATA'
self.msgss=None
#self.word=''
tr1 = Thread(target=self.download)#, args=(self.data)
tr1.start()
class ThreadingTutorial(QMainWindow, ui.Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# self._diawidth = 1500
# self._diaheight = 800
#
def show_text(self):
self.textEdit.setText("我是自定义线程")
imagefilename = QFileDialog.getOpenFileName(self, "OpenFile",
"/Users/huan/code/PycharmProjects/Unsupervised-Person-Re-identification-Clustering-and-Fine-tuning-master/mydata/imageQuery",
"Image Files(*.MTS *.jpg *.png)")
print("imagefilename1")
print(imagefilename)
imagefilename1 = "".join(tuple(imagefilename))
imagefilename = imagefilename1[0:-30]
print("imagefilename")
print(imagefilename)
image = QImage()
if imagefilename != "":
image = QImage(imagefilename)
scene = QGraphicsScene()
pixmap = QPixmap.fromImage(image)
#默认加载比例
scene.addPixmap(pixmap).setScale(0.5)
self.graphicsView.setScene(scene)
self.graphicsView.resize(150, 200)
self.graphicsView.show()
def done(self):
self.textEdit.setText("内置线程：我是系统线程完成后的done函数")
def test(self):
self.textEdit.setText("我是按钮点击事件，设置文本值")
self.thread = Thread()
self.thread.start()
#使用自定义信号
self.thread.show_text.connect(self.show_text)
#使用系统信号
self.thread.finished.connect(self.done)
def on_pushButton_released(self):
self.test()
def __init__(self):
Thread.__init__(self)
ports = serial.tools.list_ports.comports()
device = list(map(lambda port: port.device, ports))[0]
self.ser = serial.Serial(device, 115200)
self.speed_one = 0
self.speed_two = 0
self.speed_three = 0
self.thrower_speed = 1500
self.last_command = None
self.go_forward = 0
self.locked = False
def list_threads():
request_data = get_json(request)
if 'user' in request_data:
code, response = Thread.list_by_user(request_data['user'], request_data)
elif 'forum' in request_data:
code, response = Thread.list_by_forum(request_data['forum'], request_data)
else:
code, response = Codes.UNKNOWN_ERROR, 'Please enter user or forum'
return json.dumps(
{'code': code,
'response': response}
)
def __init__(self):
super().__init__()
self.kardan_min = -150
self.kardan_max = -60
self.online = False
self.torqueState = False
self.select = 0
self.dataList = [[], [], [], [], [], []]
self.xyz = [0.0, 0.0, -100]
self.alpha = 0.0
self.theta = [0.0, 0.0, 0.0]
self.sym = 0
self.presAngle = []
self.sequenceList = [0.0, 0.0, 0.0, 0.0, 0.0]
self.speed = 10.0
self.sequenceStatus = 0
self.sequenceCount = 0
self.kardanStatus = 0
self.initWindow()
self.dockWidget()
self.show()
settings = QSettings('construct')
select_getSave = settings.value('select1', type=int)
for i in range(len(self.dataList)):
self.dataList[i] = settings.value('list' + str(i), 1024)
if self.dataList[0] != 1024:
self.send_construct_save.emit(select_getSave, self.dataList)
try:
sequenceListSave = QSettings('SequenceList')
self.sequenceData = sequenceListSave.value('select2', list)
if self.sequenceData != None:
for i in range(len(self.sequenceData)):
self.send_sequenceActual.emit(self.sequenceData[i])
except:
print("error")
self.git_thread = Thread(self)
self.git_thread.send_actualPoseT.connect(self.dataFromThread)
self.git_thread.send_visialisation.connect(self.Visual)
self.git_thread.send_finish.connect(self.dynamixelFinish)
self.git_thread.start()
def create_subtasks(self):
"""Get the data from the table and create each subtask (DEV and QA)"""
if not self._check_config():
self.add_log_post("Verifique suas configurações (CTRL+J)")
return
self.progress_bar.setValue(0)
self.log_entries.clear()
if self.thread is not None and self.thread.isRunning():
self.thread.stop()
self.thread = None
return
task_list = list()
raw_html = self.stories_data.toHtml()
html_data = BeautifulSoup(raw_html, features='lxml')
for line_break in html_data.find_all("br"):
line_break.replace_with("\n")
for row in html_data.findAll('tr'):
cell = row.findAll('td')
if len(cell) == 5:
task = {
"parent":
cell[0].text.strip('\n'),
"title":
cell[1].text.strip('\n').replace("\n", " "),
"desc":
cell[2].text.strip('\n'),
"devpts":
float(cell[3].text.strip('\n') or 0),
"qapts":
float(cell[4].text.strip('\n'))
if cell[4].text.strip('\n') else ""
}
task_list.append(task)
else:
self.add_log_post(
"dá uma olhada na sua tabela, todas as linhas tem que ter 5 colunas: \
\n| Parent Story | Title | Description | DEV Points | QA Points |"
)
self.thread = Thread(task_list, self.config)
self.thread.add_log_post.connect(self.add_log_post)
self.thread.set_progress_bar.connect(self.set_progress_bar)
self.thread.finished.connect(self.done)
self.btn_stop.setEnabled(True)
self.btn_stop.disconnect()
self.btn_stop.clicked.connect(self.done)
self.btn_start.setEnabled(False)
self.thread.start()
def test_api_request():
if 'credentials' not in flask.session:
return flask.redirect('authorize')
credentials = google.oauth2.credentials.Credentials(**flask.session['credentials'])
monitorThread = Thread()
emails = monitorThread.getThreads()
# Save credentials back to session in case access token was refreshed.
# ACTION ITEM: In a production app, you likely want to save these
# credentials in a persistent database instead.
flask.session['credentials'] = credentials_to_dict(credentials)
return render_template('threads.html', threads = emails)
def create_thread(bot, context):
threads[context['job_name']] = Thread(context['job_name'],
context['script_name'],
context['chat_id'], bot,
context['user']['username'],
context['user']['password'],
context['user']['proxy'])
def reload_thread(thread):
attribute = thread.return_attribute()
new_thread = Thread(attribute['job_name'], attribute['script_name'],
attribute['chat_id'], attribute['bot'],
attribute['username'], attribute['password'],
attribute['cartella_commenti'])
return new_thread
def update():
request_data = get_json(request)
code, response = Thread.update(request_data['thread'], request_data['message'], request_data['slug'])
return json.dumps(
{'code': code,
'response': response}
)
def reload_thread(thread):
attribute = thread.return_attribute()
new_thread = Thread(attribute['job_name'], attribute['script_name'],
attribute['chat_id'], attribute['bot'],
attribute['user']['username'],
attribute['user']['password'],
attribute['user']['proxy'])
return new_thread
def startThreads(gameInstance, displayInstance, musicInstance):
'''
Purpose: To create and start threads of execution
Parameters:
- displayInstance (MainDisplay): The display instance
- gameInstance (Game): The game instance
- musicInstance (Music): The music player
Returns: None
'''
signal.signal(signal.SIGINT, exitSystem)
musicThread = Thread("musicThread", 3, musicInstance.playThemeMusic,
displayInstance)
gameplayThread = Thread("playthread", 2, gameInstance.playGame,
displayInstance)
displayInstance.updateScene(gameInstance)
def open_thread():
request_data = get_json(request)
code, response = Thread.open(request_data['thread'])
return json.dumps(
{'code': code,
'response': response}
)
def unsubscribe():
request_data = get_json(request)
code, response = Thread.unsubscribe(request_data['thread'], request_data['user'])
return json.dumps(
{'code': code,
'response': response}
)
def vote():
request_data = get_json(request)
code, response = Thread.vote(request_data['thread'], request_data['vote'])
return json.dumps(
{'code': code,
'response': response}
)
def get_thread(self):
"""
@rtype: L{Thread}
@return: Parent Thread object.
"""
if self.__thread is not None:
return self.__thread
self.__load_Thread_class()
self.__thread = Thread(self.get_tid())
return self.__thread
def publish(self, title, content, author):
"""
Creates a new Thread with the given title and adds it to the Forum.
The content and author are provided to allow you to create the first
Post object.
Threads are stored in the order that they are published.
Returns the new Thread object.
"""
new_thread = Thread(title, Post(content, author))
self._threads.append(new_thread)
return new_thread
def memory(event):
"""
Thread to monitor program memory allocations
"""
while not Thread.get_interrupt():
current, peak = tracemalloc.get_traced_memory()
logger.info(f"Current: {current / 10**6}MB | " +
f"Peak: {peak / 10**6}MB [{Thread.name()}]")
event.wait(timeout=MEMORY_WATCHDOG_INTERVAL)
logger.info(f"Terminated [{Thread.name()}]")
def details():
request_data = get_json(request)
if 'related' not in request_data:
request_data['related'] = None
code, response = Thread.details(request_data['thread'], request_data['related'])
return json.dumps(
{'code': code,
'response': response}
)
def __init__(self, builder, controller=None):
self.builder = builder
self.repeat_delay = 10
self.repeat_interval = 10
self.beep = True
self.left_handed = False
self.mouse_acceleration = 0
self.list_of_mouses = []
self.models = []
self.layouts = []
self.variants = {}
Thread(self)
class Repo:
def __init__(self):
self.threads = []
self.current_thread = None
def add_message(self, msg, me=None):
user = msg["User"]
user_thread_arr = [
thread for thread in self.threads if thread.user == user
]
if len(user_thread_arr) == 0:
user_thread = Thread(user)
self.threads.append(user_thread)
else:
user_thread = user_thread_arr[0]
if me:
msg["User"] = me
user_thread.add(msg)
if not user_thread == self.current_thread:
user_thread.mark_new()
def switch_thread(self, user):
threads = [
thread for thread in self.threads
if thread.id == user["AttrStatus"]
]
if len(threads) > 0:
self.current_thread = threads[0]
else:
self.current_thread = Thread(user)
self.threads.append(self.current_thread)
self.current_thread.mark_read()
return self.current_thread.dump()
def dump_current_thread(self):
return self.current_thread.dump() if self.current_thread else []
def all_threads(self):
return self.threads
def downloads(keys, **kwargs):
if type(keys) is str:
download_(keys, panorama=True)
return
if len(keys) > 10:
thread_list = [
Thread(target=downloads, args=(keys_, ), kwargs=kwargs)
for keys_ in _chunker(keys, 10)
]
return
[download_(key) for key in keys]
def create():
request_data = get_json(request)
request_data['title'] = request_data['title'].encode('utf-8')
columns = ', '.join(request_data.keys())
values = get_values(request_data)
code, response = Thread.insert(columns, values)
return json.dumps(
{'code': code,
'response': response}
)
def __init__(self, mqtt: MqttConnection, messaging: MessagingService,
budget_manager: BudgetManager):
self.mqtt = mqtt
self.messaging = messaging
self.budget_manager = budget_manager
self.environment_thread = Thread(self.__run_environment,
"EnvironmentThread")
self.motion_thread = Thread(self.__run_motion, "MotionThread")
self.temperature_setpoint = config.get_float("temperature_setpoint")
self.humidity_setpoint = config.get_float("humidity_setpoint")
self.motion_setpoint = config.get_float("motion_setpoint")
self.last_z = 0
self.last_y = 0
self.last_x = 0
self.environment_sensor = HTS221(
I2C(-1, Pin(26, Pin.IN), Pin(25, Pin.OUT)))
self.motion_sensor = MPU6050(I2C(-1, Pin(26, Pin.IN), Pin(25,
Pin.OUT)))
def __init__(self):
super(MainPage, self).__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.drm = True
self.ui.cmb_room.addItem("Seçiniz")
self.ui.cmb_room.addItems([str(i) for i in range(1, 21)])
self.ui.table_customer.setHorizontalHeaderLabels(('TC', 'Adı', 'Soyadı', 'Oda No'))
self.ui.table_customer.setColumnCount(4)
self.set_controller()
self.ui.table_customer.insertRow(0)
self.ui.btn_check_in.clicked.connect(self.check_in)
self.ui.btn_check_out.clicked.connect(self.check_out)
self.ui.btn_add_person.clicked.connect(self.add_person)
self.ui.check_out_date.dateChanged.connect(self.calculate_fee)
self.th = Thread()
self.th.changePixmap.connect(self.set_image)
self.th.start()
def MainLoop(gui, sim):
# Create a simulation thread, and start it at the highest priority
simthread = Thread(sim)
simthread.start(Thread.HighestPriority)
# Set sim.screenio as an event target for the gui, so that the gui can send events to the sim object
gui.setSimEventTarget(sim.screenio)
# Start the gui
gui.start()
# Stopping simulation thread
print 'Stopping Threads'
sim.stop()
simthread.quit()
simthread.wait()
def get_all_threads(self):
sql = """
SELECT
DISTINCT th.id,
th.when_updated
FROM
threads th,
users us
WHEREevent_ends
th.from_us_id = %s
OR th.to_us_id = %s
ORDER BY th.when_updated DESC;
""" % (self.id, self.id)
result = DBSession.execute(sql).fetchall()
threads = []
for row in result:
tid = row[0]
threads.append(Thread.get(tid))
return threads
class MainWindow(QMainWindow, FormMain):
srv = 'server'
cli = 'client'
clients = {}
servers = {}
downloaded_color = QColor(0xe2, 0xf5, 0xff)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
if not os.path.exists("DOWNLOADS_PATH"):
os.makedirs("DOWNLOADS_PATH")
if not os.path.exists("TORRENTS_PATH"):
os.makedirs("TORRENTS_PATH")
r = self.geometry()
r.moveCenter(QApplication.desktop().availableGeometry().center())
self.setGeometry(r)
if ("DO_LOGIN"):
self.show_login_form()
self.actions = {
PACKAGE_SENT_ACT: self.on_package_sent_act,
PACKAGE_RECEIVED_ACT: self.on_package_received_act,
SERVER_ADDED_ACT: self.on_server_added_act,
CLIENT_ADDED_ACT: self.on_client_added_act,
SERVER_REMOVED_ACT: self.on_server_removed_act,
CLIENT_REMOVED_ACT: self.on_client_removed_act,
ANSWER_ACT: self.on_answer_act,
FILE_RECEIVED_ACT: self.on_file_received_act,
}
self.cli_thread = Thread(CLI_SOCK_PATH)
self.srv_thread = Thread(SRV_SOCK_PATH)
self.cli_thread.msg_came.connect(self.handle_cli_backend_message)
self.srv_thread.msg_came.connect(self.handle_srv_backend_message)
self.cli_thread.error_came.connect(self.handle_cli_error)
self.srv_thread.error_came.connect(self.handle_srv_error)
self.cli_thread.start()
self.srv_thread.start()
self.tableView_main.rowSelected.connect(self.on_main_table_row_changed)
self.tableView_main.rowDoubleClicked.connect(self.on_row_double_clicked)
self.timer = QTimer(self)
self.connect(self.timer, SIGNAL("timeout()"), self.on_timer)
self.timer.start(100)
self.timer_iteration = 0
self.transmissions = {}
self.expected_response = 0
Logger.log("Старт приложения")
if ("DAEMONIZE"):
self.run_daemons()
self.load_torrents()
def show_login_form(self):
form = LoginWindow(self)
form.show()
def closeEvent(self, e):
Logger.log("Завершение приложения")
self.hide()
self.cli_thread.stop_thread()
self.srv_thread.stop_thread()
def run_daemons(self):
cli = subprocess.Popen("CLI", stdout=subprocess.PIPE,
stderr=subprocess.PIPE, stdin=subprocess.PIPE)
Logger.log("Клиент запущен")
srv = subprocess.Popen("SRV", stdout=subprocess.PIPE,
stderr=subprocess.PIPE, stdin=subprocess.PIPE)
Logger.log("Сервер запущен")
# Actions
def on_package_sent_act(self, data):
cli = self.clients[data['id']]
Logger.log("Часть #{n} файла '{fname}' была отправлена на адрес '{ip}'" \
.format(ip = cli['ip'], n = data['piece_id'], fname = data['file_name']))
key = "{0}-{1}".format(data['id'], data['file_name'])
if key in cli['items']:
cli['items'][key]['sent'] += 1
self.tableView_server.set_packs_sent(cli['items'][key]['sent'], key)
else:
cli['items'][key] = {
'sent': 1,
'last_index': 0,
'name': data['file_name'],
}
self.tableView_server.add_row(key, data['file_name'], cli['ip'], 1)
def on_package_received_act(self, data):
Logger.log("С адреса '{ip}' была получена часть #{n} файла '{fname}'" \
.format(ip = self.servers[data['id']]['ip'], n = data['piece_id'],
fname = self.transmissions[data['hsum']]['filename']))
self.transmissions[data['hsum']]['sent'] += 1
self.tableView_main.set_packs_sent(packs = self.transmissions[data['hsum']]['sent'], key = data['hsum'])
prc = self.transmissions[data['hsum']]['filesize']
prc = self.transmissions[data['hsum']]['sent'] * PIECE_LEN / prc
self.tableView_main.set_perc_sent(prc * 100 if prc < 1 else 100.0, data['hsum'])
self.statusWidget.add_line(data['hsum'], data['piece_id'],
self.servers[data['id']]['color'])
s = self.servers[data['id']]
s['sent'] += 1
self.tableView_client.set_packs_sent(s['sent'], s['ip'])
def on_server_added_act(self, data):
Logger.log("Подключен сервер '{ip}'".format(ip = data['ip']))
self.servers[data['id']] = {
'ip': data['ip'],
'sent': 0,
'last_index': 0,
'color': QColor.fromHsv(random.randint(0, 359), 220, 190),
}
self.tableView_client.add_row(data['ip'])
def on_client_added_act(self, data):
Logger.log("Подключен клиент '{ip}'".format(ip = data['ip']))
self.clients[data['id']] = {
'ip': data['ip'],
'items': {},
}
def on_server_removed_act(self, data):
Logger.log("Сервер '{ip}' отключился".format(ip = self.servers[data['id']]['ip']))
self.tableView_client.remove_row(self.servers[data['id']]['ip'])
del self.servers[data['id']]
def on_client_removed_act(self, data):
Logger.log("Клиент '{ip}' отключился".format(ip = self.clients[data['id']]['ip']))
for key in self.clients[data['id']]['items']:
self.tableView_server.remove_row(key)
del self.clients[data['id']]
def on_answer_act(self, data):
r = int(data['result'])
text = ''
if r != 0:
text = ": возникла ошибка {e}".format(e = data['error'])
if data['error'] == FILE_RECEIVING_FAILURE:
self.on_actionStop_transmission_triggered(data['hsum'])
Logger.log("Результат выполнения операции: {r}{text}".format(r = r, text = text))
if r == -1:
QMessageBox.information(self, "Ошибка",
"Торрент файл не может быть загружен -- нет активных серверов")
if 'act' in data and 'hsum' in data and data['hsum'] in self.transmissions:
trm = self.transmissions[data['hsum']]
if (data['act'] == STOP_TRM_ACT and r == 0) or (data['act'] == START_TRM_ACT and r != 0):
trm['sent'] = trm['active'] = trm['finished'] = 0
elif data['act'] == START_TRM_ACT:
trm['trmid'] = data['trmid']
trm['active'] = 1
self.on_main_table_row_changed(data['hsum'])
def on_file_received_act(self, data):
s = data['hsum']
struct = self.transmissions[s]
Logger.log("Файл '{name}' был полностью получен".format(name = struct['filename']))
self.create_torrent_file(struct['filename'], struct['filesize'],
data['hsum'], "DOWNLOADS_PATH/" + struct['filename'])
self.load_torrent(fname = "TORRENTS_PATH/" + s, add_row = False)
struct['sent'] = -1
struct['active'] = 0
struct['finished'] = 1
self.on_main_table_row_changed(s)
def handle_srv_error(self, class_name, msg = None):
Logger.log("Возникла ошибка в потоке сервера{msg}" \
.format(msg = ": " + msg if msg else ""))
return self.handle_error(class_name, msg, self.srv)
def handle_cli_error(self, class_name, msg = None):
Logger.log("Возникла ошибка в потоке клиента{msg}" \
.format(msg = ": " + msg if msg else ""))
return self.handle_error(class_name, msg, self.cli)
def handle_srv_backend_message(self, msg):
return self.handle_backend_message(msg, self.srv)
def handle_cli_backend_message(self, msg):
return self.handle_backend_message(msg, self.cli)
def handle_error(self, class_name, msg = None, sender = None):
QMessageBox.information(self, 'Ошибка', \
'Возникла ошибка в потоке "{thread}": {msg}'.format( \
thread = (sender == self.srv and 'Сервер') or \
(sender == self.cli and 'Клиент') or \
'Неизвестно', \
msg = msg), QMessageBox.Ok)
def handle_backend_message(self, msg, sender = None):
try:
self.__handle_backend_message(msg, sender)
except MainError as e:
self.handle_error(type(e).__name__, e.args[0])
def __handle_backend_message(self, msg, sender = None):
data = json.loads(msg, encoding='utf-8')
return self.actions[data['action']](data)
def load_torrent(self, fname = None, sent = -1, hsum = None, filename = None,
filesize = None, add_row = True):
if fname:
with open(fname, "rb") as f:
struct = pickle.load(f)
if 'default_path' in struct:
sent = -1
else:
sent = 0
return self.load_torrent(sent = sent, hsum = struct['hsum'],
filename = struct['filename'], filesize = struct['filesize'],
add_row = add_row)
if not os.path.isfile("TORRENTS_PATH/" + hsum):
self.create_torrent_file(filename, filesize, hsum)
if type(filesize) != int:
filesize = int(filesize)
pieces_count = math.ceil(filesize / PIECE_LEN)
Logger.log("Был загружен торрент файл для файла '{name}'{status}" \
.format(name = filename, status = ", статус: загружен" if sent == -1 else ""))
save = {
'filename': filename,
'filesize': filesize,
'active': 0,
'sent': sent,
'last_index': sent,
}
if (sent == -1):
save['finished'] = 1
else:
save['finished'] = 0
self.transmissions[hsum] = save
if add_row:
self.tableView_main.add_row(hsum = hsum, name = filename, packs = pieces_count, sent = sent)
self.statusWidget.init_elem(hsum, pieces_count)
if sent == -1:
self.statusWidget.add_rect(hsum, 0, pieces_count - 1, self.downloaded_color)
def load_torrents(self):
for fname in glob.glob("TORRENTS_PATH/*"):
self.load_torrent(fname = fname)
def create_torrent_file(self, filename, filesize, hsum, fname = None):
if type(filesize) != str:
filesize = str(filesize)
struct = {'filesize': filesize, 'hsum': hsum, 'filename': filename}
if fname:
struct['default_path'] = fname
fname = "TORRENTS_PATH/" + hsum
Logger.log("Был создан торрент файл для файла '{name}'" \
.format(name = filename))
with open(fname, 'wb') as f:
pickle.dump(struct, f, 0)
def update_speed(self):
count_speed = lambda delta: delta * PIECE_LEN / 1024.0
for key, e in self.transmissions.items():
delta = e['sent'] - e['last_index']
self.tableView_main.set_speed(count_speed(delta), key)
e['last_index'] = e['sent']
for e in self.servers.values():
delta = e['sent'] - e['last_index']
self.tableView_client.set_speed(count_speed(delta), e['ip'])
e['last_index'] = e['sent']
for e in self.clients.values():
for key, value in e['items'].items():
delta = value['sent'] - value['last_index']
self.tableView_server.set_speed(count_speed(delta), key)
value['last_index'] = value['sent']
@pyqtSlot()
def on_actionStart_transmission_triggered(self):
key = self.tableView_main.current_row
if not key:
return
s = self.transmissions[key]
if not s['finished']:
Logger.log("Отправлен запрос на получение файла '{name}'" \
.format(name = s['filename']))
self.cli_thread.send_message({'action': START_TRM_ACT,
'hsum': key, 'filename': s['filename'], 'filesize': str(s['filesize'])})
@pyqtSlot()
def on_actionCreate_transmission_triggered(self):
fname = QFileDialog.getOpenFileName(self, 'Open file to create a torrent', '~')
if fname:
hsum = hashlib.md5(open(fname, "rb").read()).hexdigest()
if not os.path.exists("TORRENTS_PATH/" + hsum):
self.create_torrent_file(ntpath.basename(fname), os.path.getsize(fname), hsum, fname)
self.load_torrent(fname = "TORRENTS_PATH/" + hsum)
else:
Logger.log("Торрент файл {0} уже существует".format(fname))
QMessageBox.information(self, 'Ошибка',
'Торрент файл уже существует', QMessageBox.Ok)
@pyqtSlot()
def on_actionRemove_transmission_triggered(self):
key = self.tableView_main.current_row
if not key:
return
if self.transmissions[key]['active']:
self.on_actionStop_transmission_triggered()
self.tableView_main.remove_row(key)
try:
os.remove("TORRENTS_PATH/" + key)
except OSError:
pass
Logger.log("Торрен файл для файла '{name}' был удален" \
.format(name = self.transmissions[key]['filename']))
del self.transmissions[key]
@pyqtSlot()
def on_actionStop_transmission_triggered(self, key = None):
if not key:
key = self.tableView_main.current_row
s = self.transmissions[key]
if s['active']:
Logger.log("Отправлен запрос на остановку получения файла '{name}'" \
.format(name = s['filename']))
self.cli_thread.send_message({'action': STOP_TRM_ACT, 'filename': s['filename'],
'hsum': key, 'filesize': str(s['filesize']), 'trmid': s['trmid']})
self.transmissions[key]['active'] = 0
self.statusWidget.remove_lines(key)
self.on_main_table_row_changed(key)
s['active'] = s['finished'] = s['sent'] = 0
@pyqtSlot('QString')
def on_main_table_row_changed(self, key):
if self.transmissions[key]['active']:
self.actionStop_transmission.setEnabled(True)
self.actionStart_transmission.setEnabled(False)
else:
self.actionStop_transmission.setEnabled(False)
self.actionStart_transmission.setEnabled(self.transmissions[key]['sent'] != -1)
self.actionRemove_transmission.setEnabled(True)
self.statusWidget.current_elem = key
@pyqtSlot('QString')
def on_row_double_clicked(self, key):
form = TorrentWindow(self)
s = self.transmissions[key]
form.size_edit.setText(str(s['filesize']))
form.sum_edit.setText(key)
form.name_edit.setText(s['filename'])
form.save_btn.setVisible(False)
form.show()
@pyqtSlot()
def on_actionAdd_torrent_triggered(self):
form = TorrentWindow(self)
form.size_edit.setReadOnly(False)
form.sum_edit.setReadOnly(False)
form.name_edit.setReadOnly(False)
form.save_btn.clicked.connect(self.add_remote_torrent)
self.current_torrent_form = form
form.show()
@pyqtSlot()
def on_action_showLogs_triggered(self):
form = LogsWindow(self)
form.set_logs(Logger.get_log())
form.show()
@pyqtSlot()
def on_actionAbout_triggered(self):
form = AboutWindow(self)
form.show()
@pyqtSlot()
def on_timer(self):
speed_time = 10
status_w_time = 3
table_w_time = 5
if self.timer_iteration % speed_time == 0:
self.update_speed()
if self.timer_iteration % status_w_time == 0:
self.statusWidget.repaint()
if self.timer_iteration % table_w_time == 0:
self.tableView_main.update_values()
self.tableView_client.update_values()
self.tableView_server.update_values()
if self.timer_iteration > 100 * speed_time * status_w_time * table_w_time:
self.timer_iteration = 0
self.timer_iteration += 1
@pyqtSlot(QEvent)
def add_remote_torrent(self):
form = self.current_torrent_form
if (len(form.sum_edit.text()) != 32):
QMessageBox.information(self, 'Ошибка',
'Необходимо указать корректную MD5 сумму файла', QMessageBox.Ok)
else:
form.close()
self.load_torrent(filename = form.name_edit.text(),
filesize = form.size_edit.text(), sent = 0,
hsum = form.sum_edit.text())
