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