schain Commit - r581:cd9db1f6f595 · Jicamarca Repository

Bug fixed in SignalChain GUI:...

Miguel Valdez -

r581:cd9db1f6f595

parent child

Context file:

r581:cd9db1f6f595

Collapse all files

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

schainpy/controller.py +9 -1

             '''
             Created on September , 2012
             @author:
             '''
             from xml.etree.ElementTree import Element, SubElement
             from xml.etree import ElementTree as ET
             from xml.dom import minidom
             #import datetime
             from model import *
             import ast
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
                 rough_string = ET.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):
                     if self.__formated_value != None:
                         return self.__formated_value
                     value = self.value
                     if self.format == 'bool':
                         value = int(value)
                     if self.format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if self.format == 'intlist':
                         """
                         Example:
                             value = (0,1,2)
                         """
                         strList = value.split(',')
                         intList = [int(x) for x in strList]
                         self.__formated_value = intList
                         return self.__formated_value
                     if self.format == 'floatlist':
                         """
                         Example:
                             value = (0.5, 1.4, 2.7)
                         """
                         strList = value.split(',')
                         floatList = [float(x) for x in strList]
                         self.__formated_value = floatList
                         return self.__formated_value
                     if self.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 self.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 self.format == 'pairslist':
                         """
                         Example:
                             value = (0,1),(1,2)
                         """
                         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 self.format == 'multilist':
                         """
                         Example:
                             value = (0,1,2),(3,4,5)
                         """
                         multiList = ast.literal_eval(value)
                         self.__formated_value = multiList
                         return self.__formated_value
                     format_func = eval(self.format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def setup(self, id, name, value, format='str'):
                     self.id = id
                     self.name = name
                     self.value = str(value)
                     self.format = str.lower(format)
                 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 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)
                     value = parameterObj.getValue()
                     return value
                 def setup(self, id, name, priority, type):
                     self.id = 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()
                     parmConfObj.setup(id, name, value, format)
                     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 str(self.id)
                 def getInputId(self):
                     return str(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):
                     self.id = 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')
                     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):
                     finalSts = 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)
                         finalSts = finalSts or sts
                     return finalSts
                 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 = 0
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
                     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.addRunOperation(**kwargs)
                 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, **kwargs):
                     self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     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, control=None, dataq=None):
                     self.id = None
                     self.name = None
                     self.description = None
                     self.procUnitConfObjDict = {}
                     #global data_q
                     #data_q = dataq
                     if control==None:
                         control = {}
                         control['stop'] = False
                         control['pause'] = False
                     self.control = control
                 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 setup(self, id, name, description):
                     self.id = 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):
                     #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','')
                     id = self.__getNewId()
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(id, name, datatype, parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId=0, datatype=None, name=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','')
                     id = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(id, name, datatype, inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 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):
                     return self.procUnitConfObjDict[id]
+                def getProcUnitObjByName(self, name):
+                    for obj in self.procUnitConfObjDict.values():
+                        if obj.name == name:
+                            return obj
+                    return None
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.makeXml(projectElement)
                     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):
                     #tree = ET.parse(filename)
                     self.projectElement = None
             #        self.readUnitConfObjList = []
                     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)
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                 def printattr(self):
                     print "Project[%s]: name = %s, description = %s" %(self.id,
                                                                           self.name,
                                                                           self.description)
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.printattr()
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.createObjects()
                     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 run(self):
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.run()
                     print
                     print "*"*40
                     print "   Starting SIGNAL CHAIN PROCESSING  "
                     print "*"*40
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         finalSts = False
                         for procKey in keyList:
             #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
                             sts = procUnitConfObj.run()
                             finalSts = finalSts or sts
                         #If every process unit finished so end process
                         if not(finalSts):
                             print "Every process unit have finished"
                             break
                         if self.control['pause']:
                             print "Pause..."
                             while True:
                                 time.sleep(0.1)
                                 if not self.control['pause']:
                                     break
                                 if self.control['stop']:
                                     break
                         if self.control['stop']:
                             print "Stopping process"
                             break
                     #Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
                     print "Process stopped"
                 def start(self, filename):
                     self.writeXml(filename)
                     self.readXml(filename)
                     self.createObjects()
                     self.connectObjects()
                     self.run()
             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)
             #    opObj00 = readUnitConfObj.addOperation(name='printInfo')
                 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')
             #    opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
             #    opObj11.addParameter(name='zmin', value='40', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    procUnitConfObj2 = controllerObj.addProcUnit(datatype='Voltage', inputId=procUnitConfObj0.getId())
             #
             #    opObj12 = procUnitConfObj2.addOperation(name='CohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #    opObj12.addParameter(name='overlapping', value='1', format='int')
             #
             #    procUnitConfObj3 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj2.getId())
             #    procUnitConfObj3.addParameter(name='nFFTPoints', value='32', format='int')
             #
             #    opObj11 = procUnitConfObj3.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot1', 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')
             #    opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='10', format='int')
             #    opObj11.addParameter(name='wintitle', value='RTI', format='str')
             ##    opObj11.addParameter(name='xmin', value='21', format='float')
             ##    opObj11.addParameter(name='xmax', value='22', format='float')
             #    opObj11.addParameter(name='zmin', value='40', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    opObj11.addParameter(name='showprofile', value='1', format='int')
             #    opObj11.addParameter(name='timerange', value=str(60), format='int')
             #    opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
             #    opObj10.addParameter(name='channelList', value='0,2,4,6', format='intlist')
             #
             #    opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #
             #    opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
             #    opObj10.addParameter(name='channelList', value='2,6', format='intlist')
             #
             #    opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='3', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    opObj12 = procUnitConfObj1.addOperation(name='decoder')
             #    opObj12.addParameter(name='ncode', value='2', format='int')
             #    opObj12.addParameter(name='nbauds', value='8', format='int')
             #    opObj12.addParameter(name='code0', value='001110011', format='int')
             #    opObj12.addParameter(name='code1', value='001110011', format='int')
             #    procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj1.getId())
             #
             #    opObj21 = procUnitConfObj2.addOperation(name='IncohInt', optype='external')
             #    opObj21.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj2.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='4', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot OBJ 2', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', 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/model/utils/jroutils_ftp.py +1 -1

             '''
             @author: Daniel Suarez
             '''
             import os
             import glob
             import ftplib
             try:
                 import paramiko
                 import scp
             except:
                 print "You should install paramiko if you will use SSH protocol to upload files to a server"
             import multiprocessing
             import time
             import threading
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             class Remote(threading.Thread):
                 """
                 Remote is a parent class used to define the behaviour of FTP and SSH class. These clases are
                 used to upload or download files remotely.
                 Non-standard Python modules used:
                     None
                 Written by:
                     "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe  Jun. 03, 2015
                 """
                 server = None
                 username = None
                 password = None
                 remotefolder = None
                 period = 60
                 fileList = []
                 bussy = False
                 def __init__(self, server, username, password, remotefolder, period=60):
                     threading.Thread.__init__(self)
                     self._stop = threading.Event()
                     self.status = 0
                     self.period = period
                     self.fileList = []
                     self.bussy = False
                     self.stopFlag = False
                     print "[Remote Server] Opening server: %s" %server
                     if self.open(server, username, password, remotefolder):
                         print "[Remote Server] %s server was opened successfully" %server
                 def stop(self):
                     self.stopFlag = True
                 def open(self):
                     """
                     Connect to server and create a connection class (FTP or SSH) to remote server.
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def close(self):
                     """
                     Close connection to server
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def mkdir(self, remotefolder):
                     """
                     Create a folder remotely
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def cd(self, remotefolder):
                     """
                     Change working directory in remote server
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def download(self, filename, localfolder=None):
                     """
                     Download a file from server to local host
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def sendFile(self, fullfilename):
                     """
                     sendFile method is used to upload a local file to the current directory in remote server
                     Inputs:
                         fullfilename        - full path name of local file to store in remote directory
                     Returns:
 in error case else 1
                     """
                     raise NotImplementedError, "Implement this method in child class"
                 def upload(self, fullfilename, remotefolder=None):
                     """
                     upload method is used to upload a local file to remote directory. This method changes
                     working directory before sending a file.
                     Inputs:
                         fullfilename        - full path name of local file to store in remote directory
                         remotefolder    - remote directory
                     Returns:
 in error case else 1
                     """
                     print "[Remote Server] Uploading %s to %s:%s" %(fullfilename, self.server, self.remotefolder)
                     if not self.status:
                         return 0
                     if remotefolder == None:
                         remotefolder = self.remotefolder
                     if not self.cd(remotefolder):
                         return 0
                     if not self.sendFile(fullfilename):
                         print "[Remote Server] Error uploading file %s" %fullfilename
                         return 0
                     print "[Remote Server] upload finished successfully"
                     return 1
                 def delete(self, filename):
                     """
                     Remove a file from remote server
                     """
                     pass
                 def updateFileList(self, fileList):
                     """
                     Remove a file from remote server
                     """
                     if fileList == self.fileList:
                         return 1
                     init = time.time()
                     while(self.bussy):
                         sleep(0.1)
                         if time.time() - init > 2*self.period:
                             return 0
                     self.fileList = fileList
                     return 1
                 def run(self):
                     if not self.status:
                         print "Finishing FTP service"
                         return
                     if not self.cd(self.remotefolder):
                         raise ValueError, "Could not access to the new remote directory: %s" %self.remotefolder
                     sts = True
                     while True:
                         sleep(self.period)
                         self.bussy = True
                         for thisFile in self.fileList:
                             sts = self.upload(thisFile, self.remotefolder)
                             if not sts: break
                         if not sts: break
                         self.bussy = False
                         if self.stopFlag:
                             break
                     print "[Remote Server] Thread stopped successfully"
             class FTPClient(Remote):
                 __ftpClientObj = None
                 def __init__(self, server, username, password, remotefolder, period=60):
                     """
                     """
                     Remote.__init__(self, server, username, password, remotefolder, period)
                 def open(self, server, username, password, remotefolder):
                     """
                     This method is used to set FTP parameters and establish a connection to remote server
                     Inputs:
                         server    - remote server IP Address
                         username    - remote server Username
                         password    - remote server password
                         remotefolder    - remote server current working directory
                     Return: void
                     Affects:
                         self.status        - in case of error or fail connection this parameter is set to 0 else 1
                     """
                     if server == None:
                         raise ValueError, "FTP server should be defined"
                     if username == None:
                         raise ValueError, "FTP username should be defined"
                     if password == None:
                         raise ValueError, "FTP password should be defined"
                     if remotefolder == None:
                         raise ValueError, "FTP remote folder should be defined"
                     try:
                         ftpClientObj = ftplib.FTP(server)
                     except ftplib.all_errors:
                         print "FTP server connection fail: %s" %server
                         self.status = 0
                         return 0
                     try:
                         ftpClientObj.login(username, password)
                     except ftplib.all_errors:
                         print "FTP username or password are incorrect"
                         self.status = 0
                         return 0
                     if remotefolder == None:
                         remotefolder = ftpClientObj.pwd()
                     else:
                         try:
                             ftpClientObj.cwd(remotefolder)
                         except ftplib.all_errors:
                             print "FTP remote folder is invalid: %s" %remotefolder
                             remotefolder = ftpClientObj.pwd()
                     self.server = server
                     self.username = username
                     self.password = password
                     self.remotefolder = remotefolder
                     self.__ftpClientObj = ftpClientObj
                     self.status = 1
                     return 1
                 def close(self):
                     """
                     Close connection to remote server
                     """
                     if not self.status:
                         return 0
                     self.__ftpClientObj.close()
                 def mkdir(self, remotefolder):
                     """
                     mkdir is used to make a new directory in remote server
                     Input:
                         remotefolder    - directory name
                     Return:
 in error case else 1
                     """
                     if not self.status:
                         return 0
                     try:
                         self.__ftpClientObj.mkd(dirname)
                     except ftplib.all_errors:
                         print "Error creating remote folder: %s" %remotefolder
                         return 0
                     return 1
                 def cd(self, remotefolder):
                     """
                     cd is used to change remote working directory on server
                     Input:
                         remotefolder    - current working directory
                     Affects:
                         self.remotefolder
                     Return:
 in case of error else 1
                     """
                     if not self.status:
                         return 0
                     if remotefolder == self.remotefolder:
                         return 1
                     try:
                         self.__ftpClientObj.cwd(remotefolder)
                     except ftplib.all_errors:
                         print 'Error changing to %s' %remotefolder
                         print 'Trying to create remote folder'
                         if not self.mkdir(remotefolder):
                             print 'Remote folder could not be created'
                             return 0
                         try:
                             self.__ftpClientObj.cwd(remotefolder)
                         except ftplib.all_errors:
                             return 0
                     self.remotefolder = remotefolder
                     return 1
                 def sendFile(self, fullfilename):
                     if not self.status:
                         return 0
                     file = open(fullfilename, 'rb')
                     filename = os.path.split(fullfilename)[-1]
                     command = "STOR %s" %filename
                     try:
                         self.__ftpClientObj.storbinary(command, file)
                     except ftplib.all_errors:
                         return 0
                     try:
                         self.__ftpClientObj.sendcmd('SITE CHMOD 755 ' + filename)
                     except ftplib.all_errors, e:
                         print e
                     file.close()
                     return 1
             class SSHClient(Remote):
                 __sshClientObj = None
                 __scpClientObj = None
                 def __init__(self, server, username, password, remotefolder, period=60):
                     """
                     """
                     Remote.__init__(self, server, username, password, remotefolder, period)
                 def open(self, server, username, password, remotefolder, port=22):
                     """
                     This method is used to set SSH parameters and establish a connection to a remote server
                     Inputs:
                         server    - remote server IP Address
                         username    - remote server Username
                         password    - remote server password
                         remotefolder    - remote server current working directory
                     Return: void
                     Affects:
                         self.status        - in case of error or fail connection this parameter is set to 0 else 1
                     """
                     if server == None:
                         raise ValueError, "SSH server should be defined"
                     if username == None:
                         raise ValueError, "SSH username should be defined"
                     if password == None:
                         raise ValueError, "SSH password should be defined"
                     if remotefolder == None:
                         raise ValueError, "SSH remote folder should be defined"
                     try:
                         sshClientObj = paramiko.SSHClient()
                     except:
                         print "SSH server connection fail: %s" %server
                         self.status = 0
                         return 0
                     sshClientObj.load_system_host_keys()
                     sshClientObj.set_missing_host_key_policy(paramiko.WarningPolicy())
                     try:
                         sshClientObj.connect(server, username=username, password=password, port=port)
                     except :
                         print "SSH username or password are incorrect: %s"
                         self.status = 0
                         return 0
                     scpClientObj = scp.SCPClient(sshClientObj.get_transport(), socket_timeout=30)
                     if remotefolder == None:
                         remotefolder = self.pwd()
                     self.server = server
                     self.username = username
                     self.password = password
                     self.__sshClientObj = sshClientObj
                     self.__scpClientObj = scpClientObj
                     self.status = 1
                     if not self.cd(remotefolder):
                         raise ValueError, "Could not access to remote folder: %s" %remotefolder
                         return 0
                     self.remotefolder = remotefolder
                     return 1
                 def close(self):
                     """
                     Close connection to remote server
                     """
                     if not self.status:
                         return 0
                     self.__sshObj.close()
                 def __execute(self, command):
                     """
                     __execute a command on remote server
                     Input:
                         command    - Exmaple 'ls -l'
                     Return:
 in error case else 1
                     """
                     if not self.status:
                         return 0
                     stdin, stdout, stderr = self.__sshClientObj.exec_command(command)
                     result = stderr.readlines()
                     if len(result) > 1:
                         return 0
                     result = stdout.readlines()
                     if len(result) > 1:
                         return result[0][:-1]
                     return 1
                 def mkdir(self, remotefolder):
                     """
                     mkdir is used to make a new directory in remote server
                     Input:
                         remotefolder    - directory name
                     Return:
 in error case else 1
                     """
                     command = 'mkdir %s' %remotefolder
                     return self.__execute(command)
                 def pwd(self):
                     command = 'pwd'
                     return self.__execute(command)
                 def cd(self, remotefolder):
                     """
                     cd is used to change remote working directory on server
                     Input:
                         remotefolder    - current working directory
                     Affects:
                         self.remotefolder
                     Return:
 in case of error else 1
                     """
                     if not self.status:
                         return 0
                     if remotefolder == self.remotefolder:
                         return 1
                     chk_command = "cd %s; pwd" %remotefolder
                     mkdir_command = "mkdir %s" %remotefolder
                     if not self.__execute(chk_command):
                         if not self.__execute(mkdir_command):
                             self.remotefolder = None
                             return 0
                     self.remotefolder = remotefolder
                     return 1
                 def sendFile(self, fullfilename):
                     if not self.status:
                         return 0
                     try:
                         self.__scpClientObj.put(fullfilename, remote_path=self.remotefolder)
                     except:
                         return 0
                     remotefile = os.path.join(self.remotefolder, os.path.split(fullfilename)[-1])
                     command = 'chmod 775 %s' %remotefile
                     return self.__execute(command)
             class SendToServer(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.isConfig = False
                     self.clientObj = None
-                def setup(self, server, username, password, remotefolder, localfolder, ext='.png', period=60, protocol='ftp'):
+                def setup(self, server, username, password, remotefolder, localfolder, ext='.png', period=60, protocol='ftp', **kwargs):
                     self.clientObj = None
                     self.localfolder = localfolder
                     self.ext = ext
                     self.period = period
                     if str.lower(protocol) == 'ftp':
                         self.clientObj = FTPClient(server, username, password, remotefolder, period)
                     if str.lower(protocol) == 'ssh':
                         self.clientObj = SSHClient(server, username, password, remotefolder, period)
                     if not self.clientObj:
                         raise ValueError, "%s has been chosen as remote access protocol but it is not valid" %protocol
                     self.clientObj.start()
                 def findFiles(self):
                     filenameList = glob.glob1(self.localfolder, '*%s' %self.ext)
                     if len(filenameList) < 1:
                         return []
                     fullfilenameList = [os.path.join(self.localfolder, thisFile) for thisFile in filenameList]
                     return fullfilenameList
                 def run(self, **kwargs):
                     if not self.isConfig:
                         self.init = time.time()
                         self.setup(**kwargs)
                         self.isConfig = True
                     if time.time() - self.init >= self.period:
                         fullfilenameList = self.findFiles()
                         self.clientObj.updateFileList(fullfilenameList)
                         self.init = time.time()
                 def close(self):
                     print "[Remote Server] Stopping thread"
                     self.clientObj.stop()
             class FTP(object):
                 """
                 Ftp is a public class used to define custom File Transfer Protocol from "ftplib" python module
                 Non-standard Python modules used: None
                 Written by "Daniel Suarez":mailto:daniel.suarez@jro.igp.gob.pe  Oct. 26, 2010
                 """
                 def __init__(self,server = None, username=None, password=None, remotefolder=None):
                     """
                     This method is used to setting parameters for FTP and establishing connection to remote server
                     Inputs:
                         server    - remote server IP Address
                         username    - remote server Username
                         password    - remote server password
                         remotefolder    - remote server current working directory
                     Return: void
                     Affects:
                         self.status    - in Error Case or Connection Failed this parameter is set to 1 else 0
                         self.folderList    - sub-folder list of remote folder
                         self.fileList    - file list of remote folder
                     """
                     if ((server == None) and (username==None) and (password==None) and (remotefolder==None)):
                         server, username, password, remotefolder = self.parmsByDefault()
                     self.server = server
                     self.username = username
                     self.password = password
                     self.remotefolder = remotefolder
                     self.file = None
                     self.ftp = None
                     self.status = 0
                     try:
                         self.ftp = ftplib.FTP(self.server)
                         self.ftp.login(self.username,self.password)
                         self.ftp.cwd(self.remotefolder)
             #            print 'Connect to FTP Server: Successfully'
                     except ftplib.all_errors:
                         print 'Error FTP Service'
                         self.status = 1
                         return
                     self.dirList = []
                     try:
                         self.dirList = self.ftp.nlst()
                     except ftplib.error_perm, resp:
                         if str(resp) == "550 No files found":
                                 print "no files in this directory"
                                 self.status = 1
                                 return
                     except ftplib.all_errors:
                         print 'Error Displaying Dir-Files'
                         self.status = 1
                         return
                     self.fileList = []
                     self.folderList = []
                     #only for test
                     for f in self.dirList:
                         name, ext = os.path.splitext(f)
                         if ext != '':
                             self.fileList.append(f)
             #                print 'filename: %s - size: %d'%(f,self.ftp.size(f))
                 def parmsByDefault(self):
                     server = 'jro-app.igp.gob.pe'
                     username = 'wmaster'
                     password = 'mst2010vhf'
                     remotefolder = '/home/wmaster/graficos'
                     return server, username, password, remotefolder
                 def mkd(self,dirname):
                     """
                     mkd is used to make directory in remote server
                     Input:
                         dirname    - directory name
                     Return:
 in error case else 0
                     """
                     try:
                         self.ftp.mkd(dirname)
                     except:
                         print 'Error creating remote folder:%s'%dirname
                         return 1
                     return 0
                 def delete(self,filename):
                     """
                     delete is used to delete file in current working directory of remote server
                     Input:
                         filename    - filename to delete in remote folder
                     Return:
 in error case else 0
                     """
                     try:
                         self.ftp.delete(filename)
                     except:
                         print 'Error deleting remote file:%s'%filename
                         return 1
                     return 0
                 def download(self,filename,localfolder):
                     """
                     download is used to downloading file from remote folder into local folder
                     Inputs:
                         filename    - filename to donwload
                         localfolder    - directory local to store filename
                     Returns:
                         self.status    - 1 in error case else 0
                     """
                     self.status = 0
                     if not(filename in self.fileList):
                         print 'filename:%s not exists'%filename
                         self.status = 1
                         return self.status
                     newfilename = os.path.join(localfolder,filename)
                     self.file = open(newfilename, 'wb')
                     try:
                         print 'Download: ' + filename
                         self.ftp.retrbinary('RETR ' + filename, self.__handleDownload)
                         print 'Download Complete'
                     except ftplib.all_errors:
                         print 'Error Downloading ' + filename
                         self.status = 1
                         return self.status
                     self.file.close()
                     return self.status
                 def __handleDownload(self,block):
                     """
                     __handleDownload is used to handle writing file
                     """
                     self.file.write(block)
                 def upload(self,filename,remotefolder=None):
                     """
                     upload is used to uploading local file to remote directory
                     Inputs:
                         filename    - full path name of local file to store in remote directory
                         remotefolder    - remote directory
                     Returns:
                         self.status    - 1 in error case else 0
                     """
                     if remotefolder == None:
                         remotefolder = self.remotefolder
                     self.status = 0
                     try:
                         self.ftp.cwd(remotefolder)
                         self.file = open(filename, 'rb')
                         (head, tail) = os.path.split(filename)
                         command = "STOR " + tail
                         print 'Uploading: ' + tail
                         self.ftp.storbinary(command, self.file)
                         print 'Upload Completed'
                     except ftplib.all_errors:
                         print 'Error Uploading ' + tail
                         self.status = 1
                         return self.status
                     self.file.close()
                     #back to initial directory in __init__()
                     self.ftp.cwd(self.remotefolder)
                     return self.status
                 def dir(self,remotefolder):
                     """
                     dir is used to change working directory of remote server and get folder and file list
                     Input:
                         remotefolder    - current working directory
                     Affects:
                         self.fileList    - file list of working directory
                     Return:
                         infoList    - list with filenames and size of file in bytes
                         self.folderList    -    folder list
                     """
                     self.remotefolder = remotefolder
                     print 'Change to ' + self.remotefolder
                     try:
                         self.ftp.cwd(remotefolder)
                     except ftplib.all_errors:
                         print 'Error Change to ' + self.remotefolder
                         infoList = None
                         self.folderList = None
                         return infoList,self.folderList
                     self.dirList = []
                     try:
                         self.dirList = self.ftp.nlst()
                     except ftplib.error_perm, resp:
                         if str(resp) == "550 No files found":
                                 print "no files in this directory"
                                 infoList = None
                                 self.folderList = None
                                 return infoList,self.folderList
                     except ftplib.all_errors:
                         print 'Error Displaying Dir-Files'
                         infoList = None
                         self.folderList = None
                         return infoList,self.folderList
                     infoList = []
                     self.fileList = []
                     self.folderList = []
                     for f in self.dirList:
                         name,ext = os.path.splitext(f)
                         if ext != '':
                             self.fileList.append(f)
                             value = (f,self.ftp.size(f))
                             infoList.append(value)
                         if ext == '':
                             self.folderList.append(f)
                     return infoList,self.folderList
                 def close(self):
                     """
                     close is used to close and end FTP connection
                     Inputs: None
                     Return: void
                     """
                     self.ftp.close()
             class SendByFTP(Operation):
                 def __init__(self):
                     self.status = 1
                     self.counter = 0
                 def error_print(self, ValueError):
                     print ValueError, 'Error FTP'
                     print "don't worry the program is running..."
                 def worker_ftp(self, server, username, password, remotefolder, filenameList):
                     self.ftpClientObj = FTP(server, username, password, remotefolder)
                     for filename in filenameList:
                         self.ftpClientObj.upload(filename)
                     self.ftpClientObj.close()
                 def ftp_thread(self, server, username, password, remotefolder):
                     if not(self.status):
                         return
                     p = multiprocessing.Process(target=self.worker_ftp, args=(server, username, password, remotefolder, self.filenameList,))
                     p.start()
                     p.join(3)
                     if p.is_alive():
                         p.terminate()
                         p.join()
                         print 'killing ftp process...'
                         self.status = 0
                         return
                     self.status = 1
                     return
                 def filterByExt(self, ext, localfolder):
                     fnameList = glob.glob1(localfolder,ext)
                     self.filenameList = [os.path.join(localfolder,x) for x in fnameList]
                     if len(self.filenameList) == 0:
                         self.status = 0
                 def run(self, dataOut, ext, localfolder, remotefolder, server, username, password, period=1):
                     self.counter += 1
                     if self.counter >= period:
                         self.filterByExt(ext, localfolder)
                         self.ftp_thread(server, username, password, remotefolder)
                         self.counter = 0
                     self.status = 1

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