schain-jc Commit - r677:5a045da2ac8c

Bug fixed: translating float values to integer

Miguel Valdez -

r677:5a045da2ac8c

parent child

Context file:

r677:5a045da2ac8c

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schainpy/controller.py +6 -3

             '''
             Created on September , 2012
             @author:
             '''
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
             from model import *
             from time import sleep
             import sys
             import ast
             import traceback
             SCHAIN_MAIL = "miguel.urco@jro.igp.gob.pe"
             EMAIL_SERVER = "jro.igp.gob.pe"
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
                 rough_string = tostring(elem, 'utf-8')
                 reparsed = minidom.parseString(rough_string)
                 return reparsed.toprettyxml(indent="  ")
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError, "%s: This parameter value is empty" %self.name
-                    if format == 'bool':
-                        value = int(value)
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         """
                         Example:
                             value = (0,1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(float(x)) for x in strList]
                         self.__formated_value = intList
                         return self.__formated_value
                     if format == 'floatlist':
                         """
                         Example:
                             value = (0.5, 1.4, 2.7)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         floatList = [float(x) for x in strList]
                         self.__formated_value = floatList
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         """
                         Example:
                             value = (0,1),(1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(item) for item in strList]
                         pairList = []
                         for i in range(len(intList)/2):
                             pairList.append((intList[i*2], intList[i*2 + 1]))
                         self.__formated_value = pairList
                         return self.__formated_value
                     if format == 'multilist':
                         """
                         Example:
                             value = (0,1,2),(3,4,5)
                         """
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval("(" + value + ")")
                         self.__formated_value = multiList
                         return self.__formated_value
+                    if format == 'bool':
+                        value = int(value)
+                    if format == 'int':
+                        value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     self.value = str(value)
                     self.format = str.lower(format)
                     try:
                         self.getValue()
                     except:
                         return 0
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     parmElement = SubElement(opElement, self.ELEMENTNAME)
                     parmElement.set('id', str(self.id))
                     parmElement.set('name', self.name)
                     parmElement.set('value', self.value)
                     parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     #Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                 name = None
                 priority = None
                 type = None
                 parmConfObjList = []
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.parmConfObjList) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id)*10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
             #         if not parameterObj:
             #             return None
                     value = parameterObj.getValue()
                     return value
                 def setup(self, id, name, priority, type):
                     self.id = str(id)
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, upElement):
                     opElement = SubElement(upElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     #Compatible with old signal chain version
                     #Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         #Compatible with old signal chain version
                         #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
                                                                           self.id,
                                                                           self.name,
                                                                           self.type,
                                                                           self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         opObj = className()
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = None
                 parentId = None
                 opConfObjList = []
                 procUnitObj = None
                 opObjList = []
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList)+1
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId)*10 + (int(self.id) % 10)
                     new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
                     #If this proc unit has not inputs
                     if self.inputId == '0':
                         new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id)*10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId, parentId=None):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Proc','')
                     self.id = str(id)
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.parentId = parentId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to "run" operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     id = self.__getNewId()
                     priority = self.__getPriority()
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, procUnitElement):
                     upElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     upElement.set('id', str(self.id))
                     upElement.set('name', self.name)
                     upElement.set('datatype', self.datatype)
                     upElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(upElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     if self.ELEMENTNAME == "ReadUnit":
                         self.datatype = self.datatype.replace("Reader", "")
                     if self.ELEMENTNAME == "ProcUnit":
                         self.datatype = self.datatype.replace("Proc", "")
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.getiterator(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
                                                                          self.id,
                                                                          self.name,
                                                                          self.datatype,
                                                                          self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def createObjects(self):
                     className = eval(self.name)
                     procUnitObj = className()
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = opConfObj.createObject()
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
                     is_ok = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
                                 continue
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
                         sts = self.procUnitObj.call(opType = opConfObj.type,
                                                     opName = opConfObj.name,
                                                     opId = opConfObj.id,
                                                      **kwargs)
                         is_ok = is_ok or sts
                     return is_ok
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.parentId = None
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.addRunOperation(**kwargs)
                 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.datatype = datatype
                     self.name = name
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.updateRunOperation(**kwargs)
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name = 'run', optype = 'self')
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name = 'run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
             class Project():
                 id = None
                 name = None
                 description = None
             #    readUnitConfObjList = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
                 def __init__(self):
                     self.id = None
                     self.name = None
                     self.description = None
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id)*10 + n)
                         procUnitConfObj.updateId(idProcUnit, parentId = self.id)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id, name, description):
                     self.id = str(id)
                     self.name = name
                     self.description = description
                 def update(self, name, description):
                     self.name = name
                     self.description = description
                 def addReadUnit(self, datatype=None, name=None, **kwargs):
                     idReadUnit = self.__getNewId()
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in self.procUnitConfObjDict.keys():
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.getElementName() == "ReadUnit":
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return self.procUnitConfObjDict.items()
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename):
                     self.makeXml()
                     #print prettify(self.projectElement)
                     ElementTree(self.projectElement).write(filename, method='xml')
                 def readXml(self, filename):
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         if readUnitConfObj.parentId == None:
                             readUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         if procUnitConfObj.parentId == None:
                             procUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                 def printattr(self):
                     print "Project[%s]: name = %s, description = %s" %(self.id,
                                                                           self.name,
                                                                           self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects()
                 def __connect(self, objIN, thisObj):
                     thisObj.setInput(objIN.getOutputObj())
                 def connectObjects(self):
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         #Get input object
                         puConfINObj = self.procUnitConfObjDict[inputId]
                         puObjIN = puConfINObj.getProcUnitObj()
                         #Get current object
                         thisPUObj = thisPUConfObj.getProcUnitObj()
                         self.__connect(puObjIN, thisPUObj)
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
                     """
                     returns 0 when this process has been stopped, 1 otherwise
                     """
                     if self.isPaused():
                         print "Process suspended"
                         while True:
                             sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
                         print "Process reinitialized"
                     if self.isStopped():
                         print "Process stopped"
                         return 0
                     return 1
                 def run(self):
                     print
                     print "*"*60
                     print "   Starting SIGNAL CHAIN PROCESSING  "
                     print "*"*60
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         is_ok = False
                         for procKey in keyList:
             #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
                             message = ""
                             try:
                                 sts = procUnitConfObj.run()
                                 is_ok = is_ok or sts
                             except:
                                 sleep(1)
                                 err = traceback.format_exception(sys.exc_info()[0],
                                                                  sys.exc_info()[1],
                                                                  sys.exc_info()[2])
                                 for thisLine in err:
                                     message += thisLine
                                 print message
             #                     self.sendReport(message)
                                 sleep(0.1)
                                 is_ok = False
                                 break
                         #If every process unit finished so end process
                         if not(is_ok):
                             print message
                             print "Every process unit have finished"
                             break
                         if not self.runController():
                             break
                     #Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
                     print "Process finished"
                 def start(self, filename):
                     self.writeXml(filename)
                     self.readXml(filename)
                     self.createObjects()
                     self.connectObjects()
                     self.run()
                 def sendReport(self, message, subject="Error occurred in Signal Chain", email=SCHAIN_MAIL):
                     import smtplib
                     print subject
                     print "Sending report to %s ..." %email
                     message = 'From: (Python Signal Chain API) ' + email + '\n' + \
                     'To: ' + email + '\n' + \
                     'Subject: ' + str(subject) + '\n' + \
                     'Content-type: text/html\n\n' + message
                     server = smtplib.SMTP(EMAIL_SERVER)
                     server.sendmail(email.split(',')[0],
                                     email.split(','), message)
                     server.quit()
             if __name__ == '__main__':
                 desc = "Segundo Test"
                 filename = "schain.xml"
                 controllerObj = Project()
                 controllerObj.setup(id = '191', name='test01', description=desc)
                 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
                                                             path='data/rawdata/',
                                                             startDate='2011/01/01',
                                                             endDate='2012/12/31',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
                                                             online=1,
                                                             walk=1)
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
                 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
                 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
                 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
                 opObj10.addParameter(name='minHei', value='90', format='float')
                 opObj10.addParameter(name='maxHei', value='180', format='float')
                 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
                 opObj12.addParameter(name='n', value='10', format='int')
                 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
                 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
             #    procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
                 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
                 opObj11.addParameter(name='idfigure', value='1', format='int')
                 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
                 opObj11.addParameter(name='zmin', value='40', format='int')
                 opObj11.addParameter(name='zmax', value='90', format='int')
                 opObj11.addParameter(name='showprofile', value='1', format='int')
                 print "Escribiendo el archivo XML"
                 controllerObj.writeXml(filename)
                 print "Leyendo el archivo XML"
                 controllerObj.readXml(filename)
                 #controllerObj.printattr()
                 controllerObj.createObjects()
                 controllerObj.connectObjects()
                 controllerObj.run()
   No newline at end of file

schainpy/gui/viewcontroller/basicwindow.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/gui/viewer/ui_mainwindow.py +1 -1

             # -*- coding: utf-8 -*-
             # Form implementation generated from reading ui file '/home/alex/ui/MainWindow_21_02_13_v49.ui'
             #
             # Created: Mon Mar 24 13:28:36 2014
             #      by: PyQt4 UI code generator 4.10
             #
             # WARNING! All changes made in this file will be lost!
             from PyQt4 import QtCore, QtGui
             from windows import *
             try:
                 _fromUtf8 = QtCore.QString.fromUtf8
             except AttributeError:
                 def _fromUtf8(s):
                     return s
             try:
                 _encoding = QtGui.QApplication.UnicodeUTF8
                 def _translate(context, text, disambig):
                     return QtGui.QApplication.translate(context, text, disambig, _encoding)
             except AttributeError:
                 def _translate(context, text, disambig):
                     return QtGui.QApplication.translate(context, text, disambig)
             import os
             from schainpy.gui.figures import tools
             from schainpy import __version__
             FIGURES_PATH = tools.get_path()
             class Ui_EnvWindow(object):
                 paused = False
                 def restorePauseIcon(self):
                     icon_name = "pause.png"
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionPauseToolbar.setIcon(iconPause)
                 def restoreStartIcon(self):
                     icon_name = "start.png"
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionStarToolbar.setIcon(iconStart)
                 def changePauseIcon(self, paused=False):
                     if paused == True:
                         icon_name = "pausered.png"
                     else:
                         icon_name = "pause.png"
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionPauseToolbar.setIcon(iconPause)
                     return
                 def changeStartIcon(self, started=False):
                     if started == True:
                         icon_name = "startred.png"
                     else:
                         icon_name = "start.png"
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionStarToolbar.setIcon(iconStart)
                     return
                 def setupUi(self, MainWindow):
                     self.paused=False
                     MainWindow.setObjectName(_fromUtf8("MainWindow"))
                     MainWindow.resize(1200, 800)
                     self.centralWidget = QtGui.QWidget(MainWindow)
                     self.centralWidget.setObjectName(_fromUtf8("centralWidget"))
                     self.gridLayout_16 = QtGui.QGridLayout(self.centralWidget)
                     self.gridLayout_16.setObjectName(_fromUtf8("gridLayout_16"))
                     self.splitter_2 = QtGui.QSplitter(self.centralWidget)
                     self.splitter_2.setOrientation(QtCore.Qt.Horizontal)
                     self.splitter_2.setObjectName(_fromUtf8("splitter_2"))
                     self.projectExplorerTree = QtGui.QTreeView(self.splitter_2)
                     self.projectExplorerTree.setObjectName(_fromUtf8("projectExplorerTree"))
                     self.splitter = QtGui.QSplitter(self.splitter_2)
                     self.splitter.setOrientation(QtCore.Qt.Vertical)
                     self.splitter.setObjectName(_fromUtf8("splitter"))
                     self.tabWidgetProject = QtGui.QTabWidget(self.splitter)
                     self.tabWidgetProject.setMinimumSize(QtCore.QSize(0, 278))
                     self.tabWidgetProject.setMaximumSize(QtCore.QSize(16777215, 16777215))
                     self.tabWidgetProject.setObjectName(_fromUtf8("tabWidgetProject"))
                     self.tabConsole = QtGui.QTabWidget(self.splitter)
                     self.tabConsole.setMinimumSize(QtCore.QSize(0, 0))
                     self.tabConsole.setObjectName(_fromUtf8("tabConsole"))
                     self.tab_5 = QtGui.QWidget()
                     self.tab_5.setObjectName(_fromUtf8("tab_5"))
                     self.gridLayout_4 = QtGui.QGridLayout(self.tab_5)
                     self.gridLayout_4.setObjectName(_fromUtf8("gridLayout_4"))
                     self.console = QtGui.QTextEdit(self.tab_5)
                     self.console.setObjectName(_fromUtf8("console"))
                     self.gridLayout_4.addWidget(self.console, 0, 0, 1, 1)
                     self.tabConsole.addTab(self.tab_5, _fromUtf8(""))
                     self.tabWidget = QtGui.QTabWidget(self.splitter_2)
                     self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
                     self.tabProjectProperty = QtGui.QWidget()
                     self.tabProjectProperty.setObjectName(_fromUtf8("tabProjectProperty"))
                     self.gridLayout_8 = QtGui.QGridLayout(self.tabProjectProperty)
                     self.gridLayout_8.setObjectName(_fromUtf8("gridLayout_8"))
                     self.treeProjectProperties = QtGui.QTreeView(self.tabProjectProperty)
                     self.treeProjectProperties.setObjectName(_fromUtf8("treeProjectProperties"))
                     self.gridLayout_8.addWidget(self.treeProjectProperties, 0, 0, 1, 1)
                     self.tabWidget.addTab(self.tabProjectProperty, _fromUtf8(""))
                     self.gridLayout_16.addWidget(self.splitter_2, 1, 0, 1, 1)
                     MainWindow.setCentralWidget(self.centralWidget)
                     self.toolBar = QtGui.QToolBar(MainWindow)
                     self.toolBar.setObjectName(_fromUtf8("toolBar"))
                     MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
                     self.menuBar = QtGui.QMenuBar(MainWindow)
                     self.menuBar.setGeometry(QtCore.QRect(0, 0, 1065, 25))
                     self.menuBar.setObjectName(_fromUtf8("menuBar"))
                     self.menuProject = QtGui.QMenu(self.menuBar)
                     self.menuProject.setObjectName(_fromUtf8("menuProject"))
                     self.menuRun = QtGui.QMenu(self.menuBar)
                     self.menuRun.setObjectName(_fromUtf8("menuRun"))
                     self.menuOptions = QtGui.QMenu(self.menuBar)
                     self.menuOptions.setObjectName(_fromUtf8("menuOptions"))
                     self.menuHelp = QtGui.QMenu(self.menuBar)
                     self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
                     MainWindow.setMenuBar(self.menuBar)
                     iconOpen = QtGui.QIcon()
                     iconOpen.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"open.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconCreate = QtGui.QIcon()
                     iconCreate.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"new.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconSave = QtGui.QIcon()
                     iconSave.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"save.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"start.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconStop = QtGui.QIcon()
                     iconStop.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"stop.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"pause.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconAddPU = QtGui.QIcon()
                     iconAddPU.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"branch.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconClose = QtGui.QIcon()
                     iconClose.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"close.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionOpen = QtGui.QAction(MainWindow)
                     self.actionOpen.setIcon(iconOpen)
                     self.actionOpen.setObjectName(_fromUtf8("actionOpen"))
                     self.actionCreate = QtGui.QAction(MainWindow)
                     self.actionCreate.setIcon(iconCreate)
                     self.actionCreate.setObjectName(_fromUtf8("actionCreate"))
                     self.actionSave = QtGui.QAction(MainWindow)
                     self.actionSave.setIcon(iconSave)
                     self.actionSave.setObjectName(_fromUtf8("actionSave"))
                     self.actionClose = QtGui.QAction(MainWindow)
                     self.actionClose.setIcon(iconClose)
                     self.actionClose.setObjectName(_fromUtf8("actionClose"))
                     self.actionStart = QtGui.QAction(MainWindow)
                     self.actionStart.setIcon(iconStart)
                     self.actionStart.setObjectName(_fromUtf8("actionStart"))
                     self.actionPause = QtGui.QAction(MainWindow)
                     self.actionPause.setIcon(iconPause)
                     self.actionPause.setObjectName(_fromUtf8("actionPause"))
                     self.actionStop = QtGui.QAction(MainWindow)
                     self.actionStop.setIcon(iconStop)
                     self.actionStop.setObjectName(_fromUtf8("actionStop"))
                     self.actionAbout = QtGui.QAction(MainWindow)
                     self.actionAbout.setObjectName(_fromUtf8("actionAbout"))
                     self.actionOpenToolbar = QtGui.QAction(MainWindow)
                     self.actionOpenToolbar.setIcon(iconOpen)
                     self.actionOpenToolbar.setObjectName(_fromUtf8("actionOpenToolbar"))
                     self.actionCreateToolbar = QtGui.QAction(MainWindow)
                     self.actionCreateToolbar.setIcon(iconCreate)
                     self.actionCreateToolbar.setObjectName(_fromUtf8("actionCreateToolbar"))
                     self.actionSaveToolbar = QtGui.QAction(MainWindow)
                     self.actionSaveToolbar.setIcon(iconSave)
                     self.actionSaveToolbar.setObjectName(_fromUtf8("actionSaveToolbar"))
                     self.actionStarToolbar = QtGui.QAction(MainWindow)
                     self.actionStarToolbar.setIcon(iconStart)
                     self.actionStarToolbar.setObjectName(_fromUtf8("actionStarToolbar"))
                     self.actionStopToolbar = QtGui.QAction(MainWindow)
                     self.actionStopToolbar.setIcon(iconStop)
                     self.actionStopToolbar.setObjectName(_fromUtf8("actionStopToolbar"))
                     self.actionPauseToolbar = QtGui.QAction(MainWindow)
                     self.actionPauseToolbar.setIcon(iconPause)
                     self.actionPauseToolbar.setObjectName(_fromUtf8("actionPauseToolbar"))
                     self.actionAddPU = QtGui.QAction(MainWindow)
                     self.actionAddPU.setIcon(iconAddPU)
                     self.actionAddPU.setObjectName(_fromUtf8("actionAddPU"))
                     self.actionFTP = QtGui.QAction(MainWindow)
                     self.actionFTP.setObjectName(_fromUtf8("actionFTP"))
                     self.toolBar.addAction(self.actionOpenToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionCreateToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionAddPU)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionSaveToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionStarToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionPauseToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionStopToolbar)
                     self.toolBar.addSeparator()
             #         self.actionPause.triggered.connect(self.changePauseIcon)
             #         self.actionPauseToolbar.triggered.connect(self.changePauseIcon)
                     self.menuProject.addAction(self.actionOpen)
                     self.menuProject.addAction(self.actionCreate)
                     self.menuProject.addAction(self.actionSave)
                     self.menuProject.addAction(self.actionClose)
                     self.menuRun.addAction(self.actionStart)
                     self.menuRun.addAction(self.actionPause)
                     self.menuRun.addAction(self.actionStop)
                     self.menuOptions.addAction(self.actionFTP)
                     self.menuHelp.addAction(self.actionAbout)
                     self.menuBar.addAction(self.menuProject.menuAction())
                     self.menuBar.addAction(self.menuRun.menuAction())
                     self.menuBar.addAction(self.menuOptions.menuAction())
                     self.menuBar.addAction(self.menuHelp.menuAction())
                     self.tabConsole.setCurrentIndex(0)
                     self.tabWidget.setCurrentIndex(0)
                 def retranslateUi(self, MainWindow):
                     MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
                     self.tabConsole.setTabText(self.tabConsole.indexOf(self.tab_5), _translate("MainWindow", "Console", None))
                     self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabProjectProperty), _translate("MainWindow", "Project Property", None))
                     self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar", None))
                     self.menuProject.setTitle(_translate("MainWindow", "Project", None))
                     self.menuRun.setTitle(_translate("MainWindow", "Run", None))
                     self.menuOptions.setTitle(_translate("MainWindow", "Options", None))
                     self.menuHelp.setTitle(_translate("MainWindow", "Help", None))
                     self.actionOpen.setText(_translate("MainWindow", "Open", None))
                     self.actionCreate.setText(_translate("MainWindow", "Create", None))
                     self.actionSave.setText(_translate("MainWindow", "Save", None))
                     self.actionClose.setText(_translate("MainWindow", "Close", None))
                     self.actionStart.setText(_translate("MainWindow", "Start", None))
                     self.actionPause.setText(_translate("MainWindow", "Pause", None))
                     self.actionStop.setText(_translate("MainWindow", "Stop", None))
                     self.actionAbout.setText(_translate("MainWindow", "About SChain", None))
                     self.actionOpenToolbar.setText(_translate("MainWindow", "openToolbar", None))
                     self.actionOpenToolbar.setToolTip(_translate("MainWindow", "Open a project", None))
                     self.actionCreateToolbar.setText(_translate("MainWindow", "createToolbar", None))
                     self.actionCreateToolbar.setToolTip(_translate("MainWindow", "Create a new project", None))
                     self.actionSaveToolbar.setText(_translate("MainWindow", "saveToolbar", None))
                     self.actionSaveToolbar.setToolTip(_translate("MainWindow", "Save a project", None))
                     self.actionStarToolbar.setText(_translate("MainWindow", "starToolbar", None))
                     self.actionStarToolbar.setToolTip(_translate("MainWindow", "Start process", None))
                     self.actionStopToolbar.setText(_translate("MainWindow", "stopToolbar", None))
                     self.actionStopToolbar.setToolTip(_translate("MainWindow", "Stop process", None))
                     self.actionPauseToolbar.setText(_translate("MainWindow", "pauseToolbar", None))
                     self.actionPauseToolbar.setToolTip(_translate("MainWindow", "Pause process", None))
                     self.actionAddPU.setText(_translate("MainWindow", "Add Processing Unit", None))
                     self.actionFTP.setText(_translate("MainWindow", "FTP", None))
                 def closeEvent(self, event):
                     reply = QtGui.QMessageBox.question(self, 'Message',
                         "Are you sure to quit?", QtGui.QMessageBox.Yes |
                         QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                     if reply == QtGui.QMessageBox.Yes:
                         event.accept()
                     else:
                         event.ignore()
                 def aboutEvent(self):
                     title = "Signal Chain Processing Software v%s" %__version__
                     message = """
             Developed by Jicamarca Radio Observatory
             Any comment to miguel.urco@jro.igp.gob.pe
             """
                     QtGui.QMessageBox.about(self, title, message)
             class Ui_BasicWindow(Ui_EnvWindow, Ui_ProjectTab, Ui_VoltageTab, Ui_SpectraTab, Ui_SpectraHeisTab, Ui_CorrelationTab):
                 def setupUi(self, MainWindow):
                     Ui_EnvWindow.setupUi(self, MainWindow)
                     Ui_ProjectTab.setupUi(self)
                     Ui_VoltageTab.setupUi(self)
                     Ui_SpectraTab.setupUi(self)
                     Ui_SpectraHeisTab.setupUi(self)
                     Ui_CorrelationTab.setupUi(self)
                     self.retranslateUi(MainWindow)
                     QtCore.QMetaObject.connectSlotsByName(MainWindow)
                 def retranslateUi(self, MainWindow):
                     Ui_EnvWindow.retranslateUi(self, MainWindow)
                     Ui_ProjectTab.retranslateUi(self)
                     Ui_VoltageTab.retranslateUi(self)
                     Ui_SpectraTab.retranslateUi(self)
                     Ui_SpectraHeisTab.retranslateUi(self)
                     Ui_CorrelationTab.retranslateUi(self)
             class Ui_AdvancedWindow(Ui_EnvWindow):
                 def setupUi(self, AdvancedWindow):
                     Ui_MainWindow.setupUi(self, AdvancedWindow)
                 def retranslateUi(self, AdvancedWindow):
                     Ui_MainWindow.retranslateUi(self, AdvancedWindow)
             if __name__ == "__main__":
                 import sys
                 app = QtGui.QApplication(sys.argv)
                 MainWindow = QtGui.QMainWindow()
                 ui = Ui_BasicWindow()
                 ui.setupUi(MainWindow)
                 MainWindow.show()
                 sys.exit(app.exec_())

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages