def __init__(self, parent=None, in_designer=False):
super().__init__(parent=parent)
self.in_designer = in_designer
ui = 'faultlogview.ui'
# TODO: CAMPid 9549757292917394095482739548437597676742
if not QtCore.QFileInfo(ui).isAbsolute():
ui_file = os.path.join(
QtCore.QFileInfo.absolutePath(QtCore.QFileInfo(__file__)),
ui,
)
else:
ui_file = ui
ui_file = QtCore.QFile(ui_file)
ui_file.open(QtCore.QFile.ReadOnly | QtCore.QFile.Text)
ts = QtCore.QTextStream(ui_file)
sio = io.StringIO(ts.readAll())
self.ui = PyQt5.uic.loadUi(sio, self)
view = self.ui.tree_view
view.setSelectionBehavior(view.SelectRows)
view.setSelectionMode(view.ExtendedSelection)
self.model = None
self.ui.clear_button.clicked.connect(self.clear)
def __init__(self, ui_file):
# # TODO: CAMPid 980567566238416124867857834291346779
# ico_file = os.path.join(QtCore.QFileInfo.absolutePath(QtCore.QFileInfo(__file__)), 'icon.ico')
# ico = QtGui.QIcon(ico_file)
# self.setWindowIcon(ico)
logging.debug('Loading UI from: {}'.format(ui_file))
ui = ui_file
# TODO: CAMPid 9549757292917394095482739548437597676742
if not QtCore.QFileInfo(ui).isAbsolute():
ui_file = os.path.join(
QtCore.QFileInfo.absolutePath(QtCore.QFileInfo(__file__)), ui)
else:
ui_file = ui
ui_file = QtCore.QFile(ui_file)
ui_file.open(QtCore.QFile.ReadOnly | QtCore.QFile.Text)
ts = QtCore.QTextStream(ui_file)
sio = io.StringIO(ts.readAll())
self.ui = PyQt5.uic.loadUi(sio)
self.ui.action_open.triggered.connect(lambda _: self.open())
self.ui.action_save.triggered.connect(lambda _: self.save())
self.ui.action_save_as.triggered.connect(self.save_as)
self.filters = [('JSON', ['json']), ('All Files', ['*'])]
self.view_models = {}
self.filename = None
def setDatabase(self, file: object) -> None:
""" Setter for the vulnerability's database
Args:
file (str | QtCore.QFileInfo): The database object to set
"""
if not isinstance(file, QtCore.QFileInfo):
file = self.absoluteFilePath(QtCore.QFileInfo(str(file)).fileName())
self._database = QtCore.QFileInfo(file)
def load_url(self):
# QUrl.fromLocalFile(QtCore.QFileInfo("template.html").absoluteFilePath())
url = QUrl.fromLocalFile(
QtCore.QFileInfo("template.html").absoluteFilePath())
url2 = QUrl.fromLocalFile(
QtCore.QFileInfo("template2.html").absoluteFilePath())
self.OverallCanvas.load(url)
self.OverallCanvas.loadFinished.connect(self.SelectGraph)
self.PartitionCanvas.load(url2)
self.PartitionCanvas.loadFinished.connect(self.DrawPartitionCanvas)
def downloadRequestHandler(self, downloadItem):
qurl, path = QtWidgets.QFileDialog.getSaveFileName(
self, "Save as",
QtCore.QDir(downloadItem.downloadDirectory()).filePath(
downloadItem.downloadFileName()))
if not path:
return
downloadItem.setDownloadDirectory(QtCore.QFileInfo(path).path())
downloadItem.setDownloadFileName(QtCore.QFileInfo(path).fileName())
downloadItem.accept()
def runtoprob(self):
try:
self.path = QtCore.QFileInfo(self.filename).path()
except AttributeError:
pass
self.path = QtCore.QFileInfo(self.filename).path()
g = globals()
os.chdir(str(self.path))
script = str(self.codebox.text())
import cProfile
cProfile.run(script)
def load_pre(self, filePath=None):
# if no filename provided, ask for one
if not filePath:
openFileName = QtWidgets.QFileDialog().getOpenFileName(
self, 'Open spike file', "*.txt")[0]
path = QtCore.QFileInfo(openFileName)
else:
path = QtCore.QFileInfo(filePath)
voltage = []
time = []
try:
arraydata = np.loadtxt(path.absoluteFilePath(),
dtype=float,
delimiter=',',
comments='#')
for row in arraydata:
(v, t) = row
voltage.append(v)
time.append(t)
self.pre_voltage = voltage
self.pre_time = time
if self.check_identical.isChecked():
self.post_voltage = voltage
self.post_time = time
self.max_spike_time = max(
[self.pre_time[-1], self.post_time[-1]])
self.slider.setValue(50)
self.fix_spike_timescales()
self.updateSpikes(50.0)
elif self.post_voltage and self.post_time:
self.max_spike_time = max(
[self.pre_time[-1], self.post_time[-1]])
self.fix_spike_timescales()
self.slider.setValue(50)
self.updateSpikes(50.0)
self.pre_full_filename = path.canonicalFilePath()
self.pre_filename.setText(path.baseName())
except BaseException as exc:
errMessage = QtWidgets.QMessageBox()
errMessage.setText(
"Invalid spike file! " +
"Possible problem with voltage-time series syntax.")
errMessage.setIcon(QtWidgets.QMessageBox.Critical)
errMessage.setWindowTitle("Error")
errMessage.exec_()
def __init__(self, parent=None, pathMode=0):
QtWidgets.QDialog.__init__(self, parent)
uic.loadUi('{}/dbselect.ui'.format(os.path.dirname(utils.__file__)), self)
self.customDbFilePath = QtCore.QFileInfo(QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.HomeLocation)[0]).filePath('ship.sqlite'))
self.tempDbFilePath = QtCore.QFileInfo(QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.TempLocation)[0]).filePath('ship.sqlite'))
self.existingDbFilePath = QtCore.QFileInfo()
self.dbPathCombo.currentIndexChanged.connect(self.updateDbPath)
self.dbBrowseFunc = self.dbBrowseCustomPath
self.dbBrowseBtn.clicked.connect(lambda: self.dbBrowseFunc())
self.OkBtn = self.buttonBox.button(self.buttonBox.Ok)
self.dbPathCombo.setCurrentIndex(pathMode)
self.state = self.dbError
self.updateDbPath(pathMode)
def _doCopyFile(self, src, dst):
srcFile = QtCore.QFileInfo(src)
dstFile = QtCore.QFileInfo(dst)
dstFileLoc = dstFile.absolutePath()
if (not os.path.exists(dstFileLoc)):
os.makedirs(dstFileLoc)
src, dst = srcFile.absoluteFilePath(), dstFile.absoluteFilePath()
shutil.copy(src, dst)
self.tls.info("\nCopied...\n{}\nto\n{}".format(src, dst))
if (os.path.exists(dstFile.absoluteFilePath())):
self._doProcessFile(dstFile.absoluteFilePath())
def _doFilters(self, src, dst):
srcFile = QtCore.QFileInfo(src)
dstFile = QtCore.QFileInfo(dst)
ignoreList = ['__pycache__']
ignore = False
for eachIgnoreItem in ignoreList:
if eachIgnoreItem in srcFile.absoluteFilePath():
ignore = True
if (not ignore):
self._doCopyFile(src, dst)
def runtoprob(self):
try:
self.path = QtCore.QFileInfo(self.filename).path()
self.path = QtCore.QFileInfo(self.filename).path()
g = globals()
os.chdir(str(self.path))
script = str(self.codebox.text())
import cProfile
cProfile.run(script)
except Exception as e:
print e.__doc__
print e.message
else:
import cProfile
cProfile.run(script)
def rep(self, repertoire, nom):
rep = repertoire.text()
if rep:
if QtCore.QFileInfo(rep).exists():
QtCore.QSettings().setValue("/DICT/" + nom, rep)
else:
if str(QtCore.QFileInfo(rep).path()) != '.':
QtCore.QSettings().setValue("/DICT/" + nom,
QtCore.QFileInfo(rep).path())
else:
QtCore.QSettings().setValue("/DICT/" + nom,
QtCore.QDir.homePath())
else:
QtCore.QSettings().setValue("/DICT/" + nom, QtCore.QDir.homePath())
repertoire.setText(QtCore.QSettings().value("/DICT/" + nom))
def __init__(self, parent):
QtCore.QObject.__init__(self, parent)
self.lock = Lock()
self.dbFile = None
self.dbConn = None
self.dbCursor = None
self.initialized = False
self.tagColorsDict = {}
self.settings = QtCore.QSettings()
self.dbBackupTimer = QtCore.QTimer()
self.dbBackupTimer.timeout.connect(self.doDbBackup)
dataDir = QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.AppDataLocation)[0])
defaultDbFile = QtCore.QFileInfo(dataDir.filePath('sample.sqlite'))
dbFile = QtCore.QFileInfo(self.settings.value('dbPath', defaultDbFile.absoluteFilePath(), type=str))
self.loadDb(dbFile)
def saveSession(self, new=False):
if APP.workingDirectory:
if (not new) and APP.saveFileName:
path = APP.workingDirectory
else:
path_ = QtCore.QFileInfo(QtWidgets.QFileDialog.getSaveFileName(self, \
'Save File', APP.workingDirectory, constants.SAVE_FI_PATTERN)[0])
path = path_.filePath()
APP.saveFileName = path_.fileName()
APP.workingDirectory = path_.filePath()
else:
path_ = QtCore.QFileInfo(QtWidgets.QFileDialog.getSaveFileName(self, \
'Save File', '', constants.SAVE_FI_PATTERN)[0])
path = path_.filePath()
APP.saveFileName = path_.fileName()
APP.workingDirectory = path_.filePath()
if len(path) > 0:
if str(path).endswith('csv.gz'):
opener = gzip.open
else:
opener = open
with opener(str(path), 'w', newline='') as stream:
writer = csv.writer(stream)
# Header
writer.writerow([APP.sessionName])
writer.writerow([time.strftime("%c")])
writer.writerow([
'Wordline', 'Bitline', 'Resistance', 'Amplitude (V)',
'Pulse width (s)', 'Tag', 'ReadTag', 'ReadVoltage'
])
# Actual data
for w in range(1, HW.conf.words + 1):
for b in range(1, HW.conf.bits + 1):
for row in range(len(CB.history[w][b])):
rowdata = [w, b]
# drop the start index, it's ephemeral
# and it's only needed for runtime
for item in CB.history[w][b][row][:-1]:
if item is not None:
rowdata.append(item)
else:
rowdata.append('')
writer.writerow(rowdata)
self.saveAction.setEnabled(False)
def downloadFile(self):
self.url = QtCore.QUrl(self.urlLineEdit.text())
fileInfo = QtCore.QFileInfo(self.url.path())
fileName = fileInfo.fileName()
if not fileName:
fileName = 'index.html'
if QtCore.QFile.exists(fileName):
ret = QtWidgets.QMessageBox.question(
self, "HTTP",
"There already exists a file called %s in the current directory. Overwrite?"
% fileName,
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
QtWidgets.QMessageBox.No)
if ret == QtWidgets.QMessageBox.No:
return
QtCore.QFile.remove(fileName)
self.outFile = QtCore.QFile(fileName)
if not self.outFile.open(QtCore.QIODevice.WriteOnly):
QtWidgets.QMessageBox.information(
self, "HTTP", "Unable to save the file %s: %s." %
(fileName, self.outFile.errorString()))
self.outFile = None
return
self.progressDialog.setWindowTitle("HTTP")
self.progressDialog.setLabelText("Downloading %s." % fileName)
self.downloadButton.setEnabled(False)
self.httpRequestAborted = False
self.startRequest(self.url)
def openfile(self):
"""Open a file using a FileDialog and only show csv files."""
if self.path:
f = QtGui.QFileDialog.getOpenFileName(directory=self.path,
filter="CSV data (*.csv)")[0]
else:
import os.path
if os.path.exists("X:\Spectrophotometer Jasco V-650"):
self.path = os.path.normpath(
'X:/Spectrophotometer Jasco V-650')
else:
self.path = os.path.normpath('C:/')
f = QtGui.QFileDialog.getOpenFileName(directory=self.path,
filter="CSV data (*.csv)")[0]
print(f) # Print it to the IPython console!
self.path = QtCore.QFileInfo(f).path() # store path for next time
# If there's a file, load it using Pandas!
if (f and len(self.curves) < len(self.buttonclist)):
new = Curve(f)
self.curves.append(new)
self.changelabel(f)
#print(len(self.curves))
self.doplot()
def add_file(self, filename):
"""
Add a file or directory to this widget.
"""
if filename not in self.filenames:
self.filenames.append(filename)
fileinfo = QtCore.QFileInfo(filename)
basename = os.path.basename(filename.rstrip('/'))
ip = QtWidgets.QFileIconProvider()
icon = ip.icon(fileinfo)
if os.path.isfile(filename):
size = helpers.human_readable_filesize(fileinfo.size())
else:
size = helpers.human_readable_filesize(
helpers.dir_size(filename))
item_name = '{0:s} ({1:s})'.format(basename, size)
item = QtWidgets.QListWidgetItem(item_name)
item.setToolTip(size)
item.setIcon(icon)
self.addItem(item)
self.files_updated.emit()
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(1439, 744)
root = QtCore.QFileInfo(__file__).absolutePath()
Form.setWindowIcon(QtGui.QIcon(root + '/icons/fav.ico'))
# 1.上传三率一面数据
self.upload_slym = QtWidgets.QPushButton(Form)
self.upload_slym.setGeometry(QtCore.QRect(40, 660, 181, 51))
self.upload_slym.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.upload_slym.setObjectName("upload_slym")
self.upload_slym.clicked.connect(self.Load_slym)
# 2.生成投放策略
self.calc_strategy = QtWidgets.QPushButton(Form)
self.calc_strategy.setGeometry(QtCore.QRect(250, 660, 181, 51))
self.calc_strategy.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.calc_strategy.setObjectName("calc_strategy")
self.calc_strategy.clicked.connect(self.Calc_strategy)
# 显示投放策略
self.strategy_tableView = QtWidgets.QTableView(Form)
self.strategy_tableView.setGeometry(QtCore.QRect(40, 30, 1351, 591))
self.strategy_tableView.setObjectName("strategy_tableView")
# 导出CSV文件
self.output_csv = QtWidgets.QPushButton(Form)
self.output_csv.setGeometry(QtCore.QRect(1210, 660, 181, 51))
self.output_csv.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.output_csv.setObjectName("output_csv")
self.output_csv.clicked.connect(self.Output_csv)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def filesave(self):
if self.filename.startswith("Untitled"):
self.filename = QtWidgets.QFileDialog.getSaveFileName(self, "保存脚本文件", self.filename, "TINY+ files (*.TNY)")[0]
with open(self.filename, 'w') as file:
file.write(self.input.toPlainText())
self.output.setText("文件保存成功！")
self.setWindowTitle("TINY+ Language Compiler " + QtCore.QFileInfo(self.filename).fileName())
def __init__(self, parent, dirList, fileList, scanMode, formats, sampleRates, channels, scanLimits, tag):
if dirList:
ImportDialogScan.__init__(self, parent, dirList, scanMode, formats, sampleRates, channels, scanLimits)
self.defaultTags = [tag]
else:
ImportDialog.__init__(self, parent)
unknownFiles = []
self.dirList = dirList
for filePath in fileList:
try:
info = soundfile.info(filePath)
except:
unknownFiles.append(filePath)
continue
fileInfo = QtCore.QFileInfo(filePath)
fileItem = QtGui.QStandardItem(fileInfo.fileName())
fileItem.setData(filePath, FilePathRole)
fileItem.setData(info, InfoRole)
fileItem.setToolTip(fileInfo.fileName())
fileItem.setCheckable(True)
fileItem.setCheckState(QtCore.Qt.Checked)
dirItem = QtGui.QStandardItem(fileInfo.absolutePath())
dirItem.setToolTip(fileInfo.absoluteFilePath())
lengthItem = QtGui.QStandardItem('{:.3f}'.format(float(info.frames) / info.samplerate))
formatItem = QtGui.QStandardItem(info.format)
rateItem = QtGui.QStandardItem(str(info.samplerate))
channelsItem = QtGui.QStandardItem(str(info.channels))
subtypeItem = QtGui.QStandardItem(info.subtype)
tagsItem = QtGui.QStandardItem()
tagsItem.setData([tag], TagsRole)
self.sampleModel.appendRow([fileItem, dirItem, lengthItem, formatItem, rateItem, channelsItem, subtypeItem, tagsItem])
def media_length(self, service_item):
"""
Loads and starts a media item to obtain the media length
:param service_item: The ServiceItem containing the details to be played.
"""
media_info = MediaInfo()
media_info.volume = 0
media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
# display = controller.preview_display
suffix = '*.%s' % media_info.file_info.suffix().lower()
used_players = get_media_players()[0]
player = self.media_players[used_players[0]]
if suffix not in player.video_extensions_list and suffix not in player.audio_extensions_list:
# Media could not be loaded correctly
critical_error_message_box(
translate('MediaPlugin.MediaItem', 'Unsupported Media File'),
translate('MediaPlugin.MediaItem',
'File %s not supported using player %s') %
(service_item.get_frame_path(), used_players[0]))
return False
media_data = MediaInfoWrapper.parse(service_item.get_frame_path())
# duration returns in milli seconds
service_item.set_media_length(media_data.tracks[0].duration)
return True
def add_image(self):
filename = QFileDialog.getOpenFileName(self, 'Выбрать картинку', '')[0]
# диалог возвращает полный путь к файлу "D:\.."
# нам нужно только имя файла - функция filename()
fname = QtCore.QFileInfo(filename).fileName()
con = sqlite3.connect("image.db")
cur = con.cursor()
# Создаем список жанров чтобы пользователь выбрал к какому жанру будет относится картинка
result = cur.execute("""SELECT genre from genres""").fetchall()
genres = []
for elem in result:
genres.append(elem[0])
con.close()
i, okBtnPressed = QInputDialog.getItem(self, "Выберите тему", "Тема",
genres, 0, False)
# к индексу в псике добавляем 1 так как ID у жанров в таблице начинаются с 1
genre_id = genres.index(i) + 1
if okBtnPressed:
im_name, okPressed = QInputDialog.getText(
self, "Ввод данных", "Введите название картинки:",
QLineEdit.Normal, "")
if okPressed:
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("image.db")
db.open()
model = QtSql.QSqlQueryModel(parent=None)
# добавляем запись в images
sql_text = f"INSERT INTO images (im_file, genre, im_name) VALUES ('{fname}',{genre_id},'{im_name}')"
model.setQuery(sql_text)
model.query().exec_()
# и обновляем таблицу
self.refresh_table()
db.close()
def updateFiles(self):
"""
Update files list, only when the last modified timestamp if newer.
It makes small insert/remove by inspecting the incremental difference.
"""
fileTime = QtCore.QFileInfo(
self.fileRootPath.absolutePath()).lastModified()
if self.fileTime >= fileTime:
return
self.fileTime = fileTime
self.fileRootPath.refresh()
fileInfoList = self.fileRootPath.entryInfoList()
fileListOld = [fi.fileName() for fi in self.fileInfoList]
fileListNew = [fi.fileName() for fi in fileInfoList]
difflist = list(difflib.ndiff(fileListOld, fileListNew))
i = 0
for k, g in itertools.groupby(difflist, key=lambda x: x[0]):
g = list(v[2:] for v in g)
if k == ' ':
i += len(g)
elif k == '-':
self.beginRemoveRows(QtCore.QModelIndex(), i, i + len(g))
self.fileInfoList[i:i + len(g)] = []
self.endRemoveRows()
elif k == '+':
self.beginInsertRows(QtCore.QModelIndex(), i, i + len(g))
self.fileInfoList[i:i] = fileInfoList[i:i + len(g)]
i += len(g)
self.endInsertRows()
def __init__(self, path, extensions, order=None, parent=None):
QtCore.QAbstractListModel.__init__(self, parent)
self._path = os.path.abspath(str(path))
self._extensions = extensions
# Load existing
def isImage(f):
if not os.path.isfile(os.path.join(self._path, f)):
return False
for e in extensions:
if f.lower().endswith("." + e):
return True
return False
try:
self._files = [
QtCore.QFileInfo(os.path.join(self._path, f))
for f in os.listdir(self._path) if isImage(f)
]
except (OSError, IOError) as e:
msg = "WARNING: Cannot read images from path '{0}'.\n"
sys.stderr.write(msg.format(self._path))
self._files = []
if order:
self.order(order)
self.__thumbnailCache = QtGui.QPixmapCache()
def present_answer(self, type, answer):
self.jeopardy_wall_box.setHidden(True)
self.answer_box.setHidden(False)
if type == "text":
self.answer_label.setHidden(False)
answer = answer.split("\\n")
answer_out = []
for line in answer:
answer_out.append("\n".join(wrap(line, answer_length)))
self.answer_label.setText("\n".join(answer_out))
elif type == "image":
self.answer_label.setHidden(False)
image = self.scale(
QtGui.QPixmap(os.path.join(self.file_head, answer)))
self.answer_label.setPixmap(image)
elif type == "video":
self.video_widget.setVisible(True)
media_source = QtMultimedia.QMediaContent(
QtCore.QUrl.fromLocalFile(
QtCore.QFileInfo(os.path.join(self.file_head,
answer)).absoluteFilePath()))
self.video_player.setMedia(media_source)
self.video_player.play()
elif type == "audio":
self.answer_label.setHidden(False)
self.answer_label.setText("listen up!")
self.audio = Jeopardy.Music(os.path.join(self.file_head, answer))
self.audio.play()
elif type == "audiotext":
text_split = answer.split(";")
self.answer_label.setHidden(False)
self.answer_label.setText(text_split[1])
self.audio = Jeopardy.Music(
os.path.join(self.file_head, text_split[0]))
self.audio.play()
def playRandomAudio(self):
try:
selector = randint(0, len(self.dataset) - 1)
""" we do not want the same audio played multiple times on a row """
depth = 0
while selector == self.last_random_audio:
selector = randint(0, len(self.dataset) - 1)
""" to avoid infinite loops with just one element """
depth += 1
if depth > 20:
break
self.last_random_audio = selector
filename = self.dataset[selector]["filename"]
self.current_audio_deck_id = self.dataset[selector]["rowid"]
filepath = path.join(self.deckpath, filename)
url = QtCore.QUrl.fromLocalFile(
QtCore.QFileInfo(filepath).absoluteFilePath())
content = QMediaContent(url)
self.audioPlayer.setMedia(content)
self.audioPlayer.play()
except ValueError:
""" probably an empty deck. just do nothing"""
pass
def add_file(self, filename):
"""
Add a file or directory to this widget.
"""
if filename not in self.filenames:
if not os.access(filename, os.R_OK):
Alert(strings._("not_a_readable_file", True).format(filename))
return
self.filenames.append(filename)
fileinfo = QtCore.QFileInfo(filename)
basename = os.path.basename(filename.rstrip('/'))
ip = QtWidgets.QFileIconProvider()
icon = ip.icon(fileinfo)
if os.path.isfile(filename):
size = common.human_readable_filesize(fileinfo.size())
else:
size = common.human_readable_filesize(
common.dir_size(filename))
item_name = '{0:s} ({1:s})'.format(basename, size)
item = QtWidgets.QListWidgetItem(item_name)
item.setToolTip(size)
item.setIcon(icon)
self.addItem(item)
self.files_updated.emit()
def showDialog(self):
self.int_obj.selIntButton.setEnabled(False)
# filepath = QtWidgets.QFileDialog.getOpenFileName(self, 'Open file', '/home')
par_obj.file_array = []
path = None
for path in QtWidgets.QFileDialog.getOpenFileNames(
self, "Open files", self.par_obj.filepath, "Images(*.tif *.tiff *.mrc *.dv);;"
):
if path != "" and path != "Images(*.tif *.tiff *.mrc *.dv)":
if type(path) is not list:
par_obj.file_array.append(path)
else:
par_obj.file_array
par_obj.file_array = par_obj.file_array + path
if path == None:
return
if len(par_obj.file_array) > 0:
self.par_obj.config["evalpath"] = str(QtCore.QFileInfo(path).absolutePath()) + "/"
pickle.dump(self.par_obj.config, open(str(os.path.expanduser("~") + "/.densitycount/config.p"), "wb"))
self.par_obj.csvPath = self.par_obj.config["evalpath"]
v2.import_data_fn(par_obj, par_obj.file_array)
self.int_obj.image_status_text.showMessage("Status: Loading Images. ")
if self.type == "im":
if self.par_obj.file_array.__len__() > 0:
self.int_obj.selIntButton.setEnabled(True)
self.refreshTable()
def getOpenProject(workdir: str,
appTitle: str = None,
parent: 'QtWidgets.QWidget' = None
) -> ('QtPtObjects.QProject', bool):
""" Open file dialog to select a project to open (i.e. a JSON file).
If the selected JSON file match a valid project, successfully return
the project object, else return None.
Args:
workdir (str): The working directory from which to start searching for JSON files
appTitle (str): The dialog title (default None)
parent (QtWidgets.QWidget): The parent widget on which to anchor the dialog
Returns:
(QtPtObjects.QProject, bool): The opened project and the state of success or not
"""
fileName, selectedFilter = QtWidgets.QFileDialog.getOpenFileName(
parent, 'Open JSON project file', workdir, 'JSON files (*.json)')
if len(fileName) == 0:
return None, False
file = QtCore.QFileInfo(fileName)
folder, database = file.absolutePath(), file.fileName()
if not QtPtObjects.QProject.isProject(folder, database):
msg = f'The selected file does not exist or is not a valid JSON document \n({fileName})'
result = QtWidgets.QMessageBox.critical(parent, 'Error', msg,
QtWidgets.QMessageBox.Ok)
return None, False
return QtPtObjects.QProject(folder, database).read(), True
def __init__(self, source="data/music.ogg"):
super(Jeopardy.Music, self).__init__()
url = QtCore.QUrl.fromLocalFile(
QtCore.QFileInfo(source).absoluteFilePath())
content = QtMultimedia.QMediaContent(url)
self.player = QtMultimedia.QMediaPlayer()
self.player.setMedia(content)
