def __init__(self, descriptor, var_strValue="", parent=None): """ QVariableInputForm(descriptor: ModuleDescriptor, var_strValue: str, parent: QWidget) -> QVariableInputForm Initialize with a vertical layout """ QtGui.QGroupBox.__init__(self, parent) self.setLayout(QtGui.QGridLayout()) self.layout().setMargin(5) self.layout().setSpacing(5) self.setFocusPolicy(QtCore.Qt.ClickFocus) self.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed) self.palette().setColor(QtGui.QPalette.Window, CurrentTheme.METHOD_SELECT_COLOR) # Create widget for editing variable p = ModuleParam(type=descriptor.name, identifier=descriptor.identifier, namespace=descriptor.namespace) p.strValue = var_strValue widget_type = get_widget_class(descriptor) self.widget = widget_type(p, self) self.label = QDragVariableLabel(p.type) self.layout().addWidget(self.label, 0, 0) self.layout().addWidget(self.widget, 0, 1) self.updateMethod()
def createAliasWidget(self, val=None, parent=None): if self.vtparam.identifier == "": idn = get_vistrails_basic_pkg_id() else: idn = self.vtparam.identifier reg = get_module_registry() p_descriptor = reg.get_descriptor_by_name(idn, self.vtparam.type, self.vtparam.namespace) widget_type = get_widget_class(p_descriptor) if val: self.vtparam.strValue = val return widget_type(self.vtparam, parent)
def createAliasWidget(self, val=None, parent=None): if self.vtparam.identifier == '': idn = get_vistrails_basic_pkg_id() else: idn = self.vtparam.identifier reg = get_module_registry() p_descriptor = reg.get_descriptor_by_name(idn, self.vtparam.type, self.vtparam.namespace) widget_type = get_widget_class(p_descriptor) if val: self.vtparam.strValue = val return widget_type(self.vtparam, parent)
def createAliasWidget(alias, controller, parent=None): v = controller.vtController.vistrail p = v.db_get_object(alias.component.vttype, alias.component.vtid) if p.identifier == '': idn = get_vistrails_basic_pkg_id() else: idn = p.identifier reg = get_module_registry() p_descriptor = reg.get_descriptor_by_name(idn, p.type, p.namespace) widget_type = get_widget_class(p_descriptor) p.strValue = alias.component.val return widget_type(p, parent)
def createAliasWidget(alias, controller, parent=None): v = controller.vtController.vistrail p = v.db_get_object(alias.component.vttype, alias.component.vtid) if p.identifier == '': idn = get_vistrails_basic_pkg_id() else: idn = p.identifier reg = get_module_registry() p_module = reg.get_module_by_name(idn, p.type, p.namespace) widget_type = get_widget_class(p_module) p.strValue = alias.component.val return widget_type(p, parent)
class Plot(object): def __init__(self, name, **kwargs): """A plot descriptor. Describes a Plot. These objects should be created by a VisTrails package for each Plot it wants to registers with DAT, and added to a global '_plots' variable in the 'init' module (for a reloadable package). name is mandatory and will be displayed to the user. description is a text that explains what your Plot is about, and can be localized. ports should be a list of Port objects describing the input your Plot expects. subworkflow is the path to the subworkflow that will be used for this Plot. In this string, '{package_dir}' will be replaced with the current package's path. """ self.name = name self.description = kwargs.get('description') caller = inspect.currentframe().f_back package = os.path.dirname(inspect.getabsfile(caller)) self.callback = self.subworkflow = None # Build plot from a subworkflow if 'pipeline' in kwargs and 'subworkflow' in kwargs: raise ValueError("Plot() got both pipeline and subworkflow " "parameters") elif 'pipeline' in kwargs: self.pipeline_arg = kwargs['pipeline'] elif 'subworkflow' in kwargs: self.subworkflow = kwargs['subworkflow'].format( package_dir=package) else: raise ValueError("Plot() got neither callback nor subworkflow " "parameters") self.ports = kwargs.get('ports', []) # Set the plot config widget, ensuring correct parent class from dat.gui.overlays import PlotConfigOverlay, \ DefaultPlotConfigOverlay self.configWidget = kwargs.get('configWidget', DefaultPlotConfigOverlay) if not issubclass(self.configWidget, PlotConfigOverlay): warnings.warn("Config widget of plot '%s' does not subclass " "'PlotConfigOverlay'. Using default." % self.name) self.configWidget = DefaultPlotConfigOverlay def get_pipeline(self): """Gets the pipeline. This might mean materializing it from a callback or translating it from a user-friendly format. """ if self.subworkflow is not None: locator = XMLFileLocator(self.subworkflow) vistrail = locator.load() return get_upgraded_pipeline(vistrail) else: callback_ret = self.pipeline_arg if callable(callback_ret): callback_ret = callback_ret() if isinstance(callback_ret, Pipeline): return callback_ret elif callback_ret[0] == 'pipeline': pipeline, = callback_ret[1:] return pipeline elif callback_ret[0] == 'python_lists': return build_pipeline(*callback_ret[1:]) else: raise ValueError("Plot pipeline is invalid value %s" % abbrev(repr(callback_ret))) def _read_metadata(self, package_identifier): """Reads a plot's ports from the subworkflow file Finds each InputPort module and gets the parameter name, optional flag and type from its 'name', 'optional' and 'spec' input functions. If input ports were declared in this Plot, we check that they are indeed present and were all listed (either list all of them or none). If the module type is a subclass of Constant, we will assume the port is to be set via direct input (ConstantPort), else by dragging a variable (DataPort). We also automatically add aliased input ports of compatible constant types as optional ConstantPort's. """ pipeline = self.get_pipeline() inputports = find_modules_by_type(pipeline, [InputPort]) if not inputports: raise ValueError("No InputPort module") currentports = {port.name: port for port in self.ports} seenports = set() for port in inputports: name = get_function(port, 'name') if not name: raise ValueError( "Subworkflow of plot '%s' in package '%s' has an " "InputPort with no name" % ( self.name, package_identifier)) if name in seenports: raise ValueError( "Subworkflow of plot '%s' in package '%s' has several " "InputPort modules with name '%s'" % ( self.name, package_identifier, name)) spec = get_function(port, 'spec') optional = get_function(port, 'optional') if optional == 'True': optional = True elif optional == 'False': optional = False else: optional = None try: currentport = currentports[name] except KeyError: # If the package didn't provide any port, it's ok, we can # discover them. But if some were present and some were # forgotten, emit a warning if currentports: warnings.warn( "Declaration of plot '%s' in package '%s' omitted " "port '%s'" % ( self.name, package_identifier, name)) if not spec: warnings.warn( "Subworkflow of plot '%s' in package '%s' has an " "InputPort '%s' with no type; assuming Module" % ( self.name, package_identifier, name)) spec = 'org.vistrails.vistrails.basic:Module' if not optional: optional = False type = resolve_descriptor(spec, package_identifier) if issubclass(type.module, Constant): currentport = ConstantPort( name=name, type=type, optional=optional) else: currentport = DataPort( name=name, type=type, optional=optional) self.ports.append(currentport) else: currentspec = (currentport.type.identifier + ':' + currentport.type.name) # Canonicalize spec spec = create_descriptor_string(*parse_descriptor_string( spec, package_identifier)) if ((spec and spec != currentspec) or (optional is not None and optional != currentport.optional)): warnings.warn( "Declaration of port '%s' from plot '%s' in " "package '%s' differs from subworkflow " "contents" % ( name, self.name, package_identifier)) spec = currentspec type = resolve_descriptor(currentspec, package_identifier) # Get info from the PortSpec try: (default_type, default_value, entry_type, enum_values) = read_port_specs( pipeline, port) if default_value is not None: if not issubclass(default_type, type.module): raise ValueError("incompatible type %r" % (( default_type, type.module),)) elif default_type is type.module: currentport.default_value = default_value currentport.entry_type = entry_type currentport.enum_values = enum_values except ValueError, e: raise ValueError( "Error reading specs for port '%s' from plot '%s' of " "package '%s': %s" % ( name, self.name, package_identifier, e.args[0])) seenports.add(name) # Now to add aliased parameters for module in pipeline.module_list: for function in module.functions: port = module.get_port_spec(function.name, 'input') problem = None if len(port.descriptors()) != 1: problem = ( "Aliased parameter '{alias}' on port '{port}' of " "module '{module}' in plot '{plot}' of package " "'{pkg}' has multiple descriptors") port_type = port.descriptors()[0] if not issubclass(port_type.module, Constant): problem = ( "Aliased parameter '{alias}' on port '{port}' of " "module '{module}' in plot '{plot}' of package " "'{pkg}' is not a constant") for param in function.parameters: if param.alias: if problem is not None: warnings.warn(problem.format( plot=self.name, pkg=package_identifier, module=module.name, port=function.name, alias=param.alias)) continue try: plot_port = currentports[param.alias] except KeyError: plot_port = ConstantPort( name=param.alias, type=port_type, optional=True, is_alias=True) self.ports.append(plot_port) else: plot_port.is_alias = True spec = (plot_port.type.identifier + ':' + plot_port.type.name) if spec != port_type.sigstring: warnings.warn( "Declaration of port '%s' (alias) from " "plot '%s' in package '%s' differs from " "subworkflow contents" % ( param.alias, self.name, package_identifier)) psi = port.port_spec_items[0] if (psi.entry_type is not None and psi.entry_type.startswith('enum')): plot_port.entry_type = psi.entry_type plot_port.enum_values = psi.values else: plot_port.entry_type = None plot_port.enum_values = None plot_port.default_value = param.strValue # FIXME : there is no way to not set a value here # Code to get the port's default is below for ref # if port.defaults and port.defaults[0]: # plot_port.default_value = port.defaults[0] seenports.add(param.alias) # If the package declared ports that we didn't see missingports = list(set(currentports.keys()) - seenports) if currentports and missingports: raise ValueError( "Declaration of plot '%s' in package '%s' mentions " "missing InputPort module '%s'" % ( self.name, package_identifier, missingports[0])) for port in self.ports: if isinstance(port, ConstantPort): module = port.type port.widget_class = get_widget_class(module, port.entry_type)