def save_file_dialog(self, title, default_filename, file_types, filt):
"""common method for saving files"""
if qt_version == 4:
fname = str(
QFileDialog.getSaveFileName(self, title, default_filename,
file_types, filt))
try:
flt = str(filt).split()[0]
except IndexError:
flt = None
else:
fname, flt = QFileDialog.getSaveFileName(self, title, default_filename,
file_types, filt)
return fname, flt
def save_to_file(self):
"""Save table values to file."""
df = _utils.table_to_data_frame(self.tbl_table)
if df is None:
_QMessageBox.critical(self, 'Failure', 'Empty table.',
_QMessageBox.Ok)
return
filename = _QFileDialog.getSaveFileName(
self,
caption='Save measurements file.',
directory=self.directory,
filter="Text files (*.txt *.dat)")
if isinstance(filename, tuple):
filename = filename[0]
if len(filename) == 0:
return
try:
if (not filename.endswith('.txt')
and not filename.endswith('.dat')):
filename = filename + '.txt'
df.to_csv(filename, sep='\t')
except Exception:
_traceback.print_exc(file=_sys.stdout)
msg = 'Failed to save data to file.'
_QMessageBox.critical(self, 'Failure', msg, _QMessageBox.Ok)
def save_as(self, *args, filename: Optional[str] = None, **kwargs):
"""
Save the currently selected tab, to a specific filename.
The parameters are open as to accept inputs from any signal.
Parameters
----------
filename : str, optional
The name to save the file as. If omitted, a dialog will
appear to prompt the user for a filepath.
"""
current_tree = self.get_current_tree()
serialized = self.serialize_tree(current_tree)
if serialized is None:
return
if filename is None:
filename, _ = QFileDialog.getSaveFileName(
parent=self,
caption='Save as',
filter='Json Files (*.json)',
)
try:
with open(filename, 'w') as fd:
json.dump(serialized, fd, indent=2)
except OSError:
logger.exception(f'Error saving file {filename}')
else:
self.set_current_tab_name(filename)
current_tree.full_path = filename
def _save_layers_dialog(self, selected=False):
"""Save layers (all or selected) to disk, using ``LayerList.save()``.
Parameters
----------
selected : bool
If True, only layers that are selected in the viewer will be saved.
By default, all layers are saved.
"""
msg = ''
if not len(self.viewer.layers):
msg = "There are no layers in the viewer to save"
elif selected and not len(self.viewer.layers.selected):
msg = ('Please select one or more layers to save,'
'\nor use "Save all layers..."')
if msg:
QMessageBox.warning(self, "Nothing to save", msg, QMessageBox.Ok)
return
filename, _ = QFileDialog.getSaveFileName(
parent=self,
caption=f'Save {"selected" if selected else "all"} layers',
directory=self._last_visited_dir, # home dir by default
)
if filename:
self.viewer.layers.save(filename, selected=selected)
def slot_screenshot(self) -> None:
(path, selected_filter) = QFileDialog.getSaveFileName(
parent=self.viewer,
directory=f'BlastSight Screenshot ({datetime.now().strftime("%Y%m%d-%H%M%S")})',
filter='PNG image (*.png);;')
self.viewer.take_screenshot(path)
def _export_jatos(self):
if self.main_window.current_path:
suggested_path = self.main_window.current_path + u'.zip'
else:
suggested_path = cfg.file_dialog_path
path = QFileDialog.getSaveFileName(self.main_window,
_(u'Export JATOS study…'),
directory=suggested_path,
filter=u'JATOS study (*.zip)')
if isinstance(path, tuple):
path = path[0]
if not path:
return
osexp = self._tmp_osexp()
poss_subject_nrs = self.ui.linedit_subject.text()
fullscreen = self.ui.fs_checkBox.isChecked()
export.jatos(osexp,
path,
title=self.experiment.title,
description=self.experiment.description,
subject=poss_subject_nrs,
fullscreen=fullscreen)
os.remove(osexp)
self.extension_manager.fire('notify',
message='Experiment succesfully exported',
category='success',
always_show=True)
def _convert_results(self):
from osweb import data
from datamatrix import io
jatos_results_path = QFileDialog.getOpenFileName(
self.main_window,
_(u'Select JATOS results file…'),
filter=u'JATOS results (*.txt)')
if isinstance(jatos_results_path, tuple):
jatos_results_path = jatos_results_path[0]
if not jatos_results_path:
return
self.main_window.set_busy(True)
try:
dm = data.parse_jatos_results(jatos_results_path)
finally:
self.main_window.set_busy(False)
export_path = QFileDialog.getSaveFileName(
self.main_window,
_(u'Save as…'),
filter=u'Excel (*.xlsx);;CSV (*.csv)')
if isinstance(export_path, tuple):
export_path = export_path[0]
if not export_path:
return
if export_path.lower().endswith(u'.xlsx'):
io.writexlsx(dm, export_path)
else:
io.writetxt(dm, export_path)
def _export(self, dialog_title, dialog_filter, ext):
"""Export the code to an .ipynb file."""
from jupyter_notebook_cell_parsers import parse_nbformat
language = self.extension_manager.provide('ide_current_language')
path = QFileDialog.getSaveFileName(self.main_window,
dialog_title,
filter=dialog_filter,
directory=cfg.file_dialog_path)
if isinstance(path, tuple):
path = path[0]
if not path:
return None, None
cfg.file_dialog_path = os.path.dirname(path)
if not path.lower().endswith(ext):
path += ext
if path.lower().endswith('.ipynb'):
ipynb_path = path
else:
ipynb_path = os.path.splitext(path)[0] + '.ipynb'
parse_nbformat.cells_to_notebook(
self.provide_jupyter_notebook_cells(
self.extension_manager.provide('ide_current_source')),
ipynb_path, language)
return path, ipynb_path
def _save_layers_dialog(self, selected=False):
"""Save layers (all or selected) to disk, using ``LayerList.save()``.
Parameters
----------
selected : bool
If True, only layers that are selected in the viewer will be saved.
By default, all layers are saved.
"""
msg = ''
if not len(self.viewer.layers):
msg = "There are no layers in the viewer to save"
elif selected and not len(self.viewer.layers.selected):
msg = ('Please select one or more layers to save,'
'\nor use "Save all layers..."')
if msg:
raise OSError("Nothing to save")
filename, _ = QFileDialog.getSaveFileName(
parent=self,
caption=f'Save {"selected" if selected else "all"} layers',
directory=self._last_visited_dir, # home dir by default
)
if filename:
with warnings.catch_warnings(record=True) as wa:
saved = self.viewer.layers.save(filename, selected=selected)
error_messages = "\n".join(
[str(x.message.args[0]) for x in wa])
if not saved:
raise OSError(
f"File {filename} save failed.\n{error_messages}")
def save_file_dialog(self, title: str, default_dirname: str,
file_types: str) -> Tuple[str, str]:
"""
Common method for saving files
Parameters
----------
self : ???
the main GUI; not a vbox
title : str
the title of the dialog
default_dirname : str
the default directory
file_types : str
the wildcard
'Nastran Geometry - Punch (*.bdf; *.dat; *.nas; *.ecd; *.pch);;All files (*)'
"""
assert isinstance(title, str), 'title=%s' % title
assert isinstance(default_dirname,
str), 'default_dirname=%s' % default_dirname
assert isinstance(file_types, str), 'file_types=%s' % file_types
#if qt_version == 5:
# hasn't been tested
out = QFileDialog.getSaveFileName(parent=self,
caption=title,
directory=default_dirname,
filter=file_types)
fname, wildcard_level = out
return str(fname), str(wildcard_level)
def _save_difference(self, idx):
updater = self.updater[idx]
valx = updater.vectors['val']['x']
refx = updater.vectors['ref']['x']
valy = updater.vectors['val']['y']
refy = updater.vectors['ref']['y']
if valx is None or refx is None or valy is None or refy is None:
return
sz = min(valx.size, refx.size, valy.size, refy.size)
diffx = valx[:sz] - refx[:sz]
diffy = valy[:sz] - refy[:sz]
header = '# This is an orbit variation, not a pure orbit. \n'
header += '# ' + _datetime.now().strftime('%Y/%m/%d-%H:%M:%S') + '\n'
header += '# ' + 'BPMX [um] BPMY [um] Name' + '\n'
filename = QFileDialog.getSaveFileName(
caption='Define a File Name to Save the Orbit',
directory=self.last_dir,
filter=self.EXT_FLT)
fname = filename[0]
if not fname:
return
fname += '' if fname.endswith(self.EXT) else self.EXT
data = _np.array([diffx, diffy, self._csorb.bpm_names], dtype=object)
_np.savetxt(fname,
data.T,
header=header,
fmt='%+18.8e %+18.8e %s')
self.last_dir = fname.rsplit('/', 1)[0]
def ButExportACClick(self):
self.GetDataFromDb(AC=True)
fileName, _ = QFileDialog.getSaveFileName(
self, "Export Data", "", "Pickle Files (*.pkl);;All Files (*)")
ExptData = {}
ExptData['DataAC'] = (self.DataAC)
pickle.dump(ExptData, open(fileName, 'wb'))
def do_export_selected_scans(self):
"""
export selected scans to a file
:return:
"""
# get the scans
scans_list = self._myParent.ub_matrix_processing_table.get_selected_scans(
)
scans_list.sort()
# form the output string
output_str = '# Exp = {0}.\n'.format(self._myParent.current_exp_number)
for scan in scans_list:
output_str += '{0}, '.format(scan)
# trim the last
output_str = output_str[:-2]
# get the output file name
file_filter = 'Text Files (*.dat);;All Files (*.*)'
file_name = QFileDialog.getSaveFileName(
self, 'File to export selected scans',
self._myParent.working_directory, file_filter)
if not file_name:
return
if isinstance(file_name, tuple):
file_name = file_name[0]
# write file
out_file = open(file_name, 'w')
out_file.write(output_str)
out_file.close()
def _save_result(self):
"""
Save the scaled output in one combined I(Q) file
"""
if self._stitcher is not None:
if not os.path.isdir(self._output_dir):
self._output_dir = os.path.expanduser("~")
fname = QFileDialog.getSaveFileName(self, "Save combined I(Q)",
self._output_dir,
"Data Files (*.xml)")
if not fname:
return
if isinstance(fname, tuple):
fname = fname[0]
fname = str(QFileInfo(fname).filePath())
if len(fname) > 0:
if fname.endswith('.xml'):
self._stitcher.save_combined(fname, as_canSAS=True)
elif fname.endswith('.txt'):
self._stitcher.save_combined(fname, as_canSAS=False)
else:
fname_tmp = fname + ".xml"
self._stitcher.save_combined(fname_tmp, as_canSAS=True)
fname_tmp = fname + ".txt"
self._stitcher.save_combined(fname_tmp, as_canSAS=False)
def call(self, channels, sender):
addr, port, path, mode = parseAddress(channels[0].address)
self._client = VirtualClient(addr, port)
node = self._client.root.getNode(path)
dlg = QFileDialog()
if self.save:
dataFile = dlg.getSaveFileName(caption='Select Save File', filter='YAML Files(*.yml);;Data Files(*.dat);;CSV Files(*.csv);;Numpy Files(*.npy);;All Files(*.*)')
else:
dataFile = dlg.getOpenFileName(caption='Select Open File', filter='YAML Files(*.yml);;Data Files(*.dat);;CSV Files(*.csv);;Numpy Files(*.npy);;All Files(*.*)')
# Detect QT5 return
if isinstance(dataFile,tuple):
dataFile = dataFile[0]
if dataFile == '':
logger.warning(f"Skipping empty file name for node {node.name}")
if node.isinstance(pyrogue.BaseCommand):
node.call(dataFile)
elif node.isinstance(pyrogue.BaseVariable):
if node.mode == 'RO':
logger.warning(f"Can't set file to RO node: {node.name}")
else:
node.set(dataFile)
node.get()
else:
logger.warning(f"File browser used with invalid node: {node.name}")
def save_figure(self, *args):
filetypes = self.canvas.get_supported_filetypes_grouped()
sorted_filetypes = sorted(filetypes.items())
default_filetype = self.canvas.get_default_filetype()
startpath = os.path.expanduser(
matplotlib.rcParams['savefig.directory'])
start = os.path.join(startpath, self.canvas.get_default_filename())
filters = []
selectedFilter = None
for name, exts in sorted_filetypes:
exts_list = " ".join(['*.%s' % ext for ext in exts])
filter = '%s (%s)' % (name, exts_list)
if default_filetype in exts:
selectedFilter = filter
filters.append(filter)
filters = ';;'.join(filters)
filename, filter = QFileDialog.getSaveFileName(
self.canvas.parent(), "Choose a filename to save to", start,
filters, selectedFilter)
if filename:
# Save dir for next time, unless empty str (i.e., use cwd).
if startpath != "":
matplotlib.rcParams['savefig.directory'] = (
os.path.dirname(filename))
try:
self.canvas.figure.savefig(filename)
except Exception as e:
QMessageBox.critical(self, "Error saving file", str(e),
QMessageBox.Ok, QMessageBox.NoButton)
def _save_as(self):
"""
Present a file dialog to the user and saves the content of
the UI in XML format.
"""
if self._filename is not None:
fname = self._filename
else:
fname = self._instrument + '_'
fname = QFileDialog.getSaveFileName(self, "Reduction settings - Save settings",
self._last_directory + '/' + fname,
"Settings files (*.xml)")
if not fname:
return
if isinstance(fname, tuple):
fname = fname[0]
fname = str(QFileInfo(fname).filePath())
if not fname.endswith('.xml'):
fname += ".xml"
if fname in self._recent_files:
self._recent_files.remove(fname)
self._recent_files.insert(0,fname)
while len(self._recent_files) > 10:
self._recent_files.pop()
self._last_directory = QFileInfo(fname).path()
self._filename = fname
self._save()
def on_file_dialog(self, dialog_type, directory, allow_multiple,
save_filename, file_filter):
if dialog_type == FOLDER_DIALOG:
self._file_name = QFileDialog.getExistingDirectory(
self,
self.localization['linux.openFolder'],
options=QFileDialog.ShowDirsOnly)
elif dialog_type == OPEN_DIALOG:
if allow_multiple:
self._file_name = QFileDialog.getOpenFileNames(
self, self.localization['linux.openFiles'], directory,
file_filter)
else:
self._file_name = QFileDialog.getOpenFileName(
self, self.localization['linux.openFile'], directory,
file_filter)
elif dialog_type == SAVE_DIALOG:
if directory:
save_filename = os.path.join(str(directory),
str(save_filename))
self._file_name = QFileDialog.getSaveFileName(
self, self.localization['global.saveFile'], save_filename)
self._file_name_semaphore.release()
def do_save_workspace(self):
""" save workspace to NeXus file readable to Mantid
:return:
"""
if platform.system() == 'Darwin':
file_filter = ''
else:
file_filter = 'NeXus Files (*.nxs);;All Files (*.*)'
nxs_file_name_set = QFileDialog.getSaveFileName(self, caption='Mantid Processed NeXus File Name',
directory=self._core.working_dir,
filter=file_filter)
if isinstance(nxs_file_name_set, tuple):
nxs_file_name = str(nxs_file_name_set[0])
print('[DB...BAT] Filter: {0}'.format(nxs_file_name_set[1]))
else:
nxs_file_name = str(nxs_file_name_set)
if len(nxs_file_name) == 0:
return
else:
self._core.save_nexus((self._data_key, 1), nxs_file_name)
return
def save(self):
'''
Prompts the user for project name and saves the current state of the project to a JSON file
as follows:
[[list of root paths], [list of root widget sizes]]
'''
projects_directory = self._settings['projects_directory']
if not os.path.isdir(projects_directory):
os.makedirs(projects_directory)
path, filter_ = QFileDialog.getSaveFileName(
self, 'Save Project', os.path.join(projects_directory, self._name))
if path == '' and filter_ == '':
return
root_paths = [
self._splitter.widget(index).path()
for index in range(self._splitter.count())
]
spliter_sizes = self._splitter.sizes()
state = [root_paths, spliter_sizes]
with open(path, 'w') as save_file:
json.dump(state, save_file)
self._name = os.path.splitext(os.path.basename(path))[0]
self.name_changed.emit()
def do_export_selected_scans(self):
"""
export selected scans to a file
:return:
"""
# get the scans
scans_list = self._myParent.ub_matrix_processing_table.get_selected_scans()
scans_list.sort()
# form the output string
output_str = '# Exp = {0}.\n'.format(self._myParent.current_exp_number)
for scan in scans_list:
output_str += '{0}, '.format(scan)
# trim the last
output_str = output_str[:-2]
# get the output file name
file_filter = 'Text Files (*.dat);;All Files (*.*)'
file_name = QFileDialog.getSaveFileName(self, 'File to export selected scans',
self._myParent.working_directory, file_filter)
if not file_name:
return
if isinstance(file_name, tuple):
file_name = file_name[0]
# write file
out_file = open(file_name, 'w')
out_file.write(output_str)
out_file.close()
def __save_pixel_perfect(self):
''' saves an image based on passing the image through directly '''
if len(self.image.text()) > 0:
file_name = QFileDialog.getSaveFileName(parent=self, caption='Export Report',
filter='Report File (*.jpg *.png *.jpeg)')
if file_name:
output_file = str(file_name[0]).strip()
if len(output_file) == 0:
return
else:
format = os.path.splitext(output_file)[1][1:].strip()
if format in VALID_IMG_FORMATS:
from app import wait_cursor
with wait_cursor():
self.__status_bar.showMessage(f"Saving report to {output_file}", 5000)
self.preview.canvas.figure.savefig(output_file, format=format, dpi=self.__dpi)
if self.__concat_images(format, output_file):
self.__status_bar.showMessage(f"Saved report to {output_file}", 5000)
else:
msg_box = QMessageBox()
msg_box.setText(f"Invalid output file format - {output_file} is not one of {VALID_IMG_FORMATS}")
msg_box.setIcon(QMessageBox.Critical)
msg_box.setWindowTitle('Unexpected Error')
msg_box.exec()
else:
msg_box = QMessageBox()
msg_box.setText('Unable to create report, no image selected')
msg_box.setIcon(QMessageBox.Information)
msg_box.setWindowTitle('No Image')
msg_box.exec()
def __save_report(self):
''' writes the figure to the specified format '''
formats = "Report Files (*.png *.jpg *.jpeg)"
file_name = QFileDialog.getSaveFileName(parent=self,
caption='Export Report',
filter=formats)
if file_name:
output_file = str(file_name[0]).strip()
if len(output_file) == 0:
return
else:
format = os.path.splitext(output_file)[1][1:].strip()
if format in VALID_IMG_FORMATS:
scale_factor = self.widthPixels.value() / self.__x
from app import wait_cursor
with wait_cursor():
self.__status_bar.showMessage(
f"Saving report to {output_file}", 5000)
self.preview.canvas.figure.savefig(output_file,
format=format,
dpi=self.__dpi *
scale_factor,
pad_inches=0,
bbox_inches='tight')
self.__status_bar.showMessage(
f"Saved report to {output_file}", 5000)
else:
msg_box = QMessageBox()
msg_box.setText(
f"Invalid output file format - {output_file} is not one of {VALID_IMG_FORMATS}"
)
msg_box.setIcon(QMessageBox.Critical)
msg_box.setWindowTitle('Unexpected Error')
msg_box.exec()
def _export(self):
"""
Exports the current content of the UI to a python script that can
be run within MantidPlot
"""
if self._interface is None:
return
fname = QFileDialog.getSaveFileName(self, "Mantid Python script - Save script",
self._last_export_directory,
"Python script (*.py)")
if not fname:
return
if isinstance(fname, tuple):
fname = fname[0]
fname = str(fname)
if not fname.endswith('.py'):
fname += ".py"
(folder, file_name) = os.path.split(fname)
self._last_export_directory = folder
script = self._interface.export(fname)
if script is not None:
self.statusBar().showMessage("Saved as %s" % fname)
else:
self.statusBar().showMessage("Could not save file")
def _export(self):
"""
Exports the current content of the UI to a python script that can
be run within MantidPlot
"""
if self._interface is None:
return
fname = QFileDialog.getSaveFileName(self, "Mantid Python script - Save script",
self._last_export_directory,
"Python script (*.py)")
if not fname:
return
if isinstance(fname, tuple):
fname = fname[0]
fname = str(fname)
if not fname.endswith('.py'):
fname += ".py"
(folder, file_name) = os.path.split(fname)
self._last_export_directory = folder
script = self._interface.export(fname)
if script is not None:
self.statusBar().showMessage("Saved as %s" % fname)
else:
self.statusBar().showMessage("Could not save file")
def _save_as(self):
"""
Present a file dialog to the user and saves the content of
the UI in XML format.
"""
if self._filename is not None:
fname = self._filename
else:
fname = self._instrument + '_'
fname = QFileDialog.getSaveFileName(self, "Reduction settings - Save settings",
self._last_directory + '/' + fname,
"Settings files (*.xml)")
if not fname:
return
if isinstance(fname, tuple):
fname = fname[0]
fname = str(QFileInfo(fname).filePath())
if not fname.endswith('.xml'):
fname += ".xml"
if fname in self._recent_files:
self._recent_files.remove(fname)
self._recent_files.insert(0, fname)
while len(self._recent_files) > 10:
self._recent_files.pop()
self._last_directory = QFileInfo(fname).path()
self._filename = fname
self._save()
def _save_layers_dialog(self, selected=False):
"""Save layers (all or selected) to disk, using ``LayerList.save()``.
Parameters
----------
selected : bool
If True, only layers that are selected in the viewer will be saved.
By default, all layers are saved.
"""
msg = ''
if not len(self.viewer.layers):
msg = trans._("There are no layers in the viewer to save")
elif selected and not len(self.viewer.layers.selection):
msg = trans._('Please select one or more layers to save,'
'\nor use "Save all layers..."')
if msg:
raise OSError(trans._("Nothing to save"))
# prepare list of extensions for drop down menu.
ext_str, writers = _extension_string_for_layers(
list(self.viewer.layers.selection) if selected else self.viewer.
layers)
msg = trans._("selected") if selected else trans._("all")
dlg = QFileDialog()
hist = get_save_history()
dlg.setHistory(hist)
filename, selected_filter = dlg.getSaveFileName(
parent=self,
caption=trans._('Save {msg} layers', msg=msg),
directory=hist[0], # home dir by default,
filter=ext_str,
options=(QFileDialog.DontUseNativeDialog
if in_ipython() else QFileDialog.Options()),
)
logging.debug(f'QFileDialog - filename: {filename or None} '
f'selected_filter: {selected_filter or None}')
if filename:
writer = _npe2_decode_selected_filter(ext_str, selected_filter,
writers)
with warnings.catch_warnings(record=True) as wa:
saved = self.viewer.layers.save(filename,
selected=selected,
_writer=writer)
logging.debug(f'Saved {saved}')
error_messages = "\n".join(str(x.message.args[0]) for x in wa)
if not saved:
raise OSError(
trans._(
"File {filename} save failed.\n{error_messages}",
deferred=True,
filename=filename,
error_messages=error_messages,
))
else:
update_save_history(saved[0])
def save(self):
save_file = QFileDialog.getSaveFileName(
self, "Save file", "autosave.ami",
"AMI Autosave files (*.ami);;All Files (*)")
if save_file[0]:
logger.info("Saving graph configuration to file (%s)",
save_file[0])
self.saveFile.emit(save_file[0])
def export_file(self, f, text, ffilter="*"):
"""Export to file."""
fname = QFileDialog.getSaveFileName(self, text, filter=ffilter)[0]
if fname:
try:
f(fname, ffilter)
except TypeError:
f(fname)
def saveAs(self):
self.logger.info("MainWindow.saveAs")
fileName, _filtr = QFileDialog.getSaveFileName(self)
if fileName:
return self.saveFile(fileName)
return False
def save_state_dialogue(self):
filename = QFileDialog.getSaveFileName(self, 'Save state',
self.last_state_folder,
"Text documents (*.txt)")[0]
if filename != '':
self.save_state(filename)
self.last_state_folder = os.path.dirname(filename)
print(self.last_state_folder)
def _set_new_file_name(self):
file_name, selected_filter = QFileDialog.getSaveFileName(
self._main_window,
caption="Save Environment",
filter="Hildegard Project Files (*.hp)")
if file_name:
self._file_name = file_name
self._main_window.update_title()
def _save_particles(self):
"""Callback called when save particles button is clicked"""
file = QFileDialog.getSaveFileName(self, 'Save File')
if len(file) > 0:
layer = self.viewer.layers[self._particles_layers.currentText()]
particles = SParticles(data=layer.data,
properties=layer.properties,
scale=layer.scale)
write_particles(file[0], particles)
def saveText(self):
"""
Saves the generated text to a file (opens file dialog).
"""
fname = QFileDialog.getSaveFileName(self, 'Open file', '')
if isinstance(fname, tuple):
fname = fname[0]
fid = open(fname, 'w')
fid.write(self.genText())
fid.close()
def show_savecfg_dlg(self):
filename, _ = QFileDialog.getSaveFileName(
self, self.tr("Save configuration file..."),
directory=os.path.expanduser("~"),
filter="Json file (*.json)"
)
if filename:
self.filename = filename
self.save_file()
def get_file_name_for_saving(self, extension):
"""
Pops up a file selection dialog with the filter set to the
extension type
:param extension: The file extension to use which defines the
export type
:return absolute_path: The absolute path to save to
"""
# Returns a tuple containing the filename and extension
absolute_path = QFileDialog.getSaveFileName(caption='Select filename for exported plot',
filter='*{}'.format(extension))
return absolute_path[0]
def get_save_file(parent, directory=None, caption=None, filter=dict()):
'''
This is operating under the assumption that the file_filters parameter is a dict of filter:extension
The filename will have the file extension appended if one isn't already found on it
It returns a pair (<filename with extension>, <extension>). In the case of user cancelling, the filename
returned is None
'''
# convert defaults into something useful
if not directory:
# try to get it from the parent
if parent:
try:
directory = parent._currWorkDir
except:
pass
# just give up and use the current working directory
if not directory:
directory = os.getcwd()
if not caption:
caption = 'Save File'
if filter:
dialogfilter = ';;'.join(filter.keys())
else:
dialogfilter = ''
result = QFileDialog.getSaveFileName(parent=parent, directory=directory, caption=caption,
filter=dialogfilter)
# qt4/qt5 return slightly different things
if isinstance(result, tuple):
filename, filefilter = result
else:
filename = result
filefilter = None
# check if the user canceled
if not filename:
return None, filefilter
# determine the type and add the extension
extension = os.path.splitext(str(filename))[-1]
filetype = filter.get(filefilter, None)
if filetype is None:
filetype = extension.replace('.', '')
elif not extension:
# implementation ties filetype to the extension
filename = '{}.{}'.format(filename, filetype)
return filename, filetype
def _writeToFile(out_model_dict, model_directory, parent):
fname = QFileDialog.getSaveFileName(parent, 'Save to file', model_directory)[0]
if len(fname) > 0:
# enforce correct suffix.
if not fname.endswith(".yaml"):
fname += ".yaml"
f = open(fname, "w")
yaml.dump(out_model_dict, f,default_flow_style=False)
f.close()
def _writeToFile(expression_string, model_directory, parent, header):
fname = QFileDialog.getSaveFileName(parent, 'Export to .py file', model_directory)[0]
if len(fname) > 0:
# enforce correct suffix.
if not fname.endswith(".py"):
fname += ".py"
f = open(fname, 'w')
f.write(header)
f.write(expression_string)
f.close()
def do_export_plot(self):
"""
export plot
:return:
"""
# get directory
file_name = QFileDialog.getSaveFileName(self, caption='File to save the plot',
directory=self._work_dir,
filter='Data File(*.dat);;All Files(*.*')
if not file_name:
return
if isinstance(file_name, tuple):
file_name = file_name[0]
self.ui.graphicsView_plotView.save_current_plot(None, file_name)
def data_save_dialog(self, data_type=None, title=None):
"""
Pop up a save file dialog box.
@param data_type: string used to filter the files
@param title: string to use as title
"""
if data_type is None:
data_type = self._data_type
if title is None:
title = "Save file - Set a location and name"
fname = QFileDialog.getSaveFileName(self, title,
self._settings.data_path,
data_type)
if isinstance(fname, tuple):
fname = fname[0]
return QFileInfo(fname).filePath()
def export_csv(self):
filename, _ = QFileDialog.getSaveFileName(
self, QCoreApplication.applicationName(),
filter="CSV files(*.csv);;All files (*.*)"
)
if filename == "":
return
# get current dataframe and export to csv
df = self.recordWidget.dataframe
decimal = self.settings.get(DECIMAL_SETTING)
df = df.applymap(lambda x: str(x).replace(".", decimal))
df.to_csv(
filename, index_label="time",
sep=self.settings.get(SEPARATOR_SETTING)
)
def save_list_to_file(self):
filename, filters = QFileDialog.getSaveFileName(self,
"Save connection list",
"",
"Text Files (*.txt)")
try:
with open(filename, "w") as f:
for conn in self.table_view.model().connections:
f.write(
"{p}://{a}\n".format(p=conn.protocol, a=conn.address))
self.save_status_label.setText("File saved to {}".format(filename))
except Exception as e:
msgBox = QMessageBox()
msgBox.setText("Couldn't save connection list to file.")
msgBox.setInformativeText("Error: {}".format(str(e)))
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.exec_()
def _on_save_model(self, interactive=True):
model_editor_model = self.hub.data_item.model_editor_model
# There are no models to save
if not model_editor_model.fittable_models:
QMessageBox.warning(self,
'No model available',
'No model exists to be saved.')
return
default_name = os.path.join(os.path.curdir, 'new_model.smf')
outfile = QFileDialog.getSaveFileName(
self, caption='Save Model', directory=default_name,
filter=SPECVIZ_MODEL_FILE_FILTER)[0]
# No file was selected; the user hit "Cancel"
if not outfile:
return
self._save_models(outfile)
QMessageBox.information(self,
'Model saved',
'Model successfully saved to {}'.format(outfile))
def ask_for_filename(self):
filename, _ = QFileDialog.getSaveFileName(self.editor, "Choose filename...")
return filename
