class ContentView(QWidget, ContentForm):
set_current_page_signal = Signal(int)
set_page_length_signal = Signal(int)
def __init__(self, b_id, chap_id, page_num):
super(ContentView, self).__init__()
self.setupUi(self)
self.b_id, self.chap_id = None, None
self.page_list, self.page_len, self.page_num = None, None, None
self.refresh(b_id, chap_id, page_num)
def refresh(self, b_id, chap_id, page_num=None):
self.b_id = b_id
self.chap_id = chap_id
self.page_num = page_num
self.page_list = get_pages(b_id, chap_id)
self.page_len = len(self.page_list)
if self.page_num is None:
self.page_num = 0
self.set_page_length_signal.emit(self.page_len)
self.set_current_page_signal.emit(self.page_num)
b_name = get_book('single', b_id)['name']
self.ChapterLabel.setText(f'## {b_name} -- Chapter {chap_id}')
self.ContentTextEdit.setPlainText(self.page_list[self.page_num])
def get_page_info(self):
return self.page_num, self.page_len
def set_page(self, page_num):
self.page_num = page_num
self.ContentTextEdit.setPlainText(self.page_list[self.page_num])
class ControlBar(QtWidgets.QWidget):
advance_day = Signal()
reduce_day = Signal()
current_day = Signal()
def __init__(self,parent=None):
super().__init__(parent)
self.layout = QtWidgets.QHBoxLayout(self)
#TODO can these buttons be styled better?
self.prevButton = QtWidgets.QPushButton("Previous")
self.nextButton = QtWidgets.QPushButton("Next")
self.currentButton = QtWidgets.QPushButton("Current")
##assemble the controls
self.layout.addWidget(self.prevButton)
self.layout.addWidget(self.currentButton)
self.layout.addWidget(self.nextButton)
## Wire up the signals
self.prevButton.clicked.connect(self.previous_click)
self.nextButton.clicked.connect(self.next_click)
self.currentButton.clicked.connect(self.current_clicked)
def previous_click(self):
print("previous_clicked")
self.reduce_day.emit()
def next_click(self):
print("next_clicked")
self.advance_day.emit()
def current_clicked(self):
print("current_clicked")
self.current_day.emit()
class RegisterView(QWidget, RegForm):
submit_button_signal = Signal(type)
display_status_signal = Signal(str, int)
def __init__(self):
super(RegisterView, self).__init__()
self.setupUi(self)
self.uid_empty = True
self.psw_empty = True
self.rep_psw_empty = True
self.UidInput.textChanged.connect(
lambda: self.button_enable_checker('uid'))
self.PswInput.textChanged.connect(
lambda: self.button_enable_checker('psw'))
self.RepPswInput.textChanged.connect(
lambda: self.button_enable_checker('rep_psw'))
self.RegSubmitBtn.clicked.connect(self.submit_button_onclick)
def button_enable_checker(self, val):
assert val in {'uid', 'psw', 'rep_psw'}
if val == 'uid':
self.uid_empty = (self.UidInput.text() == '')
elif val == 'psw':
self.psw_empty = (self.PswInput.text() == '')
else:
self.rep_psw_empty = (self.RepPswInput.text() == '')
flag = self.PswInput.text() == self.RepPswInput.text()
self.RepPswChecker.setChecked(flag)
self.RegSubmitBtn.setEnabled(
(self.uid_empty or self.psw_empty or self.rep_psw_empty) is False
and flag)
def submit_button_onclick(self):
uid = self.UidInput.text()
psw = self.PswInput.text()
email = self.EmailInput.text()
data = {
'type': 'register',
'data': {
'uid': uid,
'psw': psw,
'email': email
}
}
resp = get_response(data)
assert resp['type'] == 'register'
resp_data = resp['data']
if resp_data['status'] == 'ok':
self.display_status_signal.emit('Successfully registered.', 3000)
self.submit_button_signal.emit(LoginView)
else:
self.UidInput.clear()
self.PswInput.clear()
self.EmailInput.clear()
self.RepPswInput.clear()
self.display_status_signal.emit(resp_data['type'], 5000)
class CommunicationWorker(QObject):
signal_get_ping_done = Signal(int, str, str)
signal_post_history_done = Signal(str, bool)
def __init__(
self,
netloc: str,
base_path: str,
api_key: str,
guild: int,
member: int
) -> None:
super().__init__()
self.client = EvelynClient(netloc=netloc, base_path=base_path, api_key=api_key)
self.guild = guild
self.member = member
@Slot()
def get_ping(self) -> None:
try:
key = -1
text = ''
color = ''
for ping in self.client.get_ping(guild=self.guild, member=self.member, filter_ping_due=False):
key_ = ping['reminder']['key']
if key == -1 or key_ < key:
key = key_
message = ping['message']
when = ping['when']
last = ping['last']
gaps = ping['gaps']
schedule = ping['schedule']
text = (f'<b>{message}</b><br>'
f'<b>{when}</b><br>'
f'<b>Last:</b> {last}<br>'
f'<b>Gaps:</b> {gaps}<br>'
f'<b>Schedule:</b> {schedule}')
color = ping['reminder']['color_hex']
except Exception as e:
key = -1
text = str(e)
color = '#dd4b4b'
self.signal_get_ping_done.emit(key, text, color)
@Slot(int, QDateTime)
def post_history(
self,
key: int,
date_time: QDateTime
) -> None:
try:
data = self.client.post_history(
guild=self.guild, member=self.member, key=key,
time_utc=date_time.toPython() if date_time else None)
text = str(data['message'])
error = False
except Exception as e:
text = str(e)
error = True
self.signal_post_history_done.emit(text, error)
class get_file_hash_thread_work(QThread):
signal1 = Signal(str, str) # 当前hash类型及hash结果
signal2 = Signal(str, str) # 当前hash类型及进度
def __init__(self,
filename: str,
hash_task: list[str],
parent=None) -> None:
super().__init__(parent=parent)
self.filename = filename
self.hash_task = hash_task
def run(self):
self.flag = 1
for key in self.hash_task:
hashstr = hashlib.new(key)
size = os.path.getsize(self.filename)
hashed = 0
with open(self.filename, 'rb') as fileobj:
while (tempdata := fileobj.read(40960)) != b"":
if self.flag == 0:
return
hashstr.update(tempdata)
hashed = hashed + 40960
rate = round(float(hashed) * 100 / size, 1)
rate = min(rate, 100)
rate = str(rate) + "%"
self.signal2.emit(key, rate)
self.signal1.emit(key, str(hashstr.hexdigest()))
class MouseEventMixin:
mouse_left_press = Signal(QPoint)
mouse_left_move = Signal(QPoint)
mouse_left_release = Signal(QPoint)
mouse_left_double_click = Signal(QMouseEvent)
def __init__(self):
pass
def mousePressEvent(self, event):
super(MouseEventMixin, self).mousePressEvent(event)
if (event.button() == Qt.LeftButton):
pos = event.globalPosition().toPoint()
self.mouse_left_press.emit(pos)
def mouseMoveEvent(self, event):
super(MouseEventMixin, self).mouseMoveEvent(event)
if (event.buttons() & Qt.LeftButton):
pos = event.globalPosition().toPoint()
self.mouse_left_move.emit(pos)
def mouseReleaseEvent(self, event):
super(MouseEventMixin, self).mouseReleaseEvent(event)
if (event.button() == Qt.LeftButton):
pos = event.globalPosition().toPoint()
self.mouse_left_release.emit(pos)
def mouseDoubleClickEvent(self, event):
super(MouseEventMixin, self).mouseDoubleClickEvent(event)
if (event.button() == Qt.LeftButton):
self.mouse_left_double_click.emit(event)
class Worker(QThread):
# 发出进度信号
updateValueSignal = Signal(int)
# 发出文本信号
updateTextEditSignal = Signal(str, str)
def __init__(self, dir, ext, prefix):
super(Worker, self).__init__()
self.dir = dir
self.ext = ext
self.prefix = prefix
def run(self) -> None:
"""
The thread begins running from here. run() is only called after start()
"""
for (i, file) in enumerate(os.listdir(self.dir)):
_, file_ext = os.path.splitext(file)
if file_ext == self.ext:
new_file_name = self.prefix + str(i) + self.ext
src_path = os.path.join(self.dir, file)
dst_path = os.path.join(self.dir, new_file_name)
# os.rename(src, dst): src is original address of file to be renamed
# and dst is destination location with new name.
os.rename(src_path, dst_path)
time.sleep(0.2) # Uncomment if process is too fasta and want to see the updates
self.updateValueSignal.emit(i + 1)
self.updateTextEditSignal.emit(file, new_file_name)
else:
pass
# 运行结束后重置值
self.updateValueSignal.emit(0) # reset the value of the progress bar
class Communicate(QObject):
speak_number = Signal(int)
speak_word = Signal(str)
def run(self):
self.speak_number.emit(10)
self.speak_word.emit("Hello everybody!")
class MctsWorker(QObject):
move_chosen = Signal(int)
# board, analysing_player, [(move_text, probability, count)] for top 10 choices
move_analysed = Signal(GameState, int, list)
def __init__(self, player: MctsPlayer, parent: QObject = None):
super().__init__(parent)
self.player = player
@Slot(int, GameState) # type: ignore
def choose_move(self, active_player: int, game_state: GameState):
# noinspection PyBroadException
try:
if self.player.player_number != active_player:
return
move = self.player.choose_move(game_state)
# noinspection PyUnresolvedReferences
self.move_chosen.emit(move) # type: ignore
except Exception:
print_exc()
message = QMessageBox()
message.setWindowTitle('Error')
message.setText(f'Failed to choose a move.')
message.exec_()
@Slot(GameState) # type: ignore
def analyse_move(self, game_state: GameState):
move_probabilities = self.player.get_move_probabilities(game_state)
# noinspection PyUnresolvedReferences
self.move_analysed.emit(game_state, # type: ignore
self.player.player_number,
move_probabilities)
class RenderSongWorker(QObject):
finished = Signal(bool)
error = Signal(str)
progress = Signal(str)
def __init__(self, song: SongTreeWidgetItem):
super().__init__()
self.song = song
def run(self):
try:
command_str = (self.song.get("commandString")).format(**self.song.to_dict())
handler = ProcessHandler()
handler.stderr.connect(self.error.emit)
handler.stdout.connect(self.progress.emit)
errors = handler.run(command_str)
if not errors:
# cut video to exact length of song
handler = ProcessHandler()
handler.stderr.connect(self.error.emit)
handler.stdout.connect(self.progress.emit)
command_str = 'ffmpeg -loglevel error -progress pipe:1 -y -i "{tempFileOutput}" -t {songDuration} -acodec copy -vcodec copy "{fileOutput}"'.format(**self.song.to_dict())
errors = handler.run(command_str)
os.remove(self.song.get("tempFileOutput"))
self.finished.emit(not errors)
except Exception as e:
self.error.emit(traceback.format_exc())
self.finished.emit(False)
def get_duration_ms(self):
return self.song.get_duration_ms()
def __str__(self):
return self.song.get("fileOutput")
class OptionalCurrencyComboBox(QWidget):
changed = Signal()
name_updated = Signal(str)
def __init__(self, parent):
QWidget.__init__(self, parent)
self._id = 0
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.null_flag = QCheckBox(parent)
self.null_flag.setChecked(False)
self.null_flag.setText(self.tr("Currency"))
self.layout.addWidget(self.null_flag)
self.currency = CurrencyComboBox(parent)
self.currency.setEnabled(False)
self.layout.addWidget(self.currency)
self.setLayout(self.layout)
self.setFocusProxy(self.null_flag)
self.null_flag.clicked.connect(self.onClick)
self.currency.changed.connect(self.onCurrencyChange)
def setText(self, text):
self.null_flag.setText(text)
def getId(self):
return self._id if self._id else None
def setId(self, new_value):
if self._id == new_value:
return
self._id = new_value
self.updateView()
name = JalDB().get_asset_name(self._id)
self.name_updated.emit('' if name is None else name)
currency_id = Property(int, getId, setId, notify=changed, user=True)
def updateView(self):
has_value = True if self._id else False
if has_value:
self.currency.selected_id = self._id
self.null_flag.setChecked(has_value)
self.currency.setEnabled(has_value)
@Slot()
def onClick(self):
if self.null_flag.isChecked():
if self.currency.selected_id == 0:
self.currency.selected_id = JalSettings().getValue('BaseCurrency')
self.currency_id = self.currency.selected_id
else:
self.currency_id = 0
self.changed.emit()
@Slot()
def onCurrencyChange(self, _id):
self.currency_id = self.currency.selected_id
self.changed.emit()
class MainWindow(QObject):
def __init__(self):
QObject.__init__(self)
# Static Info
staticUser = "******"
staticPass = "******"
# Signals To Send Data
signalUser = Signal(str)
signalPass = Signal(str)
signalLogin = Signal(bool)
# Function To Check Login
@Slot(str, str)
def checkLogin(self, getUser, getPass):
if (self.staticUser.lower() == getUser.lower()
and self.staticPass == getPass):
# Send User And Pass
self.signalUser.emit("Username: "******"Password: "******"Login passed!")
else:
self.signalLogin.emit(False)
print("Login error!")
class WelcomeView(QWidget, WelcomeForm):
select_book_signal = Signal(type)
display_status_signal = Signal(str, int)
set_current_book_signal = Signal(int)
def __init__(self):
super(WelcomeView, self).__init__()
self.setupUi(self)
self.has_clicked = False
book_list = get_book('all')
for book in book_list:
book_item = BookListItem(book['book_id'], book['name'])
self.BookListWidget.addItem(book_item)
self.BookListWidget.itemClicked.connect(self.item_onclick)
self.BookListWidget.itemDoubleClicked.connect(self.item_onclick_double)
def item_onclick_double(self, item):
self.set_current_book_signal.emit(item.b_id)
self.select_book_signal.emit(ChapterView)
def item_onclick(self, item):
synopsis_text = self.SynopsisTextEdit.toPlainText()
if not self.has_clicked:
self.has_clicked = True
else:
index = synopsis_text.find('\n\n')
synopsis_text = synopsis_text[index + 2:]
self.SynopsisTextEdit.setPlainText(item.text() + '\n\n' +
synopsis_text)
class GenericWorker(QObject):
"""Generic worker thread object which can broadcast messages"""
message = Signal(MessageType, str)
exit_on_error = Signal()
def run(self):
"""Base method to run and post exceptions as errors"""
try:
self.run_impl()
except Exception as exc:
self.post_error(f'Thread exited with "{exc}"')
self.exit_on_error.emit()
raise
def post_debug(self, text):
"""Broadcast debug messages to anyone listening"""
self.message.emit(MessageType.DEBUG, text)
def post_error(self, text):
"""Broadcast error messages to anyone listening"""
self.message.emit(MessageType.ERROR, text)
def post_generic(self, text):
"""Broadcast messages to anyone listening"""
self.message.emit(MessageType.GENERIC, text)
class WorkerSignals(QtCore.QObject):
""" Defines signals avaliable from a worker thread.
- dataframe_result: pandas dataframe data returned from processing.
- error: error information
"""
dataframe_result: Signal = Signal(pd.DataFrame)
error: Signal = Signal(str)
class ConnectKeyboard(QThread):
found = Signal(str)
connected = Signal(BluetoothSocket)
def run(self):
config = Config()
keyboardAddr = config.get('addr') or find_keyboard()
self.found.emit(keyboardAddr)
sock = connect_keyboard(keyboardAddr)
self.connected.emit(sock)
class Statements(QObject):
load_completed = Signal(int, defaultdict)
load_failed = Signal()
def __init__(self, parent):
super().__init__()
self.parent = parent
self.items = []
self.loadStatementsList()
def loadStatementsList(self):
statements_folder = get_app_path() + Setup.IMPORT_PATH + os.sep + Setup.STATEMENT_PATH
statement_modules = [filename[:-3] for filename in os.listdir(statements_folder) if filename.endswith(".py")]
for module_name in statement_modules:
logging.debug(f"Trying to load statement module: {module_name}")
module = importlib.import_module(f"jal.data_import.broker_statements.{module_name}")
try:
statement_class_name = getattr(module, "JAL_STATEMENT_CLASS")
except AttributeError:
continue
try:
class_instance = getattr(module, statement_class_name)
except AttributeError:
logging.error(self.tr("Statement class can't be loaded: ") + statement_class_name)
continue
statement = class_instance()
self.items.append({
'name': statement.name,
'module': module,
'loader_class': statement_class_name,
'icon': statement.icon_name,
'filename_filter': statement.filename_filter
})
logging.debug(f"Class '{statement_class_name}' providing '{statement.name}' statement has been loaded")
self.items = sorted(self.items, key=lambda item: item['name'])
# method is called directly from menu, so it contains QAction that was triggered
def load(self, action):
statement_loader = self.items[action.data()]
statement_file, active_filter = QFileDialog.getOpenFileName(None, self.tr("Select statement file to import"),
".", statement_loader['filename_filter'])
if not statement_file:
return
module = statement_loader['module']
class_instance = getattr(module, statement_loader['loader_class'])
statement = class_instance()
try:
statement.load(statement_file)
statement.validate_format()
statement.match_db_ids()
totals = statement.import_into_db()
except Statement_ImportError as e:
logging.error(self.tr("Import failed: ") + str(e))
self.load_failed.emit()
return
self.load_completed.emit(statement.period()[1], totals)
class TrieView(QTreeView):
linkUnhovered = Signal()
linkHovered = Signal(str)
linkActivated = Signal(str)
def __init__(self, *args, **kwargs):
super(TrieView, self).__init__(*args, **kwargs)
self.setMouseTracking(True)
self._mousePressAnchor = ''
self._lastHoveredAnchor = ''
def mousePressEvent(self, event):
super(TrieView, self).mousePressEvent(event)
anchor = self.anchorAt(event.pos())
self._mousePressAnchor = anchor
def mouseMoveEvent(self, event):
anchor = self.anchorAt(event.pos())
if self._mousePressAnchor != anchor:
self._mousePressAnchor = ''
if self._lastHoveredAnchor != anchor:
self._lastHoveredAnchor = anchor
if self._lastHoveredAnchor:
QApplication.setOverrideCursor(QCursor(Qt.PointingHandCursor))
self.linkHovered.emit(self._lastHoveredAnchor)
else:
QApplication.restoreOverrideCursor()
self.linkUnhovered.emit()
def mouseReleaseEvent(self, event):
if self._mousePressAnchor:
anchor = self.anchorAt(event.pos())
if anchor == self._mousePressAnchor:
self.linkActivated.emit(self._mousePressAnchor)
self._mousePressAnchor = ''
super(TrieView, self).mouseReleaseEvent(event)
def anchorAt(self, pos):
index = self.indexAt(pos)
if index.isValid():
delegate = self.itemDelegate(index)
wordDelegate = delegate
if isinstance(wordDelegate, CalleesDelegate):
itemRect = self.visualRect(index)
relativeClickPosition = pos - itemRect.topLeft()
html = index.data()
if html is not None:
return wordDelegate.anchorAt(html, relativeClickPosition)
return ''
class WorkerSignals(QObject):
"""
Defines the signals available from a running worker thread.
progress
int progress complete,from 0-100
"""
progress = Signal(str, int)
finished = Signal(str)
class Worker(QObject):
finished = Signal()
progress = Signal(int)
def run(self):
"""耗时任务"""
for i in range(5):
sleep(1)
self.progress.emit(i + 1)
self.finished.emit()
class VideoLoader(QThread):
sig_start = Signal(int)
sig_progress = Signal(int, int, str)
sig_frame_finished = Signal(int, bytes, dict)
sig_all_finished = Signal()
def __init__(self, settings: Settings, parent=None):
super(VideoLoader, self).__init__(parent)
self.settings = settings
self.video_data = VideoData()
self.vid = None
self.analyzer = Analyzer(settings, self)
def set_file(self, file_path: str) -> VideoData:
self.video_data.file_path = file_path
self.vid = cv2.VideoCapture(file_path)
self.video_data.width = int(self.vid.get(cv2.CAP_PROP_FRAME_WIDTH))
self.video_data.height = int(self.vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.video_data.fps = int(self.vid.get(cv2.CAP_PROP_FPS))
self.video_data.frame_count = int(
self.vid.get(cv2.CAP_PROP_FRAME_COUNT))
return self.video_data
def run(self):
self.sig_start.emit(self.video_data.frame_count)
if self.vid is None:
QMessageBox.warning(self.parent(), '错误', '未选择文件')
return
frame_index = 0
while True:
ret, frame = self.vid.read()
if not ret:
break
color_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame_index += 1
origin_h, origin_w, ch = frame.shape
img = QImage(frame.data, origin_w, origin_h, ch * origin_w,
QImage.Format_BGR888)
base64 = self.image_to_base64(img)
frame_particles = self.analyzer.analyze(frame_index, color_frame)
self.sig_progress.emit(self.video_data.frame_count, frame_index,
self.tr(constant.status_reading))
self.sig_frame_finished.emit(frame_index, base64, frame_particles)
self.sig_all_finished.emit()
def image_to_base64(self, img: QImage) -> bytes:
quality = self.settings.int_value(default_settings.frame_quality)
byte_arr = QByteArray()
buffer = QBuffer(byte_arr)
buffer.open(QIODevice.WriteOnly)
img.save(buffer, 'jpg', quality)
return byte_arr.toBase64().data()
def switch_slot(signal: Signal, new: Callable) -> None:
"""シグナルのスロット切り替え
Parameters
----------
signal: Signal
スロットを切り替えするシグナル
new: Callable
新しく接続するシグナル
"""
signal.disconnect()
signal.connect(new)
class CheckApps(QThread):
"""Refresh list of installed apps."""
progress_signal = Signal()
app_signal = Signal(object)
def __init__(self, apps_dict):
super().__init__()
self.apps_dict = apps_dict
def run(self):
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
x = subprocess.Popen([
"powershell",
"Get-AppxPackage -PackageTypeFilter Main | Select Name, InstallLocation | ConvertTo-JSON"
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=False,
startupinfo=si,
text=True)
names_str = x.communicate()[0]
names_list = json.loads(names_str)
for i in self.apps_dict:
temp_name = self.apps_dict[i]["name"].strip("*")
self.apps_dict[i]["size"] = 0
flag = False
if temp_name != "Xbox":
for item in names_list:
name = item["Name"]
if name.find(temp_name, 0, len(name)) != -1:
flag = True
self.apps_dict[i]["size"] += get_dir_size(
item["InstallLocation"]) / 1024 / 1024
break
else:
for item in names_list:
name = item["Name"]
if name.find(temp_name, 0, len(name)) != -1 and name.find(
"XboxGameCallableUI", 0, len(name)) == -1:
flag = True
self.apps_dict[i]["size"] += get_dir_size(
item["InstallLocation"]) / 1024 / 1024
if flag:
self.app_signal.emit(i)
self.progress_signal.emit()
class ProjectTabs(QWidget):
sg_prj_page_selc = Signal(int) # int: page number
sg_prj_save = Signal()
def __init__(self, parent=None):
super().__init__(parent=parent)
pal = self.palette()
pal.setColor(QPalette.ColorRole.Window, QColor(247, 247, 247))
self.setAutoFillBackground(True)
self.setPalette(pal)
wcb_page_selc = QComboBox()
wcb_page_selc.currentTextChanged.connect(self._sl_page_selc_change)
wcb_page_selc.addItem("Home")
wcb_page_selc.addItem("Models")
wcb_page_selc.addItem("Execution")
wcb_page_selc.addItem("Deployment")
lyt_main = QHBoxLayout()
lyt_main.addWidget(wcb_page_selc)
wb_save_proj = QPushButton("Save Project")
wb_save_proj.clicked.connect(self._sl_proj_save_click)
lyt_main.addWidget(wb_save_proj)
lyt_main.addWidget(QPushButton("Press me! (Does nothing)"))
self.setLayout(lyt_main)
margin = lyt_main.contentsMargins()
margin.setTop(3)
margin.setBottom(3)
lyt_main.setContentsMargins(margin)
@Slot(str)
def _sl_page_selc_change(self, text):
try:
page_no = {
"Home": 0,
"Models": 1,
"Execution": 2,
"Deployment": 3
}[text]
except KeyError:
print(f"error: <{text}> page not implemented")
page_no = 0
self.sg_prj_page_selc.emit(page_no)
@Slot(bool)
def _sl_proj_save_click(self, _checked):
self.sg_prj_save.emit()
class OptWorker(QObject):
working_signal = Signal()
update_signal = Signal()
finished_signal = Signal()
def __init__(self, optimiser: BayesOptimiser):
self.optimiser = optimiser
self.window = None
super(OptWorker, self).__init__()
def suggest_bayes_steps(self):
self.working_signal.emit()
self.optimiser.suggest_bayes_steps()
self.finished_signal.emit()
def do_opt_steps(self):
self.run_opt_step()
while self.window.ui.checkBox_keep_running.checkState() \
and self.optimiser.current_point < self.optimiser.n_points:
self.run_opt_step()
self.finished_signal.emit()
def run_opt_step(self):
self.working_signal.emit()
self.optimiser.run_opt_step()
self.update_signal.emit()
def refit_model(self):
self.working_signal.emit()
self.optimiser.refit_model()
self.finished_signal.emit()
def renormalise_model(self):
self.working_signal.emit()
self.optimiser.renormalise()
self.optimiser.refit_model()
self.finished_signal.emit()
class ClassFilterProxyModel(QSortFilterProxyModel, QObject):
_changed_front_page_ = Signal(bool)
_changed_filter_class_ = Signal(str)
_front_page_ = True
_filter_class_ = 'all'
def __init__(self):
super().__init__()
def get_front_page(self):
return self._front_page_
def set_front_page(self, fp):
if self._front_page_ != fp:
self._front_page_ = fp
self._changed_front_page_.emit(self._front_page_)
self.invalidateFilter()
def get_filter_class(self):
return self._filter_class_
def set_filter_class(self, new_filter):
if self._filter_class_ != new_filter:
# _logger.debug(f'class filter: set_filter_class {new_filter}')
self._filter_class_ = new_filter
self._changed_filter_class_.emit(self._filter_class_)
self.invalidateFilter()
front_page = Property(bool,
get_front_page,
set_front_page,
notify=_changed_front_page_)
filter_class = Property(str,
get_filter_class,
set_filter_class,
notify=_changed_filter_class_)
def filterAcceptsRow(self, source_row, source_parent: QModelIndex):
index = self.sourceModel().index(source_row, 0, source_parent)
if self.front_page:
return True
else:
if self._filter_class_ == 'all':
return True
else:
device_class_id = index.data(DeviceRoles.DEVICE_CLASS_ID)
cb_filter = device_class_id == self._filter_class_
return cb_filter
class set_list_thread_work(QThread):
signal_fun = Signal(dict)
signal_state = Signal(str)
def __init__(self, vm_name) -> None:
super().__init__()
self.vm_name = vm_name
def run(self):
vm_state = get_vm_state(self.vm_name)
self.signal_state.emit(vm_state)
fun_dict = {}
fun_dict.update(get_vmprocessor(self.vm_name))
self.signal_fun.emit(fun_dict)
class VideoThread(QObject):
change_pixmap_signal = Signal(np.ndarray)
update_fps_signal = Signal(float)
def __init__(self, filter_list):
super().__init__()
self._fps = fps.FPS()
self._run_flag = True
self.filter_list = filter_list
self.cap = cv2.VideoCapture(0)
self._ind = 0
self.video_loop = VideoLoopBack()
@Slot()
def new_filter_slot(self, ind):
self._ind = ind
logger.debug(f'ind {ind}')
@Slot()
def start(self):
print('start')
self._fps.start()
while self._run_flag:
ret, cv_img = self.cap.read()
if ret:
fimg = self.filter_list[self._ind][1].process(cv_img)
logger.debug(cv_img.shape)
self.video_loop.new_image(fimg)
self.change_pixmap_signal.emit(fimg)
self._fps.update()
self.update_fps_signal.emit(self._fps.fps)
logger.info('Stopping thread')
self.video_loop.process2.stdin.close()
self.video_loop.process2.terminate()
logger.debug('Video writer closed')
self.cap.release()
logger.debug('Capture device closed')
@Slot()
def pause(self):
print('pause')
self._run_flag = False
def stop(self):
"""Sets run flag to False and waits for thread to finish"""
self._run_flag = False
logger.debug('Stop Ran')
class WindowDragger(QWidget):
""" Window dragger.
Args:
window (QWidget): Associated window.
parent (QWidget, optional): Parent widget.
"""
doubleClicked = Signal()
def __init__(self, window, parent=None):
QWidget.__init__(self, parent)
self._window = window
self._mousePressed = False
def mousePressEvent(self, event):
self._mousePressed = True
self._mousePos = event.globalPos()
self._windowPos = self._window.pos()
def mouseMoveEvent(self, event):
if self._mousePressed:
self._window.move(self._windowPos +
(event.globalPos() - self._mousePos))
def mouseReleaseEvent(self, event):
self._mousePressed = False
def mouseDoubleClickEvent(self, event):
self.doubleClicked.emit()
class EditAnnotationDialog(QDialog):
annotation_changed = Signal(Annotation)
def __init__(self, parent, annotation: Annotation) -> None:
super().__init__(parent=parent)
self.ui = Ui_EditAnnotationDialog()
self.ui.setupUi(self)
self.rom_variant = annotation.rom_variant
self.ui.lineEditVariant.setText(annotation.rom_variant)
self.ui.lineEditAddress.setText(hex(annotation.address))
self.ui.spinBoxLength.setValue(annotation.length)
self.ui.lineEditColor.setText(annotation.color.name())
self.ui.lineEditAuthor.setText(annotation.author)
self.ui.plainTextEditNote.setPlainText(annotation.note)
self.accepted.connect(self.on_accept)
def get_annotation(self) -> Annotation:
return Annotation(RomVariant(self.ui.lineEditVariant.text()),
parse_address(self.ui.lineEditAddress.text()),
self.ui.spinBoxLength.value(),
QColor(self.ui.lineEditColor.text()),
self.ui.lineEditAuthor.text(),
self.ui.plainTextEditNote.toPlainText().strip())
def on_accept(self) -> None:
self.annotation_changed.emit(self.get_annotation())
