def _import(self): _current_folder = self.parent_no_ui.current_folder _table_file = QFileDialog.getOpenFileName( parent=self.parent_no_ui, caption="Select File", directory=_current_folder, filter=("text (*.txt);; All Files (*.*)")) if not _table_file: return if isinstance(_table_file, tuple): _table_file = _table_file[0] new_path = os.path.dirname(_table_file) self.parent_no_ui.current_folder = new_path self._clear_table() _import_handler = ImportTable(filename=_table_file, parent=self.parent_no_ui) _import_handler.run() _pop_back_wdg = PopulateBackgroundWidgets(parent=self.parent_no_ui) _pop_back_wdg.run() _o_gui = addie.step2_handler.step2_gui_handler.Step2GuiHandler( parent=self.parent_no_ui) _o_gui.check_gui()
def handle_browse_exe(self): """ Handle file open dialog for user specified exe """ new_exe, ignore = QFileDialog.getOpenFileName( self, "Select Executable", directory=self.project_dir, options=QFileDialog.DontResolveSymlinks) if not new_exe: return key = self.replace_solver_path(new_exe) lw = self.ui.listwidget_solver_list items = [lw.item(i).text() for i in range(0, lw.count())] if key in items: self.parent.message( text='The selected solver is already in the list of ' 'available solvers.') return # check solver ok, message = self.check_exe(new_exe) if not ok: self.parent.message(text=message) return self.save_selected_exe(new_exe) self.mfix_available = True lw.insertItem(0, key) lw.setCurrentRow(0) log.debug('selected new exe %s', key)
def open_file(self, *args, filename: Optional[str] = None, **kwargs): """ Open an existing file and create a new tab containing it. 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. """ if filename is None: filename, _ = QFileDialog.getOpenFileName( parent=self, caption='Select a config', filter='Json Files (*.json)', ) if not filename: return with open(filename, 'r') as fd: serialized = json.load(fd) data = deserialize(ConfigurationFile, serialized) widget = Tree(config_file=data, full_path=filename) self.tab_widget.addTab(widget, self.get_tab_name(filename)) self.tab_widget.setCurrentIndex(self.tab_widget.count() - 1)
def load(self): load_file = QFileDialog.getOpenFileName( self, "Open file", "", "AMI Autosave files (*.ami);;All Files (*)") if load_file[0]: logger.info("Loading graph configuration from file (%s)", load_file[0]) self.loadFile.emit(load_file[0])
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 _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 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 pb_file_clicked(self): dir_current = self.gpc.get_current_working_directory() file_paths = QFileDialog.getOpenFileName(self, "Open Data File", dir_current, "HDF5 (*.h5);; All (*)") file_path = file_paths[0] if file_path: self.signal_loading_new_run.emit() def cb(file_path): result_dict = {} try: msg = self.gpc.open_data_file(file_path) status = True except Exception as ex: msg = str(ex) status = False result_dict.update({ "status": status, "msg": msg, "file_path": file_path }) return result_dict self._compute_in_background(cb, self.slot_file_clicked, file_path=file_path)
def do_load_raw(self): """ Load raw data (TIFF, NeXus HDF5, SPICE .bin) :return: """ # try: IPTS and run (regular way) ipts_number = gui_helper.parse_line_edit(self.ui.lineEdit_iptsNumber, int, False, 'IPTS number', None) run_number = gui_helper.parse_line_edit(self.ui.lineEdit_runNumber, int, False, 'Run number', None) if ipts_number is None or run_number is None: # load data file directory raw_file_name = str( QFileDialog.getOpenFileName(self, 'Get experiment data', os.getcwd())) else: # from archive raw_file_name = self.core.archive_manager.get_nexus( ipts_number, run_number) # load self.load_data_file(raw_file_name) return
def load_fod_input(self): _current_folder = self.parent.parent.current_folder [_table_file, _] = QFileDialog.getOpenFileName( parent=self.parent, caption="Input inp File", directory=_current_folder, filter=("inp files (*.inp);; All Files (*.*)")) if not _table_file: return try: fod_inputs = open(_table_file, "r") except IOError: self.err_messenger("Permission denied! Choose another input file!") return lines = fod_inputs.readlines() fod_inputs.close() for line in lines: try: if line.strip(): self.parameters[line.split('#')[1].strip()]=line.split('#')[0].strip() except IndexError: pass try: self.parent.ui.sample_1_title.setText(self.parameters['sample_1_title']) self.parent.ui.sample_2_title.setText(self.parameters['sample_2_title']) self.parent.ui.bkg_title.setText(self.parameters['background_title']) self.parent.ui.bkg_scans.setText(self.parameters['background scannrs']) self.parent.ui.sample_1_scans.setText(self.parameters['sample_1_scannrs']) self.parent.ui.sample_2_scans.setText(self.parameters['sample_2_scannrs']) self.parent.ui.secondary_scattering_ratio.setText(self.parameters['secondary_scattering_ratio']) self.parent.ui.plazcek_fit_range_min.setText(self.parameters['pla_range'].split(',')[0].strip()) self.parent.ui.plazcek_fit_range_max.setText(self.parameters['pla_range'].split(',')[1].strip()) if ',' in self.parameters['substitution_type']: self.parent.ui.subs_init.setText(self.parameters['substitution_type'].split(',')[0].strip()) self.parent.ui.subs_rep.setText(self.parameters['substitution_type'].split(',')[1].strip()) elif '/' in self.parameters['substitution_type']: self.parent.ui.subs_init.setText(self.parameters['substitution_type'].split('/')[0].strip()) self.parent.ui.subs_rep.setText(self.parameters['substitution_type'].split('/')[1].strip()) self.parent.ui.ft_qrange.setText(self.parameters['qrangeft']) self.parent.ui.ff_rrange.setText(self.parameters['fourier_range_r']) try: self.parent.ui.ff_qrange.setText(self.parameters['fourier_range_q']) except KeyError: self.parent.ui.ff_qrange.setText(self.parameters['fourier_range_Q']) except (IndexError, KeyError): msgBox = QMessageBox() msgBox.setIcon(QMessageBox.Critical) msgBox.setText("Error in FOD input file!") msgBox.setWindowTitle("Error") msgBox.setStandardButtons(QMessageBox.Ok) msgBox.exec_() return return
def _import_ipynb(self, path=None): """Import an ipynb file from path and return it as plain-text code.""" from jupyter_notebook_cell_parsers import parse_nbformat if not isinstance(path, basestring): path = QFileDialog.getOpenFileName( self.main_window, _(u'Open Jupyter/ IPython Notebook'), filter=u'Notebooks (*.ipynb)', directory=cfg.file_dialog_path) if isinstance(path, tuple): path = path[0] if not path: return cfg.file_dialog_path = os.path.dirname(path) try: language, code = parse_nbformat.notebook_to_code( path, self.extension_manager.provide('image_writer')) except Exception as e: self.extension_manager.fire( u'notify', message=_( u'Failed to read notebook. See console for details.')) self.console.write(e) return if language.lower() == 'r': ext = '.R' elif language.lower() == 'python': ext = '.py' else: ext = None self.extension_manager.fire(u'ide_new_file', source=code, ext=ext) self.extension_manager.fire(u'image_annotations_detect', code=code)
def browse_file(self, type='calibration'): if type == 'calibration': _current_folder = self.parent.calibration_folder _filter = "calib (*.h5);;all (*.*)" _caption = "Select Calibration File" _output_ui = self.parent.ui.mantid_calibration_value else: _current_folder = self.parent.characterization_folder _filter = "characterization (*-rietveld.txt);;all (*.*)" _caption = "Select Characterization File" _output_ui = self.parent.ui.mantid_characterization_value _file = QFileDialog.getOpenFileName(parent=self.parent, filter=_filter, caption=_caption, directory=_current_folder) if not _file: return if isinstance(_file, tuple): _file = _file[0] _output_ui.setText(str(_file)) _path = os.path.dirname(str(_file)) if type == 'calibration': self.parent.calibration_current_folder = _path else: self.parent.characterization_current_folder = _path
def open_file(self): # todo: when more file types are added this should # live in its own type filepath, _ = QFileDialog.getOpenFileName(self, "Open File...", "", "Python (*.py)") if not filepath: return self.editor.open_file_in_new_tab(filepath)
def _on_load_from_file(self): filename = QFileDialog.getOpenFileName( self, caption='Load Model', filter=SPECVIZ_MODEL_FILE_FILTER)[0] if not filename: return self._load_model_from_file(filename)
def open_database(self): options = QFileDialog.Options() if not self.config.value('native_dialogs', False): options |= QFileDialog.DontUseNativeDialog filename, _ = QFileDialog.getOpenFileName( self.mainwin, self.tr("Open patch database"), self.config.value('paths/last_database_path', ''), "SQLite Database (*.sqlite *.db);;All Files (*)", options=options) if filename and exists(filename): self.config.setValue('paths/last_database_path', dirname(filename)) log.info(f"Opening database file '{filename}'...") try: self.load_database(filename) except Exception as exc: log.exception(f"Error opening database file '{filename}'.") dlg = self.create_error_dlg( self.tr("Could not load patch database <i>{}</i>.").format( basename(filename)), detail=str(exc), ignore_buttons=False) dlg.exec_() else: self.config.setValue('database/last_opened', filename)
def selectPath(self): """Pops up the 'select a file/directory' dialog""" # todo: This probably needs some reworking to work properly with different scenarios... (file + dir) self._editing = True current_directory = self.getPath() # if not os.path.exists(currentDirectory): # currentDirectory = "~" if self._model.pathMustBeAFile(): current_directory = QFileDialog.getOpenFileName( self, "Select a file path", current_directory) else: current_directory = QFileDialog.getExistingDirectory( self, "Select a directory", current_directory) if not current_directory == "": if not self._model.pathMustBeAbsolute(): cwd = os.getcwd() match = re.match(cwd + "/(.*)", current_directory) if match: current_directory = match.group(1) self._path_line.setText(current_directory) self._model.setPath(self.getPath()) self._editing = False
def createEditor(self, parent, option, index): ws = option.rect.width() hs = option.rect.height() + 4 xs = option.rect.x() ys = option.rect.y() - 2 if index.column() in [2]: filt = "CGNS Files (*.hdf *.cgns)" filename = str(QFileDialog.getOpenFileName(self._table, "Select file", filter=filt)[0]) (dname, fname) = os.path.split(filename) if not dname or not fname: return None itf = QTableWidgetItem(fname) itd = QTableWidgetItem(dname) self._table.setItem(index.row(), 2, itf) self._table.setItem(index.row(), 4, itd) return None if index.column() in [1, 3]: editor = QLineEdit(parent) editor.transgeometry = (xs, ys, ws, hs) editor.installEventFilter(self) self.setEditorData(editor, index) return editor return None
def open_file_dialog(self, title, default_filename, file_types): """ Common method for opening files Parameters ---------- self : ??? the main GUI; not a vbox title : str the title of the dialog default_filename : str the default directory file_types : str the wildcard 'Nastran Geometry - Punch (*.bdf; *.dat; *.nas; *.ecd; *.pch);;All files (*)' """ options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog fname, flt = QFileDialog.getOpenFileName(self, title, default_filename, file_types, options=options) #flt = str(filt).strip() return fname, flt
def request_config_file_name(self, open_flag=True): _caption = 'Select or Define a Configuration File Name' _current_folder = self.parent.configuration_folder if open_flag: _file = QFileDialog.getOpenFileName(parent=self.parent, filter='config (*.cfg)', caption=_caption, directory=_current_folder) if isinstance(_file, tuple): _file = _file[0] else: _file, _ = get_save_file(parent=self.parent, filter={'config (*.cfg)':'cfg'}, caption=_caption, directory=_current_folder) if not _file: self.filename = '' return _new_path = os.path.dirname(_file) self.parent.configuration_folder = _new_path o_file_handler = FileHandler(filename=_file) o_file_handler.check_file_extension(ext_requested='cfg') self.filename = o_file_handler.filename
def _loadCalibrationGrid(self, default=False): home = os.path.expanduser('~') if not default: folder_month = datetime.now().strftime('%Y-%m') path = os.path.join(home, 'mounts', 'screens-iocs', folder_month) fn, _ = QFileDialog.getOpenFileName(self, 'Load Grid...', path, '*.npy') if not fn: return if self.device not in fn: ans = QMessageBox.question( self, 'Warning', 'The name of the selected file does not contain the name' + ' of this screen. Are you sure you\'re loading this grid?', QMessageBox.Yes, QMessageBox.Cancel) if ans == QMessageBox.Cancel: return else: path = os.path.join(home, 'mounts', 'screens-iocs', 'default') fn = path + '/' + self.device + '.npy' try: data = np.load(fn) self.image_view.calibrationGrid = data except Exception as e: if not default: QMessageBox.critical( self, 'Error', 'Could not load calibration grid from file ' + fn + '. ' + '\nError message: ' + str(e), QMessageBox.Ok) return # Enable showing saved grid self.checkBox_showgrid.setEnabled(True)
def open_file_dialog(self, title, default_filename, file_types): """ Common method for opening files Parameters ---------- self : ??? the main GUI; not a vbox title : str the title of the dialog default_filename : str the default directory file_types : str the wildcard 'Nastran Geometry - Punch (*.bdf; *.dat; *.nas; *.ecd; *.pch);;All files (*)' """ options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog if qt_version == 4: # works in: pyqt4, pyside # doesn't work in: pyqt5 fname, wildcard_level = QFileDialog.getOpenFileNameAndFilter( self, title, default_filename, file_types, options=options) return str(fname), str(wildcard_level) else: fname, flt = QFileDialog.getOpenFileName(self, title, default_filename, file_types, options=options) #flt = str(filt).strip() return fname, flt
def pick_file(parent, title="Select File", path=Path("~"), types=("Text Document (*.txt)",)): path = QFileDialog.getOpenFileName(parent, title, str(path.resolve()), filter="\n".join(types))[0] if path: return Path(path).resolve() return None
def open_file(self, checked): modifiers = QApplication.keyboardModifiers() try: curr_file = self.current_file() folder = os.path.dirname(curr_file) except Exception: folder = os.getcwd() filename = QFileDialog.getOpenFileName( self, "Open File...", folder, "XML (*.xml);; ALH Config (*.alhConfig)") filename = filename[0] if isinstance(filename, (list, tuple)) else filename if filename: filename = str(filename) # if alh file selected, open conversion prompt if filename[-9:] == "alhConfig": self.legacy_window = LegacyWindow(filename) self.legacy_window.exec_() if self.legacy_window.converted_filename: self.import_configuration( self.legacy_window.converted_filename) else: self.import_configuration(filename)
def load_state_dialogue(self): filename = QFileDialog.getOpenFileName(self, 'Load state', self.last_state_folder, "Text documents (*.txt)")[0] if filename != '': self.load_state(filename) self.last_state_folder = os.path.dirname(filename)
def open_file_dialog(line_edit, filter_text, directory): file_name = QFileDialog.getOpenFileName(None, 'Open', directory, filter_text) if not file_name: return if isinstance(file_name, tuple): file_name = file_name[0] line_edit.setText(file_name)
def _load_orbit_from_file(self): filename = QFileDialog.getOpenFileName(caption='Select an Orbit File.', directory=self.last_dir, filter=self.EXT_FLT) if not filename[0]: return orbx, orby = _np.loadtxt(filename[0], unpack=True, usecols=(0, 1)) self._update_and_emit('Orbit Loaded: ', orbx, orby, filename[0])
def openFile(self): fichier = QFileDialog.getOpenFileName(self, "Sélectionnez le fichier", "", "Fichier XML (*.xml)") if (fichier[0] != ""): self.nextWidget = ModifyView(fichier[0]) self.hide() else: print("notok")
def input_from(self, format_name: str, format_choose: Sequence[str]) -> str: """Get external file name.""" file_name, suffix = QFileDialog.getOpenFileName( self, f"Open {format_name}", self.env, ';;'.join(format_choose)) if file_name: self.set_locate(QFileInfo(file_name).absolutePath()) return file_name
def ButLoadDCClick(self): DCFile, _ = QFileDialog.getOpenFileName(self, "DC charact file", "", "(*.h5);; (*.*)") if DCFile: self.DevDCVals, _ = FETData.LoadDataFromFile(DCFile) self.LblDCFile.setText(DCFile.split('/')[-1]) self.ButViewDCClick()
def button_clicked(self): file_path = QFileDialog.getOpenFileName(self, 'Select image')[0] try: file_path = os.path.relpath(file_path) except ValueError: return self.path_chosen.emit(file_path)
def grouping_button(self, key=None, grouping_type='input'): message = "Select {} grouping".format(grouping_type) ext = 'Grouping (*.txt);;All (*.*)' file_name = QFileDialog.getOpenFileName(self.main_window, message, self.main_window.calibration_folder, ext) if file_name is None: return
def browse_File(self): """ Open a file dialog to get file """ filename = QFileDialog.getOpenFileName(self, 'Input File Dialog', self._defaultdir, "Data (*.nxs *.dat);;All files (*)") if isinstance(filename, tuple): filename = filename[0] self.ui.lineEdit.setText(filename) Logger("Filter_Events").information('Selected file: "{}"'.format(filename))
def show_opencfg_dlg(self): # show file dialog filename, _ = QFileDialog.getOpenFileName( self, self.tr("Open configuration file..."), directory=os.path.expanduser("~"), filter=self.tr("Json file (*.json);;All files (*.*)") ) # load config file if filename: self.load_file(filename)
def load_tool(self, checked): try: curr_dir = os.path.dirname(self.current_file()) except IndexError: logger.error("The display manager does not have a display loaded. Suggesting current work directory.") curr_dir = os.getcwd() filename = QFileDialog.getOpenFileName(self, 'Load tool...', curr_dir, 'PyDM External Tool Files (*_tool.py)') filename = filename[0] if isinstance(filename, (list, tuple)) else filename if filename: filename = str(filename) tools.install_external_tool(filename) self.update_tools_menu()
def _file_open(self, *argv): """ File chooser for loading UI parameters """ fname = QFileDialog.getOpenFileName(self, "Reduction settings - Choose a settings file", self._last_directory, "Settings files (*.xml)") if not fname: return if isinstance(fname, tuple): fname = fname[0] fname = str(QFileInfo(fname).filePath()) # Store the location of the loaded file self._last_directory = str(QFileInfo(fname).path()) self.open_file(fname)
def browse_file(self): _ascii_file = QFileDialog.getOpenFileName(parent=self.parent_no_ui, caption='Select file to display', directory=self.current_folder) if not _ascii_file: return if isinstance(_ascii_file, tuple): _ascii_file = _ascii_file[0] _ascii_file = str(_ascii_file) o_file_handler = FileHandler(filename=_ascii_file) o_file_handler.retrieve_contain() text_contain = o_file_handler.file_contain o_preview = PreviewAsciiWindow(parent=self.parent_no_ui, text=text_contain, filename=_ascii_file) o_preview.show()
def openfilecheck(open_mode, file_name='', file_ext='', file_type=''): """ :param open_mode: {str} method to open the file (e.g., 'rb' for binary read only) :param file_name: [optional] {str} full path of file to open :param file_ext: [optional] {str} file extension (e.g., '.nev') :param file_type: [optional] {str} file type for use when browsing for file (e.g., 'Blackrock NEV Files') :return: {file} opened file """ while True: if not file_name: # no file name passed from qtpy.QtWidgets import QFileDialog, QApplication # Ask user to specify a file path or browse file_name = input("Enter complete " + file_ext + " file path or hit enter to browse: ") if not file_name: if 'app' not in locals(): app = QApplication([]) if not file_ext: file_type = 'All Files' file_name = QFileDialog.getOpenFileName(QFileDialog(), "Select File", getcwd(), file_type + " (*" + file_ext + ")") # Ensure file exists (really needed for users type entering) if path.isfile(file_name): # Ensure given file matches file_ext if file_ext: _, fext = path.splitext(file_name) # check for * in extension if file_ext[-1] == '*': test_extension = file_ext[:-1] else: test_extension = file_ext if fext[0:len(test_extension)] != test_extension: file_name = '' print("\n*** File given is not a " + file_ext + " file, try again ***\n") continue break else: file_name = '' print("\n*** File given does exist, try again ***\n") print('\n' + file_name.split('/')[-1] + ' opened') return open(file_name, open_mode)
def open_file_action(self, checked): modifiers = QApplication.keyboardModifiers() try: curr_file = self.current_file() folder = os.path.dirname(curr_file) except IndexError: folder = os.getcwd() filename = QFileDialog.getOpenFileName(self, 'Open File...', folder, 'PyDM Display Files (*.ui *.py)') filename = filename[0] if isinstance(filename, (list, tuple)) else filename if filename: filename = str(filename) try: if modifiers == Qt.ShiftModifier: self.app.new_window(filename) else: self.open_file(filename) except (IOError, OSError, ValueError, ImportError) as e: self.handle_open_file_error(filename, e)
def _import(self): _current_folder = self.main_window.current_folder [_table_file, _] = QFileDialog.getOpenFileName(parent=self.main_window, caption="Select File", directory=_current_folder, filter=("text (*.txt);; All Files (*.*)")) if not _table_file: return if isinstance(_table_file, tuple): _table_file = _table_file[0] new_path = os.path.dirname(_table_file) self.main_window.current_folder = new_path self._clear_table() _import_handler = ImportTable(filename=_table_file, parent=self.main_window) _import_handler.run() _pop_back_wdg = PopulateBackgroundWidgets(main_window=self.main_window) _pop_back_wdg.run() _o_gui = addie.processing.idl.step2_gui_handler.Step2GuiHandler(main_window=self.main_window) _o_gui.check_gui()