def button_include_dir_handler(self):
initial_dir = os.path.dirname(str(self.include_dir.text()))
dirDialog = QFileDialog()
dirDialog.setFileMode(QFileDialog.Directory)
new_dir = dirDialog.getExistingDirectory(self, "Select directory", initial_dir)
if (len(new_dir) > 0):
self.include_dir.setText(new_dir)
def getFile(self):
dialg = QFileDialog()
dialg.setFileMode(QFileDialog.AnyFile)
dialg.setNameFilter("CSV Files (*.csv)")
if dialg.exec_():
fileName = dialg.selectedFiles()
f = open(fileName[0], 'r')
ml = machineLearning(f)
with open(fileName[0], 'r') as f:
data = f.read()
self.textEditor.setPlainText(data)
self.table.setRowCount(len(ml))
self.table.setColumnCount(1)
x = -1
while x <= len(ml) - 2:
x += 1
self.table.setItem(x, 0, QTableWidgetItem(ml[x]))
header = self.table.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
f.close()
else:
pass
def get_open_filename(self, parent, filter_, file_mode=None):
dialog = QFileDialog(parent, directory=self._get_default_directory(), filter=filter_)
if file_mode:
dialog.setFileMode(file_mode)
if dialog.exec_():
return dialog.selectedFiles()[0]
else:
return None
def _open_file(self, filter):
caption = 'open File'
filters = 'File (%s)' % (filter)
dlg = QFileDialog(self, caption, self.lastOpenDirPath, filters)
dlg.setDefaultSuffix(filter)
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setOption(QFileDialog.DontUseNativeDialog, False)
if dlg.exec_():
return dlg.selectedFiles()[0]
return ''
def handleAddSrcFiles(self):
fileDlg = QFileDialog(self, 'Select Files',
self.config[PATHS]['download_path'],
self.filetypes)
fileDlg.setFileMode(QFileDialog.ExistingFiles)
if fileDlg.exec_():
for filename in fileDlg.selectedFiles():
if filename not in self.filenames:
self.filenames.append(filename)
self.srcFilesList.addItem(filename)
def handleSelectSrcFiles(self):
fileDlg = QFileDialog(self, 'Select Files',
self.config[PATHS]['download_path'],
self.filetypes)
fileDlg.setFileMode(QFileDialog.ExistingFiles)
if fileDlg.exec_():
self.filenames = fileDlg.selectedFiles()
self.srcFilesList.clear()
self.srcFilesList.addItems(self.filenames)
def select_exe(self):
'''
Create a dialog to select the Prince executable
'''
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFile)
filename = dialog.getOpenFileName(self, _('Select Prince executable'), '', '')
if filename:
try:
self.exe.setText(filename)
except(TypeError):
self.exe.setText(filename[0])
def select_batch_files(self):
"""
Selection of .xml pyIMD project files for batch calculation.
"""
filter_ext = "XML (*.xml);;, All files (*.*) "
file_name = QFileDialog()
file_name.setFileMode(QFileDialog.ExistingFiles)
ret = file_name.getOpenFileNames(
self, "Select the pyIMD project files for batch processing",
self.last_selected_path, filter_ext)
files = ret[0]
for i in range(0, len(files)):
self.batchFileListWidget.addItem(str(files[i]))
def select_exe(self):
'''
Create a dialog to select the Prince executable
'''
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFile)
filename = dialog.getOpenFileName(self, _('Select Prince executable'),
'', '')
if filename:
try:
self.exe.setText(filename)
except (TypeError):
self.exe.setText(filename[0])
def openFileDlg(self):
"""Open file picker for ppscannos.py file"""
d = self.lineEditPPScannos.text()
if d:
d = os.path.dirname(d)
dlg = QFileDialog(self, "Select PPScannos File...", None, "Python Files (*.py);;All Files (*)")
dlg.setFileMode(QFileDialog.ExistingFile)
if dlg.exec():
flist = dlg.selectedFiles() # returns a list
if len(flist):
self.lineEditPPScannos.setText(flist[0])
def openFile(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setFilter(QDir.Files)
tab = self.tabWidget.widget(self.tabWidget.currentIndex())
items = tab.children()
if dialog.exec_():
file_name = dialog.selectedFiles()
if file_name[0].endswith('.py'):
with open(file_name[0], 'r+') as f:
data = f.read()
items[3].setPlainText(data)
f.close
elif file_name[0].endswith('.txt'):
with open(file_name[0], 'r+') as f:
data = f.read()
items[3].setPlainText(data)
f.close
else:
pass
def select_data_files(self):
"""
Select data files to create a new pyIMD project
"""
try:
filter_ext = "All files (*.*);; Txt (*.txt);; TDMS (*.tdms);; All files " \
"without file endings (*)"
file_name = QFileDialog()
file_name.setFileMode(QFileDialog.ExistingFiles)
ret = file_name.getOpenFileNames(self, "Pick relevant data files",
self.last_selected_path,
filter_ext)
names = ret[0]
if len(names) > 0:
# Clear previous file list
self.file_list = []
# Setting the file list
self.file_list = names
sorted_file_list = self.file_list
self.last_selected_path = os.path.dirname(sorted_file_list[0])
self.show_data()
self.print_to_console("Selected %d files." %
(len(sorted_file_list)))
# Populate drop down list with selected items.
self.noCellDataBox.clear()
self.withCellDataBox.clear()
self.measuredDataBox.clear()
self.noCellDataBox.addItems(self.file_list)
self.withCellDataBox.addItems(self.file_list)
self.measuredDataBox.addItems(self.file_list)
# Create new pyimd project
self.imd.create_pyimd_project(self.file_list[0],
self.file_list[0],
self.file_list[0], '\t', 23,
'PLL')
except Exception as e:
self.print_to_console("Error could not select files." + str(e))
def file_dialog(self, load_save_type=QFileDialog.AcceptSave):
"""Opens an file save dialog and returns the selected
filename."""
file_save_dialog = QFileDialog(self)
file_save_dialog.setFileMode(QFileDialog.AnyFile)
file_save_dialog.setAcceptMode(load_save_type)
file_save_dialog.setNameFilters(
["MPDJ files (*.{})".format(FILE_SUFFIX)])
file_save_dialog.selectNameFilter(
"MPDJ files (*.{})".format(FILE_SUFFIX))
file_save_dialog.setDefaultSuffix((FILE_SUFFIX))
exec_value = file_save_dialog.exec()
if exec_value == 0:
return None
file_names = file_save_dialog.selectedFiles()
if len(file_names) != 1:
message_box = QMessageBox()
message_box.setText('Please select only one file!')
message_box.setWindowTitle('Save error.')
message_box.setStandardButtons(QMessageBox.Ok)
message_box.setIcon(QMessageBox.Information)
message_box.exec_()
return None
return file_names[0]
def open_file_dialog(self):
# in case a file is open already, close it properly first
if self.machine:
ret = self.close_file()
if not ret:
# user canceled closing of current file; can't open new one
return
# open dialog for selecting a gcode file to be loaded
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFile)
filters = ["G-code (*.gcode)", "Any files (*)"]
dialog.setNameFilters(filters)
dialog.selectNameFilter(filters[0])
dialog.setViewMode(QFileDialog.Detail)
filename = None
if dialog.exec_():
filename = dialog.selectedFiles()
if filename:
self.run_in_background(self.load_data,
after=self.show_layer,
args=filename)
def _import_keys(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.Directory)
dialog.setOption(QFileDialog.ShowDirsOnly)
folder = dialog.getExistingDirectory(caption="Select Directory")
self._km.import_keys(folder)
def _import_keys(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.Directory)
dialog.setOption(QFileDialog.ShowDirsOnly)
folder = dialog.getExistingDirectory(caption="Select Directory")
self._km.import_keys(folder)
def open_project(self):
"""
Opens a pyIMD project file (.xml) using the IntertialMassDetermination.load_pyimd_project method
"""
# Quick hack to distinguish action depending on sender
if self.sender().objectName() == 'actionOpen_project':
project_filter_ext = "XML (*.xml);; All files (*.*)"
file_dialog = QFileDialog()
file_dialog.setFileMode(QFileDialog.ExistingFiles)
selected_project_file = file_dialog.getOpenFileName(
self, "Select a pyIMD project file", self.last_selected_path,
project_filter_ext)
else:
selected_project_file = [self.current_batch_project_file]
if len(selected_project_file[0]) > 0:
try:
# Load pyimd project
self.imd.load_pyimd_project(selected_project_file[0])
# Update ui.Settings with parameters:
self.__settings = {
"figure_format": self.imd.settings.figure_format,
"figure_width": self.imd.settings.figure_width,
"figure_height": self.imd.settings.figure_height,
"figure_units": self.imd.settings.figure_units,
"figure_resolution_dpi":
self.imd.settings.figure_resolution_dpi,
"figure_name_pre_start_no_cell":
self.imd.settings.figure_name_pre_start_no_cell,
"figure_name_pre_start_with_cell":
self.imd.settings.figure_name_pre_start_with_cell,
"figure_name_measured_data":
self.imd.settings.figure_name_measured_data,
"figure_plot_every_nth_point":
self.imd.settings.figure_plot_every_nth_point,
"conversion_factor_hz_to_khz":
self.imd.settings.conversion_factor_hz_to_khz,
"conversion_factor_deg_to_rad":
self.imd.settings.conversion_factor_deg_to_rad,
"spring_constant": self.imd.settings.spring_constant,
"cantilever_length": self.imd.settings.cantilever_length,
"cell_position": self.imd.settings.cell_position,
"initial_parameter_guess":
self.imd.settings.initial_parameter_guess,
"lower_parameter_bounds":
self.imd.settings.lower_parameter_bounds,
"upper_parameter_bounds":
self.imd.settings.upper_parameter_bounds,
"rolling_window_size":
self.imd.settings.rolling_window_size,
"correct_for_frequency_offset":
self.imd.settings.correct_for_frequency_offset,
"frequency_offset_mode":
self.imd.settings.frequency_offset_mode,
"frequency_offset_n_measurements_used":
self.imd.settings.frequency_offset_n_measurements_used,
"frequency_offset": self.imd.settings.frequency_offset,
"read_text_data_from_line":
self.imd.settings.read_text_data_from_line,
"text_data_delimiter":
self.imd.settings.text_data_delimiter
}
self.settings_dialog.__init__(self.__settings)
self.settings_dialog.set_values()
# Update ui with loaded data:
self.last_selected_path = self.imd.settings.project_folder_path.replace(
"\\", "/")
self.file_list = []
for i in range(0, len(self.imd.settings.selected_files)):
self.file_list.append(pathlib.Path().joinpath(
self.last_selected_path,
self.imd.settings.selected_files[i]).as_posix())
self.show_data()
self.noCellDataBox.clear()
self.noCellDataBox.addItems(self.file_list)
index = self.noCellDataBox.findText(
self.imd.settings.pre_start_no_cell_path.replace(
"\\", "/"), QtCore.Qt.MatchFixedString)
if index >= 0:
self.noCellDataBox.setCurrentIndex(index)
self.withCellDataBox.clear()
self.withCellDataBox.addItems(self.file_list)
index = self.withCellDataBox.findText(
self.imd.settings.pre_start_with_cell_path.replace(
"\\", "/"), QtCore.Qt.MatchFixedString)
if index >= 0:
self.withCellDataBox.setCurrentIndex(index)
self.measuredDataBox.clear()
self.measuredDataBox.addItems(self.file_list)
index = self.measuredDataBox.findText(
self.imd.settings.measurements_path.replace("\\", "/"),
QtCore.Qt.MatchFixedString)
if index >= 0:
self.measuredDataBox.setCurrentIndex(index)
for i in range(0, len(self.radio_btn_name_array)):
radio_name = getattr(self, self.radio_btn_name_array[i])
if radio_name.text() == self.imd.settings.calculation_mode:
radio_name.setChecked(True)
self.print_to_console("Project {} successfully opened".format(
pathlib.Path(selected_project_file[0]).name))
except Exception as e:
self.print_to_console("Error during opening project in UI: " +
str(e))
else:
self.print_to_console("Project opening aborted by user")
def load_media_subs():
import_dir = mw.pm.profile.get("importDirectory", "")
myfilter = "Subtitles (*.lrc *.srt);;All Files (*.*)"
open_file_dialog = QFileDialog()
open_file_dialog.setFileMode(QFileDialog.ExistingFiles)
load_media_subs_paths = open_file_dialog.getOpenFileNames(mw,
"Select Sub to Import",
import_dir,
myfilter)[0]
if not load_media_subs_paths:
return
mw.addon_RTMD.loading_media_subs = True
# thread to get feed data
class LoadSubsThreadSignals(QObject):
error_message = pyqtSignal(str)
class LoadSubsThread(QRunnable):
def __init__(self, parent, sub_path):
super(LoadSubsThread, self).__init__()
self.parent = parent
self.sub_path = sub_path
self.signals = LoadSubsThreadSignals()
def run(self):
if self.parent.loading_media_subs_need_abort \
or (not self.sub_path.endswith(".lrc")
and not self.sub_path.endswith(".srt")):
self.signals.error_message.emit("")
return
media_path_no_ext = self.sub_path[:-4]
if not os.path.split(media_path_no_ext)[1]:
self.signals.error_message.emit("Bad file name: %s" % self.sub_path)
return
folder_name = os.path.split(os.path.split(media_path_no_ext)[1])[1]
if self.sub_path.endswith(".lrc"):
media_ext = ".mp3"
if not os.path.isfile(media_path_no_ext + ".mp3"):
self.signals.error_message.emit("File not found: %s" % media_path_no_ext + ".mp3")
return
else:
video_ext = (".mp4", ".mkv", ".avi", ".flv", ".m4v", ".f4v", ".rmvb")
media_ext = ""
for ext in video_ext:
if os.path.isfile(media_path_no_ext + ext):
media_ext = ext
break
if not media_ext:
self.signals.error_message.emit("Can found media file for: %s" % self.sub_path)
return
# try to open the sub file
is_ok, sub_data = get_file_data(self.sub_path)
if not is_ok:
self.signals.error_message.emit("Encoding should be utf-8: %s" % self.sub_path)
# save sub_text as <<<start=23,end=43||say something>>>
# pattern = r"<<<id=(\d+),start=(\d+),end=(\d+)\|\|(.*?)>>>"
struct_sub = ""
# parse lrc text
if self.sub_path.endswith(".lrc"):
lrc_dict = {}
re_lrc_line = re.compile(r"(\[\d+:\d+\.\d+\])")
re_lrc_time = re.compile(r"\[(\d+):(\d+)\.\d+\]")
for line_text in sub_data.splitlines():
line_text = line_text.strip()
if not line_text or not re_lrc_time.match(line_text):
continue
line_time_points = []
line_sub_text = ""
for element in re_lrc_line.split(line_text):
if element:
if re_lrc_line.match(element):
minute, second = re_lrc_time.match(element).groups()
line_time_points.append(int(minute) * 60 + int(second))
else:
line_sub_text += element.strip()
if line_sub_text:
for second in line_time_points:
if second in lrc_dict:
lrc_dict[second] += line_sub_text
else:
lrc_dict[second] = line_sub_text
if lrc_dict:
struct_master = "<<<start=%d,end=0||%s>>>"
for second in sorted(lrc_dict.keys()):
struct_sub += struct_master % (second, lrc_dict[second])
# parse srt text
else:
sub_data = sub_data.replace("\r", "").split("\n\n")
re_srt = re.compile(r"\d+\s*\n(\d+):(\d+):(\d+),\d+ --> (\d+):(\d+):(\d+),\d+\s*\n(.*)", re.DOTALL)
struct_master = "<<<start=%d,end=%d||%s>>>"
for data_block in sub_data:
if re_srt.match(data_block):
# ('00', '00', '10', '00', '00', '11', "想不出来了\nI'm out.")
mg = re_srt.match(data_block).groups()
if len(mg) < 7:
continue
struct_sub += struct_master % \
(int(mg[0]) * 3600 + int(mg[1]) * 60 + int(mg[2]),
int(mg[3]) * 3600 + int(mg[4]) * 60 + int(mg[5]),
mg[6].strip())
# write to db
conn = sqlite3.connect(get_path("user_files", "doc.db"))
conn.execute("insert or replace into subs "
+ "(media_path_no_ext, media_ext, folder_name, sub_text, create_date) values "
+ "(?, ?, ?, ?, current_timestamp)",
(media_path_no_ext, media_ext, folder_name, struct_sub))
conn.commit()
conn.close()
self.signals.error_message.emit("")
class LoadMediaDialog(QDialog):
def __init__(self, parent, load_media_subs_paths):
super().__init__(parent)
self.parent = parent
self.load_media_subs_paths = load_media_subs_paths
self.verticalLayout =QVBoxLayout(self)
self.progress_bar = QProgressBar(self)
self.progress_bar.setProperty("value", 0)
self.progress_bar.setObjectName("progress_bar")
self.verticalLayout.addWidget(self.progress_bar)
self.status_label = QLabel(self)
self.status_label.setText("")
self.status_label.setObjectName("")
self.verticalLayout.addWidget(self.status_label)
self.abort_button = QPushButton(self)
self.abort_button.setText("Abort The Loading")
self.abort_button.clicked.connect(self.abort)
self.verticalLayout.addWidget(self.abort_button)
# start the work
self.load_subs_error_message = ""
self.loading_media_subs_need_abort = False
self.load_subs_completed_thread_count = 0
for sub_path in self.load_media_subs_paths:
load_thread = LoadSubsThread(self, sub_path)
load_thread.signals.error_message.connect(self.load_error_msg_slot)
thread_pool = QThreadPool.globalInstance()
thread_pool.start(load_thread)
def load_error_msg_slot(self, signal_error_msg):
self.load_subs_completed_thread_count += 1
if signal_error_msg:
self.load_subs_error_message += signal_error_msg + "<p>"
self.progress_bar.setValue(int(self.load_subs_completed_thread_count * 100
/ len(self.load_media_subs_paths)))
self.status_label.setText("Completed Subs %s / %s"
% (self.load_subs_completed_thread_count,
len(self.load_media_subs_paths)))
if self.load_subs_completed_thread_count == len(self.load_media_subs_paths):
if not self.loading_media_subs_need_abort:
self.status_label.setText("Completed loading.")
if self.load_subs_error_message:
show_text(self.load_subs_error_message)
if mw.addon_RTMD.loading_media_subs:
mw.addon_RTMD.loading_media_subs = False
self.abort_button.setEnabled(False)
def abort(self):
self.loading_media_subs_need_abort = True
def closeEvent(self, event):
if not mw.addon_RTMD.loading_media_subs:
event.accept()
else:
event.ignore()
LoadMediaDialog(mw, load_media_subs_paths).show()
def load_from_text_file(self):
import_dir = mw.pm.profile.get("importDirectory", "")
myfilter = "TXT/HTML (*.txt *.html);;All Files (*.*)"
open_file_dialog = QFileDialog()
open_file_dialog.setFileMode(QFileDialog.ExistingFiles)
self.load_text_file_paths = open_file_dialog.getOpenFileNames(self,
"Select Files to Import",
import_dir,
myfilter)[0]
if not self.load_text_file_paths:
return
# disable buttons
self.manual_input_button.setEnabled(False)
self.load_text_button.setEnabled(False)
self.clean_aged_button.setEnabled(False)
self.add_feed_button.setEnabled(False)
self.remove_feed_button.setEnabled(False)
self.load_feed_button.setEnabled(False)
if "load_from_text_file" not in self.hard_work:
self.hard_work.append("load_from_text_file")
self.existing_doc_id_list_part = []
# thread to get feed data
class LoadTextThreadSignals(QObject):
exit_signal = pyqtSignal(str)
class LoadTextThread(QRunnable):
def __init__(self, parent, file_path):
super(LoadTextThread, self).__init__()
self.parent = parent
self.file_path = file_path
self.signals = LoadTextThreadSignals()
def run(self):
if self.parent.need_abort:
self.signals.exit_signal.emit("")
return
desc = ""
is_ok, desc = get_file_data(self.file_path)
if not is_ok:
self.signals.exit_signal.emit("Need UTF-8 Encoding: %s" % self.file_path)
return
if desc:
link_to_set = '<p><p><a href="%s">%s</a>' % (self.file_path, self.file_path)
if "</body>" in desc:
desc = desc.replace("</body>", link_to_set + "</body>")
else:
desc = desc + link_to_set
title = os.path.basename(self.file_path)
conn = sqlite3.connect(get_path("user_files", "doc.db"),
detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
cur = conn.cursor()
cur.execute("select feed_id from doc where feed_id between ? and ?",
(int(time.time()*1000), int(time.time()*1000)+10000))
while True:
doc_id = int(time.time()*1000)
if doc_id not in self.parent.existing_doc_id_list_part:
break
self.parent.existing_doc_id_list_part.append(doc_id)
cur.execute("""insert into doc
(doc_id, link, title, descr, doc_type)
values (?, ?, ?, ?, 'tf')""",
(doc_id, self.file_path, title, desc))
conn.commit()
conn.close()
self.signals.exit_signal.emit("")
def load_exit_msg_slot(signal_error_msg):
self.load_text_completed_thread_count += 1
if signal_error_msg:
self.load_text_file_error_message += signal_error_msg + "<p>"
self.status_label.setText("Completed files %s / %s"
% (self.load_text_completed_thread_count,
len(self.load_text_file_paths)))
if self.load_text_completed_thread_count == len(self.load_text_file_paths):
if self.hard_work:
self.hard_work.remove("load_from_text_file")
if not self.need_abort:
self.status_label.setText("Completed loading.")
if not self.hard_work and self.need_abort:
self.need_abort = False
if self.load_text_file_error_message:
QMessageBox(QMessageBox.Warning, "Warning", self.load_text_file_error_message).exec()
self.load_text_file_error_message = ""
# enable buttons
self.manual_input_button.setEnabled(True)
self.load_text_button.setEnabled(True)
self.clean_aged_button.setEnabled(True)
self.add_feed_button.setEnabled(True)
self.remove_feed_button.setEnabled(True)
self.load_feed_button.setEnabled(True)
self.load_text_completed_thread_count = 0
self.load_text_file_error_message = ""
for file_path in self.load_text_file_paths:
load_thread = LoadTextThread(self, file_path)
load_thread.signals.exit_signal.connect(load_exit_msg_slot)
thread_pool = QThreadPool.globalInstance()
thread_pool.start(load_thread)
