def getModuleClassByName(self,package,moduleName,namespace=""):
"""getModuleClassByName(package: Str, moduleName: Str) -> Class
Returns the actual python class of a module; this is done by accessing
the registry to get the descriptor, and then getting the 'module'
attribute of the descriptor, which returns the class of that module.
Notice that it returns a *CLASS*, and not an instance of that class"""
return registry.get_descriptor_by_name(package,moduleName,namespace).module
def inspect_spreadsheet_cells(self, pipeline):
""" inspect_spreadsheet_cells(pipeline: Pipeline) -> None
Inspect the pipeline to see how many cells is needed
"""
self.spreadsheet_cells = []
if not pipeline: return
# 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(mId)
def getModuleClassByName(self, package, moduleName, namespace=""):
"""getModuleClassByName(package: Str, moduleName: Str) -> Class
Returns the actual python class of a module; this is done by accessing
the registry to get the descriptor, and then getting the 'module'
attribute of the descriptor, which returns the class of that module.
Notice that it returns a *CLASS*, and not an instance of that class"""
return registry.get_descriptor_by_name(package, moduleName, namespace).module
def wrapperModule(classname, instance):
""" wrapperModule(classname: str, instance: vtk class) -> Module
Create a wrapper module in VisTrails with a vtk instance
"""
result = registry.get_descriptor_by_name('edu.utah.sci.vistrails.vtk',
classname).module()
result.vtkInstance = instance
return result
def view_documentation(self):
descriptor = registry.get_descriptor_by_name(self.module.package,
self.module.name,
self.module.namespace)
widget = QPortDocumentation(descriptor,
PortEndPoint.Destination,
self.port.name)
widget.setAttribute(QtCore.Qt.WA_DeleteOnClose)
widget.exec_()
def wrapperModule(classname, instance):
""" wrapperModule(classname: str, instance: vtk class) -> Module
Create a wrapper module in VisTrails with a vtk instance
"""
result = registry.get_descriptor_by_name(
'edu.utah.sci.vistrails.vtksnl',
classname).module()
result.vtkInstance = instance
return result
def testSummonModule(self):
"""Check that summon creates a correct module"""
x = Module()
x.name = "String"
x.package = 'edu.utah.sci.vistrails.basic'
try:
c = x.summon()
m = registry.get_descriptor_by_name('edu.utah.sci.vistrails.basic',
'String').module
assert type(c) == m
except NoSummon:
msg = "Expected to get a String object, got a NoSummon exception"
self.fail(msg)
def make_registry(self):
reg_module = \
registry.get_descriptor_by_name('edu.utah.sci.vistrails.basic',
self.name).module
self._registry = ModuleRegistry()
self._registry.add_hierarchy(registry, self)
for module in self.pipeline.module_list:
if module.name == 'OutputPort':
port = self.make_port_from_module(module, 'source')
self._registry.add_port(reg_module, PortEndPoint.Source, port)
elif module.name == 'InputPort':
port = self.make_port_from_module(module, 'destination')
self._registry.add_port(reg_module, PortEndPoint.Destination,
port)
def make_port_from_module(module, port_type):
for function in module.functions:
if function.name == 'name':
port_name = function.params[0].strValue
if function.name == 'spec':
port_spec = function.params[0].strValue
port = Port(id=-1,
name=port_name,
type=port_type)
portSpecs = port_spec[1:-1].split(',')
signature = []
for s in portSpecs:
spec = s.split(':', 2)
signature.append(registry.get_descriptor_by_name(*spec).module)
port.spec = core.modules.module_registry.PortSpec(signature)
return port
def add_port_to_registry(self, port_spec):
module = \
registry.get_descriptor_by_name(self.package, self.name, self.namespace).module
if self.registry is None:
self.registry = ModuleRegistry()
self.registry.add_hierarchy(registry, self)
if port_spec.type == 'input':
endpoint = PortEndPoint.Destination
else:
endpoint = PortEndPoint.Source
portSpecs = port_spec.spec[1:-1].split(',')
signature = [registry.get_descriptor_from_name_only(spec).module
for spec in portSpecs]
port = Port()
port.name = port_spec.name
port.spec = core.modules.module_registry.PortSpec(signature)
self.registry.add_port(module, endpoint, port)
def updateModule(self, module):
""" updateModule(module: Module) -> None
Setup this tree widget to show functions of module
"""
self.clear()
if module:
try:
descriptor = registry.get_descriptor_by_name(module.package,
module.name,
module.namespace)
except registry.MissingModulePackage, e:
# FIXME handle this the same way as
# vistrail_controller:change_selected_version
raise
moduleHierarchy = registry.get_module_hierarchy(descriptor)
for baseModule in moduleHierarchy:
baseName = registry.get_descriptor(baseModule).name
base_package = registry.get_descriptor(baseModule).identifier
# Create the base widget item
baseItem = QMethodTreeWidgetItem(None,
None,
None,
self,
(QtCore.QStringList()
<< baseName
<< ''))
methods = registry.method_ports(baseModule)
# Also check the local registry
if module.registry and module.registry.has_module(base_package,
baseName):
methods += module.registry.method_ports(baseModule)
for method in methods:
sig = method.spec.create_sigstring(short=True)
QMethodTreeWidgetItem(module,
method,
method.spec,
baseItem,
(QtCore.QStringList()
<< method.name
<< sig))
self.expandAll()
self.resizeColumnToContents(0)
def delete_port_from_registry(self, id):
if not id in self.port_specs:
raise VistrailsInternalError("id missing in port_specs")
portSpec = self.port_specs[id]
portSpecs = portSpec.spec[1:-1].split(',')
signature = [registry.get_descriptor_from_name_only(spec).module
for spec in portSpecs]
port = Port(signature)
port.name = portSpec.name
port.spec = core.modules.module_registry.PortSpec(signature)
module = \
registry.get_descriptor_by_name(self.package, self.name, self.namespace).module
assert isinstance(self.registry, ModuleRegistry)
if portSpec.type == 'input':
self.registry.delete_input_port(module, port.name)
else:
self.registry.delete_output_port(module, port.name)
class vtkBaseModule(Module):
"""
vtkBaseModule is the base class for all VTK modules in VisTrails, it acts
as a wrapper to direct all input/output ports to appropriate VTK function
calls
"""
def __init__(self):
""" vtkBaseModule() -> vtkBaseModule
Instantiate an emptt VTK Module with real VTK instance
"""
Module.__init__(self)
self.vtkInstance = None
def is_cacheable(self):
# VTK objects are by default cacheable only if they're subclasses
# of vtkAlgorithm
return (issubclass(self.vtkClass, vtk.vtkAlgorithm)
and (not issubclass(self.vtkClass, vtk.vtkAbstractMapper)))
def call_input_function(self, function, params):
"""self.call_input_function(function, params) -> None
Calls the input function on the vtkInstance, or a special
input function if one exists in the class."""
if hasattr(self, '_special_input_function_' + function):
attr = getattr(self, '_special_input_function_' + function)
else:
try:
attr = getattr(self.vtkInstance, function)
except AttributeError:
# Compensates for overload by exploiting the fact that
# no VTK method has underscores.
f = function.find('_')
if f != -1:
function = function[:f]
attr = getattr(self.vtkInstance, function)
attr(*params)
# print "Called ",attr,function,params
@classmethod
def _provide_doc(cls, port_name):
f = port_name.find('_')
if f != -1:
name = port_name[:f]
else:
name = port_name
return getattr(cls.vtkClass, name).__doc__
@classmethod
def provide_input_port_documentation(cls, port_name):
return cls._provide_doc(port_name)
@classmethod
def provide_output_port_documentation(cls, port_name):
return cls._provide_doc(port_name)
def compute(self):
""" compute() -> None
Actually perform real VTK task by directing all input/output ports
to VTK function calls
"""
def call_it(function, p):
# Translate between VisTrails objects and VTK objects
if p is None:
# None indicates a call with no parameters
params = []
elif type(p) == tuple:
# A tuple indicates a call with many parameters
params = list(p)
else:
# Otherwise, it's a single parameter
params = [p]
# Unwraps VTK objects
for i in xrange(len(params)):
if hasattr(params[i], 'vtkInstance'):
params[i] = params[i].vtkInstance
try:
self.call_input_function(function, params)
except Exception, e:
msg = 'VTK Exception: '
raise ModuleError(self, msg + str(type(e)) + ': ' + str(e))
# Always re-create vtkInstance module, no caching here
if self.vtkInstance:
del self.vtkInstance
self.vtkInstance = self.vtkClass()
# We need to call method ports before anything else, and in
# the right order.
# FIXME: This does not belong here, it belongs in the main class
# No time for that now
methods = self.is_method.values()
methods.sort()
for value in methods:
(_, port) = value
conn = self.is_method.inverse[value]
p = conn()
call_it(port, p)
# Make sure all input ports are called correctly
for (function, connector_list) in self.inputPorts.iteritems():
paramList = self.forceGetInputListFromPort(function)
if function[:18] == 'SetInputConnection':
paramList = zip([int(function[18:])] * len(paramList),
paramList)
function = 'SetInputConnection'
if function == 'AddInputConnection':
desc = registry.get_descriptor_by_name(
'edu.utah.sci.vistrails.vtk', 'vtkAlgorithmOutput')
for i in xrange(len(paramList)):
if type(paramList[i]) == desc.module:
paramList[i] = (0, paramList[i])
for p, connector in izip(paramList, connector_list):
# Don't call method
if connector in self.is_method:
continue
call_it(function, p)
# Call update if appropriate
if hasattr(self.vtkInstance, 'Update'):
def ProgressEvent(obj, event):
self.logging.update_progress(self, obj.GetProgress())
isAlgorithm = issubclass(self.vtkClass, vtk.vtkAlgorithm)
if isAlgorithm:
cbId = self.vtkInstance.AddObserver('ProgressEvent',
ProgressEvent)
self.vtkInstance.Update()
if isAlgorithm:
self.vtkInstance.RemoveObserver(cbId)
# Then update the output ports also with appropriate function calls
for function in self.outputPorts.keys():
if function[:13] == 'GetOutputPort':
i = int(function[13:])
vtkOutput = self.vtkInstance.GetOutputPort(i)
output = vtkBaseModule.wrapperModule('vtkAlgorithmOutput',
vtkOutput)
self.setResult(function, output)
elif hasattr(self.vtkInstance, function):
retValues = getattr(self.vtkInstance, function)()
if issubclass(retValues.__class__, vtk.vtkObject):
className = retValues.GetClassName()
output = vtkBaseModule.wrapperModule(className, retValues)
self.setResult(function, output)
elif (type(retValues) in [tuple, list]):
result = list(retValues)
for i in xrange(len(result)):
if issubclass(result[i].__class__, vtk.vtkObject):
className = result[i].GetClassName()
result[i] = vtkBaseModule.wrapperModule(
className, result[i])
self.setResult(function, type(retValues)(result))
else:
self.setResult(function, retValues)
def getModuleClassByModule(self,module):
"""getModuleClassByModule(module: Module) -> Class
Does the same thing as the above, only it returns the class from a given module
instead of its name and package"""
return registry.get_descriptor_by_name(module.package, module.name, module.namespace).module
def getModuleClassByModule(self, module):
"""getModuleClassByModule(module: Module) -> Class
Does the same thing as the above, only it returns the class from a given module
instead of its name and package"""
return registry.get_descriptor_by_name(module.package, module.name, module.namespace).module
