def createFailedPackage(self):
""" Failed package is created so that the user can remove
it manually using package submenu """
pm = get_package_manager()
if pm.has_package(self.signature):
# do nothing
return
reg = core.modules.module_registry.get_module_registry()
# create a document hash integer from the cached sax tree
# "name" is what suds use as the cache key
name = '%s-%s' % (abs(hash(self.address)), "wsdl")
self.wsdlHash = '0'
package_id = reg.idScope.getNewId(Package.vtType)
package = Package(id=package_id,
codepath=__file__,
load_configuration=False,
name="SUDS#" + self.address,
identifier=self.signature,
version=self.wsdlHash,
)
suds_package = reg.get_package_by_name(identifier)
package._module = suds_package.module
package._init_module = suds_package.init_module
self.package = package
reg.add_package(package)
self.module = new_module(Module, str(self.signature))
reg.add_module(self.module, **{'package':self.signature,
'package_version':self.wsdlHash,
'abstract':True})
self.service = -1
def createPackage(self):
pm = get_package_manager()
if pm.has_package(self.signature):
package = pm.get_package_by_identifier()
pm.remove_package(package.codepath)
reg = core.modules.module_registry.get_module_registry()
# create a document hash integer from the cached sax tree
# "name" is what suds use as the cache key
name = '%s-%s' % (abs(hash(self.address)), "wsdl")
wsdl = package_cache.get(name)
if not wsdl:
debug.critical("File not found in SUDS cache: '%s'" % name)
self.wsdlHash = '0'
return
self.wsdlHash = str(int(hashlib.md5(str(wsdl.root)).hexdigest(), 16))
package_id = reg.idScope.getNewId(Package.vtType)
package = Package(id=package_id,
codepath=__file__,
load_configuration=False,
name="SUDS#" + self.address,
identifier=self.signature,
version=self.wsdlHash,
)
self.package = package
reg.add_package(package)
self.module = new_module(Module, str(self.signature))
reg.add_module(self.module, **{'package':self.signature,
'package_version':self.wsdlHash,
'abstract':True})
def disable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = inst.currentItem()
pos = inst.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
identifier = pm.get_package_by_codepath(codepath).identifier
if dependency_graph.in_degree(identifier) > 0:
rev_deps = dependency_graph.inverse_adjacency_list[identifier]
msg = QtGui.QMessageBox(QtGui.QMessageBox.Critical,
"Missing dependency",
("There are other packages that depend on this:\n %s" +
"Please disable those first.") % rev_deps,
QtGui.QMessageBox.Ok, self)
msg.exec_()
else:
pm.late_disable_package(codepath)
inst.takeItem(pos)
av.addItem(item)
av.sortItems()
av.clearSelection()
inst.clearSelection()
def newModule(self, descriptor):
""" newModule(descriptor: core.modules.module_registry.ModuleDescriptor)
A new module has been added to VisTrails
"""
if descriptor.module_abstract():
# skip abstract modules, they're no longer in the tree
return
moduleName = descriptor.name
identifier = descriptor.identifier
pm = get_package_manager()
packageName = pm.get_package_by_identifier(identifier).name
# NB: only looks for toplevel matches
packageItems = self.treeWidget.findItems(packageName,
QtCore.Qt.MatchExactly |
QtCore.Qt.MatchWrap)
assert(len(packageItems)<=1)
if packageItems==[]:
# didn't find a top-level package item, so let's create one
parentItem = QModuleTreeWidgetItem(None,
None,
QtCore.QStringList(packageName))
parentItem._namespace_items = {}
self.treeWidget.insertTopLevelItem(0, parentItem)
else:
parentItem = packageItems[0]
if descriptor.namespace:
parentItem = _ensure_namespace(descriptor, parentItem)
item = QModuleTreeWidgetItem(descriptor,
parentItem,
QtCore.QStringList(moduleName))
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 package_dependencies():
from core.packagemanager import get_package_manager
dependencies = [vtk_pkg_identifier, 'edu.utah.sci.vistrails.spreadsheet',
'gov.llnl.uvcdat', 'gov.llnl.uvcdat.cdms']
if get_package_manager().has_package('edu.utah.sci.vistrails.matplotlib'):
dependencies.append('edu.utah.sci.vistrails.matplotlib')
return dependencies
def getPackageVersion(self, identifier):
"""getPackageVersion(identifier: str) -> str
This will return the current version loaded of the package identified
by identifier
"""
pm = get_package_manager()
return pm.get_package_by_identifier(identifier).version
def getPackageVersion(self, identifier):
"""getPackageVersion(identifier: str) -> str
This will return the current version loaded of the package identified
by identifier
"""
pm = get_package_manager()
return pm.get_package_by_identifier(identifier).version
def handle_module_upgrade_request(self, *args, **kwargs):
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.handle_module_upgrade_request(*args, **kwargs)
return self._init_module.handle_module_upgrade_request(*args, **kwargs)
def callContextMenu(self, signature):
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.callContextMenu(signature)
return self._init_module.callContextMenu(signature)
def handle_module_upgrade_request(self, *args, **kwargs):
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.handle_module_upgrade_request(*args, **kwargs)
return self._init_module.handle_module_upgrade_request(*args, **kwargs)
def callContextMenu(self, signature):
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.callContextMenu(signature)
return self._init_module.callContextMenu(signature)
def package_dependencies():
from core.packagemanager import get_package_manager
dependencies = [
vtk_pkg_identifier, 'edu.utah.sci.vistrails.spreadsheet',
'gov.llnl.uvcdat', 'gov.llnl.uvcdat.cdms'
]
if get_package_manager().has_package('edu.utah.sci.vistrails.matplotlib'):
dependencies.append('edu.utah.sci.vistrails.matplotlib')
return dependencies
def reload_current_package_finisher(self, codepath, reverse_deps, prefix_dictionary):
# REENABLES the current package and all reverse dependencies
pm = get_package_manager()
try:
pm.reload_package_enable(reverse_deps, prefix_dictionary)
except self._current_package.InitializationFailed, e:
debug.critical("Re-initialization of package '%s' failed" %
codepath, str(e))
raise
def reload_current_package_finisher(self, codepath, reverse_deps,
prefix_dictionary):
# REENABLES the current package and all reverse dependencies
pm = get_package_manager()
try:
pm.reload_package_enable(reverse_deps, prefix_dictionary)
except self._current_package.InitializationFailed, e:
debug.critical(
"Re-initialization of package '%s' failed" % codepath, str(e))
raise
def selected_available_list(self):
item = self._available_packages_list.currentItem()
if item is None:
return # prevent back and forth looping when clearing selection
self._enabled_packages_list.setCurrentItem(None)
codepath = str(item.text())
pm = get_package_manager()
self._current_package = pm.look_at_available_package(codepath)
self.set_buttons_to_available_package()
self.set_package_information()
self._available_packages_list.setFocus()
def selected_available_list(self):
item = self._available_packages_list.currentItem()
if item is None:
return # prevent back and forth looping when clearing selection
self._enabled_packages_list.setCurrentItem(None)
codepath = str(item.text())
pm = get_package_manager()
self._current_package = pm.look_at_available_package(codepath)
self.set_buttons_to_available_package()
self.set_package_information()
self._available_packages_list.setFocus()
def reload_current_package(self):
# DISABLES the current package and all reverse dependencies
inst = self._enabled_packages_list
item = inst.currentItem()
pm = get_package_manager()
codepath = str(item.text())
palette = QModulePalette.instance()
palette.setUpdatesEnabled(False)
pm.reload_package_disable(codepath)
self.erase_cache = True
def reload_current_package(self):
# DISABLES the current package and all reverse dependencies
inst = self._enabled_packages_list
item = inst.currentItem()
pm = get_package_manager()
codepath = str(item.text())
palette = QModulePalette.instance()
palette.setUpdatesEnabled(False)
pm.reload_package_disable(codepath)
self.erase_cache = True
def populate_lists(self):
pkg_manager = get_package_manager()
enabled_pkgs = sorted(pkg_manager.enabled_package_list())
enabled_pkg_dict = dict([(pkg.codepath, pkg) for
pkg in enabled_pkgs])
for pkg in enabled_pkgs:
self._enabled_packages_list.addItem(pkg.codepath)
available_pkg_names = [pkg for pkg in
sorted(pkg_manager.available_package_names_list())
if pkg not in enabled_pkg_dict]
for pkg in available_pkg_names:
self._available_packages_list.addItem(pkg)
def connect_package_manager_signals(self):
""" connect_package_manager_signals()->None
Connect specific signals related to the package manager """
pm = get_package_manager()
self.connect(pm,
pm.add_package_menu_signal,
self.add_package_menu_items)
self.connect(pm,
pm.remove_package_menu_signal,
self.remove_package_menu_items)
self.connect(pm,
pm.package_error_message_signal,
self.show_package_error_message)
def deletedPackage(self, package):
""" deletedPackage(package):
A package has been deleted from VisTrails
"""
pm = get_package_manager()
pm.get_package_by_identifier
items = self.treeWidget.findItems(package.name,
QtCore.Qt.MatchExactly |
QtCore.Qt.MatchWrap)
assert len(items) == 1
item = items[0]
index = self.treeWidget.indexOfTopLevelItem(item)
self.treeWidget.takeTopLevelItem(index)
def handle_missing_module(self, *args, **kwargs):
"""report_missing_module(name, namespace):
Calls the package's module handle_missing_module function, if
present, to allow the package to dynamically add a missing
module.
"""
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.handle_missing_module(*args, **kwargs)
return self._init_module.handle_missing_module(*args, **kwargs)
def handle_missing_module(self, *args, **kwargs):
"""report_missing_module(name, namespace):
Calls the package's module handle_missing_module function, if
present, to allow the package to dynamically add a missing
module.
"""
# redirect webservices to SUDSWebServices
if self.identifier.startswith("SUDS#"):
from core.packagemanager import get_package_manager
pm = get_package_manager()
package = pm.get_package_by_identifier('edu.utah.sci.vistrails.sudswebservices')
return package._init_module.handle_missing_module(*args, **kwargs)
return self._init_module.handle_missing_module(*args, **kwargs)
def populate_lists(self):
pkg_manager = get_package_manager()
enabled_pkgs = sorted(pkg_manager.enabled_package_list())
enabled_pkg_dict = dict([(pkg.codepath, pkg) for pkg in enabled_pkgs])
self._enabled_packages_list.clear()
for pkg in enabled_pkgs:
self._enabled_packages_list.addItem(pkg.codepath)
self._enabled_packages_list.sortItems()
available_pkg_names = [
pkg for pkg in sorted(pkg_manager.available_package_names_list())
if pkg not in enabled_pkg_dict
]
self._available_packages_list.clear()
for pkg in available_pkg_names:
self._available_packages_list.addItem(pkg)
self._available_packages_list.sortItems()
def enable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = av.currentItem()
pos = av.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
new_deps = self._current_package.dependencies()
from core.modules.basic_modules import identifier as basic_modules_identifier
if self._current_package.identifier != basic_modules_identifier:
new_deps.append(basic_modules_identifier)
try:
pm.check_dependencies(self._current_package, new_deps)
except self._current_package.MissingDependency, e:
debug.critical("Missing dependencies", str(e))
def enable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = av.currentItem()
pos = av.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
new_deps = self._current_package.dependencies()
from core.modules.basic_modules import identifier as basic_modules_identifier
if self._current_package.identifier != basic_modules_identifier:
new_deps.append(basic_modules_identifier)
try:
pm.check_dependencies(self._current_package, new_deps)
except self._current_package.MissingDependency, e:
debug.critical("Missing dependencies", str(e))
def disable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = inst.currentItem()
pos = inst.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
identifier = pm.get_package_by_codepath(codepath).identifier
if dependency_graph.in_degree(identifier) > 0:
rev_deps = dependency_graph.inverse_adjacency_list[identifier]
debug.critical("Missing dependency",
("There are other packages that depend on this:\n %s" +
"Please disable those first.") % rev_deps)
else:
pm.late_disable_package(codepath)
self.invalidate_current_pipeline()
def updateFromModuleRegistry(self):
""" updateFromModuleRegistry(packageName: str) -> None
Setup this tree widget to show modules currently inside
module_registry.registry
"""
parentItems = {}
def createModuleItem(module):
""" createModuleItem(registry: ModuleRegistry,
parentItem: QModuleTreeWidgetItem,
module: Tree) -> QModuleTreeWidgetItem
Traverse a module to create items recursively. Then return
its module item
"""
desc = module.descriptor
labels = QtCore.QStringList(module.descriptor.name)
packageName = module.descriptor.module_package()
parentItem = parentItems[packageName]
if desc.namespace:
parentItem = _ensure_namespace(desc, parentItem)
if not desc.module_abstract():
moduleItem = QModuleTreeWidgetItem(module.descriptor,
parentItem,
labels)
for child in module.children:
createModuleItem(child)
pm = get_package_manager()
for packageName in registry.package_modules.iterkeys():
name = pm.get_package_by_identifier(packageName).name
item = QModuleTreeWidgetItem(None,
self,
QtCore.QStringList(name))
item._namespace_items = {}
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsDragEnabled)
parentItems[packageName] = item
module = registry.class_tree()
createModuleItem(module)
self.sortItems(0, QtCore.Qt.AscendingOrder)
self.expandAll()
def disable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = inst.currentItem()
pos = inst.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
identifier = pm.get_package_by_codepath(codepath).identifier
if dependency_graph.in_degree(identifier) > 0:
rev_deps = dependency_graph.inverse_adjacency_list[identifier]
debug.critical(
"Missing dependency",
("There are other packages that depend on this:\n %s" +
"Please disable those first.") % rev_deps)
else:
pm.late_disable_package(codepath)
self.invalidate_current_pipeline()
def dispatch_request(controller, module_id, current_pipeline):
reg = get_module_registry()
pm = get_package_manager()
if module_id not in current_pipeline.modules:
# It is possible that some other upgrade request has
# already removed the invalid module of this request. In
# that case, disregard the request.
debug.log("module %s already handled. skipping" % module_id)
return []
invalid_module = current_pipeline.modules[module_id]
pkg = pm.get_package_by_identifier(invalid_module.package)
if hasattr(pkg.module, 'handle_module_upgrade_request'):
f = pkg.module.handle_module_upgrade_request
return f(controller, module_id, current_pipeline)
else:
debug.log('Package "%s" cannot handle upgrade request. '
'VisTrails will attempt automatic upgrade.' % \
pkg.identifier)
auto_upgrade = UpgradeWorkflowHandler.attempt_automatic_upgrade
return auto_upgrade(controller, current_pipeline, module_id)
def set_buttons_to_enabled_package(self):
self._enable_button.setEnabled(False)
assert self._current_package
pm = get_package_manager()
from core.modules.basic_modules import identifier as basic_modules_identifier
from core.modules.abstraction import identifier as abstraction_identifier
is_not_basic_modules = (self._current_package.identifier != basic_modules_identifier)
is_not_abstraction = (self._current_package.identifier != abstraction_identifier)
can_disable = (pm.can_be_disabled(self._current_package.identifier) and
is_not_basic_modules and
is_not_abstraction)
self._disable_button.setEnabled(can_disable)
if not can_disable and is_not_basic_modules and is_not_abstraction:
msg = ("Module has reverse dependencies that must\n"+
"be first disabled.")
self._disable_button.setToolTip(msg)
else:
self._disable_button.setToolTip("")
conf = self._current_package.configuration is not None
self._configure_button.setEnabled(conf)
self._reload_button.setEnabled(is_not_basic_modules)
def set_buttons_to_enabled_package(self):
self._enable_button.setEnabled(False)
assert self._current_package
pm = get_package_manager()
from core.modules.basic_modules import identifier as basic_modules_identifier
from core.modules.abstraction import identifier as abstraction_identifier
is_not_basic_modules = (self._current_package.identifier !=
basic_modules_identifier)
is_not_abstraction = (self._current_package.identifier !=
abstraction_identifier)
can_disable = (pm.can_be_disabled(self._current_package.identifier)
and is_not_basic_modules and is_not_abstraction)
self._disable_button.setEnabled(can_disable)
if not can_disable and is_not_basic_modules and is_not_abstraction:
msg = ("Module has reverse dependencies that must\n" +
"be first disabled.")
self._disable_button.setToolTip(msg)
else:
self._disable_button.setToolTip("")
conf = self._current_package.configuration is not None
self._configure_button.setEnabled(conf)
self._reload_button.setEnabled(is_not_basic_modules)
def enable_current_package(self):
av = self._available_packages_list
inst = self._enabled_packages_list
item = av.currentItem()
pos = av.indexFromItem(item).row()
codepath = str(item.text())
pm = get_package_manager()
dependency_graph = pm.dependency_graph()
new_deps = self._current_package.dependencies()
unmet_dep = None
for dep in new_deps:
if dep not in dependency_graph.vertices:
unmet_dep = dep
break
if unmet_dep:
msg = QtGui.QMessageBox(QtGui.QMessageBox.Critical,
"Missing dependency",
("This package requires package '%s'\n" +
"to be enabled. (Complete dependency list is:\n" +
"%s)") % (dep, new_deps),
QtGui.QMessageBox.Ok, self)
msg.exec_()
else:
palette = QtGui.QApplication.instance().builderWindow.modulePalette
palette.setUpdatesEnabled(False)
try:
pm.late_enable_package(codepath)
finally:
palette.setUpdatesEnabled(True)
palette.treeWidget.expandAll()
self._current_package = pm.get_package_by_codepath(codepath)
av.takeItem(pos)
av.clearSelection()
inst.addItem(item)
inst.sortItems()
inst.clearSelection()
def createFailedPackage(self):
""" Failed package is created so that the user can remove
it manually using package submenu """
pm = get_package_manager()
if pm.has_package(self.signature):
# do nothing
return
reg = core.modules.module_registry.get_module_registry()
# create a document hash integer from the cached sax tree
# "name" is what suds use as the cache key
name = '%s-%s' % (abs(hash(self.address)), "wsdl")
self.wsdlHash = '0'
package_id = reg.idScope.getNewId(Package.vtType)
package = Package(
id=package_id,
load_configuration=False,
name="SUDS#" + self.address,
identifier=self.signature,
version=self.wsdlHash,
)
suds_package = reg.get_package_by_name(identifier)
package._module = suds_package.module
package._init_module = suds_package.init_module
self.package = package
reg.add_package(package)
reg.signals.emit_new_package(self.signature)
self.module = new_module(Module, str(self.signature))
reg.add_module(
self.module, **{
'package': self.signature,
'package_version': self.wsdlHash,
'abstract': True
})
self.service = -1
def clicked_on_enabled_list(self, item):
codepath = str(item.text())
pm = get_package_manager()
self._current_package = pm.get_package_by_codepath(codepath)
self.set_buttons_to_enabled_package()
self.set_package_information()
def load(self, loadworkflow=True):
config = ConfigParser.ConfigParser()
if config.read(self.config_file):
if config.has_section('global'):
if config.has_option('global', 'cellnum'):
self.cellnum = config.getint('global', 'cellnum')
if config.has_option('global', 'filenum'):
self.filenum = config.getint('global', 'filenum')
if config.has_option('global', 'varnum'):
self.varnum = config.getint('global', 'varnum')
print " ------ Loaded plot %s, varnum = %d ------ " % ( self.name, self.varnum )
if config.has_option('global', 'workflow_tag'):
self.workflow_tag = config.get('global', 'workflow_tag')
# else:
# debug.warning("CDAT Package: file %s does not contain a required option 'workflow_tag'. Widget will not be loaded."%self.config_file)
# self.loaded = False
# return
if config.has_option('global', 'filetypes'):
types = config.get('global', 'filetypes')
tlist = [t.strip() for t in types.split(";")]
for t in tlist:
kv = t.split(":")
self.filetypes[kv[0].strip()] = [v.strip()
for v in kv[1].split(",")]
if config.has_option('global', 'qt_filter'):
self.qt_filter = config.get('global', 'qt_filter')
if config.has_option('global', 'dependencies'):
deps = config.get('global', 'dependencies')
self.dependencies = [d.strip() for d in deps.split(",")]
if config.has_option('global', 'serialized_config_alias'):
self.serializedConfigAlias = config.get('global', 'serialized_config_alias')
for y in range(self.filenum):
self.files.append( 'Filename' + str(y+1) )
for v in range(self.varnum):
self.vars.append( 'VariableName' + str(v+1) )
self.axes.append( 'Axes' + str(v+1) )
for x in range(self.cellnum):
section_name = 'cell' + str(x+1)
if config.has_section(section_name):
cellType = config.get(section_name, 'celltype')
if config.has_option(section_name, 'address_alias'):
self.cells.append( Cell( cellType, None, None,
config.get(section_name, 'address_alias') ) )
else:
self.cells.append(Cell( cellType,"Row"+str(x+1), "Column"+str(x+1) ) )
else:
for y in range(self.filenum):
option_name = 'filename_alias' + str(y+1)
if config.has_option('global', option_name):
self.files.append(config.get('global', option_name))
for v in range(self.varnum):
option_name = 'varname_alias' + str(v+1)
if config.has_option('global', option_name):
self.vars.append(config.get('global', option_name))
axes_name = 'axes_alias' + str(v+1)
if config.has_option('global', axes_name):
self.axes.append(config.get('global', axes_name))
for x in range(self.cellnum):
section_name = 'cell' + str(x+1)
if (config.has_section(section_name) and
config.has_option(section_name, 'celltype') and
config.has_option(section_name, 'row_alias') and
config.has_option(section_name, 'col_alias')):
self.cells.append(Cell(config.get(section_name, 'celltype'),
config.get(section_name, 'row_alias'),
config.get(section_name, 'col_alias')))
if loadworkflow:
#load workflow in vistrail
#only if dependencies are enabled
manager = get_package_manager()
self.unsatisfied_deps = []
for dep in self.dependencies:
if not manager.has_package(dep):
self.unsatisfied_deps.append(dep)
if len(self.unsatisfied_deps) == 0:
try:
(self.plot_vistrail, abstractions , thumbnails, mashups) = load_vistrail(self.locator)
controller = VistrailController()
controller.set_vistrail(self.plot_vistrail, self.locator,
abstractions, thumbnails,
mashups)
self.workflow_version = self.plot_vistrail.get_version_number(self.workflow_tag) if self.workflow_tag else controller.get_latest_version_in_graph()
print " Loaded %s version: %s" % ( self.name, str( self.workflow_version ) )
controller.change_selected_version(self.workflow_version)
self.workflow = controller.current_pipeline
self.loaded = True
except Exception, err:
debug.warning( "Error loading workflow %s: %s" % ( self.name, err ) )
self.loaded = False
else:
debug.warning("UV-CDAT: %s widget could not be loaded \
because it depends on packages that are not loaded:"%self.name)
debug.warning(" %s"%", ".join(self.unsatisfied_deps))
self.loaded = False
else:
debug.warning("UV-CDAT: file %s does not contain a 'global'\
section. Widget will not be loaded."%self.config_file)
self.loaded = False
sys.path.append(pth)
pkgnm = "samplepkg"
import core.application as vt_app
from core.packagemanager import get_package_manager
import core.modules.vistrails_module
print "imported vt"
print 'Initing'
vt_app.init({'dotVistrails': '.vistrails','output':''})
#vt_app.init({'output':''})
print "Voila"
pm = get_package_manager()
print "Voila"
import core.api
print "imported core"
vt=core.api.get_api()
basic = vt.get_package("edu.utah.sci.vistrails.basic")
for p,c in [
("edu.utah.sci.vistrails.spreadsheet","spreadsheet"),
("gov.llnl.uvcdat","uvcdat"),
("gov.llnl.uvcdat.cdms","uvcdat_cdms"),
## ("edu.utah.sci.vistrails.vtk","vtk"),
## ("edu.utah.sci.vistrails.numpyscipy","NumSciPy"),
def initialize(*args, **keywords):
import core.modules.module_registry
from packages.vtDV3D.CDMS_VariableReaders import CDMSVariableSource, CDMSTransientVariable, CDMS_HoffmullerReader, CDMS_VolumeReader, CDMS_ChartDataReader, CDMS_SliceReader, CDMS_VectorReader, CDMS_HoffmullerReaderConfigurationWidget, CDMS_VolumeReaderConfigurationWidget, CDMS_ChartDataConfigurationWidget, CDMS_SliceReaderConfigurationWidget, CDMS_VectorReaderConfigurationWidget
from packages.vtDV3D.VolumeSlicerModule import VolumeSlicer
from packages.vtDV3D.VolumeRenderModule import VolumeRenderer
from packages.vtDV3D.ParallelCoordinatesModule import ParallelCoordinateViewer
from packages.vtDV3D.WorldMapModule import WorldFrame
from packages.vtDV3D.VoxelizerModule import Voxelizer
from packages.uvcdat.init import Variable, VariableSource
# from DemoDataModule import DemoData, DemoDataConfigurationWidget
# from packages.vtDV3D.InteractiveConfiguration import LayerConfigurationWidget
from packages.vtDV3D.LevelSurfaceModule import LevelSurface
from packages.vtDV3D.CurtainPlotModule import CurtainPlot
from packages.uvcdat_cdms.init import CDMSVariable
from packages.vtDV3D.ResampleModule import Resample
from packages.vtDV3D.CDATUtilitiesModule import CDMS_CDATUtilities, CDATUtilitiesModuleConfigurationWidget
from packages.vtDV3D.GradientModule import Gradient
from packages.vtDV3D.WorkflowModule import WorkflowModule
from packages.vtDV3D.VectorCutPlaneModule import GlyphArrayCutPlane, StreamlineCutPlane
from packages.vtDV3D.VectorVolumeModule import VectorVolume
from packages.spreadsheet.basic_widgets import CellLocation
from core.modules.basic_modules import Integer, Float, String, Boolean, Variant, Color
import api
reg = core.modules.module_registry.get_module_registry()
vtkAlgorithmOutputType = typeMap('vtkAlgorithmOutput')
vtkImageDataType = typeMap('vtkImageData')
reg.add_module( AlgorithmOutputModule, abstract=True) # hide_descriptor=True )
reg.add_module( AlgorithmOutputModule3D, abstract=True) # hide_descriptor=True )
reg.add_module( AlgorithmOutputModule2D, abstract=True) # hide_descriptor=True )
reg.add_module( WorkflowModule, abstract=True) # hide_descriptor=True )
reg.add_module( CDMSDataset, abstract=True) # hide_descriptor=True )
reg.add_module( MapCell3D, configureWidgetType=MapCell3DConfigurationWidget, namespace='spreadsheet' )
reg.add_input_port( MapCell3D, "volume", AlgorithmOutputModule3D )
reg.add_input_port( MapCell3D, "cell_location", [ ( String, 'cell_coordinates' ) ], True )
reg.add_input_port( MapCell3D, "world_cut", Integer, optional=True )
reg.add_input_port( MapCell3D, "map_border_size", [ ( Float, 'border_in_degrees' ) ], optional=True )
reg.add_input_port( MapCell3D, "enable_basemap", [ ( Boolean, 'enable' ) ], optional=True )
reg.add_input_port( MapCell3D, "world_map", [ ( File, 'map_file' ), ( Integer, 'map_cut' ) ], optional=True )
reg.add_input_port( MapCell3D, "map_opacity", [ ( Float, 'value' ) ], optional=True )
reg.add_input_port( MapCell3D, "title", [ ( String, 'value' ) ], optional=True )
MapCell3D.registerConfigurableFunctions( reg )
reg.add_module( CloudCell3D, configureWidgetType=CloudCell3DConfigurationWidget, namespace='spreadsheet' )
reg.add_input_port( CloudCell3D, "pointcloud", AlgorithmOutputModule3D )
reg.add_input_port( CloudCell3D, "cell_location", [ ( String, 'cell_coordinates' ) ], True )
reg.add_input_port( CloudCell3D, "title", [ ( String, 'value' ) ], optional=True )
CloudCell3D.registerConfigurableFunctions( reg )
reg.add_module( ChartCell, configureWidgetType=ChartCellConfigurationWidget, namespace='spreadsheet' )
reg.add_input_port( ChartCell, "chart", AlgorithmOutputModule2D )
reg.add_input_port( ChartCell, "cell_location", [ ( String, 'cell_coordinates' ) ], True )
reg.add_input_port( ChartCell, "opacity", [ ( Float, 'value' ) ], optional=True )
reg.add_input_port( ChartCell, "title", [ ( String, 'value' ) ], optional=True )
ChartCell.registerConfigurableFunctions( reg )
# reg.add_module( WorldFrame )
# reg.add_input_port( WorldFrame, "world_cut", Integer, optional=True )
# reg.add_input_port( WorldFrame, "map_border_size", [ ( Float, 'border_in_degrees' ) ], optional=True )
# reg.add_input_port( WorldFrame, "world_map", [ ( File, 'map_file' ), ( Integer, 'map_cut' ) ], optional=True )
# reg.add_input_port( WorldFrame, "opacity", [ ( Float, 'value' ) ], optional=True )
# reg.add_input_port( WorldFrame, "zscale", [ ( Float, 'value' ) ], optional=True )
# reg.add_input_port( WorldFrame, "volume", AlgorithmOutputModule3D )
# reg.add_output_port( WorldFrame, "volume", AlgorithmOutputModule3D )
# WorldFrame.registerConfigurableFunctions( reg )
# reg.add_module( CDMS_VCDATInterfaceSpecs, configureWidgetType=VCDATInterfaceWidget, namespace='cdms', hide_descriptor=True )
# reg.add_input_port( CDMS_VCDATInterfaceSpecs, "zscale", [ ( Float, 'value' ) ], optional=True )
# reg.add_module( CDMS_VCDATInterface, namespace='cdms' )
# reg.add_input_port( CDMS_VCDATInterface, "vcdatInputSpecs", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "vcdatCellSpecs", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "FileName", [ ( String, 'FileName' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName2", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName3", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Axes", [ ( String, 'Axes' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row2", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column2", [ ( String, 'Value' ) ], True )
# reg.add_output_port( CDMS_VCDATInterface, "executionSpecs", [ CDMS_VCDATInterfaceSpecs ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation", [ ( String, 'cellLocation' ) ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation1", [ ( String, 'cellLocation' ) ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation2", [ ( String, 'cellLocation' ) ] )
reg.add_module( CDMSTransientVariable, namespace='cdms' )
reg.add_input_port( CDMSTransientVariable, "inputId", String )
reg.add_module( CDMS_FileReader, configureWidgetType=CDMSDatasetConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_FileReader, "executionSpecs", [ ( String, 'serializedConfiguration' ), ], True )
reg.add_input_port( CDMS_FileReader, "datasets", [ ( String, 'serializedDatasetMap' ) ], True )
reg.add_input_port( CDMS_FileReader, "datasetId", [ ( String, 'currentDatasetId' ), ( Integer, 'version' ) ], True )
reg.add_input_port( CDMS_FileReader, "timeRange", [ ( Integer, 'startTimeIndex' ), ( Integer, 'endTimeIndex' ), ( Float, 'relativeStartTime' ), ( Float, 'relativeTimeStep' )], True )
reg.add_input_port( CDMS_FileReader, "roi", [ ( Float, 'lon0' ), ( Float, 'lat0' ), ( Float, 'lon1' ), ( Float, 'lat1' ) ], True )
reg.add_input_port( CDMS_FileReader, "grid", [ ( String, 'selectedGrid' ) ], optional=True )
reg.add_input_port( CDMS_FileReader, "decimation", [ ( Integer, 'clientDecimation' ), ( Integer, 'serverDecimation' ) ], optional=True )
reg.add_input_port( CDMS_FileReader, "zscale", [ ( Float, 'value' ) ], optional=True )
reg.add_output_port( CDMS_FileReader, "dataset", CDMSDataset )
CDMS_FileReader.registerConfigurableFunctions( reg )
reg.add_module( CDMSVariableSource, namespace='cdms' )
reg.add_input_port( CDMSVariableSource, "inputId", String )
reg.add_output_port( CDMSVariableSource, "self", VariableSource )
reg.add_output_port( CDMSVariableSource, "axes", String )
reg.add_module( CDMS_HoffmullerReader, configureWidgetType=CDMS_HoffmullerReaderConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_HoffmullerReader, "dataset", CDMSDataset )
reg.add_input_port( CDMS_HoffmullerReader, "variable", Variable )
reg.add_input_port( CDMS_HoffmullerReader, "portData", [ ( String, 'serializedPortData' ), ( Integer, 'version' ) ], True )
reg.add_output_port( CDMS_HoffmullerReader, "volume", AlgorithmOutputModule3D )
CDMS_HoffmullerReader.registerConfigurableFunctions( reg )
reg.add_module( CDMS_VolumeReader, configureWidgetType=CDMS_VolumeReaderConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_VolumeReader, "dataset", CDMSDataset )
reg.add_input_port( CDMS_VolumeReader, "variable", Variable )
reg.add_input_port( CDMS_VolumeReader, "portData", [ ( String, 'serializedPortData' ), ( Integer, 'version' ) ], True )
reg.add_output_port( CDMS_VolumeReader, "volume", AlgorithmOutputModule3D )
CDMS_VolumeReader.registerConfigurableFunctions( reg )
reg.add_module( CDMS_ChartDataReader, configureWidgetType=CDMS_ChartDataConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_ChartDataReader, "dataset", CDMSDataset )
reg.add_input_port( CDMS_ChartDataReader, "portData", [ ( String, 'serializedPortData' ), ( Integer, 'version' ) ], True )
reg.add_output_port( CDMS_ChartDataReader, "volume", AlgorithmOutputModule3D )
CDMS_ChartDataReader.registerConfigurableFunctions( reg )
reg.add_module( CDMS_SliceReader, configureWidgetType=CDMS_SliceReaderConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_SliceReader, "dataset", CDMSDataset )
reg.add_input_port( CDMS_SliceReader, "portData", [ ( String, 'serializedPortData' ), ( Integer, 'version' ) ], True )
reg.add_output_port( CDMS_SliceReader, "slice", AlgorithmOutputModule )
CDMS_SliceReader.registerConfigurableFunctions( reg )
reg.add_module( CDMS_VectorReader, configureWidgetType=CDMS_VectorReaderConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_VectorReader, "dataset", CDMSDataset )
reg.add_input_port( CDMS_VectorReader, "variable", Variable )
reg.add_input_port( CDMS_VectorReader, "variable2", Variable )
reg.add_input_port( CDMS_VectorReader, "variable3", Variable )
reg.add_input_port( CDMS_VectorReader, "variable4", Variable )
reg.add_input_port( CDMS_VectorReader, "portData", [ ( String, 'serializedPortData' ), ( Integer, 'version' ) ], True )
reg.add_output_port( CDMS_VectorReader, "volume", AlgorithmOutputModule3D )
CDMS_SliceReader.registerConfigurableFunctions( reg )
reg.add_module( CDMS_CDATUtilities, configureWidgetType=CDATUtilitiesModuleConfigurationWidget, namespace='cdms' )
reg.add_input_port( CDMS_CDATUtilities, "dataset", CDMSDataset )
reg.add_input_port( CDMS_CDATUtilities, "task", [ ( String, 'taskData' ) ], True ) # [ ( String, 'taskName' ), ( String, 'inputVars' ), ( String, 'outputVars' ) ], True )
reg.add_output_port( CDMS_CDATUtilities, "dataset", CDMSDataset )
reg.add_module( VolumeSlicer, namespace='vtk' )
reg.add_output_port( VolumeSlicer, "slice", AlgorithmOutputModule )
reg.add_input_port( VolumeSlicer, "contours", AlgorithmOutputModule3D )
reg.add_input_port( VolumeSlicer, "volume", AlgorithmOutputModule3D )
reg.add_output_port( VolumeSlicer, "volume", AlgorithmOutputModule3D )
VolumeSlicer.registerConfigurableFunctions( reg )
reg.add_module( Gradient, namespace='vtk|experimental' )
reg.add_input_port( Gradient, "computeVorticity", Integer )
reg.add_input_port( Gradient, "volume", AlgorithmOutputModule3D )
reg.add_output_port( Gradient, "volume", AlgorithmOutputModule3D )
reg.add_module( GlyphArrayCutPlane, namespace='vtk' )
reg.add_input_port( GlyphArrayCutPlane, "colors", AlgorithmOutputModule3D )
reg.add_output_port( GlyphArrayCutPlane, "slice", AlgorithmOutputModule )
reg.add_input_port( GlyphArrayCutPlane, "volume", AlgorithmOutputModule3D )
reg.add_output_port( GlyphArrayCutPlane, "volume", AlgorithmOutputModule3D )
GlyphArrayCutPlane.registerConfigurableFunctions( reg )
reg.add_module( StreamlineCutPlane, namespace='vtk' )
reg.add_input_port( StreamlineCutPlane, "colors", AlgorithmOutputModule3D )
reg.add_input_port( StreamlineCutPlane, "volume", AlgorithmOutputModule3D )
reg.add_output_port( StreamlineCutPlane, "volume", AlgorithmOutputModule3D )
StreamlineCutPlane.registerConfigurableFunctions( reg )
reg.add_module( VectorVolume, namespace='vtk' )
reg.add_input_port( VectorVolume, "colors", AlgorithmOutputModule3D )
reg.add_input_port( VectorVolume, "volume", AlgorithmOutputModule3D )
reg.add_output_port( VectorVolume, "volume", AlgorithmOutputModule3D )
VectorVolume.registerConfigurableFunctions( reg )
reg.add_module( Voxelizer, namespace='vtk' )
reg.add_input_port( Voxelizer, "volume", AlgorithmOutputModule3D )
reg.add_output_port( Voxelizer, "pointcloud", AlgorithmOutputModule3D )
Voxelizer.registerConfigurableFunctions( reg )
# reg.add_module( Resample )
# reg.add_input_port( Resample, "position", [ ( Float, 'x' ), ( Float, 'y' ), ( Float, 'z' ) ], True )
# reg.add_output_port( Resample, "position", [ ( Float, 'x' ), ( Float, 'y' ), ( Float, 'z' ) ], True )
# reg.add_input_port( Resample, "volume", AlgorithmOutputModule3D )
# reg.add_output_port( Resample, "volume", AlgorithmOutputModule3D )
# Resample.registerConfigurableFunctions( reg )
reg.add_module( CurtainPlot, namespace='vtk' )
reg.add_input_port( CurtainPlot, "volume", AlgorithmOutputModule3D )
reg.add_input_port( CurtainPlot, "path", ( File, 'path_file' ) )
reg.add_output_port( CurtainPlot, "volume", AlgorithmOutputModule3D )
CurtainPlot.registerConfigurableFunctions( reg )
# reg.add_module( DemoData, configureWidgetType=DemoDataConfigurationWidget )
# reg.add_input_port( DemoData, "dataset", [ ( String, 'name' ), ] )
# reg.add_input_port( DemoData, "maxNTimeSteps", [ ( Integer, 'nts' ) ] )
# reg.add_output_port( DemoData, "volume", AlgorithmOutputModule3D )
# DemoData.registerConfigurableFunctions( reg )
reg.add_module( VolumeRenderer, namespace='vtk' ) # , configureWidgetType=LayerConfigurationWidget )
reg.add_input_port( VolumeRenderer, "volume", AlgorithmOutputModule3D )
# reg.add_input_port( VolumeRenderer, "layer", [ ( String, 'layer' ), ] )
reg.add_output_port( VolumeRenderer, "volume", AlgorithmOutputModule3D )
VolumeRenderer.registerConfigurableFunctions( reg )
reg.add_module( ParallelCoordinateViewer, namespace='vtk' ) # , configureWidgetType=LayerConfigurationWidget )
reg.add_input_port( ParallelCoordinateViewer, "volume", AlgorithmOutputModule3D )
reg.add_input_port( ParallelCoordinateViewer, "slice", AlgorithmOutputModule )
# reg.add_input_port( VolumeRenderer, "layer", [ ( String, 'layer' ), ] )
reg.add_output_port( ParallelCoordinateViewer, "chart", AlgorithmOutputModule2D )
ParallelCoordinateViewer.registerConfigurableFunctions( reg )
reg.add_module( LevelSurface, namespace='vtk' )
reg.add_input_port( LevelSurface, "texture", AlgorithmOutputModule3D )
reg.add_input_port( LevelSurface, "volume", AlgorithmOutputModule3D )
reg.add_output_port( LevelSurface, "volume", AlgorithmOutputModule3D )
# reg.add_input_port( LevelSurface, "layer", [ ( String, 'activeLayerName' ) ] )
LevelSurface.registerConfigurableFunctions( reg )
from core.packagemanager import get_package_manager
if get_package_manager().has_package('edu.utah.sci.vistrails.matplotlib'):
mpl_dict = {'linux-ubuntu': 'python-matplotlib', 'linux-fedora': 'python-matplotlib'}
matplotlib = py_import('matplotlib', mpl_dict)
pylab = py_import('pylab', mpl_dict)
from SlicePlotModule import SlicePlotCell, SlicePlotConfigurationWidget
reg.add_module( SlicePlotCell, namespace='spreadsheet', configureWidgetType=SlicePlotConfigurationWidget )
reg.add_input_port( SlicePlotCell, "Location", CellLocation)
reg.add_input_port( SlicePlotCell, "slice", AlgorithmOutputModule )
reg.add_input_port( SlicePlotCell, "plotType", [ ( String, 'fillType' ), ( String, 'contourType' ), ( Integer, 'numContours' ), ( Integer, 'version' ) ], True )
reg.add_output_port( SlicePlotCell, 'File', File)
SlicePlotCell.registerConfigurableFunctions( reg )
else:
print "Matplotlib dependent features will be disabled."
def clicked_on_available_list(self, item):
codepath = str(item.text())
pm = get_package_manager()
self._current_package = pm.look_at_available_package(codepath)
self.set_buttons_to_available_package()
self.set_package_information()
def initialize(*args, **keywords):
import core.modules.module_registry
from packages.vtDV3D.CDMS_VariableReaders import CDMSVariableSource, CDMS_PointReader, CDMSTransientVariable, CDMS_HoffmullerReader, CDMS_VolumeReader, CDMS_ChartDataReader, CDMS_SliceReader, CDMS_VectorReader, CDMS_HoffmullerReaderConfigurationWidget, CDMS_PointReaderConfigurationWidget, CDMS_VolumeReaderConfigurationWidget, CDMS_ChartDataConfigurationWidget, CDMS_SliceReaderConfigurationWidget, CDMS_VectorReaderConfigurationWidget
from packages.vtDV3D.VolumeSlicerModule import VolumeSlicer
from packages.vtDV3D.MultiVolumeSlicerModule import MultiVolumeSlicer
from packages.vtDV3D.VolumeRenderModule import VolumeRenderer
from packages.vtDV3D.ParallelCoordinatesModule import ParallelCoordinateViewer
from packages.vtDV3D.WorldMapModule import WorldFrame
from packages.vtDV3D.VoxelizerModule import Voxelizer
from packages.uvcdat.init import Variable, VariableSource
# from DemoDataModule import DemoData, DemoDataConfigurationWidget
# from packages.vtDV3D.InteractiveConfiguration import LayerConfigurationWidget
from packages.vtDV3D.LevelSurfaceModule import LevelSurface
from packages.vtDV3D.CurtainPlotModule import CurtainPlot
from packages.uvcdat_cdms.init import CDMSVariable
from packages.vtDV3D.ResampleModule import Resample
from packages.vtDV3D.CDATUtilitiesModule import CDMS_CDATUtilities, CDATUtilitiesModuleConfigurationWidget
from packages.vtDV3D.GradientModule import Gradient
from packages.vtDV3D.WorkflowModule import WorkflowModule
from packages.vtDV3D.VectorCutPlaneModule import GlyphArrayCutPlane, StreamlineCutPlane
from packages.vtDV3D.VectorVolumeModule import VectorVolume
# from packages.vtDV3D.CPCViewer import CPCViewer, CPCViewerConfigurationWidget
from packages.spreadsheet.basic_widgets import CellLocation
from core.modules.basic_modules import Integer, Float, String, Boolean, Variant, Color
# from packages.CPCViewer.PointCloudViewer import CPCPlot, kill_all_zombies
from core import command_line
import api
get = command_line.CommandLineParser().get_option
if get('kill_all_zombies') != None: kill_all_zombies()
reg = core.modules.module_registry.get_module_registry()
vtkAlgorithmOutputType = typeMap('vtkAlgorithmOutput')
vtkImageDataType = typeMap('vtkImageData')
reg.add_module(AlgorithmOutputModule,
abstract=True) # hide_descriptor=True )
reg.add_module(AlgorithmOutputModule3D,
abstract=True) # hide_descriptor=True )
reg.add_module(AlgorithmOutputModule2D,
abstract=True) # hide_descriptor=True )
reg.add_module(WorkflowModule, abstract=True) # hide_descriptor=True )
reg.add_module(CDMSDataset, abstract=True) # hide_descriptor=True )
reg.add_module(MapCell3D,
configureWidgetType=MapCell3DConfigurationWidget,
namespace='spreadsheet')
reg.add_input_port(MapCell3D, "volume", AlgorithmOutputModule3D)
reg.add_input_port(MapCell3D, "cell_location",
[(String, 'cell_coordinates')], True)
reg.add_input_port(MapCell3D, "world_cut", Integer, optional=True)
reg.add_input_port(MapCell3D,
"map_border_size", [(Float, 'border_in_degrees')],
optional=True)
reg.add_input_port(MapCell3D,
"enable_basemap", [(Boolean, 'enable')],
optional=True)
reg.add_input_port(MapCell3D,
"world_map", [(File, 'map_file'), (Integer, 'map_cut')],
optional=True)
reg.add_input_port(MapCell3D,
"map_opacity", [(Float, 'value')],
optional=True)
reg.add_input_port(MapCell3D, "title", [(String, 'value')], optional=True)
MapCell3D.registerConfigurableFunctions(reg)
reg.add_module(CloudCell3D,
configureWidgetType=CloudCell3DConfigurationWidget,
namespace='spreadsheet')
reg.add_input_port(CloudCell3D, "pointcloud", AlgorithmOutputModule3D)
reg.add_input_port(CloudCell3D, "cell_location",
[(String, 'cell_coordinates')], True)
reg.add_input_port(CloudCell3D,
"title", [(String, 'value')],
optional=True)
CloudCell3D.registerConfigurableFunctions(reg)
reg.add_module(ChartCell,
configureWidgetType=ChartCellConfigurationWidget,
namespace='spreadsheet')
reg.add_input_port(ChartCell, "chart", AlgorithmOutputModule2D)
reg.add_input_port(ChartCell, "cell_location",
[(String, 'cell_coordinates')], True)
reg.add_input_port(ChartCell, "opacity", [(Float, 'value')], optional=True)
reg.add_input_port(ChartCell, "title", [(String, 'value')], optional=True)
ChartCell.registerConfigurableFunctions(reg)
# reg.add_module( WorldFrame )
# reg.add_input_port( WorldFrame, "world_cut", Integer, optional=True )
# reg.add_input_port( WorldFrame, "map_border_size", [ ( Float, 'border_in_degrees' ) ], optional=True )
# reg.add_input_port( WorldFrame, "world_map", [ ( File, 'map_file' ), ( Integer, 'map_cut' ) ], optional=True )
# reg.add_input_port( WorldFrame, "opacity", [ ( Float, 'value' ) ], optional=True )
# reg.add_input_port( WorldFrame, "zscale", [ ( Float, 'value' ) ], optional=True )
# reg.add_input_port( WorldFrame, "volume", AlgorithmOutputModule3D )
# reg.add_output_port( WorldFrame, "volume", AlgorithmOutputModule3D )
# WorldFrame.registerConfigurableFunctions( reg )
# reg.add_module( CDMS_VCDATInterfaceSpecs, configureWidgetType=VCDATInterfaceWidget, namespace='cdms', hide_descriptor=True )
# reg.add_input_port( CDMS_VCDATInterfaceSpecs, "zscale", [ ( Float, 'value' ) ], optional=True )
# reg.add_module( CDMS_VCDATInterface, namespace='cdms' )
# reg.add_input_port( CDMS_VCDATInterface, "vcdatInputSpecs", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "vcdatCellSpecs", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "FileName", [ ( String, 'FileName' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName2", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "VariableName3", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Axes", [ ( String, 'Axes' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column1", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Row2", [ ( String, 'Value' ) ], True )
# reg.add_input_port( CDMS_VCDATInterface, "Column2", [ ( String, 'Value' ) ], True )
# reg.add_output_port( CDMS_VCDATInterface, "executionSpecs", [ CDMS_VCDATInterfaceSpecs ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation", [ ( String, 'cellLocation' ) ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation1", [ ( String, 'cellLocation' ) ] )
# reg.add_output_port( CDMS_VCDATInterface, "cellLocation2", [ ( String, 'cellLocation' ) ] )
reg.add_module(CDMSTransientVariable, namespace='cdms')
reg.add_input_port(CDMSTransientVariable, "inputId", String)
reg.add_module(CDMS_FileReader,
configureWidgetType=CDMSDatasetConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_FileReader, "executionSpecs", [
(String, 'serializedConfiguration'),
], True)
reg.add_input_port(CDMS_FileReader, "datasets",
[(String, 'serializedDatasetMap')], True)
reg.add_input_port(CDMS_FileReader,
"datasetId", [(String, 'currentDatasetId'),
(Integer, 'version')], True)
reg.add_input_port(CDMS_FileReader, "timeRange",
[(Integer, 'startTimeIndex'), (Integer, 'endTimeIndex'),
(Float, 'relativeStartTime'),
(Float, 'relativeTimeStep')], True)
reg.add_input_port(CDMS_FileReader, "roi",
[(Float, 'lon0'), (Float, 'lat0'), (Float, 'lon1'),
(Float, 'lat1')], True)
reg.add_input_port(CDMS_FileReader,
"grid", [(String, 'selectedGrid')],
optional=True)
reg.add_input_port(CDMS_FileReader,
"decimation", [(Integer, 'clientDecimation'),
(Integer, 'serverDecimation')],
optional=True)
reg.add_input_port(CDMS_FileReader,
"zscale", [(Float, 'value')],
optional=True)
reg.add_output_port(CDMS_FileReader, "dataset", CDMSDataset)
CDMS_FileReader.registerConfigurableFunctions(reg)
reg.add_module(CDMSVariableSource, namespace='cdms')
reg.add_input_port(CDMSVariableSource, "inputId", String)
reg.add_output_port(CDMSVariableSource, "self", VariableSource)
reg.add_output_port(CDMSVariableSource, "axes", String)
reg.add_module(
CDMS_HoffmullerReader,
configureWidgetType=CDMS_HoffmullerReaderConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_HoffmullerReader, "dataset", CDMSDataset)
reg.add_input_port(CDMS_HoffmullerReader, "variable", Variable)
reg.add_input_port(CDMS_HoffmullerReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_HoffmullerReader, "volume",
AlgorithmOutputModule3D)
CDMS_HoffmullerReader.registerConfigurableFunctions(reg)
# reg.add_module( CPCViewer, configureWidgetType=CPCViewerConfigurationWidget, namespace='vtk' )
# reg.add_input_port( CPCViewer, "pointCloud", AlgorithmOutputModule3D )
# reg.add_input_port( CPCViewer, "cpcConfigData", [ ( String, 'serializedConfigData' ), ( Integer, 'version' ) ], True )
# reg.add_output_port( CPCViewer, "pointCloud", AlgorithmOutputModule3D )
# CPCViewer.registerConfigurableFunctions( reg )
reg.add_module(CDMS_VolumeReader,
configureWidgetType=CDMS_VolumeReaderConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_VolumeReader, "dataset", CDMSDataset)
reg.add_input_port(CDMS_VolumeReader, "variable", Variable)
reg.add_input_port(CDMS_VolumeReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_VolumeReader, "volume", AlgorithmOutputModule3D)
CDMS_VolumeReader.registerConfigurableFunctions(reg)
reg.add_module(CDMS_PointReader,
configureWidgetType=CDMS_PointReaderConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_PointReader, "variable", Variable)
reg.add_input_port(CDMS_PointReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_PointReader, "pointCloud",
AlgorithmOutputModule3D)
CDMS_PointReader.registerConfigurableFunctions(reg)
reg.add_module(CDMS_ChartDataReader,
configureWidgetType=CDMS_ChartDataConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_ChartDataReader, "dataset", CDMSDataset)
reg.add_input_port(CDMS_ChartDataReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_ChartDataReader, "volume",
AlgorithmOutputModule3D)
CDMS_ChartDataReader.registerConfigurableFunctions(reg)
reg.add_module(CDMS_SliceReader,
configureWidgetType=CDMS_SliceReaderConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_SliceReader, "dataset", CDMSDataset)
reg.add_input_port(CDMS_SliceReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_SliceReader, "slice", AlgorithmOutputModule)
CDMS_SliceReader.registerConfigurableFunctions(reg)
reg.add_module(CDMS_VectorReader,
configureWidgetType=CDMS_VectorReaderConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_VectorReader, "dataset", CDMSDataset)
reg.add_input_port(CDMS_VectorReader, "variable", Variable)
reg.add_input_port(CDMS_VectorReader, "variable2", Variable)
reg.add_input_port(CDMS_VectorReader, "variable3", Variable)
reg.add_input_port(CDMS_VectorReader, "variable4", Variable)
reg.add_input_port(CDMS_VectorReader,
"portData", [(String, 'serializedPortData'),
(Integer, 'version')], True)
reg.add_output_port(CDMS_VectorReader, "volume", AlgorithmOutputModule3D)
CDMS_SliceReader.registerConfigurableFunctions(reg)
reg.add_module(CDMS_CDATUtilities,
configureWidgetType=CDATUtilitiesModuleConfigurationWidget,
namespace='cdms')
reg.add_input_port(CDMS_CDATUtilities, "dataset", CDMSDataset)
reg.add_input_port(
CDMS_CDATUtilities, "task", [(String, 'taskData')], True
) # [ ( String, 'taskName' ), ( String, 'inputVars' ), ( String, 'outputVars' ) ], True )
reg.add_output_port(CDMS_CDATUtilities, "dataset", CDMSDataset)
reg.add_module(VolumeSlicer, namespace='vtk')
reg.add_output_port(VolumeSlicer, "slice", AlgorithmOutputModule)
reg.add_input_port(VolumeSlicer, "contours", AlgorithmOutputModule3D)
reg.add_input_port(VolumeSlicer, "volume", AlgorithmOutputModule3D)
reg.add_output_port(VolumeSlicer, "volume", AlgorithmOutputModule3D)
VolumeSlicer.registerConfigurableFunctions(reg)
reg.add_module(MultiVolumeSlicer, namespace='vtk')
reg.add_output_port(MultiVolumeSlicer, "slice", AlgorithmOutputModule)
reg.add_input_port(MultiVolumeSlicer, "contours", AlgorithmOutputModule3D)
reg.add_input_port(MultiVolumeSlicer, "volume", AlgorithmOutputModule3D)
reg.add_output_port(MultiVolumeSlicer, "volume", AlgorithmOutputModule3D)
MultiVolumeSlicer.registerConfigurableFunctions(reg)
reg.add_module(Gradient, namespace='vtk|experimental')
reg.add_input_port(Gradient, "computeVorticity", Integer)
reg.add_input_port(Gradient, "volume", AlgorithmOutputModule3D)
reg.add_output_port(Gradient, "volume", AlgorithmOutputModule3D)
reg.add_module(GlyphArrayCutPlane, namespace='vtk')
reg.add_input_port(GlyphArrayCutPlane, "colors", AlgorithmOutputModule3D)
reg.add_output_port(GlyphArrayCutPlane, "slice", AlgorithmOutputModule)
reg.add_input_port(GlyphArrayCutPlane, "volume", AlgorithmOutputModule3D)
reg.add_output_port(GlyphArrayCutPlane, "volume", AlgorithmOutputModule3D)
GlyphArrayCutPlane.registerConfigurableFunctions(reg)
reg.add_module(StreamlineCutPlane, namespace='vtk')
reg.add_input_port(StreamlineCutPlane, "colors", AlgorithmOutputModule3D)
reg.add_input_port(StreamlineCutPlane, "volume", AlgorithmOutputModule3D)
reg.add_output_port(StreamlineCutPlane, "volume", AlgorithmOutputModule3D)
StreamlineCutPlane.registerConfigurableFunctions(reg)
reg.add_module(VectorVolume, namespace='vtk')
reg.add_input_port(VectorVolume, "colors", AlgorithmOutputModule3D)
reg.add_input_port(VectorVolume, "volume", AlgorithmOutputModule3D)
reg.add_output_port(VectorVolume, "volume", AlgorithmOutputModule3D)
VectorVolume.registerConfigurableFunctions(reg)
reg.add_module(Voxelizer, namespace='vtk')
reg.add_input_port(Voxelizer, "volume", AlgorithmOutputModule3D)
reg.add_output_port(Voxelizer, "pointcloud", AlgorithmOutputModule3D)
Voxelizer.registerConfigurableFunctions(reg)
# reg.add_module( Resample )
# reg.add_input_port( Resample, "position", [ ( Float, 'x' ), ( Float, 'y' ), ( Float, 'z' ) ], True )
# reg.add_output_port( Resample, "position", [ ( Float, 'x' ), ( Float, 'y' ), ( Float, 'z' ) ], True )
# reg.add_input_port( Resample, "volume", AlgorithmOutputModule3D )
# reg.add_output_port( Resample, "volume", AlgorithmOutputModule3D )
# Resample.registerConfigurableFunctions( reg )
reg.add_module(CurtainPlot, namespace='vtk')
reg.add_input_port(CurtainPlot, "volume", AlgorithmOutputModule3D)
reg.add_input_port(CurtainPlot, "path", (File, 'path_file'))
reg.add_output_port(CurtainPlot, "volume", AlgorithmOutputModule3D)
CurtainPlot.registerConfigurableFunctions(reg)
# reg.add_module( DemoData, configureWidgetType=DemoDataConfigurationWidget )
# reg.add_input_port( DemoData, "dataset", [ ( String, 'name' ), ] )
# reg.add_input_port( DemoData, "maxNTimeSteps", [ ( Integer, 'nts' ) ] )
# reg.add_output_port( DemoData, "volume", AlgorithmOutputModule3D )
# DemoData.registerConfigurableFunctions( reg )
reg.add_module(
VolumeRenderer,
namespace='vtk') # , configureWidgetType=LayerConfigurationWidget )
reg.add_input_port(VolumeRenderer, "volume", AlgorithmOutputModule3D)
# reg.add_input_port( VolumeRenderer, "layer", [ ( String, 'layer' ), ] )
reg.add_output_port(VolumeRenderer, "volume", AlgorithmOutputModule3D)
VolumeRenderer.registerConfigurableFunctions(reg)
reg.add_module(
ParallelCoordinateViewer,
namespace='vtk') # , configureWidgetType=LayerConfigurationWidget )
reg.add_input_port(ParallelCoordinateViewer, "volume",
AlgorithmOutputModule3D)
reg.add_input_port(ParallelCoordinateViewer, "slice",
AlgorithmOutputModule)
# reg.add_input_port( VolumeRenderer, "layer", [ ( String, 'layer' ), ] )
reg.add_output_port(ParallelCoordinateViewer, "chart",
AlgorithmOutputModule2D)
ParallelCoordinateViewer.registerConfigurableFunctions(reg)
reg.add_module(LevelSurface, namespace='vtk')
reg.add_input_port(LevelSurface, "texture", AlgorithmOutputModule3D)
reg.add_input_port(LevelSurface, "volume", AlgorithmOutputModule3D)
reg.add_output_port(LevelSurface, "volume", AlgorithmOutputModule3D)
# reg.add_input_port( LevelSurface, "layer", [ ( String, 'activeLayerName' ) ] )
LevelSurface.registerConfigurableFunctions(reg)
from core.packagemanager import get_package_manager
if get_package_manager().has_package('edu.utah.sci.vistrails.matplotlib'):
mpl_dict = {
'linux-ubuntu': 'python-matplotlib',
'linux-fedora': 'python-matplotlib'
}
matplotlib = py_import('matplotlib', mpl_dict)
pylab = py_import('pylab', mpl_dict)
from SlicePlotModule import SlicePlotCell, SlicePlotConfigurationWidget
reg.add_module(SlicePlotCell,
namespace='spreadsheet',
configureWidgetType=SlicePlotConfigurationWidget)
reg.add_input_port(SlicePlotCell, "Location", CellLocation)
reg.add_input_port(SlicePlotCell, "slice", AlgorithmOutputModule)
reg.add_input_port(SlicePlotCell,
"plotType", [(String, 'fillType'),
(String, 'contourType'),
(Integer, 'numContours'),
(Integer, 'version')], True)
reg.add_output_port(SlicePlotCell, 'File', File)
SlicePlotCell.registerConfigurableFunctions(reg)
else:
print "Matplotlib dependent features will be disabled."
p.load()
except Exception, e:
msg = 'ERROR: Could not load package.'
self._name_label.setText(msg)
self._version_label.setText(msg)
self._identifier_label.setText(msg)
self._dependencies_label.setText(msg)
self._description_label.setText(msg)
self._reverse_dependencies_label.setText(msg)
debug.critical('Cannot load package', str(e))
else:
self._name_label.setText(p.name)
deps = ', '.join(str(d) for d in p.dependencies()) or \
'No package dependencies.'
try:
pm = get_package_manager()
reverse_deps = \
(', '.join(pm.reverse_dependencies(p.identifier)) or
'No reverse dependencies.')
except KeyError:
reverse_deps = ("Reverse dependencies only " +
"available for enabled packages.")
self._identifier_label.setText(p.identifier)
self._version_label.setText(p.version)
self._dependencies_label.setText(deps)
self._description_label.setText(p.description)
self._reverse_dependencies_label.setText(reverse_deps)
##########################################################################
# Signal handling
