def load_general_setting_values(self):
normalize_to_bin_width = "on" == ConfigService.getString(
self.NORMALIZATION).lower()
show_title = "on" == ConfigService.getString(self.SHOW_TITLE).lower()
self.view.normalize_to_bin_width.setChecked(normalize_to_bin_width)
self.view.show_title.setChecked(show_title)
def should_show_on_startup():
""" Determines if the first time dialog should be shown
:return: True if the dialog should be shown
"""
# first check the facility and instrument
facility = ConfigService.getString(AboutPresenter.FACILITY)
instrument = ConfigService.getString(AboutPresenter.INSTRUMENT)
if not facility:
return True
else:
# check we can get the facility and instrument
try:
facilityInfo = ConfigService.getFacility(facility)
instrumentInfo = ConfigService.getInstrument(instrument)
logger.information("Default facility '{0}', instrument '{1}'\n".format(facilityInfo.name(),
instrumentInfo.name()))
except RuntimeError:
# failed to find the facility or instrument
logger.error("Could not find your default facility '{0}' or instrument '{1}' in facilities.xml, "
+ "showing please select again.\n".format(facility, instrument))
return True
settings = QSettings()
settings.beginGroup(AboutPresenter.DO_NOT_SHOW_GROUP)
doNotShowUntilNextRelease =int(settings.value(AboutPresenter.DO_NOT_SHOW, '0'))
lastVersion = settings.value(AboutPresenter.LAST_VERSION, "")
settings.endGroup()
if not doNotShowUntilNextRelease:
return True
# Now check if the version has changed since last time
version = release_notes_url()
return version != lastVersion
def pcolormesh_on_axis(ax, ws, color_norm=None, normalize_by_bin_width=None):
"""
Plot a pcolormesh plot of the given workspace on the given axis
:param ax: A matplotlib axes instance
:param ws: A mantid workspace instance
:param color_norm: A matplotlib.colours Normalize instance (or any of its subclasses)
:param normalize_by_bin_width: Optional keyword argument to pass to imshow in the event of a plot restoration
:return:
"""
ax.clear()
ax.set_title(ws.name())
scale = _get_colorbar_scale() if not color_norm else color_norm
if use_imshow(ws):
pcm = ax.imshow(ws,
cmap=ConfigService.getString("plots.images.Colormap"),
aspect='auto',
origin='lower',
norm=scale,
normalize_by_bin_width=normalize_by_bin_width)
# remove normalize_by_bin_width from cargs if present so that this can be toggled in future
for cargs in pcm.axes.creation_args:
cargs.pop('normalize_by_bin_width')
else:
pcm = ax.pcolormesh(
ws,
cmap=ConfigService.getString("plots.images.Colormap"),
norm=scale)
return pcm
def load_current_setting_values(self):
background = ConfigService.getString(self.AUTO_BACKGROUND).split(
" ", 1)
if self.view.auto_bkg.findText(background[0], Qt.MatchExactly) != -1:
self.view.auto_bkg.setCurrentText(background[0])
else:
self.view.auto_bkg.setCurrentText("LinearBackground")
if len(background) > 1:
self.view.background_args.setText(background[1])
default_peak = ConfigService.getString(self.DEFAULT_PEAK)
if self.view.default_peak.findText(default_peak,
Qt.MatchExactly) != -1:
self.view.default_peak.setCurrentText(default_peak)
else:
self.view.auto_bkg.setCurrentText("Gaussian")
fwhm = ConfigService.getString(self.FWHM)
if fwhm == "":
self.view.findpeaks_fwhm.setValue(7)
else:
self.view.findpeaks_fwhm.setValue(int(fwhm))
tolerance = ConfigService.getString(self.TOLERANCE)
if tolerance == "":
self.view.findpeaks_tol.setValue(4)
else:
self.view.findpeaks_tol.setValue(int(tolerance))
def get_plot_fig(overplot=None,
ax_properties=None,
window_title=None,
axes_num=1,
fig=None):
"""
Create a blank figure and axes, with configurable properties.
:param overplot: If true then plotting on figure will plot over previous plotting. If an axis object the overplotting
will be done on the axis passed in
:param ax_properties: A dict of axes properties. E.g. {'yscale': 'log'} for log y-axis
:param window_title: A string denoting the name of the GUI window which holds the graph
:param axes_num: The number of axes to create on the figure
:param fig: An optional figure object
:return: Matplotlib fig and axes objects
"""
import matplotlib.pyplot as plt
if fig and overplot:
fig = fig
elif fig:
fig, _, _, _ = create_subplots(axes_num, fig)
elif overplot:
# The create subplot below assumes no figure was passed in, this is ensured by the elif above
# but add an assert which prevents a future refactoring from breaking this assumption
assert not fig
fig = plt.gcf()
if not fig.axes:
plt.close(fig)
# The user is likely trying to overplot on a non-existent plot, create one for them
fig, _, _, _ = create_subplots(axes_num)
else:
fig, _, _, _ = create_subplots(axes_num)
if not ax_properties and not overplot:
ax_properties = {}
if ConfigService.getString("plots.xAxesScale").lower() == 'log':
ax_properties['xscale'] = 'log'
else:
ax_properties['xscale'] = 'linear'
if ConfigService.getString("plots.yAxesScale").lower() == 'log':
ax_properties['yscale'] = 'log'
else:
ax_properties['yscale'] = 'linear'
if ax_properties:
for axis in fig.axes:
axis.set(**ax_properties)
if window_title:
fig.canvas.set_window_title(window_title)
if not overplot:
if ConfigService.getString("plots.ShowMinorTicks").lower() == "on":
for ax in fig.axes:
ax.minorticks_on()
for ax in fig.axes:
ax.show_minor_gridlines = ConfigService.getString(
"plots.ShowMinorGridlines").lower() == "on"
return fig, fig.axes
def __init__(self):
super(PythonInterfacesStartupTest, self).__init__()
self._app = get_application()
self._interface_directory = ConfigService.getString('mantidqt.python_interfaces_directory')
self._interface_scripts = [interface.split("/")[1] for interface in
ConfigService.getString('mantidqt.python_interfaces').split()
if interface.split("/")[1] not in EXCLUDED_SCRIPTS]
def setup_error_bar_group(self):
error_width = float(ConfigService.getString(self.ERROR_WIDTH))
capsize = float(ConfigService.getString(self.CAPSIZE))
cap_thickness = float(ConfigService.getString(self.CAP_THICKNESS))
error_every = int(ConfigService.getString(self.ERROR_EVERY))
self.view.error_width.setValue(error_width)
self.view.capsize.setValue(capsize)
self.view.cap_thickness.setValue(cap_thickness)
self.view.error_every.setValue(error_every)
def setup_legend_group(self):
legend_location = ConfigService.getString(
PlotProperties.LEGEND_LOCATION.value)
self.view.legend_location.addItems(self.LEGEND_LOCATION_LIST)
if legend_location in self.LEGEND_LOCATION_LIST:
self.view.legend_location.setCurrentIndex(
self.view.legend_location.findText(legend_location))
legend_font_size = float(
ConfigService.getString(PlotProperties.LEGEND_FONT_SIZE.value))
self.view.legend_font_size.setValue(legend_font_size)
def _add_default_plot_kwargs_from_settings(plot_kwargs, errors):
if 'linestyle' not in plot_kwargs:
plot_kwargs['linestyle'] = ConfigService.getString("plots.line.Style")
if 'drawstyle' not in plot_kwargs:
plot_kwargs['drawstyle'] = ConfigService.getString(
"plots.line.DrawStyle")
if 'linewidth' not in plot_kwargs:
plot_kwargs['linewidth'] = float(
ConfigService.getString("plots.line.Width"))
if 'marker' not in plot_kwargs:
plot_kwargs['marker'] = MARKER_MAP[ConfigService.getString(
"plots.marker.Style")]
if 'markersize' not in plot_kwargs:
plot_kwargs['markersize'] = float(
ConfigService.getString("plots.marker.Size"))
if errors:
if 'capsize' not in plot_kwargs:
plot_kwargs['capsize'] = float(
ConfigService.getString("plots.errorbar.Capsize"))
if 'capthick' not in plot_kwargs:
plot_kwargs['capthick'] = float(
ConfigService.getString("plots.errorbar.CapThickness"))
if 'errorevery' not in plot_kwargs:
plot_kwargs['errorevery'] = int(
ConfigService.getString("plots.errorbar.errorEvery"))
if 'elinewidth' not in plot_kwargs:
plot_kwargs['elinewidth'] = float(
ConfigService.getString("plots.errorbar.Width"))
def setup_marker_group(self):
marker_style = ConfigService.getString(self.MARKER_STYLE)
self.view.marker_style.addItems(MARKER_STYLES)
if marker_style in MARKER_STYLES:
self.view.marker_style.setCurrentIndex(
self.view.marker_style.findText(marker_style))
else:
self.view.marker_style.setCurrentIndex(0)
marker_size = float(ConfigService.getString(self.MARKER_SIZE))
self.view.marker_size.setValue(marker_size)
def setup_line_group(self):
line_style = ConfigService.getString(self.LINE_STYLE)
self.view.line_style.addItems(VALID_LINE_STYLE)
if line_style in VALID_LINE_STYLE:
self.view.line_style.setCurrentIndex(
self.view.line_style.findText(line_style))
else:
self.view.line_style.setCurrentIndex(0)
line_width = float(ConfigService.getString(self.LINE_WIDTH))
self.view.line_width.setValue(line_width)
def setup_line_group(self):
line_style = ConfigService.getString(PlotProperties.LINE_STYLE.value)
self._setup_style_combo_boxes(line_style, self.view.line_style,
VALID_LINE_STYLE)
draw_style = ConfigService.getString(PlotProperties.DRAW_STYLE.value)
self._setup_style_combo_boxes(draw_style, self.view.draw_style,
VALID_DRAW_STYLE)
line_width = float(
ConfigService.getString(PlotProperties.LINE_WIDTH.value))
self.view.line_width.setValue(line_width)
def setup_marker_group(self):
marker_style = ConfigService.getString(
PlotProperties.MARKER_STYLE.value)
if marker_style in MARKER_STYLES.keys():
self.view.marker_style.setCurrentIndex(
self.view.marker_style.findText(marker_style))
else:
self.view.marker_style.setCurrentIndex(0)
marker_size = float(
ConfigService.getString(PlotProperties.MARKER_SIZE.value))
self.view.marker_size.setValue(marker_size)
def load_general_setting_values(self):
normalize_to_bin_width = "on" == ConfigService.getString(
PlotProperties.NORMALIZATION.value).lower()
show_title = "on" == ConfigService.getString(
PlotProperties.SHOW_TITLE.value).lower()
show_legend = "on" == ConfigService.getString(
PlotProperties.SHOW_LEGEND.value).lower()
self.view.normalize_to_bin_width.setChecked(normalize_to_bin_width)
self.view.show_title.setChecked(show_title)
self.view.show_legend.setChecked(show_legend)
self.populate_font_combo_box()
def load_current_setting_values(self):
self.view.prompt_save_on_close.setChecked(CONF.get(self.PROMPT_SAVE_ON_CLOSE))
self.view.prompt_save_editor_modified.setChecked(CONF.get(self.PROMPT_SAVE_EDITOR_MODIFIED))
# compare lower-case, because MantidPlot will save it as lower case,
# but Python will have the bool's first letter capitalised
pr_enabled = ("true" == ConfigService.getString(self.PR_RECOVERY_ENABLED).lower())
pr_time_between_recovery = int(ConfigService.getString(self.PR_TIME_BETWEEN_RECOVERY))
pr_number_checkpoints = int(ConfigService.getString(self.PR_NUMBER_OF_CHECKPOINTS))
self.view.project_recovery_enabled.setChecked(pr_enabled)
self.view.time_between_recovery.setValue(pr_time_between_recovery)
self.view.total_number_checkpoints.setValue(pr_number_checkpoints)
def load_general_setting_values(self):
normalize_to_bin_width = "on" == ConfigService.getString(
PlotProperties.NORMALIZATION.value).lower()
show_title = "on" == ConfigService.getString(
PlotProperties.SHOW_TITLE.value).lower()
show_minor_ticks = "on" == ConfigService.getString(
PlotProperties.SHOW_MINOR_TICKS.value).lower()
show_minor_gridlines = "on" == ConfigService.getString(
PlotProperties.SHOW_MINOR_GRIDLINES.value).lower()
self.view.normalize_to_bin_width.setChecked(normalize_to_bin_width)
self.view.show_title.setChecked(show_title)
self.view.show_minor_ticks.setChecked(show_minor_ticks)
self.view.show_minor_gridlines.setEnabled(show_minor_ticks)
self.view.show_minor_gridlines.setChecked(show_minor_gridlines)
def remove_output_files(list_of_names=None):
"""Removes output files created during a test."""
# import ConfigService here to avoid:
# RuntimeError: Pickling of "mantid.kernel._kernel.ConfigServiceImpl"
# instances is not enabled (http://www.boost.org/libs/python/doc/v2/pickle.html)
from mantid.kernel import ConfigService
if not isinstance(list_of_names, list):
raise ValueError("List of names is expected.")
if not all(isinstance(i, str) for i in list_of_names):
raise ValueError("Each name should be a string.")
save_dir_path = ConfigService.getString("defaultsave.directory")
if save_dir_path != "": # default save directory set
all_files = os.listdir(save_dir_path)
else:
all_files = os.listdir(os.getcwd())
for filename in all_files:
for name in list_of_names:
if name in filename:
full_path = os.path.join(save_dir_path, filename)
if os.path.isfile(full_path):
os.remove(full_path)
break
def _save(self):
self.__is_saving = True
try:
workspaces_to_save = self._get_workspace_names_to_save()
if self.save_altered_workspaces_only:
workspaces_to_save = self._filter_unaltered_workspaces(
workspaces_to_save)
# Calculate the size of the workspaces in the project.
project_size = self._get_project_size(workspaces_to_save)
warning_size = int(
ConfigService.getString("projectSaving.warningSize"))
# If a project is > the value in the properties file, question the user if they want to continue.
result = None
if project_size > warning_size:
result = self._offer_large_size_confirmation()
if result is None or result != QMessageBox.Cancel:
plots_to_save = self.plot_gfm.figs
if self.save_altered_workspaces_only:
plots_to_save = self._filter_plots_with_unaltered_workspaces(
plots_to_save, workspaces_to_save)
interfaces_to_save = self.interface_populating_function()
project_saver = ProjectSaver(self.project_file_ext)
project_saver.save_project(
file_name=self.last_project_location,
workspace_to_save=workspaces_to_save,
plots_to_save=plots_to_save,
interfaces_to_save=interfaces_to_save)
self.__saved = True
finally:
self.__is_saving = False
def __init__(self, parent, view=None, usage_reporting_verification_view = None):
self.view = view if view else AboutView(parent, self, version_str(), release_date().strip())
self.usage_reporting_verification_view = usage_reporting_verification_view \
if usage_reporting_verification_view else UsageReportingVerificationView(parent, self)
self.parent = parent
self.view.clbReleaseNotes.clicked.connect(self.action_open_release_notes)
self.view.clbSampleDatasets.clicked.connect(self.action_open_download_website)
self.view.clbMantidIntroduction.clicked.connect(self.action_open_mantid_introduction)
self.view.clbPythonIntroduction.clicked.connect(self.action_open_python_introduction)
self.view.clbPythonInMantid.clicked.connect(self.action_open_python_in_mantid)
self.view.clbExtendingMantid.clicked.connect(self.action_open_extending_mantid)
self.view.lblPrivacyPolicy.linkActivated.connect(self.action_open_external_link)
self.view.pbMUD.clicked.connect(self.action_manage_user_directories)
self.view.pbClose.clicked.connect(self.action_close)
self.setup_facilities_group()
# set chkAllowUsageData
isUsageReportEnabled = ConfigService.getString(self.USAGE_REPORTING, True)
if isUsageReportEnabled == "0":
self.view.chkAllowUsageData.setChecked(False)
self.view.chkAllowUsageData.stateChanged.connect(self.action_usage_data_changed)
# set do not show
qSettings = QSettings()
qSettings.beginGroup(self.DO_NOT_SHOW_GROUP)
doNotShowUntilNextRelease = int(qSettings.value(self.DO_NOT_SHOW, "0"))
qSettings.endGroup()
self.view.chkDoNotShowUntilNextRelease.setChecked(doNotShowUntilNextRelease)
self.view.chkDoNotShowUntilNextRelease.stateChanged.connect(self.action_do_not_show_until_next_release)
def test_large_file_dialog_does_not_appear_for_small_file(self):
CreateSampleWorkspace(OutputWorkspace="ws1")
self.project._get_project_size = mock.MagicMock(return_value=
int(ConfigService.getString("projectSaving.warningSize")) - 1)
self.project._offer_large_size_confirmation = mock.MagicMock()
self.project._save()
self.assertEqual(self.project._offer_large_size_confirmation.call_count, 0)
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
# sanity check the mappable
mappable = self._validate_mappable(mappable)
self.ax.clear()
try: # Use current cmap
cmap = get_current_cmap(self.colorbar)
except AttributeError:
# else use default
cmap = ConfigService.getString("plots.images.Colormap")
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = mappable.get_clim()
self.update_clim_text()
self.cmap_changed(cmap, False)
mappable_cmap = get_current_cmap(mappable)
if mappable_cmap.name.endswith('_r'):
self.crev.setChecked(True)
else:
self.crev.setChecked(False)
self.cmap.setCurrentIndex(
self.cmap_list.index(mappable_cmap.name.replace('_r', '')))
self.redraw()
def _get_colorbar_scale():
"""Get the scale type (Linear, Log) for the colorbar in image type plots"""
scale = ConfigService.getString("plots.images.ColorBarScale")
if scale == "Log":
return matplotlib.colors.LogNorm()
else:
return matplotlib.colors.Normalize()
def remove_output_files(list_of_names=None):
"""Removes output files created during a test."""
# import ConfigService here to avoid:
# RuntimeError: Pickling of "mantid.kernel._kernel.ConfigServiceImpl"
# instances is not enabled (http://www.boost.org/libs/python/doc/v2/pickle.html)
from mantid.kernel import ConfigService
if not isinstance(list_of_names, list):
raise ValueError("List of names is expected.")
if not all(isinstance(i, str) for i in list_of_names):
raise ValueError("Each name should be a string.")
save_dir_path = ConfigService.getString("defaultsave.directory")
if save_dir_path != "": # default save directory set
all_files = os.listdir(save_dir_path)
else:
all_files = os.listdir(os.getcwd())
for filename in all_files:
for name in list_of_names:
if name in filename:
full_path = os.path.join(save_dir_path, filename)
if os.path.isfile(full_path):
os.remove(full_path)
break
def setup_checkbox_signals(self):
self.view.show_invisible_workspaces.setChecked(
"true" == ConfigService.getString(self.SHOW_INVISIBLE_WORKSPACES).lower())
self.view.show_invisible_workspaces.stateChanged.connect(self.action_show_invisible_workspaces)
self.view.project_recovery_enabled.stateChanged.connect(self.action_project_recovery_enabled)
self.view.time_between_recovery.valueChanged.connect(self.action_time_between_recovery)
self.view.total_number_checkpoints.valueChanged.connect(self.action_total_number_checkpoints)
def setup_axes_group(self):
x_axes_scale = ConfigService.getString(self.X_AXES_SCALE)
y_axes_scale = ConfigService.getString(self.Y_AXES_SCALE)
self.view.x_axes_scale.addItems(self.AXES_SCALE)
self.view.y_axes_scale.addItems(self.AXES_SCALE)
if x_axes_scale in self.AXES_SCALE:
self.view.x_axes_scale.setCurrentIndex(
self.view.x_axes_scale.findText(x_axes_scale))
else:
self.view.x_axes_scale.setCurrentIndex(0)
if y_axes_scale in self.AXES_SCALE:
self.view.y_axes_scale.setCurrentIndex(
self.view.y_axes_scale.findText(y_axes_scale))
else:
self.view.y_axes_scale.setCurrentIndex(0)
def __init__(self, initial_type):
self._save_directory = ConfigService.getString('defaultsave.directory')
self._type_factory_dict = {
BinningType.SaveAsEventData: SaveAsEventData(),
BinningType.Custom: CustomBinning(),
BinningType.FromMonitors: BinningFromMonitors()
}
self._settings, self._type = self._settings_from_type(initial_type)
def __init__(self, initial_type):
self._save_directory = ConfigService.getString('defaultsave.directory')
self._type_factory_dict = {
BinningType.SAVE_AS_EVENT_DATA: SaveAsEventData(),
BinningType.CUSTOM: CustomBinning(),
BinningType.FROM_MONITORS: BinningFromMonitors()
}
self._settings, self._type = self._settings_from_type(initial_type)
def setup_axes_group(self):
x_axes_scale = ConfigService.getString(
PlotProperties.X_AXES_SCALE.value)
y_axes_scale = ConfigService.getString(
PlotProperties.Y_AXES_SCALE.value)
if x_axes_scale in self.AXES_SCALE:
self.view.x_axes_scale.setCurrentIndex(
self.view.x_axes_scale.findText(x_axes_scale))
else:
self.view.x_axes_scale.setCurrentIndex(0)
if y_axes_scale in self.AXES_SCALE:
self.view.y_axes_scale.setCurrentIndex(
self.view.y_axes_scale.findText(y_axes_scale))
else:
self.view.y_axes_scale.setCurrentIndex(0)
def load_current_setting_values(self):
self.view.prompt_save_on_close.setChecked(
CONF.get(self.PROMPT_SAVE_ON_CLOSE))
self.view.prompt_save_editor_modified.setChecked(
CONF.get(self.PROMPT_SAVE_EDITOR_MODIFIED))
# compare lower-case, because MantidPlot will save it as lower case,
# but Python will have the bool's first letter capitalised
pr_enabled = ("true" == ConfigService.getString(
self.PR_RECOVERY_ENABLED).lower())
pr_time_between_recovery = int(
ConfigService.getString(self.PR_TIME_BETWEEN_RECOVERY))
pr_number_checkpoints = int(
ConfigService.getString(self.PR_NUMBER_OF_CHECKPOINTS))
self.view.project_recovery_enabled.setChecked(pr_enabled)
self.view.time_between_recovery.setValue(pr_time_between_recovery)
self.view.total_number_checkpoints.setValue(pr_number_checkpoints)
def __init__(self):
super(PythonInterfacesStartupTest, self).__init__()
import mantidqtinterfaces
self._interface_directory = os.path.dirname(
mantidqtinterfaces.__file__)
self._interface_scripts = [
interface.split("/")[1] for interface in ConfigService.getString(
'mantidqt.python_interfaces').split()
]
def populate_font_combo_box(self):
fonts = self.model.get_font_names()
self.view.plot_font.addItems(fonts)
current_font = ConfigService.getString(PlotProperties.PLOT_FONT.value)
if current_font:
self.view.plot_font.setCurrentText(current_font)
else:
self.view.plot_font.setCurrentText(
self.model.get_current_mpl_font())
def pcolormesh_on_axis(ax, ws):
"""
Plot a pcolormesh plot of the given workspace on the given axis
:param ax: A matplotlib axes instance
:param ws: A mantid workspace instance
:return:
"""
ax.clear()
ax.set_title(ws.name())
if use_imshow(ws):
pcm = ax.imshow(ws,
cmap=ConfigService.getString("plots.images.Colormap"),
aspect='auto',
origin='lower')
else:
pcm = ax.pcolormesh(
ws, cmap=ConfigService.getString("plots.images.Colormap"))
return pcm
def setup_images_group(self):
colormap = ConfigService.getString(PlotProperties.COLORMAP.value)
if self.view.default_colormap_combo_box.findText(colormap) != -1:
self.view.default_colormap_combo_box.setCurrentIndex(
self.view.default_colormap_combo_box.findText(colormap))
self.view.reverse_colormap_check_box.setChecked(False)
elif colormap.endswith(
'_r') and self.view.default_colormap_combo_box.findText(
colormap[:-2]):
self.view.default_colormap_combo_box.setCurrentIndex(
self.view.default_colormap_combo_box.findText(colormap[:-2]))
self.view.reverse_colormap_check_box.setChecked(True)
colorbar_scale = ConfigService.getString(
PlotProperties.COLORBAR_SCALE.value)
if colorbar_scale in self.AXES_SCALE:
self.view.colorbar_scale.setCurrentIndex(
self.view.colorbar_scale.findText(colorbar_scale))
else:
self.view.colorbar_scale.setCurrentIndex(0)
def get_number_of_checkpoints():
"""
:return: int; The maximum number of checkpoints project recovery should allow
"""
try:
return int(ConfigService.getString("projectRecovery.numberOfCheckpoints"))
except Exception as e:
if isinstance(e, KeyboardInterrupt):
raise
# Fail silently and return 5 (the default)
return DEFAULT_NUM_CHECKPOINTS
def __init__(self, input_filename=None, group_name=None):
if isinstance(input_filename, str):
self._input_filename = input_filename
try:
self._hash_input_filename = self.calculate_ab_initio_file_hash()
except IOError as err:
logger.error(str(err))
except ValueError as err:
logger.error(str(err))
# extract name of file from the full path in the platform independent way
filename = os.path.basename(self._input_filename)
if filename.strip() == "":
raise ValueError("Name of the file cannot be an empty string.")
else:
raise ValueError("Invalid name of input file. String was expected.")
if isinstance(group_name, str):
self._group_name = group_name
else:
raise ValueError("Invalid name of the group. String was expected.")
core_name = filename[0:filename.rfind(".")]
save_dir_path = ConfigService.getString("defaultsave.directory")
self._hdf_filename = os.path.join(save_dir_path, core_name + ".hdf5") # name of hdf file
try:
self._advanced_parameters = self._get_advanced_parameters()
except IOError as err:
logger.error(str(err))
except ValueError as err:
logger.error(str(err))
self._attributes = {} # attributes for group
# data for group; they are expected to be numpy arrays or
# complex data sets which have the form of Python dictionaries or list of Python
# dictionaries
self._data = {}
def test_get_number_of_checkpoints(self):
self.assertEqual(int(ConfigService.getString(NO_OF_CHECKPOINTS_KEY)),
self.prm.get_number_of_checkpoints())
def __init__(self, initial_type):
self._save_directory = ConfigService.getString('defaultsave.directory')
self._type_factory_dict = {BinningType.SaveAsEventData: SaveAsEventData(),
BinningType.Custom: CustomBinning(),
BinningType.FromMonitors: BinningFromMonitors()}
self._settings, self._type = self._settings_from_type(initial_type)
def instrument(self):
return ConfigService.getString('default.instrument')
def save_directory(self):
return ConfigService.getString('defaultsave.directory')