def createEditor(self, parent, option, index):
if self.displayedComboItems:
registry = get_module_registry()
if index.column() == 1: # Port type
combo = QtGui.QComboBox(parent)
combo.setEditable(False)
# FIXME just use descriptors here!!
for _, pkg in sorted(registry.packages.iteritems()):
for _, descriptor in sorted(pkg.descriptors.iteritems()):
if descriptor.name in self.displayedComboItems:
combo.addItem("%s (%s)" % (descriptor.name,
descriptor.identifier),
QtCore.QVariant(descriptor.sigstring))
return combo
else:
return QtGui.QItemDelegate.createEditor(self, parent, option, index)
else:
registry = get_module_registry()
if index.column() == 1: # Port type
combo = QtGui.QComboBox(parent)
combo.setEditable(False)
# FIXME just use descriptors here!!
for _, pkg in sorted(registry.packages.iteritems()):
for _, descriptor in sorted(pkg.descriptors.iteritems()):
combo.addItem("%s (%s)" % (descriptor.name,
descriptor.identifier),
QtCore.QVariant(descriptor.sigstring))
return combo
else:
return QtGui.QItemDelegate.createEditor(self, parent, option, index)
def initialize(*args, **keywords):
mows_pygdp = get_module_registry()
mows_pygdp.add_module(mows_pyGDP)
format_step = get_module_registry()
format_step.add_module(FormatStep)
#parse = get_module_registry()
#parse.add_module(Parse)
zipData = get_module_registry()
zipData.add_module(ZipData)
def initialize(*args, **keywords):
"""
Set everything up for vistrails; called from the top level initialize
"""
import os
# third party
import qgis.core
# vistrails
from core.modules.module_registry import get_module_registry
from core.modules.basic_modules import String, File
# eo4vistrails
# local
from GeoStrings import GMLString, GeoJSONString, GeoString, WKTString, \
GeoStringConstantWidget, Proj4String
# Vistrails
reg = get_module_registry()
mynamespace = "data|geostrings"
# GeoString
reg.add_module(GeoString,
namespace=mynamespace,
abstract=True)
reg.add_module(GMLString,
configureWidgetType=GeoStringConstantWidget,
namespace=mynamespace)
reg.add_module(GeoJSONString,
configureWidgetType=GeoStringConstantWidget,
namespace=mynamespace)
reg.add_module(WKTString,
configureWidgetType=GeoStringConstantWidget,
namespace=mynamespace)
def initialize(*args, **keywords):
"""This method is called by higher-level ones,
to ensure that registration with VisTrails takes place."""
from core.modules.module_registry import get_module_registry
import core.requirements
from gui.modules.python_source_configure import \
PythonSourceConfigurationWidget
from core.modules import basic_modules
import RPyC
reg = get_module_registry()
rpyc_namespace = "rpyc"
manager = core.packagemanager.get_package_manager()
if manager.has_package('za.co.csir.rpyc4vistrails'):
#Dummy Module Mixed into all RPYCSafeModules
#reg.add_module(RPyC.RPyCModule,
# namespace=rpyc_namespace,
# abstract=True)
pass
else:
#Generic Module
reg.add_module(RPyC.RPyCModule,
namespace=rpyc_namespace,
abstract=True)
def registerControl(module):
"""This function is used to register the control modules. In this way, all of
them will have the same style and shape."""
reg = get_module_registry()
reg.add_module(module, moduleRightFringe=[(0.0,0.0),(0.25,0.5),(0.0,1.0)],\
moduleLeftFringe=[(0.0,0.0),(0.0,1.0)])
def check_port_spec(module, port_name, port_type, descriptor=None,
sigstring=None):
from core.modules.basic_modules import identifier as basic_pkg
reg = get_module_registry()
found = False
try:
if descriptor is not None:
s = reg.get_port_spec_from_descriptor(descriptor, port_name,
port_type)
found = True
sigstring = reg.expand_port_spec_string(sigstring, basic_pkg)
if s.sigstring != sigstring:
msg = ('%s port "%s" of module "%s" exists, but '
'signatures differ "%s" != "%s"') % \
(port_type.capitalize(), port_name, module.name,
s.sigstring, sigstring)
raise UpgradeWorkflowError(msg, module, port_name, port_type)
except MissingPort:
pass
if not found and \
not module.has_portSpec_with_name((port_name, port_type)):
msg = '%s port "%s" of module "%s" does not exist.' % \
(port_type.capitalize(), port_name, module.name)
raise UpgradeWorkflowError(msg, module, port_name, port_type)
def __init__(self, param, parent=None):
""" QParameterQuery(param: ModuleParam) -> QParameterQuery
Construct the widget layout
"""
QtGui.QWidget.__init__(self, parent)
self.value = param.strValue
self.type = param.type
layout = QtGui.QHBoxLayout()
layout.setSpacing(0)
layout.setMargin(0)
self.setLayout(layout)
self.label = QtGui.QLabel('')
layout.addWidget(self.label)
self.selector = QParameterQuerySelector(self.type)
layout.addWidget(self.selector)
reg = get_module_registry()
constant_class = reg.get_module_by_name(param.identifier, param.type,
param.namespace)
widget_type = get_widget_class(constant_class)
self.editor = widget_type(param)
layout.addWidget(self.editor)
self.connect(self.selector.operationActionGroup,
QtCore.SIGNAL('triggered(QAction*)'),
self.operationChanged)
if self.type == 'String':
self.connect(self.selector.caseActionGroup,
QtCore.SIGNAL('triggered(QAction*)'),
self.caseChanged)
self.selector.initAction(param.queryMethod)
def inspect_spreadsheet_cells(self, pipeline):
""" inspect_spreadsheet_cells(pipeline: Pipeline) -> None
Inspect the pipeline to see how many cells is needed
"""
registry = get_module_registry()
self.spreadsheet_cells = []
if not pipeline: return
def find_spreadsheet_cells(pipeline, root_id=None):
if root_id is None:
root_id = []
# Sometimes we run without the spreadsheet!
if registry.has_module('edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell'):
# First pass to check cells types
cellType = registry.get_descriptor_by_name( \
'edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell').module
for mId, module in pipeline.modules.iteritems():
desc = registry.get_descriptor_by_name(
module.package, module.name, module.namespace)
if issubclass(desc.module, cellType):
self.spreadsheet_cells.append(root_id + [mId])
for subworkflow_id in self.find_subworkflows(pipeline):
subworkflow = pipeline.modules[subworkflow_id]
if subworkflow.pipeline is not None:
find_spreadsheet_cells(subworkflow.pipeline,
root_id + [subworkflow_id])
find_spreadsheet_cells(pipeline)
def initialize(*args, **keywords):
from core.modules.module_registry import get_module_registry
from core.modules import basic_modules
#modules in this package
from TemporalLayerTransformer import SpatialTemporalTransform
from Transformer import Transform
reg = get_module_registry()
transform_namespace = "tools|transform"
transform_test_namespace = "transform|tests"
# =========================================================================
# Abstract Modules - these MUST appear FIRST
# =========================================================================
reg.add_module(Transform,
namespace=transform_namespace,
abstract=True)
# =========================================================================
# Simple Modules - without ports
# =========================================================================
# =========================================================================
# Standard Modules
# =========================================================================
reg.add_module(SpatialTemporalTransform,
namespace=transform_namespace)
"""
def create_entries(self, signature):
# This is reasonably messy code. The intent is that a
# signature given by the user in a call like this
# add_input_port(module, name, signature) should be one of the
# following:
# type only: add_input_port(_, _, Float)
# type plus description: add_input_port(_, _, (Float, 'radius'))
# multiple parameters, where each parameter can be either of the above:
# add_input_port(_, _, [Float, (Integer, 'count')])
from core.modules.module_registry import get_module_registry
registry = get_module_registry()
self._entries = []
def canonicalize(sig_item):
if type(sig_item) == __builtin__.tuple:
# assert len(sig_item) == 2
# assert type(sig_item[0]) == __builtin__.type
# assert type(sig_item[1]) == __builtin__.str
return sig_item
elif type(sig_item) == __builtin__.list:
return (registry.get_descriptor_by_name(
'edu.utah.sci.vistrails.basic',
'List').module, '<no description>')
else:
# type(sig_item) == __builtin__.type:
return (sig_item, '<no description>')
# def _add_entry(sig_item):
if type(signature) != __builtin__.list:
self._entries.append(canonicalize(signature))
else:
self._entries.extend(canonicalize(item) for item in signature)
def updateModule(self, module):
if self.updateLocked:
return
self.check_need_save_changes()
self.module = module
self.confWidget.setUpdatesEnabled(False)
self.confWidget.setVisible(False)
self.confWidget.clear()
if module and self.controller:
# if module.has_annotation_with_key('__desc__'):
# label = module.get_annotation_by_key('__desc__').value.strip()
# title = '%s (%s) Module Configuration'%(label,
# module.name)
# else:
# title = '%s Module Configuration'%module.name
# self.setWindowTitle(title)
registry = get_module_registry()
getter = registry.get_configuration_widget
widgetType = getter(module.package, module.name, module.namespace)
if not widgetType:
widgetType = DefaultModuleConfigurationWidget
widget = widgetType(module, self.controller)
self.confWidget.setUpWidget(widget)
self.connect(widget, QtCore.SIGNAL("doneConfigure"), self.configureDone)
self.connect(widget, QtCore.SIGNAL("stateChanged"), self.stateChanged)
self.confWidget.setUpdatesEnabled(True)
self.confWidget.setVisible(True)
self.hasChanges = False
# we need to reset the title in case there were changes
self.setWindowTitle("Module Configuration")
def register_self():
registry = get_module_registry()
# For now, we don't have configuration widget
registry.add_module(PVGenericCell)
registry.add_input_port(PVGenericCell, "Location", CellLocation)
registry.add_input_port(PVGenericCell, "representation", [])
registry.add_output_port(PVGenericCell, "self", PVGenericCell)
def get_values(self, count):
""" get_values() -> []
Convert the user define function into a list. Size specifies the size
request.
"""
param_info = self._param_info
registry = get_module_registry()
module = registry.get_module_by_name(param_info.identifier,
param_info.type,
param_info.namespace)
def get():
import code
values = []
d = {}
try:
exec(self.function) in {}, d
except Exception, e:
return [module.default_value] * count
def evaluate(i):
try:
v = d['value'](i)
if v == None:
return module.default_value
return v
except Exception, e:
return str(e)
def get_values(self, count):
""" get_values(count) -> []
Convert the list values into a list
count should be an integer with the expected size of the list (given
by the dimension 'size' in the exploration)
"""
param_info = self._param_info
registry = get_module_registry()
module = registry.get_module_by_name(param_info.identifier,
param_info.type,
param_info.namespace)
result = [module.translate_to_python(m)
for m in self._str_values]
if len(result) != count:
show_warning('Inconsistent Size',
'One of the <i>%s</i>\'s list '
'interpolated '
'values has a different '
'size from the step count. '
'Expected %d, got %d instead. '
'Parameter Exploration aborted.'
% (self.type, count, len(result)))
return None
return result
def loadWidget( self, pipeline):
from PyQt4 import QtGui
aliases = pipeline.aliases
widget = QtGui.QWidget()
layout = QtGui.QVBoxLayout()
hidden_aliases = self.plot.computeHiddenAliases()
for name, (type, oId, parentType, parentId, mId) in aliases.iteritems():
if name not in hidden_aliases:
p = pipeline.db_get_object(type, oId)
if p.identifier == '':
idn = 'edu.utah.sci.vistrails.basic'
else:
idn = p.identifier
reg = get_module_registry()
p_module = reg.get_module_by_name(idn, p.type, p.namespace)
if p_module is not None:
widget_type = get_widget_class(p_module)
else:
widget_type = StandardConstantWidget
p_widget = widget_type(p, None)
a_layout = QtGui.QHBoxLayout()
label = QtGui.QLabel(name)
a_layout.addWidget(label)
a_layout.addWidget(p_widget)
layout.addLayout(a_layout)
self.alias_widgets[name] = p_widget
widget.setLayout(layout)
return widget
def compute(self):
reg = get_module_registry()
tf = self.getInputFromPort('TransferFunction')
new_tf = copy.copy(tf)
if self.hasInputFromPort('Input'):
port = self.getInputFromPort('Input')
algo = port.vtkInstance.GetProducer()
output = algo.GetOutput(port.vtkInstance.GetIndex())
(new_tf._min_range, new_tf._max_range) = output.GetScalarRange()
elif self.hasInputFromPort('Dataset'):
algo = self.getInputFromPort('Dataset').vtkInstance
output = algo
(new_tf._min_range, new_tf._max_range) = output.GetScalarRange()
else:
(new_tf._min_range,
new_tf._max_range) = self.getInputFromPort('Range')
self.setResult('TransferFunction', new_tf)
(of, cf) = new_tf.get_vtk_transfer_functions()
of_module = reg.get_descriptor_by_name(
'edu.utah.sci.vistrails.vtk', 'vtkPiecewiseFunction').module()
of_module.vtkInstance = of
cf_module = reg.get_descriptor_by_name(
'edu.utah.sci.vistrails.vtk', 'vtkColorTransferFunction').module()
cf_module.vtkInstance = cf
self.setResult('vtkPicewiseFunction', of_module)
self.setResult('vtkColorTransferFunction', cf_module)
def _get_base_descriptor(self):
if self._base_descriptor is None and self.base_descriptor_id >= 0:
from core.modules.module_registry import get_module_registry
reg = get_module_registry()
self._base_descriptor = \
reg.descriptors_by_id[self.base_descriptor_id]
return self._base_descriptor
def create_descriptor_list(self):
from core.modules.module_registry import get_module_registry, \
module_registry_loaded
if not module_registry_loaded():
return None
registry = get_module_registry()
assert self.sigstring[0] == '(' and self.sigstring[-1] == ')'
recompute_sigstring = False
self._descriptors = []
if self.sigstring != '()':
for sig in self.sigstring[1:-1].split(','):
k = sig.split(':', 2)
if len(k) < 2:
d = registry.get_descriptor_from_name_only(k[0])
self._descriptors.append(d)
recompute_sigstring = True
else:
d = registry.get_descriptor_by_name(*k)
self._descriptors.append(d)
if recompute_sigstring:
self.sigstring = "(" + \
",".join(d.sigstring for d in self._descriptors) + ")"
self.create_tooltip()
def inspect_input_output_ports(self, pipeline):
""" inspect_input_output_ports(pipeline: Pipeline) -> None
Inspect the pipeline input/output ports, useful for submodule
"""
registry = get_module_registry()
self.input_ports = {}
self.input_port_by_name = {}
self.output_ports = {}
self.output_port_by_name = {}
if not pipeline: return
for cId, conn in pipeline.connections.iteritems():
src_module = pipeline.modules[conn.source.moduleId]
dst_module = pipeline.modules[conn.destination.moduleId]
if src_module.name == 'InputPort':
spec = registry.getInputPortSpec(dst_module,
conn.destination.name)
name = self.get_port_name(src_module)
if name == '':
name = conn.destination.name
self.input_ports[src_module.id] = (name, spec[0])
self.input_port_by_name[name] = src_module.id
if dst_module.name == 'OutputPort':
spec = registry.getOutputPortSpec(src_module, conn.source.name)
name = self.get_port_name(dst_module)
if name == '':
name = conn.source.name
self.output_ports[dst_module.id] = (name, spec[0])
self.output_port_by_name[name] = dst_module.id
def contextMenuEvent(self, event):
# Just dispatches the menu event to the widget item
item = self.itemAt(event.pos())
if item:
# find top level
p = item
while p.parent():
p = p.parent()
# get package identifier
identifiers = [i for i, j in self.parent().packages.iteritems()
if j == weakref.ref(p)]
if identifiers:
identifier = identifiers[0]
registry = get_module_registry()
package = registry.packages[identifier]
if package.has_contextMenuName():
name = package.contextMenuName(str(item.text(0)))
if name:
act = QtGui.QAction(name, self)
act.setStatusTip(name)
def callMenu():
if package.has_callContextMenu():
name = package.callContextMenu(str(item.text(0)))
QtCore.QObject.connect(act,
QtCore.SIGNAL("triggered()"),
callMenu)
menu = QtGui.QMenu(self)
menu.addAction(act)
menu.exec_(event.globalPos())
return
item.contextMenuEvent(event, self)
def contextMenuEvent(self, event):
# Just dispatches the menu event to the widget item
item = self.itemAt(event.pos())
if item:
# find top level
p = item
while p.parent():
p = p.parent()
# get package identifier
identifiers = [i for i, j in self.parent().packages.iteritems()
if j == weakref.ref(p)]
if identifiers:
identifier = identifiers[0]
registry = get_module_registry()
package = registry.packages[identifier]
if package.has_contextMenuName():
name = package.contextMenuName(str(item.text(0)))
if name:
act = QtGui.QAction(name, self)
act.setStatusTip(name)
def callMenu():
if package.has_callContextMenu():
name = package.callContextMenu(str(item.text(0)))
QtCore.QObject.connect(act,
QtCore.SIGNAL("triggered()"),
callMenu)
menu = QtGui.QMenu(self)
menu.addAction(act)
menu.exec_(event.globalPos())
return
item.contextMenuEvent(event, self)
def getModuleClass( mid ):
import api
registry = get_module_registry()
controller = api.get_current_controller()
reg_module = controller.current_pipeline.modules[ mid ]
descriptor = registry.get_descriptor_by_name( reg_module.package, reg_module.name, reg_module.namespace )
return descriptor.module
def find_descriptor(controller, pipeline, module_id, desired_version=''):
from core.modules.abstraction \
import identifier as local_abstraction_pkg
reg = get_module_registry()
get_descriptor = reg.get_descriptor_by_name
pm = get_package_manager()
invalid_module = pipeline.modules[module_id]
mpkg, mname, mnamespace, mid = (invalid_module.package,
invalid_module.name,
invalid_module.namespace,
invalid_module.id)
pkg = pm.get_package_by_identifier(mpkg)
desired_version = ''
d = None
# don't check for abstraction/subworkflow since the old module
# could be a subworkflow
if reg.has_abs_upgrade(*invalid_module.descriptor_info):
return reg.get_abs_upgrade(*invalid_module.descriptor_info)
try:
try:
d = get_descriptor(mpkg, mname, mnamespace, '', desired_version)
except MissingModule, e:
r = None
if pkg.can_handle_missing_modules():
r = pkg.handle_missing_module(controller, module_id,
pipeline)
d = get_descriptor(mpkg, mname, mnamespace, '',
desired_version)
if not r:
raise e
except MissingModule, e:
return None
def make_port_specs(self):
self._port_specs = {}
self._input_port_specs = []
self._output_port_specs = []
self._input_remap = {}
self._output_remap = {}
if self.pipeline is None:
return
registry = get_module_registry()
for module in self.pipeline.module_list:
if module.name == 'OutputPort' and module.package == basic_pkg:
(port_name, sigstring, optional, _) = \
self.get_port_spec_info(module)
port_spec = registry.create_port_spec(port_name, 'output',
None, sigstring,
optional)
self._port_specs[(port_name, 'output')] = port_spec
self._output_port_specs.append(port_spec)
self._output_remap[port_name] = module
elif module.name == 'InputPort' and module.package == basic_pkg:
(port_name, sigstring, optional, _) = \
self.get_port_spec_info(module)
port_spec = registry.create_port_spec(port_name, 'input', None,
sigstring, optional)
self._port_specs[(port_name, 'input')] = port_spec
self._input_port_specs.append(port_spec)
self._input_remap[port_name] = module
def addAlgorithmPorts(module):
""" addAlgorithmPorts(module: Module) -> None
If module is a subclass of vtkAlgorithm, this function will add all
SetInputConnection([id],[port]) and GetOutputPort([id]) as
SetInputConnection{id}([port]) and GetOutputPort{id}.
"""
if issubclass(get_description_class(module.vtkClass), vtksnl.vtkAlgorithm):
if get_description_class(module.vtkClass)!=vtksnl.vtkStructuredPointsGeometryFilter:
# We try to instantiate the class here to get the number of
# ports and to avoid abstract classes
try:
instance = module.vtkClass()
except TypeError:
pass
else:
registry = get_module_registry()
des = registry.get_descriptor_by_name('edu.utah.sci.vistrails.vtksnl',
'vtkAlgorithmOutput')
for i in xrange(0,instance.GetNumberOfInputPorts()):
registry.add_input_port(module, 'SetInputConnection%d'%i,
des.module)
for i in xrange(0,instance.GetNumberOfOutputPorts()):
registry.add_output_port(module, 'GetOutputPort%d'%i,
des.module)
def get_values(self):
from core.modules.module_registry import get_module_registry
reg = get_module_registry()
ManagedRef = reg.get_descriptor_by_name("edu.utah.sci.vistrails.persistence.exp", "ManagedRef").module
functions = []
if self.new_file and self.new_file.get_path():
functions.append(("value", [self.new_file.get_path()]))
ref = ManagedRef()
if self.managed_new.isChecked():
if self.existing_ref and self.existing_ref._exists:
ref.id = self.existing_ref.id
ref.version = self.existing_ref.version
else:
ref.id = str(uuid.uuid1())
ref.version = None
ref.name = str(self.name_edit.text())
ref.tags = str(self.tags_edit.text())
elif self.managed_existing.isChecked():
(ref.id, ref.version, ref.name, ref.tags) = self.ref_widget.get_info()
if self.keep_local.isChecked():
functions.append(("localPath", [self.local_path.get_path()]))
functions.append(("readLocal", [str(self.r_priority_local.isChecked())]))
functions.append(("writeLocal", [str(self.write_managed_checkbox.isChecked())]))
# ref.local_path = self.local_path.get_path()
# ref.local_read = self.r_priority_local.isChecked()
# ref.local_writeback = self.write_managed_checkbox.isChecked()
else:
ref.local_path = None
functions.append(("ref", [ManagedRef.translate_to_string(ref)]))
self.controller.update_functions(self.module, functions)
def _get_module_descriptor(self):
if self._module_descriptor is None or \
self._module_descriptor() is None:
reg = get_module_registry()
self._module_descriptor = \
weakref.ref(reg.get_descriptor_by_name(*self.descriptor_info))
return self._module_descriptor()
def create_descriptor_list(self):
from core.modules.module_registry import get_module_registry, \
module_registry_loaded
if not module_registry_loaded():
return None
registry = get_module_registry()
assert self.sigstring[0] == '(' and self.sigstring[-1] == ')'
recompute_sigstring = False
self._descriptors = []
if self.sigstring != '()':
for sig in self.sigstring[1:-1].split(','):
k = sig.split(':', 2)
if len(k) < 2:
d = registry.get_descriptor_from_name_only(k[0])
self._descriptors.append(d)
recompute_sigstring = True
else:
d = registry.get_descriptor_by_name(*k)
self._descriptors.append(d)
if recompute_sigstring:
self.sigstring = "(" + \
",".join(d.sigstring for d in self._descriptors) + ")"
self.create_tooltip()
def create_entries(self, signature):
# This is reasonably messy code. The intent is that a
# signature given by the user in a call like this
# add_input_port(module, name, signature) should be one of the
# following:
# type only: add_input_port(_, _, Float)
# type plus description: add_input_port(_, _, (Float, 'radius'))
# multiple parameters, where each parameter can be either of the above:
# add_input_port(_, _, [Float, (Integer, 'count')])
from core.modules.module_registry import get_module_registry
registry = get_module_registry()
self._entries = []
def canonicalize(sig_item):
if type(sig_item) == __builtin__.tuple:
# assert len(sig_item) == 2
# assert type(sig_item[0]) == __builtin__.type
# assert type(sig_item[1]) == __builtin__.str
return sig_item
elif type(sig_item) == __builtin__.list:
return (registry.get_descriptor_by_name('edu.utah.sci.vistrails.basic',
'List').module,
'<no description>')
else:
# type(sig_item) == __builtin__.type:
return (sig_item, '<no description>')
# def _add_entry(sig_item):
if type(signature) != __builtin__.list:
self._entries.append(canonicalize(signature))
else:
self._entries.extend(canonicalize(item) for item in signature)
def createAllModules(g):
""" createAllModules(g: ClassTree) -> None
Traverse the VTK class tree and add all modules into the module registry
"""
if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
assert len(g.tree[0]) == 1
base = g.tree[0][0]
assert base.name == 'vtkObjectBase'
vtkObjectBase = new_module(vtkBaseModule, 'vtkObjectBase')
vtkObjectBase.vtkClass = vtk.vtkObjectBase
registry = get_module_registry()
registry.add_module(vtkObjectBase)
if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
for child in base.children:
if child.name in disallowed_classes:
continue
createModule(vtkObjectBase, child)
else:
for base in g.tree[0]:
for child in base.children:
if child.name in disallowed_classes:
continue
createModule(vtkObjectBase, child)
def loadWidget(self):
from PyQt4 import QtGui
aliases = self.workflow.aliases
widget = QtGui.QWidget()
layout = QtGui.QVBoxLayout()
hidden_aliases = self.computeHiddenAliases()
for name, (type, oId, parentType, parentId, mId) in aliases.iteritems():
if name not in hidden_aliases:
p = self.workflow.db_get_object(type, oId)
if p.identifier == '':
idn = 'edu.utah.sci.vistrails.basic'
else:
idn = p.identifier
reg = get_module_registry()
p_module = reg.get_module_by_name(idn, p.type, p.namespace)
if p_module is not None:
widget_type = get_widget_class(p_module)
else:
widget_type = StandardConstantWidget
p_widget = widget_type(p, None)
a_layout = QtGui.QHBoxLayout()
label = QtGui.QLabel(name)
a_layout.addWidget(label)
a_layout.addWidget(p_widget)
layout.addLayout(a_layout)
self.alias_widgets[name] = p_widget
widget.setLayout(layout)
self._widget = widget
def __init__(self, param, size, parent=None):
""" QParameterWidget(param: ParameterInfo, size: int, parent: QWidget)
-> QParameterWidget
"""
QtGui.QWidget.__init__(self, parent)
self.param = param
self.prevWidget = 0
hLayout = QtGui.QHBoxLayout(self)
hLayout.setMargin(0)
hLayout.setSpacing(0)
self.setLayout(hLayout)
hLayout.addSpacing(5+16+5)
self.label = QtGui.QLabel(param.type)
self.label.setFixedWidth(50)
hLayout.addWidget(self.label)
registry = get_module_registry()
module = registry.get_module_by_name(param.identifier,
param.type,
param.namespace)
assert issubclass(module, Constant)
self.editor = QParameterEditor(param, size)
hLayout.addWidget(self.editor)
self.selector = QDimensionSelector()
self.connect(self.selector.radioButtons[4],
QtCore.SIGNAL('toggled(bool)'),
self.disableParameter)
hLayout.addWidget(self.selector)
def register_self(cls, **kwargs):
registry = get_module_registry()
def resolve_type(t):
if type(t) == tuple:
return registry.get_descriptor_by_name(*t).module
elif type(t) == type:
return t
else:
assert False, ("Unknown type " + str(type(t)))
registry.add_module(cls, **kwargs)
try:
ips = cls.input_ports
except AttributeError:
pass
else:
for (port_name, types) in ips:
registry.add_input_port(cls,
port_name,
list(resolve_type(t) for t in types))
try:
ops = cls.output_ports
except AttributeError:
pass
else:
for (port_name, types) in ops:
registry.add_output_port(cls,
port_name,
list(resolve_type(t) for t in types))
def inspect_spreadsheet_cells(self, pipeline):
""" inspect_spreadsheet_cells(pipeline: Pipeline) -> None
Inspect the pipeline to see how many cells is needed
"""
registry = get_module_registry()
self.spreadsheet_cells = []
if not pipeline: return
def find_spreadsheet_cells(pipeline, root_id=None):
if root_id is None:
root_id = []
# Sometimes we run without the spreadsheet!
if registry.has_module('edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell'):
# First pass to check cells types
cellType = registry.get_descriptor_by_name( \
'edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell').module
for mId, module in pipeline.modules.iteritems():
desc = registry.get_descriptor_by_name(module.package,
module.name,
module.namespace)
if issubclass(desc.module, cellType):
self.spreadsheet_cells.append(root_id + [mId])
for subworkflow_id in self.find_subworkflows(pipeline):
subworkflow = pipeline.modules[subworkflow_id]
if subworkflow.pipeline is not None:
find_spreadsheet_cells(subworkflow.pipeline,
root_id + [subworkflow_id])
find_spreadsheet_cells(pipeline)
def register_self():
registry = get_module_registry()
# For now, we don't have configuration widget
registry.add_module(PVGenericCell)
registry.add_input_port(PVGenericCell, "Location", CellLocation)
registry.add_input_port(PVGenericCell, "representation", [])
registry.add_output_port(PVGenericCell, "self", PVGenericCell)
def initialize(*args, **keywords):
from core.modules.module_registry import get_module_registry
reg = get_module_registry()
reg.add_module(Divide,
configureWidgetType=DivideConfigurationWidget,
namespace='divide')
def inspect_input_output_ports(self, pipeline):
""" inspect_input_output_ports(pipeline: Pipeline) -> None
Inspect the pipeline input/output ports, useful for submodule
"""
registry = get_module_registry()
self.input_ports = {}
self.input_port_by_name = {}
self.output_ports = {}
self.output_port_by_name = {}
if not pipeline: return
for cId, conn in pipeline.connections.iteritems():
src_module = pipeline.modules[conn.source.moduleId]
dst_module = pipeline.modules[conn.destination.moduleId]
if src_module.name=='InputPort':
spec = registry.getInputPortSpec(dst_module,
conn.destination.name)
name = self.get_port_name(src_module)
if name=='':
name = conn.destination.name
self.input_ports[src_module.id] = (name,
spec[0])
self.input_port_by_name[name] = src_module.id
if dst_module.name=='OutputPort':
spec = registry.getOutputPortSpec(src_module,
conn.source.name)
name = self.get_port_name(dst_module)
if name=='':
name = conn.source.name
self.output_ports[dst_module.id] = (name,
spec[0])
self.output_port_by_name[name] = dst_module.id
def register_self(cls, **kwargs):
registry = get_module_registry()
def resolve_type(t):
if type(t) == tuple:
return registry.get_descriptor_by_name(*t).module
elif type(t) == type:
return t
else:
assert False, ("Unknown type " + str(type(t)))
registry.add_module(cls, **kwargs)
try:
ips = cls.input_ports
except AttributeError:
pass
else:
for (port_name, types) in ips:
registry.add_input_port(cls, port_name,
list(resolve_type(t) for t in types))
try:
ops = cls.output_ports
except AttributeError:
pass
else:
for (port_name, types) in ops:
registry.add_output_port(cls, port_name,
list(resolve_type(t) for t in types))
def createAllModules(g):
""" createAllModules(g: ClassTree) -> None
Traverse the VTK class tree and add all modules into the module registry
"""
if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
assert len(g.tree[0]) == 1
base = g.tree[0][0]
assert base.name == 'vtkObjectBase'
vtkObjectBase = new_module(vtkBaseModule, 'vtkObjectBase')
vtkObjectBase.vtkClass = vtk.vtkObjectBase
registry = get_module_registry()
registry.add_module(vtkObjectBase)
if tuple(vtk.vtkVersion().GetVTKVersion().split('.')) < ('5', '7', '0'):
for child in base.children:
if child.name in disallowed_classes:
continue
createModule(vtkObjectBase, child)
else:
for base in g.tree[0]:
for child in base.children:
if child.name in disallowed_classes:
continue
createModule(vtkObjectBase, child)
def _get_module_descriptor(self):
if self._module_descriptor is None or \
self._module_descriptor() is None:
reg = get_module_registry()
self._module_descriptor = \
weakref.ref(reg.get_descriptor_by_name(*self.descriptor_info))
return self._module_descriptor()
def compute(self):
reg = get_module_registry()
tf = self.getInputFromPort('TransferFunction')
new_tf = copy.copy(tf)
if self.hasInputFromPort('Input'):
port = self.getInputFromPort('Input')
algo = port.vtkInstance.GetProducer()
output = algo.GetOutput(port.vtkInstance.GetIndex())
(new_tf._min_range, new_tf._max_range) = output.GetScalarRange()
elif self.hasInputFromPort('Dataset'):
algo = self.getInputFromPort('Dataset').vtkInstance
output = algo
(new_tf._min_range, new_tf._max_range) = output.GetScalarRange()
else:
(new_tf._min_range, new_tf._max_range) = self.getInputFromPort('Range')
self.setResult('TransferFunction', new_tf)
(of,cf) = new_tf.get_vtk_transfer_functions()
of_module = reg.get_descriptor_by_name('edu.utah.sci.vistrails.vtk',
'vtkPiecewiseFunction').module()
of_module.vtkInstance = of
cf_module = reg.get_descriptor_by_name('edu.utah.sci.vistrails.vtk',
'vtkColorTransferFunction').module()
cf_module.vtkInstance = cf
self.setResult('vtkPicewiseFunction', of_module)
self.setResult('vtkColorTransferFunction', cf_module)
def to_module(self, controller, pkg_identifier=None):
reg = get_module_registry()
if pkg_identifier is None:
pkg_identifier = identifier
module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name(pkg_identifier, self.__class__.__name__))
return module
def registerControl(module):
"""This function is used to register the control modules. In this way, all of
them will have the same style and shape."""
reg = get_module_registry()
reg.add_module(module, moduleRightFringe=[(0.0,0.0),(0.25,0.5),(0.0,1.0)],\
moduleLeftFringe=[(0.0,0.0),(0.0,1.0)])
def run_code(self, code_str,
use_input=False,
use_output=False):
"""run_code runs a piece of code as a VisTrails module.
use_input and use_output control whether to use the inputport
and output port dictionary as local variables inside the
execution."""
import core.packagemanager
def fail(msg):
raise ModuleError(self, msg)
def cache_this():
self.is_cacheable = lambda *args, **kwargs: True
locals_ = locals()
if use_input:
inputDict = dict([(k, self.getInputFromPort(k))
for k in self.inputPorts])
locals_.update(inputDict)
if use_output:
outputDict = dict([(k, None)
for k in self.outputPorts])
locals_.update(outputDict)
_m = core.packagemanager.get_package_manager()
reg = get_module_registry()
locals_.update({'fail': fail,
'package_manager': _m,
'cache_this': cache_this,
'registry': reg,
'self': self})
del locals_['source']
exec code_str in locals_, locals_
if use_output:
for k in outputDict.iterkeys():
if locals_[k] != None:
self.setResult(k, locals_[k])
def get_packages(self):
if self._packages is None:
self._packages = {}
reg = get_module_registry()
for package in reg.package_list:
pkg = Package(package.identifier, package.version)
self._packages[package.identifier] = pkg
return self._packages
def to_module(self, controller, pkg_identifier=None):
reg = get_module_registry()
if pkg_identifier is None:
pkg_identifier = identifier
module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name(pkg_identifier,
self.__class__.__name__))
return module
def updateModule(self, module):
""" updateModule(module: Module) -> None
Setup this tree widget to show functions of module
"""
self.clear()
if module and module.is_valid:
registry = get_module_registry()
try:
descriptor = module.module_descriptor
except ModuleRegistryException, e:
# FIXME handle this the same way as
# vistrail_controller:change_selected_version
# FIXME add what we know and let the rest be blank
# in other words, add the methods as base and the
# set methods
# probably want to disable adding methods!
# need a "COPY values method FROM m1 to m2"
raise
moduleHierarchy = registry.get_module_hierarchy(descriptor)
base_items = {}
# Create the base widget item for each descriptor
for descriptor in moduleHierarchy:
baseName = descriptor.name
base_package = descriptor.identifier
baseItem = QMethodTreeWidgetItem(
None, None, self, (QtCore.QStringList() << baseName << ''))
base_items[descriptor] = baseItem
method_specs = {}
# do this in reverse to ensure proper overloading
# !!! NOTE: we have to use ***all*** input ports !!!
# because a subclass can overload a port with a
# type that isn't a method
for descriptor in reversed(moduleHierarchy):
method_specs.update((name, (descriptor, spec))
for name, spec in \
registry.module_ports('input',
descriptor))
# add local registry last so that it takes precedence
method_specs.update((spec.name, (descriptor, spec))
for spec in module.port_spec_list
if spec.type == 'input')
for _, (desc, method_spec) in sorted(method_specs.iteritems()):
if registry.is_method(method_spec):
baseItem = base_items[desc]
sig = method_spec.short_sigstring
QMethodTreeWidgetItem(
module, method_spec, baseItem,
(QtCore.QStringList() << method_spec.name << sig))
self.expandAll()
self.resizeColumnToContents(0)
def createModule(baseModule, node):
""" createModule(baseModule: a Module subclass, node: TreeNode) -> None
Construct a module inherits baseModule with specification from node
"""
if node.name in disallowed_modules: return
def obsolete_class_list():
lst = []
items = ['vtkInteractorStyleTrackball',
'vtkStructuredPointsGeometryFilter',
'vtkConstrainedPointHandleRepresentation',
'vtkTypePromotion']
def try_to_add_item(item):
try:
lst.append(getattr(titan, item))
except AttributeError:
pass
for item in items:
try_to_add_item(item)
return lst
obsolete_list = obsolete_class_list()
pack1 = vtk
for i in titan2:
if getattr(i, node.name, None) != None:
pack1 = i
def is_abstract():
"""is_abstract tries to instantiate the class. If it's
abstract, this will raise."""
# Consider obsolete classes abstract
if node.klass in obsolete_list:
return True
try:
getattr(pack1, node.name)()
except TypeError: # VTK raises type error on abstract classes
return True
return False
module = new_module(baseModule, node.name,
class_dict(baseModule, node),
docstring=getattr(pack1, node.name).__doc__
)
# This is sitting on the class
if hasattr(fix_classes, node.klass.__name__ + '_fixed'):
module.vtkClass = getattr(fix_classes, node.klass.__name__ + '_fixed')
else:
module.vtkClass = node.klass
registry = get_module_registry()
registry.add_module(module, abstract=is_abstract(),
signatureCallable=vtk_hasher)
for child in node.children:
if child.name in disallowed_classes:
continue
createModule(module, child)
def register_self():
registry = get_module_registry()
registry.add_module(PVContourRepresentation)
registry.add_output_port(PVContourRepresentation, "self",
PVContourRepresentation)
registry.add_input_port(PVContourRepresentation, "contour_values",
basic_modules.String)
registry.add_input_port(PVContourRepresentation, "cdms_variable",
CDMSVariable)
def register_self():
registry = get_module_registry()
r = registry.get_descriptor_by_name('edu.utah.sci.vistrails.vtksnl',
'vtkRenderer').module
registry.add_module(VTKRenderOffscreen)
registry.add_input_port(VTKRenderOffscreen, 'renderer', r)
registry.add_input_port(VTKRenderOffscreen, 'width', Integer)
registry.add_input_port(VTKRenderOffscreen, 'height', Integer)
registry.add_output_port(VTKRenderOffscreen, 'image', File)
def getModuleClass(mid):
import api
registry = get_module_registry()
controller = api.get_current_controller()
reg_module = controller.current_pipeline.modules[mid]
descriptor = registry.get_descriptor_by_name(reg_module.package,
reg_module.name,
reg_module.namespace)
return descriptor.module
def initialize():
registry = get_module_registry()
if registry.has_module('edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell'):
import visitcell
visitcell.registerSelf()
else:
print 'Spreadsheet not found!'
def view_documentation(self):
registry = get_module_registry()
descriptor = registry.get_descriptor_by_name(self.module.package,
self.module.name,
self.module.namespace)
widget = QPortDocumentation(descriptor, PortEndPoint.Destination,
self.spec.name)
widget.setAttribute(QtCore.Qt.WA_DeleteOnClose)
widget.exec_()
def handle_module_upgrade_request(controller, module_id, pipeline):
from core.upgradeworkflow import UpgradeWorkflowHandler
reg = get_module_registry()
def outputName_remap(old_conn, new_module):
ops = []
old_src_module = pipeline.modules[old_conn.source.moduleId]
op_desc = reg.get_descriptor(OutputPath)
new_x = (old_src_module.location.x + new_module.location.x) / 2.0
new_y = (old_src_module.location.y + new_module.location.y) / 2.0
op_module = \
controller.create_module_from_descriptor(op_desc, new_x, new_y)
ops.append(('add', op_module))
create_new_connection = UpgradeWorkflowHandler.create_new_connection
new_conn_1 = create_new_connection(controller, old_src_module,
old_conn.source, op_module, "name")
ops.append(('add', new_conn_1))
new_conn_2 = create_new_connection(controller, op_module, "value",
new_module, "outputPath")
ops.append(('add', new_conn_2))
return ops
module_remap = {
'FileSink': [(None, '1.6', None, {
'dst_port_remap': {
'overrideFile': 'overwrite',
'outputName': outputName_remap
},
'function_remap': {
'overrideFile': 'overwrite',
'outputName': 'outputPath'
}
})],
'GetItemsFromDirectory': [(None, '1.6', 'Directory', {
'dst_port_remap': {
'dir': 'value'
},
'src_port_remap': {
'itemlist': 'itemList'
},
})],
'InputPort': [(None, '1.6', None, {
'dst_port_remap': {
'old_name': None
}
})],
'OutputPort': [(None, '1.6', None, {
'dst_port_remap': {
'old_name': None
}
})],
'PythonSource': [(None, '1.6', None, {})],
}
return UpgradeWorkflowHandler.remap_module(controller, module_id, pipeline,
module_remap)
