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