def __init__(self, *args, **kwargs):
"""
Valid keyword arguments for an AtomContents are:
atom_contents: a list of tuples containing the atom content
object uuids, property names and default amounts
"""
my_kwargs = self.pop_kwargs(
kwargs, *[
names[0]
for names in type(self).Meta.get_local_storable_properties()
])
super(AtomContents, self).__init__(*args, **kwargs)
kwargs = my_kwargs
# Load atom contents:
self._atom_contents = []
for uuid, prop, amount in self.get_kwarg(kwargs, [], "atom_contents"):
# uuid's are resolved when resolve_relations is called
self._atom_contents.append(AtomContentObject(uuid, prop, amount))
def on_change(*args):
if self.enabled: # no need for updates in this case
self.data_changed.emit()
self._atom_contents_observer = ListObserver(on_change,
on_change,
prop_name="atom_contents",
model=self)
def __init__(self, *args, **kwargs):
my_kwargs = self.pop_kwargs(kwargs,
"data_CSDS_distribution", "data_sigma_star", "data_components",
"data_G", "G", "data_R", "R",
"data_probabilities", "based_on_uuid", "based_on_index",
"inherit_probabilities",
*[names[0] for names in Phase.Meta.get_local_storable_properties()]
)
super(Phase, self).__init__(*args, **kwargs)
kwargs = my_kwargs
with self.data_changed.hold():
CSDS_distribution = self.get_kwarg(kwargs, None, "CSDS_distribution", "data_CSDS_distribution")
self.CSDS_distribution = self.parse_init_arg(
CSDS_distribution, DritsCSDSDistribution, child=True,
default_is_class=True, parent=self
)
self.inherit_CSDS_distribution = self.get_kwarg(kwargs, False, "inherit_CSDS_distribution")
self.display_color = self.get_kwarg(kwargs, choice(self.line_colors), "display_color")
self.inherit_display_color = self.get_kwarg(kwargs, False, "inherit_display_color")
self.sigma_star = self.get_kwarg(kwargs, self._sigma_star, "sigma_star", "data_sigma_star")
self.inherit_sigma_star = self.get_kwarg(kwargs, False, "inherit_sigma_star")
self.components = self.get_list(kwargs, [], "components", "data_components", parent=self)
G = self.get_kwarg(kwargs, 1, "G", "data_G")
R = self.get_kwarg(kwargs, 0, "R", "data_R")
if G is not None and G > 0:
for i in range(len(self.components), G):
new_comp = Component(name="Component %d" % (i + 1), parent=self)
self.components.append(new_comp)
self.observe_model(new_comp)
# Observe components
for component in self.components:
self.observe_model(component)
# Connect signals to lists and dicts:
self._components_observer = ListObserver(
self.on_component_inserted,
self.on_component_removed,
prop_name="components",
model=self
)
self.probabilities = self.parse_init_arg(
self.get_kwarg(kwargs, None, "probabilities", "data_probabilities"),
get_correct_probability_model(R, G), default_is_class=True, child=True)
self.probabilities.update() # force an update
inherit_probabilities = kwargs.pop("inherit_probabilities", None)
if inherit_probabilities is not None:
for prop in self.probabilities.Meta.get_inheritable_properties():
setattr(self.probabilities, prop.inh_name, bool(inherit_probabilities))
self._based_on_uuid = self.get_kwarg(kwargs, None, "based_on_uuid")
self._based_on_index = self.get_kwarg(kwargs, None, "based_on_index")
def __init__(self, **kwargs):
"""
Valid keyword arguments for a Component are:
*ucp_a*: unit cell property along a axis
*ucp_b*: unit cell property along b axis
*d001*: unit cell length c (aka d001)
*default_c*: default c-value
*delta_c*: the variation in basal spacing due to defects
*layer_atoms*: ObjectListStore of layer Atoms
*interlayer_atoms*: ObjectListStore of interlayer Atoms
*atom_relations*: ObjectListStore of AtomRelations
*inherit_ucp_a*: whether or not to inherit the ucp_a property from
the linked component (if linked)
*inherit_ucp_b*: whether or not to inherit the ucp_b property from
the linked component (if linked)
*inherit_d001*: whether or not to inherit the d001 property from
the linked component (if linked)
*inherit_default_c*: whether or not to inherit the default_c
property from the linked component (if linked)
*inherit_delta_c*: whether or not to inherit the delta_c
property from the linked component (if linked)
*inherit_layer_atoms*: whether or not to inherit the layer_atoms
property from the linked component (if linked)
*inherit_interlayer_atoms*: whether or not to inherit the
interlayer_atoms property from the linked component (if linked)
*inherit_atom_relations*: whether or not to inherit the
atom_relations property from the linked component (if linked)
*linked_with_uuid*: the UUID for the component this one is linked
with
Deprecated, but still supported:
*linked_with_index*: the index of the component this one is
linked with in the ObjectListStore of the parent based on phase.
"""
my_kwargs = self.pop_kwargs(
kwargs, "data_name", "data_layer_atoms", "data_interlayer_atoms",
"data_atom_relations", "data_atom_ratios", "data_d001",
"data_default_c", "data_delta_c", "lattice_d", "data_cell_a",
"data_ucp_a", "data_cell_b", "data_ucp_b", "linked_with_uuid",
"linked_with_index", "inherit_cell_a", "inherit_cell_b", *[
names[0]
for names in type(self).Meta.get_local_storable_properties()
])
super(Component, self).__init__(**kwargs)
kwargs = my_kwargs
# Setup signals:
self.atoms_changed = HoldableSignal()
# Set up data object
self._data_object = ComponentData(d001=0.0, delta_c=0.0)
# Set attributes:
self.name = self.get_kwarg(kwargs, "", "name", "data_name")
# Load lists:
self.layer_atoms = self.get_list(kwargs, [],
"layer_atoms",
"data_layer_atoms",
parent=self)
self.interlayer_atoms = self.get_list(kwargs, [],
"interlayer_atoms",
"data_interlayer_atoms",
parent=self)
self.atom_relations = self.get_list(kwargs, [],
"atom_relations",
"data_atom_relations",
parent=self)
# Add all atom ratios to the AtomRelation list
for atom_ratio in self.get_list(kwargs, [],
"atom_ratios",
"data_atom_ratios",
parent=self):
self.atom_relations.append(atom_ratio)
# Observe the inter-layer atoms, and make sure they get stretched
for atom in self.interlayer_atoms:
atom.stretch_values = True
self.observe_model(atom)
# Observe the layer atoms
for atom in self.layer_atoms:
self.observe_model(atom)
# Resolve their relations and observe the atom relations
for relation in self.atom_relations:
relation.resolve_relations()
self.observe_model(relation)
# Connect signals to lists and dicts:
self._layer_atoms_observer = ListObserver(self._on_layer_atom_inserted,
self._on_layer_atom_removed,
prop_name="layer_atoms",
model=self)
self._interlayer_atoms_observer = ListObserver(
self._on_interlayer_atom_inserted,
self._on_interlayer_atom_removed,
prop_name="interlayer_atoms",
model=self)
self._atom_relations_observer = ListObserver(
self._on_atom_relation_inserted,
self._on_atom_relation_removed,
prop_name="atom_relations",
model=self)
# Update lattice values:
self.d001 = self.get_kwarg(kwargs, self._d001, "d001", "data_d001")
self._default_c = float(
self.get_kwarg(kwargs, self._d001, "default_c", "data_default_c"))
self.delta_c = float(
self.get_kwarg(kwargs, self._delta_c, "delta_c", "data_delta_c"))
self.update_lattice_d()
# Set/Create & observe unit cell properties:
ucp_a = self.get_kwarg(kwargs, None, "ucp_a", "data_ucp_a",
"data_cell_a")
if isinstance(ucp_a, float):
ucp_a = UnitCellProperty(name="cell length a",
value=ucp_a,
parent=self)
self._ucp_a = self.parse_init_arg(ucp_a,
UnitCellProperty,
child=True,
default_is_class=True,
name="Cell length a [nm]",
parent=self)
self.observe_model(self._ucp_a)
ucp_b = self.get_kwarg(kwargs, None, "ucp_b", "data_ucp_b",
"data_cell_b")
if isinstance(ucp_b, float):
ucp_b = UnitCellProperty(name="cell length b",
value=ucp_b,
parent=self)
self._ucp_b = self.parse_init_arg(ucp_b,
UnitCellProperty,
child=True,
default_is_class=True,
name="Cell length b [nm]",
parent=self)
self.observe_model(self._ucp_b)
# Set links:
self._linked_with_uuid = self.get_kwarg(kwargs, "", "linked_with_uuid")
self._linked_with_index = self.get_kwarg(kwargs, -1,
"linked_with_index")
# Set inherit flags:
self.inherit_d001 = self.get_kwarg(kwargs, False, "inherit_d001")
self.inherit_ucp_a = self.get_kwarg(kwargs, False, "inherit_ucp_a",
"inherit_cell_a")
self.inherit_ucp_b = self.get_kwarg(kwargs, False, "inherit_ucp_b",
"inherit_cell_b")
self.inherit_default_c = self.get_kwarg(kwargs, False,
"inherit_default_c")
self.inherit_delta_c = self.get_kwarg(kwargs, False, "inherit_delta_c")
self.inherit_layer_atoms = self.get_kwarg(kwargs, False,
"inherit_layer_atoms")
self.inherit_interlayer_atoms = self.get_kwarg(
kwargs, False, "inherit_interlayer_atoms")
self.inherit_atom_relations = self.get_kwarg(kwargs, False,
"inherit_atom_relations")
def __init__(self, *args, **kwargs):
"""
Constructor takes any of its properties as a keyword argument
except for:
- needs_saving
In addition to the above, the constructor still supports the
following deprecated keywords, mapping to a current keyword:
- goniometer: the project-level goniometer, is passed on to the
specimens
- axes_xscale: deprecated alias for axes_xlimit
- axes_yscale: deprecated alias for axes_ynormalize
Any other arguments or keywords are passed to the base class.
"""
my_kwargs = self.pop_kwargs(
kwargs, "goniometer", "data_goniometer", "data_atom_types",
"data_phases", "axes_yscale", "axes_xscale", "filename", *[
names[0]
for names in type(self).Meta.get_local_storable_properties()
])
super(Project, self).__init__(*args, **kwargs)
kwargs = my_kwargs
with self.data_changed.hold():
with self.visuals_changed.hold():
self.filename = self.get_kwarg(kwargs, self.filename,
"filename")
self.layout_mode = self.get_kwarg(kwargs, self.layout_mode,
"layout_mode")
self.display_marker_align = self.get_kwarg(
kwargs, self.display_marker_align, "display_marker_align")
self.display_marker_color = self.get_kwarg(
kwargs, self.display_marker_color, "display_marker_color")
self.display_marker_base = self.get_kwarg(
kwargs, self.display_marker_base, "display_marker_base")
self.display_marker_top = self.get_kwarg(
kwargs, self.display_marker_top, "display_marker_top")
self.display_marker_top_offset = self.get_kwarg(
kwargs, self.display_marker_top_offset,
"display_marker_top_offset")
self.display_marker_angle = self.get_kwarg(
kwargs, self.display_marker_angle, "display_marker_angle")
self.display_marker_style = self.get_kwarg(
kwargs, self.display_marker_style, "display_marker_style")
self.display_calc_color = self.get_kwarg(
kwargs, self.display_calc_color, "display_calc_color")
self.display_exp_color = self.get_kwarg(
kwargs, self.display_exp_color, "display_exp_color")
self.display_calc_lw = self.get_kwarg(kwargs,
self.display_calc_lw,
"display_calc_lw")
self.display_exp_lw = self.get_kwarg(kwargs,
self.display_exp_lw,
"display_exp_lw")
self.display_calc_ls = self.get_kwarg(kwargs,
self.display_calc_ls,
"display_calc_ls")
self.display_exp_ls = self.get_kwarg(kwargs,
self.display_exp_ls,
"display_exp_ls")
self.display_calc_marker = self.get_kwarg(
kwargs, self.display_calc_marker, "display_calc_marker")
self.display_exp_marker = self.get_kwarg(
kwargs, self.display_exp_marker, "display_exp_marker")
self.display_plot_offset = self.get_kwarg(
kwargs, self.display_plot_offset, "display_plot_offset")
self.display_group_by = self.get_kwarg(kwargs,
self.display_group_by,
"display_group_by")
self.display_label_pos = self.get_kwarg(
kwargs, self.display_label_pos, "display_label_pos")
self.axes_xlimit = self.get_kwarg(kwargs, self.axes_xlimit,
"axes_xlimit", "axes_xscale")
self.axes_xmin = self.get_kwarg(kwargs, self.axes_xmin,
"axes_xmin")
self.axes_xmax = self.get_kwarg(kwargs, self.axes_xmax,
"axes_xmax")
self.axes_xstretch = self.get_kwarg(kwargs, self.axes_xstretch,
"axes_xstretch")
self.axes_ylimit = self.get_kwarg(kwargs, self.axes_ylimit,
"axes_ylimit")
self.axes_ynormalize = self.get_kwarg(kwargs,
self.axes_ynormalize,
"axes_ynormalize",
"axes_yscale")
self.axes_yvisible = self.get_kwarg(kwargs, self.axes_yvisible,
"axes_yvisible")
self.axes_ymin = self.get_kwarg(kwargs, self.axes_ymin,
"axes_ymin")
self.axes_ymax = self.get_kwarg(kwargs, self.axes_ymax,
"axes_ymax")
goniometer = None
goniometer_kwargs = self.get_kwarg(kwargs, None, "goniometer",
"data_goniometer")
if goniometer_kwargs:
goniometer = self.parse_init_arg(goniometer_kwargs,
None,
child=True)
# Set up and observe atom types:
self.atom_types = self.get_list(kwargs, [],
"atom_types",
"data_atom_types",
parent=self)
self._atom_types_observer = ListObserver(
self.on_atom_type_inserted,
self.on_atom_type_removed,
prop_name="atom_types",
model=self)
# Resolve json references & observe phases
self.phases = self.get_list(kwargs, [],
"phases",
"data_phases",
parent=self)
for phase in self.phases:
phase.resolve_json_references()
self.observe_model(phase)
self._phases_observer = ListObserver(self.on_phase_inserted,
self.on_phase_removed,
prop_name="phases",
model=self)
# Set goniometer if required & observe specimens
self.specimens = self.get_list(kwargs, [],
"specimens",
"data_specimens",
parent=self)
for specimen in self.specimens:
if goniometer: specimen.goniometer = goniometer
self.observe_model(specimen)
self._specimens_observer = ListObserver(
self.on_specimen_inserted,
self.on_specimen_removed,
prop_name="specimens",
model=self)
# Observe mixtures:
self.mixtures = self.get_list(kwargs, [],
"mixtures",
"data_mixtures",
parent=self)
for mixture in self.mixtures:
self.observe_model(mixture)
self._mixtures_observer = ListObserver(
self.on_mixture_inserted,
self.on_mixture_removed,
prop_name="mixtures",
model=self)
self.name = str(
self.get_kwarg(kwargs, "Project name", "name",
"data_name"))
self.date = str(
self.get_kwarg(kwargs, time.strftime("%d/%m/%Y"), "date",
"data_date"))
self.description = str(
self.get_kwarg(kwargs, "Project description",
"description", "data_description"))
self.author = str(
self.get_kwarg(kwargs, "Project author", "author",
"data_author"))
load_default_data = self.get_kwarg(kwargs, True,
"load_default_data")
if load_default_data and self.layout_mode != 1 and \
len(self.atom_types) == 0:
self.load_default_data()
self.needs_saving = True
pass # end with visuals_changed
pass # end with data_changed
def __init__(self, *args, **kwargs):
"""
Valid keyword arguments for a Specimen are:
name: the name of the specimen
sample_name: the sample name of the specimen
calculated_pattern: the calculated pattern
experimental_pattern: the experimental pattern
exclusion_ranges: the exclusion ranges XYListStore
goniometer: the goniometer used for recording data
markers: the specimen's markers
display_vshift: the patterns vertical shift from its default position
display_vscale: the patterns vertical scale (default is 1.0)
display_calculated: whether or not to show the calculated pattern
display_experimental: whether or not to show the experimental pattern
display_residuals: whether or not to show the residuals
display_derivatives: whether or not to show the 1st derivative patterns
display_phases: whether or not to show the separate phase patterns
display_stats_in_lbl: whether or not to display the Rp values
in the pattern label
"""
my_kwargs = self.pop_kwargs(
kwargs, "data_name", "data_sample", "data_sample_length",
"data_calculated_pattern", "data_experimental_pattern",
"calc_color", "calc_lw", "inherit_calc_color", "inherit_calc_lw",
"exp_color", "exp_lw", "inherit_exp_color", "inherit_exp_lw",
"project_goniometer", "data_markers", "bg_shift", "abs_scale",
"exp_cap_value", "sample_length", "absorption", "sample_z_dev", *[
prop.label
for prop in Specimen.Meta.get_local_persistent_properties()
])
super(Specimen, self).__init__(*args, **kwargs)
kwargs = my_kwargs
self._data_object = SpecimenData()
with self.visuals_changed.hold_and_emit():
with self.data_changed.hold_and_emit():
self.name = self.get_kwarg(kwargs, "", "name", "data_name")
sample_name = self.get_kwarg(kwargs, "", "sample_name",
"data_sample")
if isinstance(sample_name, bytes):
sample_name = sample_name.decode("utf-8", "ignore")
self.sample_name = sample_name
calc_pattern_old_kwargs = {}
for kw in ("calc_color", "calc_lw", "inherit_calc_color",
"inherit_calc_lw"):
if kw in kwargs:
calc_pattern_old_kwargs[kw.replace(
"calc_", "")] = kwargs.pop(kw)
self.calculated_pattern = self.parse_init_arg(
self.get_kwarg(kwargs, None, "calculated_pattern",
"data_calculated_pattern"),
CalculatedLine,
child=True,
default_is_class=True,
label="Calculated Profile",
parent=self,
**calc_pattern_old_kwargs)
exp_pattern_old_kwargs = {}
for kw in ("exp_color", "exp_lw", "inherit_exp_color",
"inherit_exp_lw"):
if kw in kwargs:
exp_pattern_old_kwargs[kw.replace("exp_",
"")] = kwargs.pop(kw)
self.experimental_pattern = self.parse_init_arg(
self.get_kwarg(kwargs, None, "experimental_pattern",
"data_experimental_pattern"),
ExperimentalLine,
child=True,
default_is_class=True,
label="Experimental Profile",
parent=self,
**exp_pattern_old_kwargs)
self.exclusion_ranges = PyXRDLine(data=self.get_kwarg(
kwargs, None, "exclusion_ranges"),
parent=self)
# Extract old kwargs if they are there:
gonio_kwargs = {}
sample_length = self.get_kwarg(kwargs, None, "sample_length",
"data_sample_length")
if sample_length is not None:
gonio_kwargs["sample_length"] = float(sample_length)
absorption = self.get_kwarg(kwargs, None, "absorption")
if absorption is not None: # assuming a surface density of at least 20 mg/cm²:
gonio_kwargs["absorption"] = float(absorption) / 0.02
# Initialize goniometer (with optional old kwargs):
self.goniometer = self.parse_init_arg(self.get_kwarg(
kwargs, None, "goniometer", "project_goniometer"),
Goniometer,
child=True,
default_is_class=True,
parent=self,
**gonio_kwargs)
self.markers = self.get_list(kwargs,
None,
"markers",
"data_markers",
parent=self)
for marker in self.markers:
self.observe_model(marker)
self._specimens_observer = ListObserver(
self.on_marker_inserted,
self.on_marker_removed,
prop_name="markers",
model=self)
self.display_vshift = float(
self.get_kwarg(kwargs, 0.0, "display_vshift"))
self.display_vscale = float(
self.get_kwarg(kwargs, 1.0, "display_vscale"))
self.display_calculated = bool(
self.get_kwarg(kwargs, True, "display_calculated"))
self.display_experimental = bool(
self.get_kwarg(kwargs, True, "display_experimental"))
self.display_residuals = bool(
self.get_kwarg(kwargs, True, "display_residuals"))
self.display_residual_scale = float(
self.get_kwarg(kwargs, 1.0, "display_residual_scale"))
self.display_derivatives = bool(
self.get_kwarg(kwargs, False, "display_derivatives"))
self.display_phases = bool(
self.get_kwarg(kwargs, False, "display_phases"))
self.display_stats_in_lbl = bool(
self.get_kwarg(kwargs, True, "display_stats_in_lbl"))
self.statistics = Statistics(parent=self)
pass # end of with
pass # end of with
pass # end of __init__
def __init__(self, *args, **kwargs):
"""
Valid keyword arguments for a Specimen are:
name: the name of the specimen
sample_name: the sample name of the specimen
sample_length: the sample length of the specimen
absorption: the mass absorption of the specimen
calculated_pattern: the calculated pattern
experimental_pattern: the experimental pattern
exclusion_ranges: the exclusion ranges XYListStore
goniometer: the goniometer used for recording data
markers: the specimen's markers
display_vshift: the patterns vertical shift from its default position
display_vscale: the patterns vertical scale (default is 1.0)
display_calculated: whether or not to show the calculated pattern
display_experimental: whether or not to show the experimental pattern
display_residuals: whether or not to show the residuals
display_derivatives: whether or not to show the 1st derivative patterns
display_phases: whether or not to show the separate phase patterns
display_stats_in_lbl: whether or not to display the Rp values
in the pattern label
"""
my_kwargs = self.pop_kwargs(
kwargs, "data_name", "data_sample", "data_sample_length",
"data_calculated_pattern", "data_experimental_pattern",
"calc_color", "calc_lw", "inherit_calc_color", "inherit_calc_lw",
"exp_color", "exp_lw", "inherit_exp_color", "inherit_exp_lw",
"project_goniometer", "data_markers", "bg_shift", "abs_scale",
"exp_cap_value",
*[names[0] for names in self.Meta.get_local_storable_properties()])
super(Specimen, self).__init__(*args, **kwargs)
kwargs = my_kwargs
self._data_object = SpecimenData()
with self.visuals_changed.hold_and_emit():
with self.data_changed.hold_and_emit():
self.name = self.get_kwarg(kwargs, "", "name", "data_name")
self.sample_name = self.get_kwarg(kwargs, "", "sample_name",
"data_sample")
self.sample_length = float(
self.get_kwarg(kwargs, settings.SPECIMEN_SAMPLE_LENGTH,
"sample_length", "data_sample_length"))
self.absorption = float(
self.get_kwarg(kwargs, 0.9, "absorption"))
calc_pattern_old_kwargs = {}
for kw in ("calc_color", "calc_lw", "inherit_calc_color",
"inherit_calc_lw"):
if kw in kwargs:
calc_pattern_old_kwargs[kw.replace(
"calc_", "")] = kwargs.pop(kw)
self.calculated_pattern = self.parse_init_arg(
self.get_kwarg(kwargs, None, "calculated_pattern",
"data_calculated_pattern"),
CalculatedLine,
child=True,
default_is_class=True,
label="Calculated Profile",
parent=self,
**calc_pattern_old_kwargs)
exp_pattern_old_kwargs = {}
for kw in ("exp_color", "exp_lw", "inherit_exp_color",
"inherit_exp_lw"):
if kw in kwargs:
exp_pattern_old_kwargs[kw.replace("exp_",
"")] = kwargs.pop(kw)
self.experimental_pattern = self.parse_init_arg(
self.get_kwarg(kwargs, None, "experimental_pattern",
"data_experimental_pattern"),
ExperimentalLine,
child=True,
default_is_class=True,
label="Experimental Profile",
parent=self,
**exp_pattern_old_kwargs)
self.exclusion_ranges = PyXRDLine(data=self.get_kwarg(
kwargs, None, "exclusion_ranges"),
parent=self)
self.goniometer = self.parse_init_arg(
self.get_kwarg(kwargs, None, "goniometer",
"project_goniometer"),
Goniometer,
child=True,
default_is_class=True,
parent=self,
)
self.markers = self.get_list(kwargs,
None,
"markers",
"data_markers",
parent=self)
for marker in self.markers:
self.observe_model(marker)
self._specimens_observer = ListObserver(
self.on_marker_inserted,
self.on_marker_removed,
prop_name="markers",
model=self)
self.display_vshift = float(
self.get_kwarg(kwargs, 0.0, "display_vshift"))
self.display_vscale = float(
self.get_kwarg(kwargs, 1.0, "display_vscale"))
self.display_calculated = bool(
self.get_kwarg(kwargs, True, "display_calculated"))
self.display_experimental = bool(
self.get_kwarg(kwargs, True, "display_experimental"))
self.display_residuals = bool(
self.get_kwarg(kwargs, True, "display_residuals"))
self.display_residual_scale = float(
self.get_kwarg(kwargs, 1.0, "display_residual_scale"))
self.display_derivatives = bool(
self.get_kwarg(kwargs, False, "display_derivatives"))
self.display_phases = bool(
self.get_kwarg(kwargs, False, "display_phases"))
self.display_stats_in_lbl = bool(
self.get_kwarg(kwargs, True, "display_stats_in_lbl"))
self.statistics = Statistics(parent=self)
pass # end of with
pass # end of with
pass # end of __init__