schain Commit - r175:d5210476252d · Jicamarca Repository

-Estandarizacion de los nombres de paquetes y modulos escritos en minusculas...

Miguel Valdez -

r175:d5210476252d

parent child

Context file:

r175:d5210476252d

Collapse all files

schainpy/controller/controller.py ~~schainpy/Controller/controller.py~~ renamed +35 -21

             '''
             Created on September , 2012
             @author:
             '''
             from xml.etree.ElementTree import Element, SubElement, ElementTree
-            from element import  prettify
             from xml.etree import ElementTree as ET
+            from xml.dom import minidom
             import sys
+            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="  ")
             #def save(a, b):
             #
             #    nameP = "Alexnder"
             #    descripcion = self.projectWindow.Text()
             #    id = 1
             #    x = self.data.projectWindow.cmbbox.value()
             #
             #    projectObj = Project(id, name, description)
             #
             #    projectObj.setup(id, name, description)
             class Project():
                 id = None
                 name = None
                 description = None
                 readBranchObjList = None
                 procBranchObjList = None
                 def __init__(self):
             #        self.id = id
             #        self.name = name
             #        self.description = description
                     self.readBranchObjList = []
                     self.procBranchObjList = []
                 def setParms(self, id, name, description):
                     self.id = id
                     self.name = name
                     self.description = description
                 def addReadBranch(self, dpath, dataformat, readMode, startDate='', endDate='', startTime='', endTime=''):
                     id = len(self.readBranchObjList) + 1
                     readBranchObj = ReadBranch(id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime)
                     self.readBranchObjList.append(readBranchObj)
                     return readBranchObj
                 def addProcBranch(self, name):
                     id = len(self.procBranchObjList) + 1
                     procBranchObj = ProcBranch(id, name)
                     self.procBranchObjList.append(procBranchObj)
                     return procBranchObj
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     #projectElement.set('description', self.description)
                     se = SubElement(projectElement, 'description',description=self.description)#ESTO ES LO ULTIMO QUE SE TRABAJO
                     #se.text = self.description                    #ULTIMA MODIFICACION PARA SACAR UN SUB ELEMENT
                     for readBranchObj in self.readBranchObjList:
                         readBranchObj.makeXml(projectElement)
                     for procBranchObj in self.procBranchObjList:
                         procBranchObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename):
                     self.makeXml()
                     ElementTree(self.projectElement).write(filename, method='xml')
                     print prettify(self.projectElement)
-                def readXml(self,workspace):
+                def readXml(self, filename):
-                    print "Aqui estoy leyendo"
-                    tree=ET.parse(workspace)
+                    #tree = ET.parse(filename)
-                    root=tree.getroot()
+                    self.projectElement = None
-                    self.project=root.tag
+                    tree = ElementTree(self.projectElement).parse(filename)
-                    self.idProyect= root.attrib.get('id')
-                    self.nameProyect= root.attrib.get('name')
+                    self.project = self.projectElement.tag
+                    self.id = self.projectElement.get('id')
+                    self.name = self.projectElement.get('name')
+                    readElement = self.projectElement.getiterator('readBranch')
+                    root = tree.getroot()
+                    self.project = root.tag
+                    self.id = root.attrib.get('id')
+                    self.name = root.attrib.get('name')
                     for description in root.findall('description'):
                         description = description.get('description')
                     self.description= description
                     for readBranch in root.findall('readBranch'):
                         id = readBranch.get('id')
                     self.idrb=id
                     for procBranch in root.findall('procBranch'):
                         id = readBranch.get('id')
                         name = readBranch.get('name')
                     self.idpb=id
                     self.nameBranch=name
             #
-                    print self.project
-                    print self.idProyect
-                    print self.nameProyect
-                    print  self.description
-                    print self.idrb
-                    print self.idpb
-                    print self.nameBranch
             ####ESTO DEL MEDIO ESTABA COMENTADO
             #        print root.tag , root.attrib
             #
             #        print root.attrib.get('id')
             #        print root.attrib.get('name')
             #        for description in root.findall('description'):
             #            description = root.find('description').text
             #            name = root.get('name')
             #            print name, description
             #        description=root.find('description').text
             #        print description
             #   ESTO FUNCIONABA HACIA ABAJO
-                    print "Otra forma "
                     root=tree.getroot()
                     print root.tag , root.attrib
                     for child in root:
                         print child.tag ,child.attrib
                         for child in child:
                             print child.tag ,child.attrib
                             for child in child:
                                 print child.tag ,child.attrib
                                 for child in child:
                                     print child.tag ,child.attrib
             #
             class ReadBranch():
                 id = None
                 dpath = None
                 dataformat = None
                 readMode = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 def __init__(self, id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime):
                     self.id = id
                     self.dpath = dpath
                     self.dataformat = dataformat
                     self.readMode = readMode
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                 def makeXml(self, projectElement):
                     readBranchElement = SubElement(projectElement, 'readBranch')
                     readBranchElement.set('id', str(self.id))
             #        readBranchElement.set('dpath', self.dpath)
             #        readBranchElement.set('dataformat', self.dataformat)
             #        readBranchElement.set('startDate', self.startDate)
             #        readBranchElement.set('endDate', self.endDate)
             #        readBranchElement.set('startTime', self.startTime)
             #        readBranchElement.set('endTime', self.endTime)
             #        readBranchElement.set('readMode', str(self.readMode))
             #        se = SubElement(readBranchElement, 'dpath')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.dpath
             #
             #        se = SubElement(readBranchElement, 'dataformat')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.dataformat
             #
             #        se = SubElement(readBranchElement, 'startDate')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.startDate
             #
             #        se = SubElement(readBranchElement, 'endDate')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.endDate
             #
             #        se = SubElement(readBranchElement, 'startTime')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.startTime
             #
             #        se = SubElement(readBranchElement, 'endTime')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.endTime
             #
             #        se = SubElement(readBranchElement, 'readMode')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = str(self.readMode)
                     ##########################################################################
                     se = SubElement(readBranchElement, 'parameter', name='dpath'     , value=self.dpath)
                     se = SubElement(readBranchElement, 'parameter', name='dataformat', value=self.dataformat)
                     se = SubElement(readBranchElement, 'parameter', name='startDate' , value=self.startDate)
                     se = SubElement(readBranchElement, 'parameter', name='endDate'   , value=self.endDate)
                     se = SubElement(readBranchElement, 'parameter', name='startTime' , value=self.startTime)
                     se = SubElement(readBranchElement, 'parameter', name='endTime'   , value=self.endTime)
                     se = SubElement(readBranchElement, 'parameter', name='readMode'  , value=str(self.readMode))
             class ProcBranch():
                 id = None
                 name = None
                 upObjList = None
                 def __init__(self, id, name):
                     self.id = id
                     self.name = name
                     self.upObjList = []
                 def addUP(self, name, type):
                     id = len(self.upObjList) + 1
                     upObj = UP(id, name, type)
                     self.upObjList.append(upObj)
                     return upObj
                 def makeXml(self, projectElement):
                     procBranchElement = SubElement(projectElement, 'procBranch')
                     procBranchElement.set('id', str(self.id))
                     procBranchElement.set('name', self.name)
                     for upObj in self.upObjList:
                         upObj.makeXml(procBranchElement)
             class UP():
                 id = None
                 name = None
                 type = None
                 opObjList = []
                 def __init__(self, id, name, type):
                     self.id = id
                     self.name = name
                     self.type = type
                     self.opObjList = []
                 def addOperation(self, name, priority):
                     id = len(self.opObjList) + 1
                     opObj = Operation(id, name, priority)
                     self.opObjList.append(opObj)
                     return opObj
                 def makeXml(self, procBranchElement):
                     upElement = SubElement(procBranchElement, 'UP')
                     upElement.set('id', str(self.id))
                     upElement.set('name', self.name)
                     upElement.set('type', self.type)
                     for opObj in self.opObjList:
                         opObj.makeXml(upElement)
             class Operation():
                 id = 0
                 name = None
                 priority = None
                 parmObjList = []
                 def __init__(self, id, name, priority):
                     self.id = id
                     self.name = name
                     self.priority = priority
                     self.parmObjList = []
                 def addParameter(self, name, value):
                     id = len(self.parmObjList) + 1
                     parmObj = Parameter(id, name, value)
                     self.parmObjList.append(parmObj)
                     return parmObj
                 def makeXml(self, upElement):
                     opElement = SubElement(upElement, 'Operation')
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('priority', str(self.priority))
                     for parmObj in self.parmObjList:
                         parmObj.makeXml(opElement)
             class Parameter():
                 id = None
                 name = None
                 value = None
                 def __init__(self, id, name, value):
                     self.id = id
                     self.name = name
                     self.value = value
                 def makeXml(self, opElement):
                     parmElement = SubElement(opElement, 'Parameter')
                     parmElement.set('name', self.name)
                     parmElement.set('value', self.value)
+                def readXml(self, opElement):
+                    pass
             #        se = SubElement(parmElement, 'value')#ESTO ES LO ULTIMO QUE SE TRABAJO
             #        se.text = self.value
             if __name__ == '__main__':
                 desc = "Este es un test"
                 filename = "test.xml"
-                workspace=str("C:\\Users\\alex\\workspace\\GUIV2.0\\test.xml")
                 projectObj = Project()
                 projectObj.setParms(id = '11', name='test01', description=desc)
                 readBranchObj = projectObj.addReadBranch(dpath='mydata', dataformat='rawdata', readMode=0, startDate='1', endDate='3', startTime='4', endTime='5')
                 procBranchObj = projectObj.addProcBranch(name='Branch1')
                 procBranchObj1 = projectObj.addProcBranch(name='Branch2')
                 upObj1 = procBranchObj.addUP(name='UP1', type='Voltage')
                 upObj2 = procBranchObj.addUP(name='UP2', type='Voltage')
                 opObj11 = upObj1.addOperation(name='removeDC', priority=1)
                 opObj11.addParameter(name='type', value='1')
                 opObj12 = upObj1.addOperation(name='decodification', priority=2)
                 opObj12.addParameter(name='ncode', value='2')
                 opObj12.addParameter(name='nbauds', value='8')
                 opObj12.addParameter(name='code1', value='001110011')
                 opObj12.addParameter(name='code2', value='001110011')
+                print "Escribiendo el XML"
                 projectObj.writeXml(filename)
-                projectObj.readXml(workspace)
+                print "Leyendo el XML"
+                projectObj.readXml(filename)
   No newline at end of file

schainpy/controller/controller1.py ~~schainpy/Controller/controller1.py~~ renamed 0 0

NO CONTENT: file renamed from schainpy/Controller/controller1.py to schainpy/controller/controller1.py

schainpy/model/jrodata.py ~~schainpy/Model/JROData.py~~ renamed 0 0

	1	NO CONTENT: file renamed from schainpy/Model/JROData.py to schainpy/model/jrodata.py			NO CONTENT: file renamed from schainpy/Model/JROData.py to schainpy/model/jrodata.py

NO CONTENT: file renamed from schainpy/Model/JROData.py to schainpy/model/jrodata.py

schainpy/model/jrodataIO.py ~~schainpy/Model/JRODataIO.py~~ renamed 0 0

	1	NO CONTENT: file renamed from schainpy/Model/JRODataIO.py to schainpy/model/jrodataIO.py			NO CONTENT: file renamed from schainpy/Model/JRODataIO.py to schainpy/model/jrodataIO.py

NO CONTENT: file renamed from schainpy/Model/JRODataIO.py to schainpy/model/jrodataIO.py

schainpy/model/jroheaderIO.py ~~schainpy/Model/JROHeaderIO.py~~ renamed 0 0

NO CONTENT: file renamed from schainpy/Model/JROHeaderIO.py to schainpy/model/jroheaderIO.py

schainpy/model/jroplot.py ~~schainpy/Model/JROPlot.py~~ renamed 0 0

NO CONTENT: file renamed from schainpy/Model/JROPlot.py to schainpy/model/jroplot.py

schainpy/model/jroprocessing.py ~~schainpy/Model/JROProcessing.py~~ renamed +39 -18

             '''
             $Author: dsuarez $
             $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
             '''
             import os
             import numpy
             import datetime
             import time
             from JROData import *
             from JRODataIO import *
             from JROPlot import *
             class ProcessingUnit:
                 """
                 Esta es la clase base para el procesamiento de datos.
                 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                     - Metodos internos (callMethod)
                     - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                       tienen que ser agreagados con el metodo "add".
                 """
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataIn = None
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataOut = None
                 objectDict = None
                 def __init__(self):
                     self.objectDict = {}
                 def addOperation(self, object, objId):
                     """
                     Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
                     identificador asociado a este objeto.
                     Input:
                         object    :    objeto de la clase "Operation"
                     Return:
                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
                     self.object[objId] = object
                     return objId
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     if self.dataIn.isEmpty():
                         return None
                     raise ValueError, "ImplementedError"
                 def callMethod(self, name, **kwargs):
                     """
                     Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                     Input:
                         name        :    nombre del metodo a ejecutar
                         **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                     """
                     if self.dataIn.isEmpty():
                         return None
                     methodToCall = getattr(self, name)
                     methodToCall(**kwargs)
                 def callObject(self, objId, **kwargs):
                     """
                     Ejecuta la operacion asociada al identificador del objeto "objId"
                     Input:
                         objId        :    identificador del objeto a ejecutar
                         **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                     Return:
                         None
                     """
                     if self.dataIn.isEmpty():
                         return None
                     object = self.objectList[objId]
                     object.run(self.dataOut, **kwargs)
                 def call(self, operation, **kwargs):
                     """
                     Ejecuta la operacion "operation" con los argumentos "**kwargs". La operacion puede
                     ser de dos tipos:
 . Un metodo propio de esta clase:
                             operation.type = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                             operation.type = "other".
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el operation.id
                     con el id de la operacion.
                     """
                     if self.dataIn.isEmpty():
                         return None
                     if operation.type == 'self':
                         self.callMethod(operation.name, **kwargs)
                         return
                     if operation.type == 'other':
                         self.callObject(operation.id, **kwargs)
                         return
             class Operation():
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                 y necesiten acumular información previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
                 Ejemplo: Integraciones coherentes, necesita la información previa de los n perfiles anteriores (bufffer)
                 """
                 __buffer = None
+                __isConfig = False
                 def __init__(self):
                     pass
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     raise ValueError, "ImplementedError"
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     pass
                 def setup(self, dataInObj=None, dataOutObj=None):
                     self.dataInObj = dataInObj
                     if self.dataOutObj == None:
                         dataOutObj = Voltage()
                     self.dataOutObj = dataOutObj
                     return self.dataOutObj
                 def init(self):
                     if self.dataInObj.isEmpty():
                         return 0
                     self.dataOutObj.copy(self.dataInObj)
                     # No necesita copiar en cada init() los atributos de dataInObj
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
                     if self.dataInObj.isEmpty():
                         return 0
                     self.selectChannelsByIndex(channelList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOutObj.data
                         self.dataOutObj.channelIndexList
                         self.dataOutObj.nChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.systemHeaderObj.numChannels
                         self.dataOutObj.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channel in channelIndexList:
                         if channel not in self.dataOutObj.channelIndexList:
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
                     data = self.dataOutObj.data[channelIndexList,:]
                     self.dataOutObj.data = data
                     self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.channelList = [self.dataOutObj.channelList[i] for i in channelIndexList]
                     self.dataOutObj.nChannels = nChannels
                     return 1
             class CohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
+                __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 nCohInt = None
                 def __init__(self):
-                    pass
+                    self.__isConfig = False
                 def setup(self, nCohInt=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         nCohInt        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "nCohInt" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
+                    self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if nCohInt == None and timeInterval == None:
                         raise ValueError, "nCohInt or timeInterval should be specified ..."
                     if nCohInt != None:
                         self.nCohInt = nCohInt
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.nCohInt = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
-                    if self.__initime == None:
-                        self.__initime = datatime
                     if not self.__withOverapping:
                         self.__buffer += data
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer == None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than nCohInt then stakcing the data value
                     if self.__profIndex < self.nCohInt:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to nCohInt then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.nCohInt-1] = data
                     self.__profIndex = self.nCohInt
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
-                    self.__initime = None
                     if not self.__withOverapping:
                         data = self.__buffer
                         nCohInt = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, nCohInt
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     nCohInt = self.__profIndex
                     return data, nCohInt
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avg_data = None
+                    nCohInt = None
                     self.putData(data)
                     if self.__profIndex == self.nCohInt:
                         avgdata, nCohInt = self.pushData()
                         self.__dataReady = True
                     return avgdata, nCohInt
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avg_data = None
+                    nCohInt = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, nCohInt = self.pushData()
                         self.nCohInt = nCohInt
                         self.__dataReady = True
                     return avgdata, nCohInt
                 def integrate(self, data, datatime=None):
-                    if not self.__byTime:
+                    if self.__initime == None:
-                        avg_data = self.byProfiles(data)
+                        self.__initime = datatime
+                    if self.__byTime:
+                        avgdata = self.byTime(data, datatime)
                     else:
-                        avg_data = self.byTime(data, datatime)
+                        avgdata = self.byProfiles(data)
-                    self.data = avg_data
+                    self.__lastdatatime = datatime
+                    if avgdata == None:
+                        return None
+                    avgdatatime = self.__initime
+                    deltatime = datatime -self.__lastdatatime
+                    if not self.__withOverapping:
+                        self.__initime = datatime
+                    else:
+                        self.__initime += deltatime
+                return avgdata, avgdatatime
                 def run(self, dataOut, nCohInt=None, timeInterval=None, overlapping=False):
+                    if not self.__isConfig:
+                        self.setup(nCohInt, timeInterval, overlapping)
+                        self.__isConfig = True
+                    avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
             #        self.dataOutObj.timeInterval *= nCohInt
                     self.dataOutObj.flagNoData = True
-                    if myCohIntObj.__dataReady:
+                    if self.__dataReady:
-                        self.dataOutObj.data = myCohIntObj.data
+                        dataOutObj.data = avgdata
-                        self.dataOutObj.timeInterval *= myCohIntObj.nCohInt
+                        dataOutObj.timeInterval *= self.nCohInt
-                        self.dataOutObj.nCohInt = myCohIntObj.nCohInt * self.dataInObj.nCohInt
+                        dataOutObj.nCohInt *= self.nCohInt
-                        self.dataOutObj.utctime = myCohIntObj.firstdatatime
+                        dataOutObj.utctime = avgdatatime
-                        self.dataOutObj.flagNoData = False
+                        dataOutObj.flagNoData = False
  No newline at end of file
-                    return avg_data
  No newline at end of file

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