def add_catalogs(self):
config_file_to_broker = defaultdict(list)
catalog_names = list(catalog)
for name in catalog_names:
broker = Broker.named(name)
if getattr(broker, 'v2', None) is None:
msg.logMessage(
f'The broker named {name} cannot be cast to a v2 Broker.',
msg.WARNING)
continue
# catalog_dir might be in the metadata; if not, let's try to find it
if 'catalog_dir' in broker.v2.metadata:
config_file = broker.v2.metadata["catalog_dir"]
else:
config_file = find_catalog(name)
config_file_to_broker[config_file].append(broker)
for config_file, brokers in config_file_to_broker.items():
config_file_item = QStandardItem()
config_file_item.setData(config_file, Qt.DisplayRole)
self.appendRow(config_file_item)
for broker in brokers:
broker_item = QStandardItem()
broker_item.setData(broker.name, Qt.DisplayRole)
broker_item.setData(broker, self.broker_role)
config_file_item.appendRow(broker_item)
def add_model(self, model):
"""
Adds a model to the internal Qt model.
Parameters
----------
model : :class:`astropy.modeling.FittableModel`
The model instance to add.
Returns
-------
:class:`qtpy.QtCore.QModelIndex`
The index in the Qt model where the new model been added.
"""
model_name = model.name or model.__class__.name
model_count = len([self.item(idx) for idx in range(self.rowCount())
if model_name in self.item(idx).text()])
model_name = model_name + "_" + str(model_count) \
if model_count > 0 else model_name
model_item = QStandardItem(model_name)
model_item.setData(model, Qt.UserRole + 1)
for para_name in model.param_names:
# Retrieve the parameter object from the model
parameter = getattr(model, para_name)
# Store the name value
param_name = QStandardItem(parameter.name)
param_name.setData(parameter.name, Qt.UserRole + 1)
param_name.setEditable(False)
# Store the data value of the parameter
param_value = QStandardItem("{:.5g}".format(parameter.value))
param_value.setData(parameter.value, Qt.UserRole + 1)
# Store the unit information
# param_unit = QStandardItem("{}".format(parameter.unit))
param_unit = QStandardItem("Plot Units")
param_unit.setData(parameter.unit, Qt.UserRole + 1)
param_unit.setEditable(False)
# Store the fixed state of the unit
param_fixed = QStandardItem()
param_fixed.setData(parameter.fixed, Qt.UserRole + 1)
param_fixed.setCheckable(True)
param_fixed.setEditable(False)
model_item.appendRow([param_name, param_value, param_unit, param_fixed])
self.appendRow([model_item, None, None, None])
# Add this model to the model equation string. By default, all models
# are simply added together
self._equation += " + {}".format(model_name) \
if len(self._equation) > 0 else "{}".format(model_name)
return model_item.index()
def load_kpis(self, rootIndex, topology):
kpis = QStandardItem('kpis')
item = self.itemFromIndex(rootIndex)
item.appendRow(kpis)
for conn_key, conn in topology.connections.items():
conn_item = QStandardItem(conn_key)
kpis.appendRow(conn_item)
for kpi_key, kpi in conn.kpis.items():
kpi_item = QStandardItem(kpi_key)
kpi_item.setData('kpi', self.TYPE_ROLE)
kpi_item.setData(kpi, self.MODEL_ROLE)
conn_item.appendRow(kpi_item)
def add_model(self, model):
model_name = model.__class__.name
model_count = len([
self.item(idx) for idx in range(self.rowCount())
if model.__class__.name in self.item(idx).text()
])
model_name = model_name + str(
model_count) if model_count > 0 else model_name
model_item = QStandardItem(model_name)
model_item.setData(model, Qt.UserRole + 1)
for para_name in model.param_names:
# Retrieve the parameter object from the model
parameter = getattr(model, para_name)
# Store the name value
param_name = QStandardItem(parameter.name)
param_name.setData(parameter.name, Qt.UserRole + 1)
param_name.setEditable(False)
# Store the data value of the parameter
param_value = QStandardItem("{:.5g}".format(parameter.value))
param_value.setData(parameter.value, Qt.UserRole + 1)
# Store the unit information
# param_unit = QStandardItem("{}".format(parameter.unit))
param_unit = QStandardItem("Plot Units")
param_unit.setData(parameter.unit, Qt.UserRole + 1)
param_unit.setEditable(False)
# Store the fixed state of the unit
param_fixed = QStandardItem()
param_fixed.setData(parameter.fixed, Qt.UserRole + 1)
param_fixed.setCheckable(True)
param_fixed.setEditable(False)
model_item.appendRow(
[param_name, param_value, param_unit, param_fixed])
self.appendRow([model_item, None, None, None])
# Add this model to the model equation string. By default, all models
# are simply added together
self._equation += " + {}".format(model_name) \
if len(self._equation) > 0 else "{}".format(model_name)
return model_item.index()
def refresh(self):
self.clear()
if not self._proc_interface:
logger.warning('cannot refresh without a procInterface')
return
eprocs = self._proc_interface.eprocs
for device in eprocs.keys():
device_item = QStandardItem(device)
self.appendRow(device_item)
for eproc in eprocs[device]:
eproc_item = QStandardItem(eproc)
device_item.appendRow(eproc_item)
def add_catalogs(self):
config_file_to_broker = defaultdict(list)
catalog_names = list(catalog)
for name in catalog_names:
broker = Broker.named(name)
config_file = broker.v2.metadata["catalog_dir"]
config_file_to_broker[config_file].append(broker)
for config_file, brokers in config_file_to_broker.items():
config_file_item = QStandardItem()
config_file_item.setData(config_file, Qt.DisplayRole)
self.appendRow(config_file_item)
for broker in brokers:
broker_item = QStandardItem()
broker_item.setData(broker.name, Qt.DisplayRole)
broker_item.setData(broker, self.broker_role)
config_file_item.appendRow(broker_item)
def update_list(self):
self.model.clear()
packages = {} # {NodePackage: [Node]}
for node, node_package in self.main_window.node_packages.items():
if node_package in packages.keys():
packages[node_package].append(node)
else:
packages[node_package] = [node]
for node_package, nodes in packages.items():
package_item = QStandardItem(node_package.name)
package_item.setEditable(False)
for n in nodes:
node_item = NodeItem(n)
# node_item.setEditable(False)
# node_item.setDragEnabled(True)
package_item.appendRow(node_item)
self.model.appendRow(package_item)
def populatePortList(self, model, tv, ports):
tv.setModel(model)
root = model.invisibleRootItem()
portsdict = {}
for port in ports:
if port.client not in portsdict:
portsdict[port.client] = []
portsdict[port.client].append(port)
for client in humansorted(portsdict):
clientitem = QStandardItem(client)
for port in humansorted(portsdict[client],
key=attrgetter("group", "order", "name")):
portspec = (port.client, port.name)
if port.pretty_name:
label = "%s (%s)" % (port.pretty_name, port.name)
else:
label = port.name
portitem = QStandardItem(label)
portitem.setData(portspec)
portitem.setCheckable(True)
portitem.setUserTristate(False)
# Check box toggling is done in the treeview clicked handler "on_port_clicked"
portitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
portitem.setToolTip(self.makePortTooltip(port))
if portspec in self.rec_sources:
portitem.setCheckState(2)
clientitem.appendRow(portitem)
root.appendRow(clientitem)
tv.expandAll()
def load(self, type_, data, positions):
self.clear()
if type_ == 'position':
if data != 'dict..':
class_, preset_, transforms_ = presets.get_elements(
'positions', data)
class_ = class_.lower()
classes = list(presets.positions.keys())
# Build the 'class' combobox
class_item_val = QStandardItem(class_)
class_item_val.setData('class_combo', self.TYPE_ROLE)
self.appendRow([QStandardItem('class'), class_item_val])
# Build the 'preset' combobox
presets_ = list(presets.positions[class_].keys())
preset_item_val = QStandardItem(preset_)
preset_item_val.setData('preset_combo', self.TYPE_ROLE)
self.appendRow([QStandardItem('preset'), preset_item_val])
# Build the 'transforms' subtree
# NOTE: self.tr is a Qt func that helps for the translation to another language
transforms = QStandardItem(self.tr('Transformations'))
transforms.setData(positions, self.MODEL_ROLE)
self.appendRow(transforms)
# Scale -> spinbox
scale_item = QStandardItem(str(positions.absolute_scale))
scale_item.setData('spin_scale', self.TYPE_ROLE)
scale_item.setData(positions.absolute_scale, self.DATA_ROLE)
transforms.appendRow([QStandardItem('Scale'), scale_item])
# Rotate -> slider
rotate_item = QStandardItem(str(positions.angle))
rotate_item.setData('rotate_slider', self.TYPE_ROLE)
rotate_item.setData(positions.angle, self.DATA_ROLE)
transforms.appendRow([QStandardItem('Rotate'), rotate_item])
# Translate -> 2 spinboxes
translate_item = QStandardItem('Translation')
x_item = QStandardItem(str(positions.translation["x"]))
x_item.setData('spin_x', self.TYPE_ROLE)
x_item.setData(positions.translation["x"], self.DATA_ROLE)
y_item = QStandardItem(str(positions.translation["y"]))
y_item.setData('spin_y', self.TYPE_ROLE)
y_item.setData(positions.translation["y"], self.DATA_ROLE)
translate_item.appendRow([QStandardItem('x:'), x_item])
translate_item.appendRow([QStandardItem('y:'), y_item])
transforms.appendRow(translate_item)
elif type_ == 'motion':
pass
window = QMainWindow()
layout = QVBoxLayout()
model = DerivedDataModel()
from xicam.plugins.hints import PlotHint, ImageHint, CoPlotHint
parentItem = QStandardItem("blah")
parentItem.setCheckable(True)
import numpy as np
for i in range(3):
hint = PlotHint(np.arange(10),
np.random.random((10, )),
name=f"1-Time")
item = QStandardItem(hint.group)
item.setData(hint, Qt.UserRole)
item.setCheckable(True)
parentItem.appendRow(item)
hint = ImageHint(np.random.random((100, 100)),
xlabel="x",
ylabel="y",
name="2-Time")
item = QStandardItem(hint.group)
item.setData(hint, Qt.UserRole)
item.setCheckable(True)
parentItem.appendRow(item)
model.appendRow(parentItem)
workflowItem = QStandardItem("A Workflow Result")
workflowItem.setCheckable(True)
hints = []
for i in range(2):
if i == 0:
def add_device(self, client_item: QStandardItem, device: Device):
device_item = QStandardItem(device.name)
device_item.setData(device, self.happiItemRole)
client_item.appendRow(device_item)
def refresh(self):
self.clear()
if not self._app_interface:
logger.warning('cannot refresh without an appInterface')
return
proclog = self._app_interface.proclog
previous_level = 0
item_stack = deque([self])
for i, log in enumerate(proclog):
level = 0
name = ''
info = {}
for item in log:
if item == '->':
level += 1
else:
name = item['name']
info = item['information']
item = QStandardItem(name)
item.setData(True, self.IsProcedureRole)
item.setData('', self.ValueRole)
item.setData(i + 1, self.IdRole)
if isinstance(info, dict) and len(info):
data_item = QStandardItem(self.tr('data'))
data_item.setData(False, self.IsProcedureRole)
data_item.setData('', self.ValueRole)
for k, v in info.items():
entry_item = QStandardItem(k)
if isinstance(v, dict) and 'address' in v and 'value' in v:
value_item = QStandardItem('value')
value_item.setData(str(v['value']), self.ValueRole)
value_item.setData(False, self.IsProcedureRole)
entry_item.appendRow(value_item)
value_item = QStandardItem('address')
value_item.setData(str(v['address']), self.ValueRole)
value_item.setData(False, self.IsProcedureRole)
entry_item.appendRow(value_item)
value = ''
else:
value = str(v)
entry_item.setData(value, self.ValueRole)
entry_item.setData(False, self.IsProcedureRole)
data_item.appendRow(entry_item)
item.appendRow(data_item)
elif isinstance(info, str):
data_item = QStandardItem(self.tr('info'))
data_item.setData(False, self.IsProcedureRole)
data_item.setData(info, self.ValueRole)
item.appendRow(data_item)
if level > previous_level:
previous_level = level
elif level == previous_level:
item_stack.pop()
else:
item_stack.pop()
while previous_level > level and previous_level > 0:
item_stack.pop()
previous_level -= 1
item_stack[-1].appendRow(item)
item_stack.append(item)
def load(self):
self.clear()
"""Walk the tree starting from topology"""
for el, val in presets.topology.items():
item = QStandardItem(el)
self.appendRow(item)
nodes = QStandardItem('nodes')
item.appendRow(nodes)
# Walk the nodes
for node_name, nvals in val['nodes'].items():
n = QStandardItem(node_name)
nodes.appendRow(n)
for nval in nvals:
node_layout = QStandardItem('')
n.appendRow(node_layout)
p = nval.get('position')
if isinstance(p, dict):
p = 'dict..'
pos = QStandardItem(p)
pos.setData('position', self.TYPE_ROLE)
node_layout.appendRow([QStandardItem('position'), pos])
m = nval.get('motion')
if isinstance(m, dict):
m = 'dict..'
mot = QStandardItem(m)
mot.setData('motion', self.TYPE_ROLE)
node_layout.appendRow([QStandardItem('motion'), mot])
mdl = QStandardItem(nval.get('model'))
node_layout.appendRow([QStandardItem('model'), mdl])
connections = QStandardItem('connections')
item.appendRow(connections)
# Walk the connections
for conn in val['connections']:
c = QStandardItem('')
connections.appendRow(c)
src = QStandardItem('Source:')
src_val = QStandardItem(conn['source'])
src_val.setData('combo', self.TYPE_ROLE)
c.appendRow([src, src_val])
snk = QStandardItem('Sink:')
snk_val = QStandardItem(conn['sink'])
snk_val.setData('combo', self.TYPE_ROLE)
c.appendRow([snk, snk_val])
mdl = QStandardItem('Model:')
mdl_val = QStandardItem(conn['model'])
c.appendRow([mdl, mdl_val])
