def saveCSVFile(self, activated=False, filePath = None):
if self.df is None or self.df_dist is None or self.df_region is None or self.relation_matrix is None:
return
dirctory = os.path.dirname(self.filePath)
base_name = os.path.splitext(os.path.basename(self.filePath))[0]
path = os.path.join(dirctory, '{0}-info.txt'.format(base_name))
filePath, _ = QFileDialog.getSaveFileName(None, 'Save TXT File', path, "TXT files (*.txt)")
names = list(map(lambda x: x.data(Qt.UserRole), self.getCol(0)))
items = [self.graphics_items[name] for name in names]
point_list = list(filter(lambda x:type(x[1]) is FigureType.Point.value, zip(names, items)))
if len(filePath) is not 0 and len(point_list) is not 0:
logger.debug("Saving CSV file: {0}".format(filePath))
with open(filePath, "w") as fp:
for name, item in point_list:
fp.write('{0} : {1}'.format(name, item.getPoints()))
for attr in ['distance', 'region']:
path = os.path.join(dirctory, '{0}-{1}.csv'.format(base_name, attr))
filePath, _ = QFileDialog.getSaveFileName(None, 'Save CSV File', path, "CSV files (*.csv)")
if len(filePath) is not 0:
logger.debug("Saving CSV file: {0}".format(filePath))
if attr=='distance':
self.df_dist.to_csv(filePath)
elif attr=='region':
self.df_region.to_csv(filePath)
path = os.path.join(dirctory, '{0}-relation.csv'.format(base_name))
filePath, _ = QFileDialog.getSaveFileName(None, 'Save CSV File', path, "CSV files (*.csv)")
if len(filePath) is not 0:
pd.DataFrame(self.relation_matrix).to_csv(filePath)
self.savedFlag = True
def saveDataFiles(self, activated=False, filePath = None):
if len(self.df.keys())!=0:
for k, v in self.df.items():
f_name, f_ext = os.path.splitext(self.file_name_dict[k])
candidate_file_path = '{0}-fixed{1}'.format(f_name, f_ext)
filePath, _ = QFileDialog.getSaveFileName(None, 'Save CSV File', candidate_file_path, "CSV files (*.csv)")
if len(filePath) is not 0:
logger.debug("Saving CSV file: {0}".format(filePath))
df = v.copy()
col_n = df.as_matrix().shape[1]/2
col_names = np.array([('x{0}'.format(i), 'y{0}'.format(i)) for i in range(int(round(col_n)))]).flatten()
df.columns = pd.Index(col_names)
df.to_csv(filePath)
for k, v in self.line_data_dict.items():
f_name, f_ext = os.path.splitext(self.file_name_dict[k])
candidate_file_path = '{0}-fixed{1}'.format(f_name, f_ext)
filePath, _ = QFileDialog.getSaveFileName(None, 'Save JSON File', candidate_file_path, "JSON files (*.json)")
if len(filePath) is not 0:
logger.debug("Saving JSON file: {0}".format(filePath))
with open(filePath, 'w') as f_p:
json.dump(v, f_p)
def actionExport(self):
if using_qt5:
export_as = QFileDialog.getSaveFileName(self, "Export as...")[0]
else:
export_as = QFileDialog.getSaveFileName(self, "Export as...")
create_code = codegen.codegen(self, "mynode", self.blocks, self.resolution)
if export_as != "":
create_code.writeToFile(export_as)
def actionSave(self):
if using_qt5:
save_as = QFileDialog.getSaveFileName(self, "Save as...")[0]
else:
save_as = QFileDialog.getSaveFileName(self, "Save as...")
if save_as != "":
output_file = open(save_as, "w+")
for b in self.blocks:
output_file.write(" ".join([
str(b.p1()[0]), str(b.p1()[2]), str(b.p1()[1]),
str(b.p2()[0]), str(b.p2()[2]), str(b.p2()[1])]) + "\n")
output_file.close()
def saveControls(self):
self.parser.set('CONN', 'afmip',self.afmIpLine.text())
self.parser.set('CONN', 'afmsubport',str(self.afmSubPortNum.value()))
self.parser.set('CONN', 'afmpubport',str(self.afmPubPortNum.value()))
self.parser.set('CONN', 'curvename',self.curveNameLine.text())
self.parser.set('CONN', 'monitname',self.monitNameLine.text())
self.parser.set('CONN', 'xycmd',self.xyCmdTagLine.text())
self.parser.set('CONN', 'xyres',self.xyResTagLine.text())
self.parser.set('PIEZO', 'vmax',str(self.maxPiezoVoltNumDbl.value()))
self.parser.set('PIEZO', 'vmin',str(self.minPiezoVoltNumDbl.value()))
self.parser.set('PIEZO', 'zmax',str(self.maxPiezoExtNumDbl.value()))
self.parser.set('PIEZO', 'zmin',str(self.minPiezoExtNumDbl.value()))
self.parser.set('PIEZO','nearfar',str(self.farNearCmbBox.currentIndex()))
self.parser.set('PIEZO','movobj',str(self.movingObjCmbBox.currentIndex()))
self.parser.set('PIEZO', 'maxspeed',str(self.maxSpeedNumDbl.value()))
self.parser.set('PIEZO', 'tostartspeed',str(self.toStartSpeedNumDbl.value()))
self.parser.set('OTHER','deflsign',str(self.deflSignCmbBox.currentIndex()))
self.parser.set('OTHER','deflmax',str(self.maxDeflVoltNumDbl.value()))
self.parser.set('OTHER','deflmin',str(self.minDeflVoltNumDbl.value()))
self.parser.set('OTHER', 'sumthr',str(self.sumThrNumDbl.value()))
self.parser.set('OTHER', 'imax',str(self.iGainMaxNumDbl.value()))
self.parser.set('OTHER', 'pmax',str(self.pGainMaxNumDbl.value()))
self.parser.set('OTHER', 'defdir', self.defDirLine.text())
self.parser.set('OTHER', 'defbasename', self.defBaseNameLine.text())
warningDial = QMessageBox(self)
warningDial.setWindowTitle('Saving...')
warningDial.setText('Do you want to create a new configuration file?')
warningDial.setStandardButtons(QMessageBox.Yes|QMessageBox.No)
warningDial.setDefaultButton(QMessageBox.No)
answer = warningDial.exec_()
if answer == 65536:
fp = open(self.cfgFile,'w')
else:
if ENV == 'PyQt5':
fname = str(QFileDialog.getSaveFileName(self,'Choose a name for your new configuration file:',filter='Ini (*.ini)')[0])
else:
fname = str(QFileDialog.getSaveFileName(self,'Choose a name for your new configuration file:',filter='Ini (*.ini)'))
sf = splitext(fname)
if sf[1] != '.ini':
fname = sf[0]+'.ini'
fp = open(fname,'w')
self.parser.write(fp)
fp.close()
def save_workspace(self):
filename = QFileDialog.getSaveFileName(self, "Save analysis workspace", "workspace.apolw",
"Apol Workspace Files (*.apolw);;"
"All Files (*)")[0]
if not filename:
return
workspace = {}
workspace["__policy__"] = os.path.abspath(str(self._policy))
workspace["__permmap__"] = os.path.abspath(str(self._permmap))
workspace["__tabs__"] = []
for index in range(self.AnalysisTabs.count()):
tab = self.AnalysisTabs.widget(index)
settings = tab.save()
# add the tab info to the settings.
settings["__title__"] = self.AnalysisTabs.tabText(index)
settings["__tab__"] = type(tab).__name__
workspace["__tabs__"].append(settings)
with open(filename, "w") as fd:
json.dump(workspace, fd, indent=1)
def save(self):
#: So self.title has to be modified
self.save_title = self.title.split(' ')[1] + '.png'
print('save_title is ', self.save_title)
if "edr" in self.filename:
filename = QFileDialog.getSaveFileName(self,
"G.R.O.M. Editor -- Save File As", self.save_title,
"png (*.png *.*)")
print('filename is ', filename)
if len(filename[0]) == 0:
return
self.filenameSave = filename[0]
print('Save graph ', self.filenameSave)
# self.setWindowTitle(QFileInfo(self.filename).fileName())
exception = None
fh = None
try:
# fh = QFile(self.filenameSave)
# if not fh.open(QIODevice.WriteOnly):
# raise IOError(str(fh.errorString()))
self.plotToolWidget.saveFig(self.filenameSave)
except EnvironmentError as e:
exception = e
print('error in saving ', e)
def savetdms(self):
if self.data is None:
self.statusBar().showMessage('无Abf数据')
QMessageBox.information(self, "标题", "无Abf数据", QMessageBox.Ok)
return None
file_choices = "mat (*.mat)"
path = QFileDialog.getSaveFileName(self, 'Save file', '', file_choices)
if path:
if self.checkBox_5_tdms.isChecked():
self.start = int(self.doubleSpinBox_8_tdms.value() * self.sam)
self.end = int(self.doubleSpinBox_9_tdms.value() * self.sam)
if self.start >= self.end:
QMessageBox.information(self, "标题", "请正确设置时间范围", QMessageBox.Ok)
return None
else:
self.part_tdms=np.array((self.time[self.start:self.end],self.data[self.start:self.end]))
sio.savemat(path[0], {'f': self.part_tdms.T})
self.statusBar().showMessage('Saved to %s' % path[0])
self.statusBar().showMessage('数据保存完成')
QMessageBox.information(self, "标题", "数据保存完成", QMessageBox.Ok)
else:
sio.savemat(path[0], {'f': np.array((self.time,self.data)).T})
self.statusBar().showMessage('Saved to %s' % path[0])
self.statusBar().showMessage('数据保存完成')
QMessageBox.information(self, "标题", "数据保存完成", QMessageBox.Ok)
else:
self.statusBar().showMessage('请选择保存文件位置')
pass
def exportSinglePost(self, post):
# Here I need to get the post, convert it to dict, and put it into a text file.
postAsDict = ujson.loads(post)
if len(postAsDict["Body"]) < 25:
fileName = postAsDict["Body"]
else:
fileName = postAsDict["Body"][0:25] + ".."
from PyQt5.QtWidgets import QFileDialog
dialog = QFileDialog()
filePath = dialog.getSaveFileName(None, "Please select a location to save a post.", fileName + ".txt")
filePath = filePath[0]
postText = u"""%s\n
by %s, at %s\n
Gathered from Aether network. Aether is a distributed network of anonymous forums. Join us at www.getaether.net.
This post is licensed under CC-BY-SA.""" % (
postAsDict["Body"],
postAsDict["OwnerUsername"],
str(datetime.utcfromtimestamp(float(postAsDict["CreationDate"]))),
)
postText = postText.encode("utf8")
f = open(filePath, "wb")
f.write(postText)
f.close()
return True
def saveFile(self, dlg=False):
fileNameToSave = self.currentTab.fileName
if (not fileNameToSave) or dlg:
markupClass = self.currentTab.getActiveMarkupClass()
if (markupClass is None) or not hasattr(markupClass, 'default_extension'):
defaultExt = self.tr("Plain text (*.txt)")
ext = ".txt"
else:
defaultExt = self.tr('%s files',
'Example of final string: Markdown files') \
% markupClass.name + ' (' + str.join(' ',
('*'+extension for extension in markupClass.file_extensions)) + ')'
if markupClass == markups.MarkdownMarkup:
ext = globalSettings.markdownDefaultFileExtension
elif markupClass == markups.ReStructuredTextMarkup:
ext = globalSettings.restDefaultFileExtension
else:
ext = markupClass.default_extension
fileNameToSave = QFileDialog.getSaveFileName(self,
self.tr("Save file"), "", defaultExt)[0]
if fileNameToSave:
if not QFileInfo(fileNameToSave).suffix():
fileNameToSave += ext
self.actionSetEncoding.setDisabled(self.autoSaveActive())
if fileNameToSave:
if self.currentTab.saveTextToFile(fileNameToSave):
self.moveToTopOfRecentFileList(self.currentTab.fileName)
return True
else:
QMessageBox.warning(self, '',
self.tr("Cannot save to file because it is read-only!"))
return False
def get_save_path(self, folder):
"""
Displays a dialog for selecting a file to save. Returns the selected
path. Defaults to start in the referenced folder.
"""
path, _ = QFileDialog.getSaveFileName(self.widget, 'Save file', folder)
return path
def saveFileDialog(self):
fname = self.filename()
if fname == None:
directory = "."
else:
directory = QFileInfo(fname).path()
if util.isWindows(): # required for native looking file window
fname = QFileDialog.getSaveFileName(
self.win,
"%s - Save As" % QApplication.applicationName(),
directory,
"%s (*.json)" % QApplication.applicationName())
self.writeDocumentToFile(fname)
else: # access through non-blocking callback
fdialog = QFileDialog(
self.win,
"%s - Save As" % QApplication.applicationName(),
directory,
"%s (*.json)" % QApplication.applicationName())
fdialog.setAcceptMode(QFileDialog.AcceptSave)
fdialog.setWindowFlags(Qt.Sheet)
fdialog.setWindowModality(Qt.WindowModal)
self.filesavedialog = fdialog
self.filesavedialog.filesSelected.connect(
self.saveFileDialogCallback)
fdialog.open()
def yaml_export(self, filepath=None):
# filepath is set for unittest
if not filepath:
filepath = QFileDialog.getSaveFileName(
self,
"Export project",
self.name,
".yaml"
)
filepath = ''.join(filepath)
else:
selected_file = open(filepath, 'w')
with open(filepath, 'w') as file:
project_objects = {
subtype: {
str(obj.name): {
property.name: str(getattr(obj, property.name))
for property in properties
}
for obj in self.network_view.network.ftr(
subtype_to_type[subtype],
subtype
)
}
for subtype, properties in object_ie.items()
}
dump(project_objects, file, default_flow_style=False)
def saveAsDoc(self, doc: MasterDocument):
fn = QFileDialog.getSaveFileName(self)[0]
if fn == "":
return False
doc.saveToFile(fn)
self.ui.statusbar.showMessage("Document saved as {}".format(fn), 5000)
return True
def getImageFilenameAndLink(self):
if self.tab.fileName:
saveDir = os.path.dirname(self.tab.fileName)
else:
saveDir = os.getcwd()
imageFileName = self.findNextImageName(os.listdir(saveDir))
chosenFileName = QFileDialog.getSaveFileName(self,
self.tr('Save image'),
os.path.join(saveDir, imageFileName),
self.tr('Images (*.png *.jpg)'))[0]
if chosenFileName:
# Use relative links for named documents
if self.tab.fileName:
try:
link = os.path.relpath(chosenFileName, saveDir)
except ValueError: # different roots
link = chosenFileName
else:
link = chosenFileName
else:
link = None
return chosenFileName, link
def save(self):
if "Unnamed" in self.filename:
filename = QFileDialog.getSaveFileName(self,
"G.R.O.M. Editor -- Save File As", self.filename,
"MD files (*.mdp *.itp *.top *.*)")
print('filename is ', filename)
if len(filename[0]) == 0:
return
self.filename = filename[0]
self.setWindowTitle(QFileInfo(self.filename).fileName())
exception = None
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(str(fh.errorString()))
stream = QTextStream(fh)
stream.setCodec("UTF-8")
stream << self.toPlainText()
self.document().setModified(False)
except EnvironmentError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def select_save_path(self):
"""
Open a dialog where the user can select a file name to save the
hydrograph.
"""
if self.wldset is None:
return
ffmat = "*.pdf;;*.svg;;*.png"
fname = find_unique_filename(osp.join(
self.save_fig_dir, 'hydrograph_%s.pdf' % self.wldset['Well']))
fname, ftype = QFileDialog.getSaveFileName(
self, "Save Figure", fname, ffmat)
if fname:
ftype = ftype.replace('*', '')
fname = fname if fname.endswith(ftype) else fname + ftype
self.save_fig_dir = os.path.dirname(fname)
try:
self.save_figure(fname)
except PermissionError:
msg = "The file is in use by another application or user."
QMessageBox.warning(self, 'Warning', msg, QMessageBox.Ok)
self.select_save_path()
def runExtensionCommand(self, command, filefilter, defaultext):
of = ('%of' in command)
html = ('%html' in command)
if of:
if defaultext and not filefilter:
filefilter = '*'+defaultext
fileName = QFileDialog.getSaveFileName(self,
self.tr('Export document'), '', filefilter)[0]
if not fileName:
return
if defaultext and not QFileInfo(fileName).suffix():
fileName += defaultext
basename = '.%s.retext-temp' % self.currentTab.getDocumentTitle(baseName=True)
if html:
tmpname = basename+'.html'
self.saveHtml(tmpname)
else:
tmpname = basename + self.currentTab.getMarkupClass().default_extension
self.currentTab.saveTextToFile(fileName=tmpname, addToWatcher=False)
command = command.replace('%of', '"out'+defaultext+'"')
command = command.replace('%html' if html else '%if', '"'+tmpname+'"')
try:
Popen(str(command), shell=True).wait()
except Exception as error:
errorstr = str(error)
QMessageBox.warning(self, '', self.tr('Failed to execute the command:')
+ '\n' + errorstr)
QFile(tmpname).remove()
if of:
QFile('out'+defaultext).rename(fileName)
def btn_save_clicked(self):
"""
Action performed after clicking "Save as..."
"""
if not self.screenshot:
return
# display dialog with path to image
(path, _) = QFileDialog.getSaveFileName(parent=self,
caption="Path to store image",
filter=self.filter)
if not path:
# cancel clicked
return
_, extension = os.path.splitext(path)
extension = extension[1:] # ignore dot at the beginning of extension
format = ''
if extension not in self.supported_extensions:
# unexpected extension, fallback to png
format = 'png'
self.screenshot.save(path, format=format)
def createXmi(self):
""" Create XMI file """
msg = 'Sorry, we were unable to process your request'
root = self.__basepath if self.__basepath != '' else os.getenv('HOME')
filename, type = QFileDialog.getSaveFileName(self, 'Open file for inspection', root)
path, name = os.path.split(filename)
if not os.access(path, os.R_OK):
self.showMessage('Sorry, this file couldn’t be written to')
return
if self.__xmi is None:
self.__xmi = Xmi()
try:
self.__xmi.setTree(self.__data.getSymbolTree())
self.__xmi.write(filename)
self.statusBar().showMessage('{} successfully written'.format(name), 6000)
return True
except ValueError as em:
print('bad format for data: {}'.format(em))
except RuntimeError as em:
print('should not be here: {}'.format(em))
except OSError as em:
msg = 'Sorry, we were unable to write to this file'
print('inform: problem writing file {}'.format(em))
self.showMessage(msg)
def Convert():
func = Functions()
InFile = getattr(self, convertID+'InEdit').text()
if InFile:
dialog = QFileDialog()
dialog.raise_()
fileName, _ = dialog.getSaveFileName(self, "Save As...", InFile, "All Files (*.*)", options=QFileDialog.Options())
if fileName:
convertBtn = getattr(self, convertID+'ConvertBtn')
old_text = convertBtn.text()
convertBtn.setText('proc...')
self.setEnabled(False)
QApplication.processEvents()
if fileName != InFile:
print("Saving file as "+ fileName)
if convertID == "At3":
if self.At3EditorEdit.text() and self.FFEditorEdit.text():
func.At3Convert(InFile, fileName)
else:
self.make_ErrorMessage("FFMpeg or the At3Tool has not been configured in the settings.")
elif convertID == "Vid":
if self.FFEditorEdit.text():
func.VidConvert(InFile, fileName)
else:
self.make_ErrorMessage("FFMpeg has not been configured in the settings.")
elif convertID == "Pmf":
func.PmfConvert(InFile, fileName)
convertBtn.setText(old_text)
else:
self.make_ErrorMessage("You can't save over the file you are converting!")
self.setEnabled(True)
else:
self.make_ErrorMessage('You are missing an input file.')
def saveAs(self):
if settings.get("file_dialog_dir"):
self.curDir = '~/'
else:
self.curDir = settings.get("file_dialog_dir")
filename = QFileDialog.getSaveFileName(self,
self.tr("Save document"), self.curDir,
self.tr("ODT document (*.odt);;Text file (*.txt);;"
"HTML file (*.html);;PDF file(*.pdf)")
)
if not filename: return
self.curDir = os.path.dirname(filename)
settings.set("file_dialog_dir", self.curDir)
dw = QTextDocumentWriter()
dw.setFormat('ODF') # Default format
# Check for alternative output format
if filename.rsplit('.', 1)[1] == "txt":
dw.setFormat('plaintext')
if filename.rsplit('.', 1)[1] in ("html", "htm"):
dw.setFormat('HTML')
if filename.rsplit('.', 1)[1] in ("PDF", "pdf"):
self.filePrintPdf(filename)
return
dw.setFileName(filename)
dw.write(self.document())
def get_save_file_name(*args, **kwargs):
filename, _selected_filter = QFileDialog.getSaveFileName(*args, **kwargs)
if len(filename) > 0:
filename = QDir.toNativeSeparators(filename)
return filename
def saveImageButtonClicked(self):
filters = 'Portable Network Graphics (*.png)'
filters += ';;' + 'Joint Photographic Experts Group (*.jpg)'
filters += ';;' + 'Windows Bitmap (*.bmp)'
filters += ';;' + 'Tagged Image File Format (*.tiff)'
filename = QFileDialog.getSaveFileName(
caption='Save Image As',
directory='ptchan_image.png',
filter=filters,
initialFilter='Portable Network Graphics (*.png)')
# retrieve data from PTchan engine
data_raw = self.engine.getFilmView().getData()
data = array('f', data_raw) # this converts data into proper array
# convert from float in [0.0,1.0] to bytes in [0,255]
list = []
for comp in data:
list.append(int(255.0 * comp))
# transform list of integers into byte array
byte_array = array('B', list)
image = QImage(
byte_array.tostring(),
self.engine.getFilmView().getWidth(),
self.engine.getFilmView().getHeight(),
QImage.Format_RGB888)
# default mirrored() inverts vertical, exactly what is needed to transform
# image data from OpenGL coord frame
image.mirrored().save(filename[0])
def saveAs(self):
fileName, _ = QFileDialog.getSaveFileName(self, "Save As",
self.curFile)
if not fileName:
return False
return self.saveFile(fileName)
def saveText(self):
"""Executes the conversion of the analysis results to raw text data."""
fileName = QFileDialog.getSaveFileName(self, 'Export Path')
if len(fileName[0]) > 0:
path, file_extension = os.path.splitext(fileName[0])
boxIndex = 0
requestedParameters = []
for box in self.checkboxes:
if box.isChecked():
requestedParameters.append(self.keys[boxIndex])
boxIndex += 1
tableHeadings = []
for par in requestedParameters:
tableHeadings.append(self.checkboxdict[par])
f = open(path + ".txt", "w")
row_format = " {:>20} " * (len(requestedParameters) + 1)
f.write(row_format.format("", *tableHeadings))
f.write("\n")
for c in self.contacts:
currentContactProperties = []
for p in requestedParameters:
exec("propertyToAdd = c." + p + "()")
if isinstance(propertyToAdd, float):
propertyToAdd = "{0:.3f}".format(propertyToAdd)
currentContactProperties.append(propertyToAdd)
f.write(row_format.format(c.human_readable_title(), *currentContactProperties))
f.write("\n")
f.close()
def saveImage(self):
def ext_for_filter(s):
return re.match(r'(?:[A-Z]+) \(\*\.([a-z]+)\)$', s).group(1)
if not self.pixmap:
return
filters = ['PNG (*.png)', 'JPEG (*.jpg)', 'GIF (*.gif)']
obj = self.current.data(ResultModel.RoleObject)
name = '%s.%s' % (obj.title or obj.id or u'', obj.ext or 'png')
default = filters[0]
for f in filters:
if name.endswith(ext_for_filter(f)):
default = f
filters = ';;'.join(filters)
target = os.path.join(self.parent().lastSaveDir, name)
out, filter = QFileDialog.getSaveFileName(self, 'Save image', target, filters, default)
if not out:
return
ext = ext_for_filter(filter)
self.parent().lastSaveDir = os.path.dirname(out)
if not os.path.splitext(out)[1]:
out = '%s.%s' % (out, ext)
if os.path.exists(out):
q = self.tr('%s already exists, are you sure you want to replace it?') % out
reply = QMessageBox.question(self, self.tr('Overwrite?'), q)
if reply == QMessageBox.No:
return self.saveImage()
self.pixmap.save(out, ext.upper())
def mergeToHdrClicked(self):
if self.fileTreeWidget.topLevelItemCount() == 0:
self.statusBar().showMessage("No files in stack.", 5000)
return
files = []
for index in range(self.fileTreeWidget.topLevelItemCount()):
item = self.fileTreeWidget.topLevelItem(index)
imagePath = item.text(4) + "/" + item.text(0)
files.append(imagePath)
filename = QFileDialog.getSaveFileName(self, "Save OpenEXR File", "", "OpenEXR Images (*.exr)")
if filename[1] == "":
self.statusBar().showMessage("Save aborted.", 5000)
return
self.mergerThread = HdrMergerThread(files, filename[0])
self.mergerThread.newOutputLine.connect(self.addOutputLine)
self.clearOutput()
self.addOutputLine("<b>Starting merge of images:</b>")
self.mergerThread.start()
def enableButton():
self.mergeToHdrPushButton.setEnabled(True)
self.addOutputLine("<b>Merge finished.</b>")
self.mergerThread.finished.connect(enableButton)
self.mergeToHdrPushButton.setEnabled(False)
def saveFile(self):
"""Save edited file
If no file path is set, a file dialog is shown to ask the user where to save content.
"""
path = self.path
newFile = not path
if newFile:
path, qfilter = QFileDialog.getSaveFileName(self, self.tr('Save file'), os.path.expanduser('~'))
if not path:
return False
path = path
data = self._writeText(self.text())
self.fileAboutToBeSaved.emit(path)
try:
io.writeBytesToFile(path, data)
except IOError:
LOGGER.error('cannot write file %r', path, exc_info=True)
return False
self.path = path
self.setModified(False)
if newFile:
self.fileSavedAs.emit(path)
else:
self.fileSaved.emit(path)
return True
def save_settings(self):
try:
settings = self._get_settings()
except TabFieldError as ex:
self.log.critical("Errors in the query prevent saving the settings. {0}".format(ex))
self.error_msg.critical(self, "Unable to save settings",
"Please resolve errors in the tab before saving the settings."
)
return
filename = QFileDialog.getSaveFileName(self, "Save analysis tab settings", "analysis.apolt",
"Apol Tab Settings File (*.apolt);;"
"All Files (*)")[0]
if not filename:
return
try:
with open(filename, "w") as fd:
json.dump(settings, fd, indent=1)
except OSError as ex:
self.log.critical("Unable to save settings file \"{0.filename}\": {0.strerror}".
format(ex))
self.error_msg.critical(self, "Failed to save settings",
"Failed to save \"{0.filename}\": {0.strerror}".format(ex))
except Exception as ex:
self.log.critical("Unable to save settings file \"{0}\": {1}".format(filename, ex))
self.error_msg.critical(self, "Failed to save settings", str(ex))
else:
self.log.info("Successfully saved settings file \"{0}\"".format(filename))
def select_premerge_file(self):
filename, _filter = QFileDialog.getSaveFileName(
self.dlg, "Select output file ", "", '*.shp')
self.dlg.SelectPreMergeOutputButton.setText(filename)
def select_output_file(self):
filename, _filter = QFileDialog.getSaveFileName(
self.dlg, "Select output file ", "", '*.shp')
self.dlg.outputHeirarchyFileName.setText(filename)
def select_target(self):
target, fileType = QFileDialog.getSaveFileName(
self, "select the save directory", "C:/")
self.target_le.setText(str(target))
def saveFile(self):
name = QFileDialog.getSaveFileName(self, 'Save File')
if name[0]:
with open(name[0], 'w') as file:
text = self.textEdit.toPlainText()
file.write(text)
def file_save_as(self):
name = QFileDialog.getSaveFileName(self, 'Save File')
file = open(name[0], 'w')
text = self.plainTextEdit_2.toPlainText()
file.write(text)
file.close()
def file_btn_click_event(self, clicked_btn):
name = self.info_table.item(0, 0)
if name is None:
QMessageBox.about(self, "Error", "There is no searching history")
return
# search information
searched_type = str(self.search_type_list.currentText())
searched_input = self.search_line.text()
selected_species = []
if self.species_all.isChecked():
selected_species.append('all')
else:
if self.species_btn1.isChecked():
selected_species.append('zebra fish')
if self.species_btn2.isChecked():
selected_species.append('fathead minnow')
if self.species_btn3.isChecked():
selected_species.append('medaka')
if self.species_btn4.isChecked():
selected_species.append('daphnia')
if self.species_others.isChecked():
selected_species.append('others')
selected_species = ', '.join(selected_species)
selected_ep = []
if self.ep_all.isChecked():
selected_ep.append('all')
else:
if self.ep_lc_btn.isChecked():
selected_ep.append('LC50')
if self.ep_ec_btn.isChecked():
selected_ep.append('EC50')
if self.ep_others.isChecked():
selected_ep.append('others')
selected_ep = ', '.join(selected_ep)
# chemical information
name = self.info_table.item(0, 0).text()
iupac_name = self.info_table.item(1, 0).text()
cas = self.info_table.item(2, 0).text()
smiles = self.info_table.item(3, 0).text()
# toxic information
poison_text = self.poison_text.toPlainText()
meta_all = self.meta_all.toPlainText()
# mass spectrum
try:
self.MS_data[smiles]
fig = self.mass_fig
fig.set_size_inches(12.5, 7.0)
fig.savefig('mass_fig.png', dpi=100)
# self.mass_fig.savefig('mass_fig.png',
# dpi=100,
# papertype='a4')
# bbox_inches='tight')
reference = self.reference_line.text()
except:
pass
# Make the entire text edit for save/print
entire_text = QTextEdit('')
entire_text.append('\n' + '=' * 10 + 'Search Information' + '=' * 10 +
'\n')
entire_text.append('Searched type: {}'.format(searched_type))
entire_text.append('Searched input: {}'.format(searched_input))
entire_text.append('Selected species: {}'.format(selected_species))
entire_text.append('Selected end point: {}'.format(selected_ep))
entire_text.append('\n' + '=' * 10 + 'Chemical Information' +
'=' * 10 + '\n')
entire_text.append('Name: {}'.format(name))
entire_text.append('IUPAC name: {}'.format(iupac_name))
entire_text.append('CAS number: {}'.format(cas))
entire_text.append('SMILES: {}'.format(smiles))
entire_text.append('\n' + '=' * 10 + 'Toxic Information' + '=' * 10 +
'\n')
entire_text.append(poison_text)
try:
self.MS_data[smiles]
entire_text.append('\n' + '=' * 10 + 'Mass Spectrum' + '=' * 10 +
'\n')
entire_text.append('reference: {}'.format(reference) + '\n')
cursor = entire_text.textCursor()
entire_text.moveCursor(QTextCursor.End)
# img = Image.open('mass_fig.png')
# img_re = img.resize((int(img.width/2.5), int(img.height/2.5)), Image.ANTIALIAS)
# img_re.save('mass_fig2.png')
cursor.insertImage('mass_fig.png')
entire_text.append(meta_all)
except:
pass
if clicked_btn == 'save':
fn, _ = QFileDialog.getSaveFileName(
self, 'Export PDF', None, 'PDF files (.pdf);;All Files()')
if fn != '':
if QFileInfo(fn).suffix() == "": fn += '.pdf'
printer = QPrinter(QPrinter.HighResolution)
# printer = QPrinter(QPrinter.ScreenResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fn)
entire_text.document().print_(printer)
try:
os.remove('mass_fig.png')
except:
pass
elif clicked_btn == 'print':
printer = QPrinter(QPrinter.HighResolution)
dialog = QPrintDialog(printer, self)
if dialog.exec_() == QPrintDialog.Accepted:
entire_text.print_(printer)
try:
os.remove('mass_fig.png')
except:
pass
def save():
fname = QFileDialog.getSaveFileName(qgv, "Save", "", "*.json")
if (fname[0] != ""):
qgv.saveAsJson(fname[0])
def getSaveFileName(self, data_dir, message, file_format):
save_file, _ = QFileDialog.getSaveFileName(self, message, data_dir,\
file_format)
return save_file
def __saveAs(self):
saveAspath, _ = QFileDialog.getSaveFileName(self, 'Save as',
QDir.currentPath(),
"CSV Files(*.csv)")
if saveAspath != '':
self.pathContainer['SaveAsPath'] = saveAspath
def unloadCSV(self):
direction = QFileDialog.getSaveFileName(self, 'Сохранить', '',
'*.csv')[0]
with open(direction, mode='w', encoding='utf8') as file:
file.write(self.textEdit.toPlainText())
def save_text(self):
filename = QFileDialog.getSaveFileName(self, 'Save File', os.getenv('HOME'))
with open(filename[0], 'w') as f:
my_text = self.text.toPlainText()
f.write(my_text)
def saveFile(self):
pathfile = QFileDialog.getSaveFileName(self, "Save File")
createpdf(self.path, pathfile[0], self.y_pred)
def save_as_file(self):
self.file_path = QFileDialog.getSaveFileName(self, 'Сохранить как...',
'/home')[0]
self.save_file()
def action_output_file_browser_clicked(self):
output_path, type = QFileDialog.getSaveFileName(
self, "导出合成影像", os.getcwd(), "*.tif;;*.jpg;;*.bmp")
self.output_file_path.setText(output_path)
def handle_browse_button(self):
save_location = QFileDialog.getSaveFileName(self,
caption="Save As",
directory=".",
filter="All files (*.*)")
self.SaveLocationText.setText(save_location[0])
def exportDocument(self):
document = Krita.instance().activeDocument()
if not document:
return
fileName = QFileDialog.getSaveFileName()[0]
document.exportImage(fileName, InfoObject())
def on_click_set_path(self):
QFileDialog.getSaveFileName()
self.ui.lineEdit_save_image.setText(self.set_filename_open())
def __prepare_file_chooser(self):
filename, _ = QFileDialog.getSaveFileName(self, "Save PDF report", filter="PDF Files (*.pdf)")
return filename
def save_plan(self):
plan, _ = QFileDialog.getSaveFileName(
self.centralwidget,
'Salvar planilha',
)
wb.save(plan + '.xlsx')
def excel_export(self, selected_file=None):
# to convert a list of object into a string of a list of strings
# useful for AS nodes, edges, links as well as area nodes and links
to_string = lambda s: str(list(map(str, s)))
# filepath is set for unittest
if not selected_file:
filepath = QFileDialog.getSaveFileName(self, "Export project",
self.name, ".xls")
selected_file = ''.join(filepath)
print(selected_file)
# else:
# selected_file = open(filepath, 'w')
excel_workbook = xlwt.Workbook()
for obj_subtype, properties in object_ie.items():
# we have one excel sheet per subtype of object.
# we filter the network pool based on the subtype to
# retrieve only the object of the corresponding subtype
# this was done because objects have different properties
# depending on the subtype, and we want to avoid using
# hasattr() all the time to check if a property exists.
obj_type = subtype_to_type[obj_subtype]
if obj_subtype == 'site':
pool_obj = list(self.site_view.network.nodes.values())
else:
pool_obj = list(
self.network_view.network.ftr(obj_type, obj_subtype))
# we create an excel sheet only if there's at least one object
# of a given subtype
if pool_obj:
xls_sheet = excel_workbook.add_sheet(obj_subtype)
for id, property in enumerate(properties):
xls_sheet.write(0, id, property.name)
for i, obj in enumerate(pool_obj, 1):
xls_sheet.write(i, id, str(getattr(obj,
property.name)))
pool_AS = list(self.network_view.network.pnAS.values())
if pool_AS:
AS_sheet = excel_workbook.add_sheet('AS')
for i, AS in enumerate(self.network_view.network.pnAS.values(), 1):
AS_sheet.write(i, 0, str(AS.name))
AS_sheet.write(i, 1, str(AS.AS_type))
AS_sheet.write(i, 2, str(AS.id))
AS_sheet.write(i, 3, to_string(AS.pAS['node']))
AS_sheet.write(i, 4, to_string(AS.pAS['link']))
node_AS_sheet = excel_workbook.add_sheet('per-AS node properties')
cpt = 1
for AS in self.network_view.network.pnAS.values():
for node in AS.nodes:
node_AS_sheet.write(cpt, 0, AS.name)
node_AS_sheet.write(cpt, 1, node.name)
for idx, property in enumerate(
perAS_properties[node.subtype], 2):
node_AS_sheet.write(cpt, idx,
str(node(AS.name, property.name)))
cpt += 1
if_AS_sheet = excel_workbook.add_sheet(
'per-AS interface properties')
cpt = 1
for AS in self.network_view.network.pnAS.values():
if AS.AS_type != 'BGP':
for link in AS.links:
for interface in (link.interfaceS, link.interfaceD):
if_AS_sheet.write(cpt, 0, AS.name)
if_AS_sheet.write(cpt, 1, str(interface.link))
if_AS_sheet.write(cpt, 2, str(interface.node))
for idx, property in enumerate(
ethernet_interface_perAS_properties, 3):
if_AS_sheet.write(
cpt, idx,
str(interface(AS.name, property.name)))
cpt += 1
has_area = lambda a: a.has_area
pool_area = list(
filter(has_area, self.network_view.network.pnAS.values()))
if pool_area:
area_sheet = excel_workbook.add_sheet('area')
cpt = 1
for AS in filter(lambda a: a.has_area,
self.network_view.network.pnAS.values()):
for area in AS.areas.values():
area_sheet.write(cpt, 0, str(area.name))
area_sheet.write(cpt, 1, str(area.AS))
area_sheet.write(cpt, 2, str(area.id))
area_sheet.write(cpt, 3, to_string(area.pa['node']))
area_sheet.write(cpt, 4, to_string(area.pa['link']))
cpt += 1
if self.site_view.network.nodes:
site_sheet = excel_workbook.add_sheet('sites')
for cpt, site in enumerate(self.site_view.network.nodes.values()):
site_sheet.write(cpt, 0, str(site.name))
site_sheet.write(cpt, 1, to_string(site.ps['node']))
site_sheet.write(cpt, 2, to_string(site.ps['link']))
excel_workbook.save(selected_file)
def save_screenshot(self):
fname,_ = QFileDialog.getSaveFileName(self,filter=self.IMAGE_EXTENSIONS)
if fname is not '':
self._get_view().Dump(fname)
def _saveData(self, dataFmt):
"""Save the content of the list box to a file.
"""
fileExt = ""
textFmt = ""
if dataFmt == self.FMT_JSON:
fileExt = "json"
textFmt = "JSON Data File"
elif dataFmt == self.FMT_CSV:
fileExt = "csv"
textFmt = "CSV Data File"
else:
return False
# Generate the file name
saveDir = self.mainConf.lastPath
if not os.path.isdir(saveDir):
saveDir = os.path.expanduser("~")
fileName = "sessionStats.%s" % fileExt
savePath = os.path.join(saveDir, fileName)
dlgOpt = QFileDialog.Options()
dlgOpt |= QFileDialog.DontUseNativeDialog
savePath, _ = QFileDialog.getSaveFileName(
self, "Save Document As", savePath, options=dlgOpt
)
if not savePath:
return False
self.mainConf.setLastPath(savePath)
# Do the actual writing
wSuccess = False
errMsg = ""
try:
with open(savePath, mode="w", encoding="utf8") as outFile:
if dataFmt == self.FMT_JSON:
jsonData = []
for _, sD, tT, wD, wA, wB in self.filterData:
jsonData.append({
"date": sD,
"length": tT,
"newWords": wD,
"novelWords": wA,
"noteWords": wB,
})
json.dump(jsonData, outFile, indent=2)
wSuccess = True
if dataFmt == self.FMT_CSV:
outFile.write(
'"Date","Length (sec)","Words Changed","Novel Words","Note Words"\n'
)
for _, sD, tT, wD, wA, wB in self.filterData:
outFile.write(f'"{sD}",{tT:.0f},{wD},{wA},{wB}\n')
wSuccess = True
except Exception as e:
errMsg = str(e)
wSuccess = False
# Report to user
if wSuccess:
self.theParent.makeAlert(
"%s file successfully written to:<br>%s" % (
textFmt, savePath
), nwAlert.INFO
)
else:
self.theParent.makeAlert(
"Failed to write %s file.<br>%s" % (
textFmt, errMsg
), nwAlert.ERROR
)
return wSuccess
def saveToFile(self):
if self.Xpic_min is None:
self.HintLabel.setText('Please pick X_min')
return
elif self.Ypic_min is None:
self.HintLabel.setText('Please pick Y_min')
return
elif self.Xpic_max is None:
self.HintLabel.setText('Please pick X_max')
return
elif self.Ypic_max is None:
self.HintLabel.setText('Please pick Y_max')
return
elif self.Xreal_min is None:
self.HintLabel.setText('Please pick X_min')
return
elif self.Yreal_min is None:
self.HintLabel.setText('Please pick Y_min')
return
elif self.Xreal_max is None:
self.HintLabel.setText('Please pick X_max')
return
elif self.Yreal_max is None:
self.HintLabel.setText('Please pick Y_max')
return
elif self.Xsampled is None:
self.HintLabel.setText('Please pick data')
return
elif self.Ysampled is None:
self.HintLabel.setText('Please pick data')
return
else:
self.HintLabel.setText('')
self.x = []
self.y = []
if self.XScaleType is 'linear':
for xs in self.Xsampled:
self.x.append(self.Xreal_min +
(self.Xreal_max - self.Xreal_min) /
(self.Xpic_max - self.Xpic_min) *
(xs - self.Xpic_min))
elif self.XScaleType is 'log':
Xreal_min = log10(self.Xreal_min)
Xreal_max = log10(self.Xreal_max)
for xs in self.Xsampled:
self.x.append(10**(Xreal_min + (xs - self.Xpic_min) /
(self.Xpic_max - self.Xpic_min) *
(Xreal_max - Xreal_min)))
if self.YScaleType is 'linear':
for ys in self.Ysampled:
self.y.append(self.Yreal_min +
(self.Yreal_max - self.Yreal_min) /
(self.Ypic_max - self.Ypic_min) *
(ys - self.Ypic_min))
elif self.YScaleType is 'log':
Yreal_min = log10(self.Yreal_min)
Yreal_max = log10(self.Yreal_max)
for ys in self.Ysampled:
self.y.append(10**(Yreal_min + (ys - self.Ypic_min) /
(self.Ypic_max - self.Ypic_min) *
(Yreal_max - Yreal_min)))
fname, _ = QFileDialog.getSaveFileName(self)
with open(fname, 'w') as fid:
for xpt, ypt in zip(self.x, self.y):
fid.write("{} {}\n".format(xpt, ypt))
def func():
text = filename_e.text()
_filter = "*.csv" if text.endswith(".csv") else "*.json" if text.endswith(".json") else None
p, __ = QFileDialog.getSaveFileName(None, select_msg, text, _filter)
if p:
filename_e.setText(p)
def pushButtonFilterGlobal_export_clicked(self):
if self.playback_widget:
self.playback_widget.close()
self.playback_widget = None
if self.playback_control_widget:
self.playback_control_widget.close()
self.playback_control_widget = None
if self.frame_acceptance_np is None:
msgbox = QMessageBox(self)
msgbox.setWindowTitle('Error')
msgbox.setIcon(QMessageBox.Warning)
msgbox.setText('Nothing to export.\nPlease run filters first!')
msgbox.show()
return
filename = QFileDialog.getSaveFileName(
self,
'Export video',
os.path.dirname(os.path.abspath(self.cv_video_cap.file_handle)),
filter='*.avi')[0] # type: str
if not filename:
return
if not filename.lower().endswith(".avi"):
filename += ".avi"
if os.path.exists(filename):
msg = "Are you really sure you want to overwrite the file?\n%s" % filename
reply = QMessageBox.question(self, 'One sec...', msg,
QMessageBox.Yes, QMessageBox.No)
if reply != QMessageBox.Yes:
return
self.create_progressbar_dialog('Loading...')
print('Write to file [%s]' % filename)
codec = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter(filename, codec, 2,
(int(self.cv_video_cap.get_frame_width()),
int(self.cv_video_cap.get_frame_height())))
def worker_function(progress_changed, state_changed):
state_changed.emit('Preparing to export...')
key_frames = np.where(self.frame_acceptance_np)[0]
num_key_frames = len(key_frames)
progress = 0
state_changed.emit('Writing frames...')
for i in key_frames:
self.cv_video_cap.set_position_frame(i)
frame = self.cv_video_cap.read()
if frame:
out.write(frame.cv_mat)
progress += 1 / num_key_frames
progress_changed.emit(progress)
state_changed.emit('Writing finished, releasing file...')
out.release()
state_changed.emit('Done! Exported to %s.' % filename)
print('Export Done!')
sleep(1)
self.export_worker_thread = QThread(self)
self.export_worker_thread.start()
self.export_worker = ProgressWorker(worker_function)
self.export_worker.moveToThread(self.export_worker_thread)
self.export_worker.progress_changed.connect(
self.update_progressbar_dialog_value)
self.export_worker.state_changed.connect(
self.update_progressbar_dialog_title)
self.export_worker.finished.connect(self.destroy_progressbar_dialog)
self.export_worker.finished.connect(self.update_filter_status)
self.export_worker.start.emit()
def select_output_file(self):
filename, _ = QFileDialog.getSaveFileName(self, "Seleziona file",
QDir.currentPath(), "")
if filename != "":
self.output_file.setText(filename)
def on_button_browse(self):
file_path, ok = QFileDialog.getSaveFileName(
self, 'Select Result Excel Path', '',
'XLSX Files (*.xlsx);;All Files (*)')
if ok:
self.__edit_path.setText(file_path)
def dosya_kaydet(self):
dosya_ismi = QFileDialog.getSaveFileName(self, "Dosya Kaydet", os.getenv("HOME"))
with open(dosya_ismi[0], "w") as file:
file.write(self.yazi_alani.toPlainText())
def __ascii_to_fds(self):
if self.__check_wind():
# Note: normally, this would be dangerous as
# either of these could be None, but since the user
# cannot access this function until both are loaded
# TODO: ensure that DEM and fuel map are both same size
# idea: user cannot load fuel map that is not same size as DEM and vice versa
if self.__check_ambient_temp():
if self.__check_sim_time():
# Get user's working directory
user_settings = UserSettings()
file, filt = QFileDialog.getSaveFileName(
self, 'Save File', user_settings.working_dir,
"fds (*.fds)")
if file:
if not file.endswith(Fds.file_ext()):
file += Fds.file_ext()
# Note: Logically, this is where we would ensure that all of the fire line times
# are less than the simulation duration, however WFDS does not care weather or not such
# ignition points are present, hence we do not entirely care either.
fl_map_parser = self._fl_map_editor.parser()
dem_parser = self._ign_pt_editor.parser()
sim_time = float(self._sim_duration_line_edit.text())
ambient_temp = util.fahrenheit_to_celsius(
float(self._ambient_temp_line_edit.text()))
wind_speed = util.mph_to_ms(
float(self._wind_speed_line_edit.text()))
wind_direction = self._wind_direction_combo_box.currentText(
)
sim_settings = SimulationSettings(
'default.sim_settings')
sim_settings.sim_duration = sim_time
sim_settings.ambient_temp = ambient_temp
sim_settings.wind_vel = wind_speed
sim_settings.wind_direction = wind_direction
ascii_fds_converter = AsciiToFds(
fl_map_parser, dem_parser, sim_settings)
save_success = ascii_fds_converter.save(
self._fl_map_editor.values_grid(),
self._ign_pt_editor.fire_lines(), file)
if save_success:
usr_reply = QMessageBox.question(
self, "Export successful",
"Environment successfully created. "
"Would you like to set it as the current environment?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if usr_reply == QMessageBox.Yes:
self._fds.fds_file = file
self._fds.read()
self._sim_title_label.setText(
'Simulation Title: ' +
self._fds.job_name())
def on_saveasPushButton_clicked(self):
filename = QFileDialog.getSaveFileName(self, 'Save Email', os.getcwd(),
'Email (*.msg, *.eml)')
print(f'filename: {filename}')
