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 _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