def createNewWorkflow(self):
""" createnewWorkflow(filename: str)
createNewWorkflow is called when the user selects a new file. It makes
a new workflow and appends it to the workflow list.
"""
if self.workflows == []:
api.get_current_controller().change_selected_version(0)
self.currentWorkflow = Workflow()
self.workflows.append(self.currentWorkflow)
def createNewWorkflow(self):
""" createnewWorkflow(filename: str)
createNewWorkflow is called when the user selects a new file. It makes
a new workflow and appends it to the workflow list.
"""
if self.workflows == []:
api.get_current_controller().change_selected_version(0)
self.currentWorkflow = Workflow()
self.workflows.append(self.currentWorkflow)
def updateModuleOps(self, name, args):
""" updateModule(name: str, args: list)
updateModule updates the vistrail module given the module name and a
list of tuples where each tuple = (input port name, value)
"""
if name not in list(self.modules):
return
module = self.modules[name]
for portName, value in args:
api.get_current_controller().update_function(module, portName,
[value])
def updateModuleOps(self, name, args):
""" updateModule(name: str, args: list)
updateModule updates the vistrail module given the module name and a
list of tuples where each tuple = (input port name, value)
"""
if name not in list(self.modules):
return
module = self.modules[name]
for portName, value in args:
api.get_current_controller().update_function(
module, portName, [value])
def updateModule(self, name, portName, value):
""" updateModule(name: str, portName: str, value: *)
updateModule updates the vistrail module given the module name, input
port name, and value
"""
if name not in list(self.modules):
return
# Set the filename associated w/ this workflow
if name == open_name:
self.filename = value
module = self.modules[name]
api.get_current_controller().update_function(module, portName, [value])
def updateModule(self, name, portName, value):
""" updateModule(name: str, portName: str, value: *)
updateModule updates the vistrail module given the module name, input
port name, and value
"""
if name not in list(self.modules):
return
# Set the filename associated w/ this workflow
if name == open_name:
self.filename = value
module = self.modules[name]
api.get_current_controller().update_function(module, portName, [value])
def getRedoVersion(self):
"""looks at all child versions, and returns that which has the most
recent uvcdat-last-visit annotation, if any """
try:
vistrail = api.get_current_controller().vistrail
except api.NoVistrail:
return None
graph = vistrail.tree.getVersionTree()
maxes = [datetime.min, None] #time, version
def _findMostRecent(version):
children = graph.edges_from(version)
for (child, _) in children:
annotation = vistrail.get_action_annotation(
child, 'uvcdat-last-visit')
if annotation is not None:
time = datetime.strptime(annotation.value,
ControllerCell.DATE_FORMAT)
if time > maxes[0]:
maxes[0] = time
maxes[1] = child
else:
_findMostRecent(child)
_findMostRecent(self.current_parent_version)
# if maxes[1]:
# print "Found redo version: %d" % maxes[1]
return maxes[1]
def printPersistentModuleMap(label, controller=None):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
object_map = vistrails_interpreter.find_persistent_entities(
controller.current_pipeline)[0]
def getWorkflowObjectMap(controller=None):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
return vistrails_interpreter.find_persistent_entities(controller.current_pipeline)[0]
def getWorkflowObjectMap(controller=None):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
return vistrails_interpreter.find_persistent_entities(
controller.current_pipeline)[0]
def getFunctionList(mid, controller=None):
if controller == None:
import api
controller = api.get_current_controller()
module = controller.current_pipeline.modules[mid]
return module.functions if module.functions else []
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 activateFromCell(self, canvas):
self.activeCanvas = canvas
self.setColorsFromCanvas()
self.controller = api.get_current_controller()
self.version = self.controller.current_version
self.pipeline = self.controller.vistrail.getPipeline(self.version)
self.plots = CDMSPipelineHelper.find_plot_modules(self.pipeline)
#set up plot combo box
# self.plotCb.clear()
# for i in range(len(self.plots)):
# found = False
# for func in self.plots[i].functions:
# if func.name == 'graphicsMethodName':
# self.plotCb.addItem(self.plots[i].module_descriptor.module.plot_type \
# + '_' + func.params[0].strValue, userData=i)
# found = True
# if not found:
# self.plotCb.addItem(self.plots[i].module_descriptor.module.plot_type, userData=i)
# self.plotCb.setCurrentIndex(0)
self.mapNameChanged = False
self.cellsDirty = False
self.show()
def __init__( self, mid, **args ):
import api
PersistentVisualizationModule.__init__( self, mid, **args )
self.primaryInputPorts = [ 'volume', 'contours' ]
self.addConfigurableLevelingFunction( 'colorScale', 'C', label='Colormap Scale', units='data', setLevel=self.scaleColormap, getLevel=self.getDataRangeBounds, layerDependent=True, adjustRangeInput=0 )
self.addConfigurableLevelingFunction( 'opacity', 'O', label='Slice Plane Opacity', rangeBounds=[ 0.0, 1.0 ], setLevel=self.setOpacity, activeBound='min', getLevel=self.getOpacity, isDataValue=False, layerDependent=True, bound = False )
self.addConfigurableLevelingFunction( 'zScale', 'z', label='Vertical Scale', setLevel=self.setZScale, activeBound='max', getLevel=self.getScaleBounds, windowing=False, sensitivity=(10.0,10.0), initRange=[ 2.0, 2.0, 1 ] )
self.addConfigurableLevelingFunction( 'contourDensity', 'g', label='Contour Density', activeBound='max', setLevel=self.setContourDensity, getLevel=self.getContourDensity, layerDependent=True, windowing=False, rangeBounds=[ 3.0, 30.0, 1 ], bound=False, isValid=self.hasContours )
self.addConfigurableLevelingFunction( 'contourColorScale', 'S', label='Contour Colormap Scale', units='data', setLevel=self.scaleContourColormap, getLevel=lambda:self.getDataRangeBounds(1), layerDependent=True, adjustRangeInput=1, isValid=self.hasContours )
self.addConfigurableMethod('Show Outline Map', self.toogleOutlineMap, 'm' )
self.addUVCDATConfigGuiFunction( 'contourColormap', ColormapConfigurationDialog, 'K', label='Choose Contour Colormap', setValue=lambda data: self.setColormap(data,1) , getValue=lambda: self.getColormap(1), layerDependent=True, isValid=self.hasContours )
self.sliceOutputShape = args.get( 'slice_shape', [ 100, 50 ] )
self.opacity = [ 1.0, 1.0 ]
self.iOrientation = 0
self.updatingPlacement = False
self.isSlicing = False
self.planeWidgetX = None
self.planeWidgetY = None
self.planeWidgetZ = None
self.opacityUpdateCount = 0
self.generateContours = False
self.contourLineActors = {}
self.contourLineMapperer = None
self.contours = None
self.NumContours = 10.0
self.showOutlineMap = True
try:
controller = api.get_current_controller()
# print " Volume Slicer init, id = %x " % id(self)
VolumeSlicerModules[mid] = self
except api.NoVistrail:
pass
def getRedoVersion(self):
"""looks at all child versions, and returns that which has the most
recent uvcdat-last-visit annotation, if any """
try:
vistrail = api.get_current_controller().vistrail
except api.NoVistrail:
return None
graph = vistrail.tree.getVersionTree()
maxes = [datetime.min, None] #time, version
def _findMostRecent(version):
children = graph.edges_from(version)
for (child, _) in children:
annotation = vistrail.get_action_annotation(child,
'uvcdat-last-visit')
if annotation is not None:
time = datetime.strptime(annotation.value,
ControllerCell.DATE_FORMAT)
if time > maxes[0]:
maxes[0] = time
maxes[1] = child
else:
_findMostRecent(child)
_findMostRecent(self.current_parent_version)
# if maxes[1]:
# print "Found redo version: %d" % maxes[1]
return maxes[1]
def activateFromCell(self,canvas):
self.activeCanvas = canvas
self.setColorsFromCanvas()
self.controller = api.get_current_controller()
self.version = self.controller.current_version
self.pipeline = self.controller.vistrail.getPipeline(self.version)
self.plots = CDMSPipelineHelper.find_plot_modules(self.pipeline)
#set up plot combo box
# self.plotCb.clear()
# for i in range(len(self.plots)):
# found = False
# for func in self.plots[i].functions:
# if func.name == 'graphicsMethodName':
# self.plotCb.addItem(self.plots[i].module_descriptor.module.plot_type \
# + '_' + func.params[0].strValue, userData=i)
# found = True
# if not found:
# self.plotCb.addItem(self.plots[i].module_descriptor.module.plot_type, userData=i)
# self.plotCb.setCurrentIndex(0)
self.mapNameChanged = False
self.cellsDirty = False
self.show()
def printPersistentModuleMap(label, controller=None):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
object_map = vistrails_interpreter.find_persistent_entities(controller.current_pipeline)[0]
def pushUndoVersion(self, version = None):
"""adds timestamp annotation to mark this version as an undo point"""
if version is None:
version = self.current_parent_version
controller = api.get_current_controller()
controller.vistrail.set_action_annotation(version, 'uvcdat-last-visit',
datetime.strftime(datetime.now(), ControllerCell.DATE_FORMAT))
def pushUndoVersion(self, version=None):
"""adds timestamp annotation to mark this version as an undo point"""
if version is None:
version = self.current_parent_version
controller = api.get_current_controller()
controller.vistrail.set_action_annotation(
version, 'uvcdat-last-visit',
datetime.strftime(datetime.now(), ControllerCell.DATE_FORMAT))
def save(self):
self.email = str(self.usernameEdit.text())
vt_filepath = api.get_current_controller().get_locator().name
url="http://einstein.sv.cmu.edu/estimator?email='"+self.email+"'&vfile='"+vt_filepath+"'"
print >> sys.stderr, url
webbrowser.open_new(url)
self.hide()
def getTaggedVersionNumber(tag, controller=None):
tagged_version_number = -1
if tag <> None:
if controller == None:
import api
controller = api.get_current_controller()
if controller.vistrail.hasTag(tag):
tagged_version_number = controller.vistrail.get_version_number(tag)
return tagged_version_number
def getTaggedVersionNumber( tag, controller = None ):
tagged_version_number = -1
if tag <> None:
if controller == None:
import api
controller = api.get_current_controller()
if controller.vistrail.hasTag( tag ):
tagged_version_number = controller.vistrail.get_version_number( tag )
return tagged_version_number
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 updateLabel( self, recreate = False ):
if self.isClient: return
module = self.getRegisteredModule()
if module.has_annotation_with_key('__desc__'):
import api
controller = api.get_current_controller()
label = module.get_annotation_by_key('__desc__').value.strip()
controller.add_annotation( ('__desc__', str(label)), module.id )
if recreate: controller.current_pipeline_view.recreate_module( controller.current_pipeline, module.id )
def update_functions(self, module_name, functions):
#// @todo: Check with Ben if this is the right way to do it:
import api
controller = api.get_current_controller()
module = PlotPipelineHelper.find_module_by_name(controller.current_pipeline, module_name)
action = controller.update_functions(module, functions)
if action is not None:
window = get_vistrails_application().uvcdatWindow
window.get_current_project_controller().cell_was_changed(action)
def writePipelineToCurrentVistrail(self, aliases):
"""writePipelineToVistrail(aliases: dict) -> list of actions
It will compute necessary actions and add to the current vistrail,
starting at self.parent_version. In the case self.parent_version
does not contain a valid workflow, we will start from the root with
a new pipeline.
"""
actions = []
#print self.current_controller
if self.current_controller is None:
self.current_controller = api.get_current_controller()
self.current_parent_version = 0L
else:
if self.current_parent_version > 0L:
pipeline = self.current_controller.vistrail.getPipeline(self.current_parent_version)
if (len(pipeline.aliases) >= len(self.workflow.aliases) and
self.checkIfWorkflowsAreCompatible()):
paliases = set(pipeline.aliases.keys())
waliases = set(self.workflow.aliases.keys())
if len(waliases - paliases) != 0:
actions.append(self.resetWorkflow())
# print "writePipelineToCurrentVistrail: controller ", self.current_controller
#print "version ", self.current_parent_version
pipeline = self.current_controller.vistrail.getPipeline(self.current_parent_version)
if len(pipeline.module_list) == 0:
#create actions and paste them in current vistrail
vistrail = self.current_controller.vistrail
if vistrail:
action = self.addPipelineAction(self.workflow,
self.current_controller,
vistrail,
self.current_parent_version)
actions.append(action)
newid = action.id
#no tagging for now
# newtag = self.name
# count = 1
# while vistrail.hasTag(newtag):
# newtag = "%s %s"%(self.name, count)
# count += 1
# vistrail.addTag(newtag, newid)
self.current_parent_version = newid
#now we update pipeline with current parameter values
pipeline = self.current_controller.vistrail.getPipeline(self.current_parent_version)
print " @@ Pipeline aliases: ", str( pipeline.aliases )
self.addMergedAliases( aliases, pipeline )
action = self.addParameterChangesFromAliasesAction(pipeline,
self.current_controller,
self.current_controller.vistrail,
self.current_parent_version, aliases)
actions.append(action)
if action:
self.current_parent_version = action.id
return actions
def updateLabel(self, recreate=False):
if self.isClient: return
module = self.getRegisteredModule()
if module.has_annotation_with_key('__desc__'):
import api
controller = api.get_current_controller()
label = module.get_annotation_by_key('__desc__').value.strip()
controller.add_annotation(('__desc__', str(label)), module.id)
if recreate:
controller.current_pipeline_view.recreate_module(
controller.current_pipeline, module.id)
def activateFromCell(self, canvas):
self.activeCanvas = canvas
self.setColorsFromCanvas()
self.controller = api.get_current_controller()
self.version = self.controller.current_version
self.pipeline = self.controller.vistrail.getPipeline(self.version)
self.plots = CDMSPipelineHelper.find_plot_modules(self.pipeline)
self.mapNameChanged = False
self.cellsDirty = False
self.show()
def getUndoVersion(self):
"""returns first ancestor that has uvcdat-last-visit annotation"""
try:
vistrail = api.get_current_controller().vistrail
except api.NoVistrail:
return None
def _getParent(version):
if version != 0:
try:
return vistrail.actionMap[version].parent
except KeyError, e:
return None
return None
def getUndoVersion(self):
"""returns first ancestor that has uvcdat-last-visit annotation"""
try:
vistrail = api.get_current_controller().vistrail
except api.NoVistrail:
return None
def _getParent(version):
if version != 0:
try:
return vistrail.actionMap[version].parent
except KeyError, e:
return None
return None
def writePipelineToCurrentVistrail(self, aliases):
"""writePipelineToVistrail(aliases: dict) -> None
It will compute necessary actions and add to the current vistrail,
starting at self.parent_version. In the case self.parent_version
does not contain a valid workflow, we will start from the root with
a new pipeline.
"""
#print self.current_controller
if self.current_controller is None:
self.current_controller = api.get_current_controller()
self.current_parent_version = 0L
else:
if self.current_parent_version > 0L:
pipeline = self.current_controller.vistrail.getPipeline(
self.current_parent_version)
if len(pipeline.aliases) >= len(self.workflow.aliases):
paliases = set(pipeline.aliases.keys())
waliases = set(self.workflow.aliases.keys())
if len(waliases - paliases) != 0:
self.current_parent_version = 0
# print "writePipelineToCurrentVistrail: controller ", self.current_controller
#print "version ", self.current_parent_version
if self.current_parent_version == 0L:
#create actions and paste them in current vistrail
vistrail = self.current_controller.vistrail
if vistrail:
newid = self.addPipelineAction(self.workflow,
self.current_controller,
vistrail,
self.current_parent_version)
newtag = self.name
count = 1
while vistrail.hasTag(newtag):
newtag = "%s %s" % (self.name, count)
count += 1
vistrail.addTag(newtag, newid)
self.current_parent_version = newid
#now we update pipeline with current parameter values
pipeline = self.current_controller.vistrail.getPipeline(
self.current_parent_version)
self.addMergedAliases(aliases, pipeline)
newid = self.addParameterChangesFromAliasesAction(
pipeline, self.current_controller,
self.current_controller.vistrail, self.current_parent_version,
aliases)
self.current_parent_version = newid
def getDownstreamModules(mid):
import api
controller = api.get_current_controller()
pipeline = controller.current_pipeline
current_module = pipeline.modules[mid]
test_modules = [current_module]
downstream_modules = []
while len(test_modules):
test_mod = test_modules.pop()
output_port_specs = test_mod.output_port_specs
for output_port in output_port_specs:
out_modules = pipeline.get_outputPort_modules(test_mod.id, output_port.name)
downstream_modules.extend(out_modules)
test_modules.extend(out_modules)
return downstream_modules
def tagCurrentVersion( tag ):
if tag:
import api
ctrl = api.get_current_controller()
vistrail = ctrl.vistrail
tagged_version_number = -1
if tag <> None:
if vistrail.hasTag( tag ):
tagged_version_number = vistrail.get_version_number( tag )
vistrail.changeTag( None, tagged_version_number )
try:
vistrail.addTag( tag, ctrl.current_version )
print " --- Tagging version %d as %s" % ( ctrl.current_version, tag )
except VersionAlreadyTagged, err:
curr_tag = vistrail.get_tag( ctrl.current_version )
print>>sys.stderr, " !! Version %d already tagged as %s, applying tag %s, prev tagged version: %d" % ( ctrl.current_version, tag, curr_tag, tagged_version_number )
def getWorkflowModule( mid, forceGet = True, controller = None ):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
object_map = vistrails_interpreter.find_persistent_entities( controller.current_pipeline )[0]
module_instance = object_map.get( mid, None )
if (module_instance == None) and forceGet:
current_version = controller.current_version
min_version = current_version - 3 if current_version > 3 else 0
for version in range( current_version-1, min_version, -1 ):
pipeline = controller.vistrail.getPipeline( version )
object_map = vistrails_interpreter.find_persistent_entities( pipeline )[0]
module_instance = object_map.get( mid, None )
if module_instance <> None: return module_instance
return module_instance
def getDownstreamModules(mid):
import api
controller = api.get_current_controller()
pipeline = controller.current_pipeline
current_module = pipeline.modules[mid]
test_modules = [current_module]
downstream_modules = []
while len(test_modules):
test_mod = test_modules.pop()
output_port_specs = test_mod.output_port_specs
for output_port in output_port_specs:
out_modules = pipeline.get_outputPort_modules(
test_mod.id, output_port.name)
downstream_modules.extend(out_modules)
test_modules.extend(out_modules)
return downstream_modules
def writePipelineToCurrentVistrail(self, aliases):
"""writePipelineToVistrail(aliases: dict) -> None
It will compute necessary actions and add to the current vistrail,
starting at self.parent_version. In the case self.parent_version
does not contain a valid workflow, we will start from the root with
a new pipeline.
"""
#print self.current_controller
if self.current_controller is None:
self.current_controller = api.get_current_controller()
self.current_parent_version = 0L
else:
if self.current_parent_version > 0L:
pipeline = self.current_controller.vistrail.getPipeline(self.current_parent_version)
if len(pipeline.aliases) >= len(self.workflow.aliases):
paliases = set(pipeline.aliases.keys())
waliases = set(self.workflow.aliases.keys())
if len(waliases - paliases) != 0:
self.current_parent_version = 0
# print "writePipelineToCurrentVistrail: controller ", self.current_controller
#print "version ", self.current_parent_version
if self.current_parent_version == 0L:
#create actions and paste them in current vistrail
vistrail = self.current_controller.vistrail
if vistrail:
newid = self.addPipelineAction(self.workflow,
self.current_controller,
vistrail,
self.current_parent_version)
newtag = self.name
count = 1
while vistrail.hasTag(newtag):
newtag = "%s %s"%(self.name, count)
count += 1
vistrail.addTag(newtag, newid)
self.current_parent_version = newid
#now we update pipeline with current parameter values
pipeline = self.current_controller.vistrail.getPipeline(self.current_parent_version)
self.addMergedAliases( aliases, pipeline )
newid = self.addParameterChangesFromAliasesAction(pipeline,
self.current_controller,
self.current_controller.vistrail,
self.current_parent_version, aliases)
self.current_parent_version = newid
def tagCurrentVersion(tag):
if tag:
import api
ctrl = api.get_current_controller()
vistrail = ctrl.vistrail
tagged_version_number = -1
if tag <> None:
if vistrail.hasTag(tag):
tagged_version_number = vistrail.get_version_number(tag)
vistrail.changeTag(None, tagged_version_number)
try:
vistrail.addTag(tag, ctrl.current_version)
print " --- Tagging version %d as %s" % (ctrl.current_version,
tag)
except VersionAlreadyTagged, err:
curr_tag = vistrail.get_tag(ctrl.current_version)
print >> sys.stderr, " !! Version %d already tagged as %s, applying tag %s, prev tagged version: %d" % (
ctrl.current_version, tag, curr_tag, tagged_version_number)
def getWorkflowModule(mid, forceGet=True, controller=None):
if controller == None:
import api
controller = api.get_current_controller()
vistrails_interpreter = getDefaultInterpreter()
object_map = vistrails_interpreter.find_persistent_entities(
controller.current_pipeline)[0]
module_instance = object_map.get(mid, None)
if (module_instance == None) and forceGet:
current_version = controller.current_version
min_version = current_version - 3 if current_version > 3 else 0
for version in range(current_version - 1, min_version, -1):
pipeline = controller.vistrail.getPipeline(version)
object_map = vistrails_interpreter.find_persistent_entities(
pipeline)[0]
module_instance = object_map.get(mid, None)
if module_instance <> None: return module_instance
return module_instance
def createModule(self):
""" createModule() -> None
Collect parameters, values and operator, and create a
PythonCalc module to the current pipeline using the API
provided in vistrails.api.
"""
pythoncalc = "edu.utah.sci.vistrails.pythoncalc"
module = api.add_module(0, 0, pythoncalc, 'PythonCalc', '')
api.get_current_controller().update_function(
module, 'value1', [str(self.value1Edit.text())])
api.get_current_controller().update_function(
module, 'value2', [str(self.value2Edit.text())])
api.get_current_controller().update_function(
module, 'op', [str(self.opCombo.currentText())])
api.switch_to_pipeline_view()
def createModule(self):
""" createModule() -> None
Collect parameters, values and operator, and create a
PythonCalc module to the current pipeline using the API
provided in vistrails.api.
"""
pythoncalc = "edu.utah.sci.vistrails.pythoncalc"
module = api.add_module(0, 0, pythoncalc, 'PythonCalc', '')
api.get_current_controller().update_function(module, 'value1',
[str(self.value1Edit.text())])
api.get_current_controller().update_function(module, 'value2',
[str(self.value2Edit.text())])
api.get_current_controller().update_function(module, 'op',
[str(self.opCombo.currentText())])
api.switch_to_pipeline_view()
def send(self):
# this line prints out the latest workflow name which we can leverage later
#workflow_name = api.get_available_versions()[1][api.get_available_versions()[0][-1]]
workflow_name="tmp"
# login info
username = loginWindow.username
password = loginWindow.password
vt_filepath = api.get_current_controller().get_locator().name
print >> sys.stderr, "##### vt_filepath: "+vt_filepath
remote_filename = username + "_" + str(uuid.uuid4()) + "_" + vt_filepath.split('/')[-1][:-3]
# spawn the scp pexpect thread and login
config_text = "email: "+str(self.emailEdit.text())+"\\nworkflow_name: "+str(workflow_name)+"\\nscheduling: "
config_text += "\\n type: "+str(self.prefCombo.itemData(self.prefCombo.currentIndex()).toString())
"""
config_text += "\\n ncpus: "+str(self.ncpusEdit.text())
config_text += "\\n node: "+str(self.nodeCombo.itemData(self.nodeCombo.currentIndex()).toString())
config_text += "\\n select: "+str(self.selectEdit.text())
"""
print >> sys.stderr, "##### config_text: "+config_text
#look at http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html
command=ssh_command_pre+" \"echo -ne '"+config_text+"' >> ~/hecc/Server/config/"+remote_filename+".yml" + "\""
print >> sys.stderr, "##### ssh_command: "+command
os.system(command)
#Sample: scp -i ~/Downloads/gonghankey.pem test.py [email protected]:~/hecc/job_queue
destination="~/hecc/Server/job_queue/"+remote_filename+".vt"
command=scp_command_pre+" "+vt_filepath+" ubuntu@"+public_dns+":"+destination
print >> sys.stderr, "##### scp_command: "+command
os.system(command)
self.hide()
def build_plot_pipeline_action(controller, version, var_modules, plots,row, col):
# FIXME want to make sure that nothing changes if var_module
# or plot_module do not change
#plot_type = plots[0].parent
#plot_gm = plots[0].name
if controller is None:
controller = api.get_current_controller()
version = 0L
reg = get_module_registry()
ops = []
cell_module = None
pipeline = controller.vistrail.getPipeline(version)
var_module = var_modules[0]
try:
temp_var_module = pipeline.get_module_by_id(var_module.id)
except KeyError:
temp_var_module = None
if temp_var_module is not None:
var_module = temp_var_module
else:
ops.append(('add',var_module))
for plot in plots:
plot_type = plot.parent
plot_gm = plot.name
import re
plotname = re.sub(r'\s', '', plot_gm)
plot_module = PlotPipelineHelper.find_module_by_name(pipeline, plotname)
if plot_module is not None:
continue
plot_descriptor = reg.get_descriptor_by_name('gov.lbl.visit', 'VisItCell')
plot_module = controller.create_module_from_descriptor(plot_descriptor)
ops.append(('add',plot_module))
#if cell_module is None:
# cell_module = PlotPipelineHelper.find_module_by_name(pipeline, "VisItCell")
if cell_module is None:
#cell_desc = reg.get_descriptor_by_name('gov.lbl.visit', "VisItCell")
#cell_module = controller.create_module_from_descriptor(cell_desc)
#ops.append(('add', cell_module))
cell_module = plot_module
if issubclass(var_modules[0].module_descriptor.module, CDMSVariable):
conn = controller.create_connection(var_module, 'self',
plot_module, 'variable')
else:
conn = controller.create_connection(var_module, 'self',
cell_module, 'variable')
ops.append(('add', conn))
#print 'connection source id is ', conn.sourceId
#print 'connection dest id is ', conn.destinationId
loc_module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name('edu.utah.sci.vistrails.spreadsheet',
'CellLocation'))
functions = controller.create_functions(loc_module,
[('Row', [str(row+1)]), ('Column', [str(col+1)])])
for f in functions:
loc_module.add_function(f)
loc_conn = controller.create_connection(loc_module, 'self',
cell_module, 'Location')
ops.extend([('add', loc_module),
('add', loc_conn)])
type_of_plot = str(plot_gm)
param_module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name('gov.lbl.visit', 'VisItParams'))
functions = controller.create_functions(param_module,
[('renderType', [type_of_plot])])
for f in functions:
param_module.add_function(f)
param_conn = controller.create_connection(param_module, 'self',
plot_module, 'visitparams')
ops.extend([('add', param_module),
('add', param_conn)])
# Create connection between the cell and the representation
#conn = controller.create_connection(plot_module, 'self',
# cell_module, 'representation')
# Add the connection to the pipeline operations
#ops.append(('add', conn))
action = core.db.action.create_action(ops)
controller.change_selected_version(version)
controller.add_new_action(action)
controller.perform_action(action)
return action
def check_dependencies(self, index):
"""
determines if current VisTrail will be
supported by the repository's VisTrail server
"""
if not index: return
self._unrunnable_wfs = {}
# are we logged in?
if not self.dialog.cookiejar:
self._repository_status['support_status'] = "Please login"
self._repository_status['details'] = ""
self.update_push_information()
self._push_button.setEnabled(False)
self._branch_button.hide()
else:
self.repository_supports_vt = True
# get packages supported by VisTrails repository
server = self.serverCombo.itemData(index).toList()[1].toString()
packages_url = "%s/packages/supported_packages/%s" % \
(self.config.webRepositoryURL, server)
try:
get_supported_packages = urllib2.urlopen(url=packages_url)
except urllib2.HTTPError, e:
self._repository_status['support_status'] = ""
self._repository_status['details'] = ""
if e.code == 500:
self._repository_status['support_status'] = \
("Error connecting to repository (server side issues)")
else:
debug.critical(str(e))
self._push_button.setEnabled(False)
self.update_push_information()
self.populate_table()
return
server_packages = json.loads(get_supported_packages.read())
# get local packages and local data modules
local_packages = []
self.local_data_modules = ['File', 'FileSink', 'Path']
self.unavailable_data = set()
self.unsupported_packages = set()
has_python_source = False
vistrail = api.get_current_vistrail()
for version_id in vistrail.get_tagMap():
pipeline = vistrail.getPipeline(version_id)
tag = vistrail.get_tagMap()[version_id]
workflow_packages = []
for module in pipeline.module_list:
# count modules that use data unavailable to web repository
on_repo = False
if module.name[-6:] == 'Reader' or \
module.name in self.local_data_modules:
for edge in pipeline.graph.edges_to(module.id):
if pipeline.modules[edge[0]].name in [
'HTTPFile', 'RepoSync'
]:
on_repo = True
if not on_repo:
if tag not in self._unrunnable_wfs.keys():
self._unrunnable_wfs[tag] = []
self._unrunnable_wfs[tag].append(module.name)
self.unavailable_data.add(module.name)
if module.name == "PythonSource":
if tag not in self._unrunnable_wfs.keys():
self._unrunnable_wfs[tag] = []
self._unrunnable_wfs[tag].append(module.name)
has_python_source = True
# get all packages used in tagged versions of this workflow
if module.package not in workflow_packages:
workflow_packages.append(module.package)
# find unsupported packages
wf_unsupported_packages = filter((lambda p: p not in \
server_packages),
workflow_packages)
if wf_unsupported_packages:
if tag not in self._unrunnable_wfs.keys():
self._unrunnable_wfs[tag] = []
for package in wf_unsupported_packages:
self._unrunnable_wfs[tag].append(package)
self.unsupported_packages.add(package)
# display unsupported packages
self._repository_status['details'] = "Details:\n"
if self.unsupported_packages:
self.repository_supports_vt = False
self._repository_status['details'] += \
"Packages incompatible with web repository: %s\n\n" % \
(', '.join(self.unsupported_packages)[:-2])
# display unsupported data modules
if len(self.unavailable_data):
self.repository_supports_vt = False
self._repository_status['details'] += \
"Data sources not available on web repository: %s\n"%\
(', '.join(self.unavailable_data)[:-2])
if has_python_source:
self.repository_supports_vt = False
self._repository_status['details'] += \
("This Vistrail contains PythonSource module(s) and "
"will have to be verified by admins before it can be "
"run on the web repository. You will be notified when"
" your workflows have been verfied")
self._repository_status['support_status'] = ""
controller = api.get_current_controller()
if controller.vistrail.get_annotation('repository_vt_id'):
# Since repository_vt_id doesn't mirror crowdlabs vt id
# get the crowdlabs vt id for linkage
vt_url = "%s/vistrails/details/%s" % \
(self.config.webRepositoryURL,
controller.vistrail.get_annotation('repository_vt_id').value)
try:
request = urllib2.urlopen(url=vt_url)
# TODO: check project that vistrail is part of and notify user
# that branching will add it to a different project
if request.code == 200:
# the vistrail exists on the repository, setup merge settings
self.permission_gb.setTitle(
("Default Global Permissions "
"(only applicable to branching):"))
self._push_button.setText("Commit changes")
self._branch_button.setEnabled(True)
self._branch_button.show()
vistrail_link = "%s/vistrails/details/%s" % \
(self.config.webRepositoryURL,
controller.vistrail.get_annotation('repository_vt_id').value)
self._repository_status['support_status'] = \
("You are attempting to update this vistrail: "
"<a href='%s'>%s</a>. This will possibly update your local version with changes from the web repository<br><br>") % \
(vistrail_link, vistrail_link)
except urllib2.HTTPError:
# the vistrail has *probably* been deleted or doesn't exist
# remove repository_vt_id annotation
repo_annotation = controller.vistrail.get_annotation(
'repository_vt_id')
if repo_annotation:
controller.vistrail.db_delete_annotation(
repo_annotation)
if self.repository_supports_vt:
self._repository_status['support_status'] += \
("All of this VisTrail's tagged versions are supported"
" on the VisTrails Repository.")
else:
self._repository_status['support_status'] += \
("This VisTrail contains packages or modules that are"
" not supported by the VisTrails Repository.<br>"
"You may still upload the VisTrail but it will "
"not be run by the Repository.")
self._push_button.setEnabled(True)
self.update_push_information()
self.populate_table()
def executeWorkflow():
import api
controller = api.get_current_controller()
controller.execute_current_workflow()
def updateScene():
import api
controller = api.get_current_controller()
controller.current_pipeline_view.setupScene(controller.current_pipeline)
def setupSaveConfigurations():
import api
ctrl = api.get_current_controller()
scene = ctrl.current_pipeline_view
scene.connect( scene, SIGNAL('moduleSelected'), VisItConfigurationWidget.saveConfigurations )
def send(self):
# [The LOGIN function is directly copied from remoteLogin package]
# LOGIN -- handle the login with all its odd 'expected' cases of
# failure/success. returns a boolean indicating the ability to
# login to the prompt with the given username and password
def login( thePrompt, password ):
theResult = thePrompt.expect( ['continue connecting',
'assword:',
pexpect.EOF] )
# check if this is the first time we have tried to login to the server
if theResult==0:
print >> sys.stderr," [scpModule] login -- first time fingerprint"
thePrompt.sendline( 'yes' )
theResult = thePrompt.expect( ['continue connecting',
'assword:',
pexpect.EOF] )
# respond to the result after potential fingerprint acceptance
if theResult==0:
print >> sys.stderr," [scpModule] login -- sanity failure -- first time fingerprint again"
raise RuntimeError, "sanity failure -- fingerprint double check"
elif theResult==2:
print >> sys.stderr," [scpModule] login -- received EOF signal"
raise RuntimeError, "login failure -- early EOF received"
# otherwise process the password prompt
elif theResult==1:
print >> sys.stderr," [scpModule] login -- received password prompt"
thePrompt.sendline( password )
theResult = thePrompt.expect( ['assword:',pexpect.EOF] )
# check the responses
if theResult==0:
print >> sys.stderr," [scpModule] login -- failure denied password"
raise RuntimeError,"login failure -- denied username/password"
else:
print >> sys.stderr," [scpModule] successful login..."
# this line prints out the latest workflow name which we can leverage later
workflow_name = api.get_available_versions()[1][api.get_available_versions()[0][-1]]
# login info
username = loginWindow.username
password = loginWindow.password
vt_filepath = api.get_current_controller().get_locator().name
remote_filename = username + "_" + str(uuid.uuid4()) + "_" + vt_filepath.split('/')[-1][:-3]
# spawn the scp pexpect thread and login
config_text = "email: "+str(self.emailEdit.text())+"\\nworkflow_name: "+str(workflow_name)+"\\nscheduling: "
config_text += "\\n type: "+str(self.prefCombo.itemData(self.prefCombo.currentIndex()).toString())
"""
config_text += "\\n ncpus: "+str(self.ncpusEdit.text())
config_text += "\\n node: "+str(self.nodeCombo.itemData(self.nodeCombo.currentIndex()).toString())
config_text += "\\n select: "+str(self.selectEdit.text())
"""
#print >> sys.stderr, config_text
spawnLine_cfg = "ssh " + username + "@ok.freya.cc \"" + "echo -ne '"+config_text+"' >> /home/hecc/config/"+remote_filename+".yml" + "\""
#print >> sys.stderr, spawnLine_cfg
thePrompt_cfg = pexpect.spawn( spawnLine_cfg )
login( thePrompt_cfg, password )
spawnLine = "scp " + vt_filepath + " " + username + "@ok.freya.cc:/home/hecc/job_queue/" + remote_filename + ".vt"
#print >> sys.stderr," [scp Module] scp spawning line: (" + spawnLine + ")"
thePrompt = pexpect.spawn( spawnLine )
login( thePrompt, password )
self.hide()
def build_plot_pipeline_action(controller, version, var_modules, plots,
row, col):
# FIXME want to make sure that nothing changes if var_module
# or plot_module do not change
#plot_type = plots[0].parent
#plot_gm = plots[0].name
if controller is None:
controller = api.get_current_controller()
version = 0L
reg = get_module_registry()
ops = []
cell_module = None
pipeline = controller.vistrail.getPipeline(version)
var_module = var_modules[0]
try:
temp_var_module = pipeline.get_module_by_id(var_module.id)
except KeyError:
temp_var_module = None
if temp_var_module is not None:
var_module = temp_var_module
else:
ops.append(('add', var_module))
for plot in plots:
plot_type = plot.parent
plot_gm = plot.name
import re
plotname = re.sub(r'\s', '', plot_gm)
plot_module = PlotPipelineHelper.find_module_by_name(
pipeline, plotname)
if plot_module is not None:
continue
plot_descriptor = reg.get_descriptor_by_name(
'gov.lbl.visit', 'VisItCell')
plot_module = controller.create_module_from_descriptor(
plot_descriptor)
ops.append(('add', plot_module))
#if cell_module is None:
# cell_module = PlotPipelineHelper.find_module_by_name(pipeline, "VisItCell")
if cell_module is None:
#cell_desc = reg.get_descriptor_by_name('gov.lbl.visit', "VisItCell")
#cell_module = controller.create_module_from_descriptor(cell_desc)
#ops.append(('add', cell_module))
cell_module = plot_module
if issubclass(var_modules[0].module_descriptor.module,
CDMSVariable):
conn = controller.create_connection(
var_module, 'self', plot_module, 'variable')
else:
conn = controller.create_connection(
var_module, 'self', cell_module, 'variable')
ops.append(('add', conn))
#print 'connection source id is ', conn.sourceId
#print 'connection dest id is ', conn.destinationId
loc_module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name(
'edu.utah.sci.vistrails.spreadsheet', 'CellLocation'))
functions = controller.create_functions(
loc_module, [('Row', [str(row + 1)]),
('Column', [str(col + 1)])])
for f in functions:
loc_module.add_function(f)
loc_conn = controller.create_connection(
loc_module, 'self', cell_module, 'Location')
ops.extend([('add', loc_module), ('add', loc_conn)])
type_of_plot = str(plot_gm)
param_module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name('gov.lbl.visit', 'VisItParams'))
functions = controller.create_functions(
param_module, [('renderType', [type_of_plot])])
for f in functions:
param_module.add_function(f)
param_conn = controller.create_connection(
param_module, 'self', plot_module, 'visitparams')
ops.extend([('add', param_module), ('add', param_conn)])
# Create connection between the cell and the representation
#conn = controller.create_connection(plot_module, 'self',
# cell_module, 'representation')
# Add the connection to the pipeline operations
#ops.append(('add', conn))
action = core.db.action.create_action(ops)
controller.change_selected_version(version)
controller.add_new_action(action)
controller.perform_action(action)
return action
def executeWorkflow():
import api
controller = api.get_current_controller()
controller.execute_current_workflow()
def __init__(self, mid, **args):
import api
PersistentVisualizationModule.__init__(self, mid, **args)
self.primaryInputPorts = ['volume', 'contours']
self.addConfigurableLevelingFunction('colorScale',
'C',
label='Colormap Scale',
units='data',
setLevel=self.scaleColormap,
getLevel=self.getDataRangeBounds,
layerDependent=True,
adjustRangeInput=0,
group=ConfigGroup.Color)
self.addConfigurableLevelingFunction('opacity',
'O',
label='Slice Plane Opacity',
rangeBounds=[0.0, 1.0],
setLevel=self.setOpacity,
activeBound='min',
getLevel=self.getOpacity,
isDataValue=False,
layerDependent=True,
bound=False,
group=ConfigGroup.Rendering)
self.addConfigurableLevelingFunction('zScale',
'z',
label='Vertical Scale',
setLevel=self.setZScale,
activeBound='max',
getLevel=self.getScaleBounds,
windowing=False,
sensitivity=(10.0, 10.0),
initRange=[2.0, 2.0, 1],
group=ConfigGroup.Display)
self.addConfigurableLevelingFunction('contourDensity',
'g',
label='Contour Density',
activeBound='max',
setLevel=self.setContourDensity,
getLevel=self.getContourDensity,
layerDependent=True,
windowing=False,
rangeBounds=[3.0, 30.0, 1],
bound=False,
isValid=self.hasContours,
group=ConfigGroup.Rendering)
self.addConfigurableLevelingFunction(
'contourColorScale',
'S',
label='Contour Colormap Scale',
units='data',
setLevel=self.scaleContourColormap,
getLevel=lambda: self.getDataRangeBounds(1),
layerDependent=True,
adjustRangeInput=1,
isValid=self.hasContours,
group=ConfigGroup.Color)
self.addConfigurableLevelingFunction(
'coastlines_Line',
'm0',
label='Coastline Line',
setLevel=self.setBasemapCoastlineLineSpecs,
getLevel=self.getBasemapCoastlineLineSpecs,
sliderLabels=['Thickness', 'Density'],
layerDependent=False,
rangeBounds=[0.0, 3.49],
initRange=[1.0, 1.0, 1],
group=ConfigGroup.BaseMap)
self.addConfigurableLevelingFunction(
'countries_Line',
'm1',
label='Countries Line',
setLevel=self.setBasemapCountriesLineSpecs,
getLevel=self.getBasemapCountriesLineSpecs,
sliderLabels=['Thickness', 'Density'],
layerDependent=False,
rangeBounds=[0.0, 3.49],
initRange=[0.0, 1.0, 0],
group=ConfigGroup.BaseMap)
self.addConfigurableLevelingFunction(
'states_Line',
'm2',
label='States Line',
setLevel=self.setBasemapStatesLineSpecs,
getLevel=self.getBasemapStatesLineSpecs,
sliderLabels=['Thickness', 'Density'],
layerDependent=False,
rangeBounds=[0.0, 3.49],
initRange=[0.0, 1.0, 0],
group=ConfigGroup.BaseMap)
self.addConfigurableLevelingFunction(
'lakes_Line',
'm3',
label='Lakes Line',
setLevel=self.setBasemapLakesLineSpecs,
getLevel=self.getBasemapLakesLineSpecs,
sliderLabels=['Thickness', 'Density'],
layerDependent=False,
rangeBounds=[0.0, 3.49],
initRange=[0.0, 1.0, 0],
group=ConfigGroup.BaseMap)
self.addUVCDATConfigGuiFunction(
'contourColormap',
ColormapConfigurationDialog,
'K',
label='Choose Contour Colormap',
setValue=lambda data: self.setColormap(data, 1),
getValue=lambda: self.getColormap(1),
layerDependent=True,
isValid=self.hasContours,
group=ConfigGroup.Color)
self.sliceOutputShape = args.get('slice_shape', [100, 50])
self.polygonActor = None
self.opacity = [1.0, 1.0]
self.iOrientation = 0
self.updatingPlacement = False
self.isSlicing = False
self.planeWidgetX = None
self.planeWidgetY = None
self.planeWidgetZ = None
self.opacityUpdateCount = 0
self.generateContours = False
self.contourLineActors = {}
self.contourLineMapperer = None
self.shapefilePolylineActors = {}
self.basemapLineSpecs = {}
self.contours = None
self.NumContours = 10.0
self.showOutlineMap = True
try:
controller = api.get_current_controller()
# print " Volume Slicer init, id = %x " % id(self)
VolumeSlicerModules[mid] = self
except api.NoVistrail:
pass
def updateScene():
import api
controller = api.get_current_controller()
controller.current_pipeline_view.setupScene(controller.current_pipeline)
def setupSaveConfigurations():
import api
ctrl = api.get_current_controller()
scene = ctrl.current_pipeline_view
scene.connect(scene, SIGNAL("moduleSelected"), PVClimateConfigurationWidget.saveConfigurations)
def push_vistrail_to_repository(self, branching=False):
""" uploads current VisTrail to web repository """
self._repository_status['details'] = "Pushing to repository..."
self._push_button.setEnabled(False)
self._branch_button.setEnabled(False)
self.update_push_information()
try:
# create temp file
self.directory = tempfile.mkdtemp(prefix='vt_tmp')
(fd, filename) = tempfile.mkstemp(suffix='.vt',
prefix='vt_tmp',
dir=self.directory)
os.close(fd)
# writing tmp vt and switching back to orginal vt
locator = ZIPFileLocator(filename)
controller = api.get_current_controller()
tmp_controller = VistrailController()
tmp_controller.set_vistrail(controller.vistrail.do_copy(), locator)
tmp_controller.changed = True
tmp_controller.write_vistrail(locator)
# check if this vt is from the repository
if controller.vistrail.get_annotation('repository_vt_id'):
repository_vt_id = controller.vistrail.get_annotation(
'repository_vt_id').value
else:
repository_vt_id = -1
# upload vistrail temp file to repository
register_openers(cookiejar=self.dialog.cookiejar)
project = self.serverCombo.itemData(
self.serverCombo.currentIndex()).toList()[0].toString()
if project == "Default": project = ""
params = {'vistrail_file': open(filename, 'rb'),
'action': 'upload',
'name': controller.locator.short_name,
'repository_vt_id': repository_vt_id if not branching else -1,
'is_runnable': not bool(len(self.unsupported_packages)+ \
len(self.local_data_modules)),
'vt_id': 0,
'branched_from': "" if not branching else repository_vt_id,
'project': project,
'everyone_can_view': self.perm_view.checkState(),
'everyone_can_edit': self.perm_edit.checkState(),
'everyone_can_download': self.perm_download.checkState()
}
upload_url = "%s/vistrails/remote_upload/" % \
self.config.webRepositoryURL
datagen, headers = multipart_encode(params)
request = urllib2.Request(upload_url, datagen, headers)
result = urllib2.urlopen(request)
updated_response = result.read()
os.unlink(filename)
if updated_response[:6] == "upload":
# No update, just upload
if result.code != 200:
self._repository_status['details'] = \
"Push to repository failed"
else:
repository_vt_id = int(updated_response[8:])
controller.vistrail.set_annotation('repository_vt_id',
repository_vt_id)
controller.vistrail.set_annotation(
'repository_creator', self.dialog.loginUser.text())
# ensure that the annotations get saved
controller.set_changed(True)
self._repository_status['details'] = \
"Push to repository was successful"
else:
# update, load updated vistrail
if result.code != 200:
self._repository_status['details'] = "Update Failed"
else:
debug.log("getting version from web")
# request file to download
download_url = "%s/vistrails/download/%s/" % \
(self.config.webRepositoryURL, updated_response)
request = urllib2.Request(download_url)
result = urllib2.urlopen(request)
updated_file = result.read()
# create temp file of updated vistrail
self.directory = tempfile.mkdtemp(prefix='vt_tmp')
(fd,
updated_filename) = tempfile.mkstemp(suffix='.vtl',
prefix='vtl_tmp',
dir=self.directory)
os.close(fd)
updated_vt = open(updated_filename, 'w')
updated_vt.write(updated_file)
updated_vt.close()
# switch vistrails to updated one
controller = api.get_current_controller()
updated_locator = FileLocator(updated_filename)
(up_vistrail, abstractions, thumbnails, mashups) = \
load_vistrail(updated_locator)
controller.set_vistrail(up_vistrail,
controller.vistrail.locator,
abstractions, thumbnails, mashups)
# update version tree drawing
controller.recompute_terse_graph()
controller.invalidate_version_tree()
os.remove(updated_filename)
os.remove(updated_filename[:-1])
os.rmdir(self.directory)
self._repository_status['details'] = \
"Update to repository was successful"
except Exception, e:
debug.critical(str(e))
self._repository_status['details'] = "An error occurred"
def build_plot_pipeline_action(controller, version, var_modules, plots,row, col, template=None):
#// @todo: want to make sure that nothing changes if var_module
#// or plot_module do not change
# Get controller
if controller is None:
controller = api.get_current_controller()
version = 0L
# Get module registry
reg = get_module_registry()
ops = []
cell_module = None
#// First get the pipeline
pipeline = controller.vistrail.getPipeline(version)
#// @todo: Add support for multiple variables per plot
#// Use only the first var module for now
var_module = var_modules[0]
#// @Aashish: As of now, very first time var module is being added to the pipeline by the project controller
#// but second time on the same cell, it gets removed and hence we needed to add var module again to pipeline.
#// I need to put this code under try catch because as of now looking for an id that does not exists
#// results in exception.
try:
temp_var_module = pipeline.get_module_by_id(var_module.id)
except KeyError:
temp_var_module = None
if temp_var_module is not None:
var_module = temp_var_module
else:
# This time we need to add var module to the pipeline
ops.append(('add', var_module))
for plot in plots:
plot_gm = plot.name
#// Create plot module from the descriptor
#// Is there a better way? I looked around and found none
import re
plotUsableName = re.sub(r'\s', '', plot_gm)
plot_module = PlotPipelineHelper.find_module_by_name(pipeline, plotUsableName)
if plot_module is not None:
continue
plot_descriptor = reg.get_descriptor_by_name('com.kitware.pvclimate', plotUsableName)
#// @Aashish: Looks like the pipeline is using the cached representation
plot_module = controller.create_module_from_descriptor(plot_descriptor)
ops.append(('add', plot_module))
#// @Aashish: This is no longer required as of this commit
#// e13bb034ceb302afe3aad3caf20153e1525586db
#// I am not sure though why we still need to add plot module
#ops.append(('add', var_modules[0]))
#// Create cell - representation linkage
#// Check to see if a cell already exits, if yes then set the input (representation on it) or else
#// create a new one and then set the representation on it.
if cell_module is None:
cell_module = PlotPipelineHelper.find_module_by_name(pipeline, "PVGenericCell")
#// If cell module is None, then create a new one
if cell_module is None:
cell_desc = reg.get_descriptor_by_name('com.kitware.pvclimate', "PVGenericCell")
cell_module = controller.create_module_from_descriptor(cell_desc)
ops.append(('add', cell_module))
#// Create a connection between the cell and the variable
#// @Aashish: I am expecting that every time we drop a variable, we will get a
#// pipeline that does not have modules from the previous execution. I need to verify
#// this but for now this assumption seems to hold.
oport = CDMSPipelineHelper.get_output_port_name(
var_module.module_descriptor.module)
conn = controller.create_connection(var_module, oport,
plot_module, 'cdms_variable')
ops.append(('add', conn))
loc_module = controller.create_module_from_descriptor(
reg.get_descriptor_by_name('edu.utah.sci.vistrails.spreadsheet',
'CellLocation'))
functions = controller.create_functions(loc_module,
[('Row', [str(row+1)]), ('Column', [str(col+1)])])
for f in functions:
loc_module.add_function(f)
loc_conn = controller.create_connection(loc_module, 'self',
cell_module, 'Location')
ops.extend([('add', loc_module),
('add', loc_conn)])
#// Create connection between the cell and the representation
conn = controller.create_connection(plot_module, 'self',
cell_module, 'representation')
#// Add the connection to the pipeline operations
ops.append(('add', conn))
action = core.db.action.create_action(ops)
controller.change_selected_version(version)
controller.add_new_action(action)
controller.perform_action(action)
return action
def plot(self, var1, var2):
""" Connect / disconnect the necessary ports and exec workflow -> plot
into the cell
"""
self.currentWorkflow.updatePorts(var1, var2)
api.get_current_controller().execute_current_workflow()
def plot(self, var1, var2):
""" Connect / disconnect the necessary ports and exec workflow -> plot
into the cell
"""
self.currentWorkflow.updatePorts(var1, var2)
api.get_current_controller().execute_current_workflow()