import core.modules.module_registry import core.modules.vistrails_module from logging import debug, warn from core.vistrail.connection import Connection from core.vistrail.port import Port from PyQt4 import QtGui, QtCore import api import vcs import os cdat_id = "edu.utah.sci.vistrails.cdat" # Module names # Note: open_name, quickplot_name, etc... are used in cdat_window.py # and graphics_method_controller.py open_name = 'open' quickplot_name = 'Quickplot' variable_name = 'Variable' cdatcell_name = 'CDATCell' gm_name = 'GraphicsMethod' # Port names # Module Namespaces namespace = {} namespace[open_name] = 'cdms2' namespace[quickplot_name] = 'cdat' namespace[variable_name] = 'cdat' namespace[cdatcell_name] = 'cdat' namespace[gm_name] = 'cdat' # MAJOR TODO: Support for multiple workflows class Workflow(): """ A Workflow contains a dict of modules belonging to the workflow. Workflow manages the updating of its modules connections / values """ def __init__(self): """ Workflow contains a dictionary of modules in the workflow. * Key - if module is a variable then the key is the name of the variable otherwise the key is the name of the module. ***** IMPORTANT ***** * Value - module object """ self.modules = {} self.variableNames = [] # Names of the variables in this workflow self.filename = None # Name of the cdms file associated with this workflow def moduleExists(self, key): return key in list(self.modules) def addModule(self, name, module, isVariable=False): self.modules[name] = module # If the module is a variable save the name and connect the variable # module to the open module if isVariable: self.variableNames.append(name) self.connectPorts(self.modules[open_name], 'dataset', module, 'cdmsfile') def updatePorts(self, var1, var2): """ updatePorts(var1: str, var2: str) updatePorts connects the output ports of Variable modules with vars var1 and var2 to the input ports of Graphics Method and then connects the output of Graphics Method to the input of CDATCell. """ m_open = self.modules[open_name] m_variable1 = self.modules[var1] m_gm = self.modules[gm_name] m_cdatcell = self.modules[cdatcell_name] # Connect the variable module being plotted to the graphics method # module and store the connection self.connectPorts(m_variable1, 'variable', m_gm, 'slab1') # Connect graphics method module & cdatcell module self.connectPorts(m_gm, 'canvas', m_cdatcell, 'canvas') self.connectPorts(m_gm, 'slab1', m_cdatcell, 'slab1') # Connect the second variable module (if given) to graphics method # and Graphics Method to CDATCell if var2 is not None: m_var2 = self.modules[var2] self.connectPorts(m_var2, 'variable', m_gm, 'slab2') self.connectPorts(m_gm, 'slab2', m_cdatcell, 'slab2') def connectPorts(self, moduleA, outputPortName, moduleB, inputPortName): """ connectPorts(moduleA: Module, outputPortName: str, moduleB: Module, inputPortName: str) -> Connection connectPorts connects moduleA's outputPort to moduleB's inputPort. """ reg = api.get_module_registry() in_port = moduleA.get_port_spec(outputPortName, 'output') out_port = moduleB.get_port_spec(inputPortName, 'input') return api.add_connection(moduleA.id, outputPortName, moduleB.id, inputPortName) 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 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]) class GuiController(QtCore.QObject): """ GuiController calls vistrails functions and handles recording and displaying teaching commands. The two most important functions that GuiController provides are: 'createModule' and 'updateModule'. 'createModule' creates a new box. 'updateModule' updates the input of a box. Widgets interact with GuiController by sending signals (which is why GuiController inherits from QObject). """ def __init__(self, fileWidget, defVarWidget, varWidget): """ __init__(fileWidget: QCDATFileWidget, defVarWidget:QDefinedVariable, varWidget: QVariableView) """ QtCore.QObject.__init__(self) self.teachingCommands = '' self.editorPid = 0 self.recordCommands = True self.workflows = [] # List of workflows # X coordinates of open, variable, and plot related modules self.openX = -300 self.variableX = -300 self.plotX = -320 self.m_open = None self.m_variable = None self.m_graphics_method = None self.m_cdat_cell = None # Connect the 3 main widgets to the primary GuiController # functionality. If a childwidget of the 3 main widgets wants to # send signals to GuiController, then it must send it through one of the # main widgets to try to keep things less messy self.connect(fileWidget, QtCore.SIGNAL('createModule'), self.createModule) self.connect(fileWidget, QtCore.SIGNAL('updateModule'), self.updateModule) self.connect(fileWidget, QtCore.SIGNAL('recordTeachingCommand'), self.recordTeachingCommand) self.connect(defVarWidget, QtCore.SIGNAL('createModule'), self.createModule) self.connect(defVarWidget, QtCore.SIGNAL('updateModule'), self.updateModule) self.connect(defVarWidget, QtCore.SIGNAL('recordTeachingCommand'), self.recordTeachingCommand) self.connect(varWidget, QtCore.SIGNAL('recordTeachingCommand'), self.recordTeachingCommand) self.connect(varWidget, QtCore.SIGNAL('createModule'), self.createModule) self.connect(varWidget, QtCore.SIGNAL('updateModule'), self.updateModule) self.connect(varWidget, QtCore.SIGNAL('updateModuleOps'), self.updateModuleOps) self.connect(varWidget, QtCore.SIGNAL('plot'), self.plot) 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 getCoordinates(self, name): """ getCoordinates(name: str) -> x: int, y: int Return the x, y coordinate of where to place the new module given the name. """ if name == open_name: self.openX += 100 return self.openX, 170 elif name == variable_name or name == quickplot_name: self.variableX += 120 return self.variableX, 70 elif name == gm_name: self.plotX += 160 return self.plotX, -70 elif name == cdatcell_name: return self.plotX, -170 def createModule(self, name, key=None): """ createModule(name: str, key: str) createModule creates a new module given the name and adds it to the current workflow. If key is specified, use the key instead of the name as the key into the workflow's module dictionary. Note: For Variable modules I pass key = variabe name (the tabName) """ # If module is the 'open' module, create a new workflow if name == open_name: self.createNewWorkflow() # If module is 'quickplot' module, and it already exists, do nothing if name == quickplot_name: if self.currentWorkflow.moduleExists(quickplot_name.lower()): return # Create & add the module x, y = self.getCoordinates(name) module = api.add_module(x, y, cdat_id, name, namespace[name]) if key is not None: self.currentWorkflow.addModule(key, module, isVariable=True) else: self.currentWorkflow.addModule(name, module) 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 """ self.currentWorkflow.updateModule(name, 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) """ self.currentWorkflow.updateModuleOps(name, args) 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 initTeachingCommands(self): """ The initial teaching commands still have 4 canvases like the old vcdat. This allows you to run the teaching commands independently of vistrails' spreadsheets. """ self.teachingCommands += 'import cdms2, vcs, cdutil, genutil, os, sys\n' self.teachingCommands += 'import MV2\n' self.teachingCommands += '\n# Initialize the four VCS Canvases by creating\n' self.teachingCommands += '# a list to hold the 4 VCS Canvas\n' self.teachingCommands += 'vcs_canvas_list = []\n' self.teachingCommands += '\n# Loop (from 0 to 3) to create VCS Canvas 1, 2, 3, and 4\n' self.teachingCommands += 'for i in range(4):\n' self.teachingCommands += ' vcs_canvas_list.append(vcs.init())\n' self.teachingCommands += '\n# Set the Command Line VCS Canvas hooks\n' self.teachingCommands += 'vcs_hook1 = vcs_canvas_list[0]\n' self.teachingCommands += 'vcs_hook2 = vcs_canvas_list[1]\n' self.teachingCommands += 'vcs_hook3 = vcs_canvas_list[2]\n' self.teachingCommands += 'vcs_hook4 = vcs_canvas_list[3]\n' self.writeTeachingCommands() def recordTeachingCommand(self, command): if (self.recordCommands == True): self.teachingCommands += command self.writeTeachingCommands() def setRecordCommands(self, recordCommands): self.recordCommands = recordCommands def writeTeachingCommands(self): try: fn = '%s/PCMDI_GRAPHICS' % os.environ['HOME'] except: print "Could not find the $HOME directory. Set your environment variable 'HOME'" print "to your home directory. (e.g., 'setenv HOME /home/user')." sys.exit() # Create PCMDI_GRAPHICS directory if it does not exist if (os.access(fn, os.X_OK) == 0): try: os.mkdir(fn) except: print 'Do not have write permission for home directory. Must have write permissions.' sys.exit() # Write teaching commands to vcdat_recording_script_file.py self.teachingScript = fn + '/vcdat_recording_script_file.py' file = open(self.teachingScript, 'w') file.write(self.teachingCommands) file.flush() def viewTeachingCommands(self): """ Open the teaching commands script in a child process """ self.editorPid = os.fork() if (self.editorPid == 0): editor = 'idle' # If idle editor is found, view teaching commands with idle for path in os.environ["PATH"].split(os.pathsep): file = os.path.join(path, editor) if (os.path.exists(file)): args = (editor, self.teachingScript) os.execvp(editor, args) return # If idle editor is not found, use default editor secondaryEditor = os.environ['EDITOR'] args = (secondaryEditor, self.teachingScript) os.execvp(secondaryEditor, args) def closeTeachingCommands(self): if (self.editorPid != 0): os.kill(self.editorPid, 9) self.editorPid = 0