Changeset 3277


Ignore:
Timestamp:
28/01/08 13:29:22 (12 years ago)
Author:
domlowe
Message:

more doctrings and fixing indentation

Location:
TI02-CSML/trunk/csml/csmllibs
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/csml/csmllibs/csmlbuilder.py

    r3241 r3277  
    22import sys 
    33 
    4 #Class for building the csml document.  
    54class csmlBuilder(object): 
    6     #this class contains all the method calls to create and populate a csmldoc 
    7     #it needs to be provided with several bits of information to be able to do this. 
     5    '''this class contains all the method calls to create and populate a csml document. Calling the build method will start the build process 
     6    it needs to be provided with several bits of information to be able to do this. Csmlscan uses this class to run the build process.''' 
    87    def __init__(self,datasetid, directory,csmlft, mapping, timedimension ,outputfile,printscreen,timestorage,spatialstorage,valuestorage, minaxes, secallow, secdeny): 
     8        ''' The entry point for building a csml document.  
     9        @param datasetid:   identifier for the Dataset id attributes    
     10        @param directory:   directory in which to start scanning 
     11        @param csmlft:    name of the feature type 
     12        @param mapping:     name of the feature to file mapping (e.g. 'onetomany') 
     13        @param timedimension:    name of the time dimension in the data to be scanned 
     14        @param outputfile:    name of the csml outputfile 
     15        @param printscreen:    boolean - whether to print to std out or not 
     16        @param timestorage:     whether to store times inline ('inline') or in file extracts ('fileextract') 
     17        @param spatialstorage:    whether to store spatial domain  inline ('inline') or in file extracts ('fileextract') 
     18        @param valuestorage:    whether to store rangeset inline ('inline') or in file extracts ('fileextract') 
     19        @param minaxes:    the minimum dimensionality of features to be found. 
     20        @param secallow:    security information   
     21        @param secdeny:    security information 
     22         
     23        ''' 
     24         
    925        if datasetid is not None: 
    1026            self.datasetid = datasetid 
     
    2743          
    2844    def build(self): 
    29         #wrapper method to call methods in correct order. 
     45        ''' Wrapper method to call methods in correct order. Controls the scannign process''' 
    3046        self.createDataset() 
    3147        try: 
     
    5066 
    5167    def createDataset(self): 
    52         #************************************************************************************* 
    53         #Creates empty CSML Dataset object with standard attributes 
    54         #************************************************************************************* 
     68        '''Creates empty CSML Dataset object with standard attributes''' 
    5569               
    5670        ########### The Dataset  ############## 
     
    6377 
    6478    def addGMLMetadata(self): 
    65         #********************************************************************************* 
    66         # Adds main GML Metadata elements to dataset element 
    67         #********************************************************************************* 
     79        ''' Adds main GML Metadata elements to dataset element ''' 
     80         
    6881        #Note: TODO: The Parser has a problem with gml:Name from AbstractGML. 
    6982        strMetaDataProperty = 'http://ndg.nerc.ac.uk/Metadata' + self.directory 
     
    110123         
    111124    def createFeatureFileMap(self): 
     125        ''' creates the  FeatureFileMap''' 
    112126        print "Create FFMAP" 
    113          #    print "creating filemap" 
    114127        fmm = csml.csmllibs.csmlfiles.FileMapMaker(self.directory, self.csmlfeaturetype) 
    115128        if self.mapping=='onetomany': 
     
    123136         
    124137    def makeFileExtracts(self): 
     138        ''' creates the file extracts''' 
    125139        print "make FEs" 
    126140        feBuilder =csml.csmllibs.csmlfileextracts.fileExtractBuilder( self.ds, self.ffmap, self.timedimension) 
     
    131145     
    132146    def createFeatureCollection(self): 
    133         #creates empty feature collection (list) 
     147        ''' creates empty feature collection (list)''' 
    134148        self.featureCollection = csml.parser.CSMLFeatureCollection() 
    135149  
    136150    def createFeatures(self): 
     151        ''' creates the features''' 
    137152        print "create Features" 
    138153        if not hasattr(self, 'extractType'): 
     
    159174                     
    160175    def insertXlinks(self): 
     176        ''' creates xlinks ''' 
    161177        self.ds=csml.csmllibs.csmlxlink.createXlinks(self.ds) 
    162178         
    163179    def insertBoundingBoxes(self): 
     180        ''' creates bounding boxes ''' 
    164181        self.ds.featureCollection =csml.csmllibs.csmlextra.addBoundingBoxes(self.ds)  
    165182        self.ds.featureCollection =csml.csmllibs.csmlextra.addEnvelope(self.featureCollection)  
    166183         
    167184    def saveFile(self): 
     185        ''' saves the csml file''' 
    168186        print "Creating CSML document and saving file" 
    169187        #call the toXML method of the Dataset object: 
     
    181199 
    182200    def printToScreen(self): 
     201        ''' prints the finished csml''' 
    183202        if self.printscreen=='1': 
    184203            print self.strCSML 
  • TI02-CSML/trunk/csml/csmllibs/csmlcrs.py

    r3222 r3277  
    55 
    66class CRSystem(object): 
     7    ''' Represents a Coordinate Reference System.''' 
    78    def __init__(self, srsName, axes): 
    89        self.srsName=srsName 
     
    1920     
    2021    def getAxisLabels(self): 
     22        ''' returns the names of the axes in the system''' 
    2123        labelList=[] 
    2224        for item in self.axisLabels.split(): 
     
    2527 
    2628class CRSCatalogue(object): 
     29    ''' represents a Catalogue of coordinate reference systems. CRSystem instances are defined in this catalogue. ''' 
    2730    def __init__(self): 
    2831        # dictionary to hold known CRSystems: 
     
    164167                     
    165168    def getCRS(self, srsName): 
    166         #given the name of a CRS e.g. 'ndg:crs:xypt' return the CRSystem object  
     169        '''given the name of a CRS e.g. 'ndg:crs:xypt' return the CRSystem object ''' 
    167170        try: 
    168171            return self.systems[srsName] 
     
    172175     
    173176    def getUnitType(self, unit): 
    174         #unittype='unknown' 
     177        ''' tries to identify unit types''' 
     178        unittype='unknown' 
    175179        if string.lower(unit) in ['second', 'seconds', 's', 'mins','minute','minutes','hour','hours','h','hr','hrs','day','days']: 
    176180            unittype='time' 
     
    238242     
    239243    def _compareRealAxisNames(self, axes): 
    240         ''' will find complete exact matches only''' 
     244        ''' Used for identifying coordinate systems - will find complete exact matches only''' 
    241245        crs = None 
    242246        axisorder={} 
     
    255259         
    256260    def _getAxisOrder(self, axes, crsaxes): 
    257         #given a list of axis names and a list of comparable crsaxes returns an axis order list e.g. [3,2,1,0] where '3' means the first item in axes corresponds to the item at index 3 in the crsaxes list. 
     261        '''given a list of axis names and a list of comparable crsaxes returns an axis order list e.g. [3,2,1,0] where '3' means the first item in axes corresponds to the item at index 3 in the crsaxes list.''' 
    258262        axisorder={} 
    259263        for ax in axes: 
     
    263267     
    264268    def _compareNamesAndUnits(self, axes, units, crsMap, stdNames=None): 
    265         #build a map of axes and units - use std names to help! 
     269        '''build a map of axes and units - use std names to help ''' 
    266270        crs = None 
    267271        axisorder={} 
  • TI02-CSML/trunk/csml/csmllibs/csmldataiface.py

    r3072 r3277  
    11#!/usr/bin/env python 
    22 
    3 #************************************************************************************** 
    4 #csmldataIface.py 
    5 #contains classes for interfacing with various files 
    6 #currently supports cdunif (NetCDF, PP, Grib(untested)) And Nappy (NASAAmes) 
    7 #use by instantiating the factory class: DataInterface 
    8 #v0.00 30th November 2005 
    9 #Dominic Lowe, BADC 
    10 #************************************************************************************** 
     3''' 
     4************************************************************************************** 
     5csmldataIface.py 
     6contains classes for interfacing with various files 
     7currently supports cdunif (NetCDF, PP, Grib(untested)) And Nappy (NASAAmes) 
     8use by instantiating the factory class: DataInterface 
     9last updated 28 January 2008 
     10Dominic Lowe, BADC 
     11************************************************************************************** 
     12''' 
    1113 
    1214import pdb 
     
    4446 
    4547class DataInterface(object): 
    46         #Use DataInterface and setInterfaceType to instantiate the correct 
    47         #subclass for data  
     48        '''DataInterface is the entry point for all data types. Use DataInterface and setInterfaceType to instantiate the correct 
     49        subclass for data'''  
    4850        def __init__(self): 
    4951                self.iface ='None' 
    5052                 
    5153        def setInterfaceType(self,interfaceType): 
    52                 # function returns approprate data interface 
    53                 #set interfaceType: should correspond to available datainterface subclasses 
     54                '''returns approprate data interface 
     55                @param interfaceType:     should correspond to available datainterface subclasses 
     56                @return:    a subclass of DataInterface e.g. a ImageFileInterface''' 
    5457                self.iface =interfaceType 
    5558                if self.iface == 'nappy': 
     
    6467                 
    6568        def getUnknownInterfaceType(self, filename): 
    66                 #if the interface type is not known at the time of instantiation, then use 
    67                 #this function to examine the file and return the correct interface (if it exists). 
     69                '''if the interface type is not known at the time of instantiation, then use 
     70                this method to examine the file and return the correct interface (if it exists). 
     71                @param filename:      name of data file''' 
    6872                fileExtension = str(filename)[-3:] 
    6973                if fileExtension == '.nc': 
     
    9094                                                         
    9195class AbstractDI(object):                
    92         #Abstract data interface class 
    93         #does nothing, but contains templates for methods required for a data interface class 
    94         #individual interfaces (e.g NappyInterface) should override these methods 
     96        '''Abstract data interface class 
     97        does nothing, but contains templates for methods required for a data interface class 
     98        individual interfaces (e.g NappyInterface) should override these methods. This is the minimum 
     99        set required for data access and subsetting. 
     100        Note that if scanning of data (for CSML creation) is required more methods may be needed - see cdunif interface''' 
    95101 
    96102        def __init__(self): 
     103                ''' When subclassed: unique 'type'  and 'prefix' must be defined''' 
    97104                self.extractType='' 
    98105                self.extractPrefix = '' 
    99106                                         
    100107        def openFile(self, filename): 
    101            #opens file, must be overwritten by subclass 
    102             raise NotImplementedError  
     108           ''' When subclassed: opens file, sets self.file''' 
     109           raise NotImplementedError  
    103110                 
    104111        def closeFile(self): 
    105            #closes file, probably needs to be overwritten by subclass 
    106             try: 
    107                 self.file.close() 
    108             except: 
    109                 raise NotImplementedError 
     112           '''closes file, probably needs to be overwritten by subclass''' 
     113           try: 
     114               self.file.close() 
     115           except: 
     116               raise NotImplementedError 
    110117          
    111118        def setAxis(self,axis): 
    112            #'set' the name of the current axis , must be overwritten by subclass 
    113            #this may just involve a stub (see NASAAmes interface) or may involve 
    114            #calling a real set method of the underlying api (see cdunif Interface) 
    115            raise NotImplementedError  
     119               '''set' the name of the current axis , must be overwritten by subclass 
     120           this may just involve a stub (see NASAAmes interface) or may involve 
     121           calling a real set method of the underlying api (see cdunif Interface)''' 
     122               raise NotImplementedError  
    116123                         
    117124        def getDataForAxis(self): 
    118             #return all data for axis, must be overwritten by subclass 
    119            raise NotImplementedError     
     125               ''' return all data for axis, must be overwritten by subclass ''' 
     126               raise NotImplementedError         
    120127         
    121128        def setVariable(self,varname): 
    122              #As for setAxis, 'set' the name of the current axis , must be overwritten by subclass 
     129             '''As for setAxis, 'set' the name of the current axis , must be overwritten by subclass''' 
    123130             raise NotImplementedError 
    124131         
    125132        def getDataForVar(self): 
    126             #return all data for variable, must be overwritten by subclass 
    127            raise NotImplementedError     
     133               '''return all data for variable, must be overwritten by subclass''' 
     134               raise NotImplementedError         
    128135         
    129136        def getSubsetOfDataForVar(self,**kwargs): 
    130             #return subset of data for variable, must be overwritten by subclass 
     137            '''return subset of data for variable, must be overwritten by subclass''' 
    131138            raise NotImplementedError 
    132139         
    133140         
    134141class NappyInterface(AbstractDI):        
    135         # Data Interface for Nappy (NASA Ames Processing in Python) 
     142        ''' Data Interface for Nappy (NASA Ames Processing in Python)''' 
    136143     
    137144        def __init__(self): 
     
    140147                                          
    141148        def openFile(self, filename): 
    142                 #print 'opening NA file: ' + str(filename) 
     149                ''' open file''' 
    143150                self.file=nappy.openNAFile(filename) 
    144                 #print 'reading data....' 
    145                 #self.file.readData() 
    146                 #print 'nappyopen ' + filename 
    147151 
    148152        def getListOfAxes(self): 
     153                ''' gets list of axes in file''' 
    149154                axes=self.file.XNAME 
    150155                #print 'before units stripped' + str(axes) 
     
    154159 
    155160        def setAxis(self,axis): 
     161                '''sets selected axis in Data Interface''' 
    156162                axes = self.getListOfAxes() 
    157163                self.axisstub=axes.index(axis) 
    158164 
    159165        def getAxisAttribute(self, att): 
    160                 #need to do something here...? maybe 
     166                ''' not implemented yet -should return axis attribute''' 
     167                #need to do something here...? maybe 
    161168                attValue=None 
    162169                return attValue 
    163170 
    164171        def getTimeUnits(self): 
     172                ''' returns units of time axis''' 
    165173                axes = self.getListOfAxes() 
    166174                for axis in axes: 
     
    187195 
    188196        def getDataForAxis(self):            
     197            ''' gets data for an axis''' 
    189198            if self.file.X == None: 
    190199                    #print 'reading data....' 
     
    207216 
    208217        def getSizeOfAxis(self,axis): 
    209  
     218                ''' gets size of an axis''' 
    210219                #check this function is okay 
    211220                #is time always the first dimension in NA?? 
     
    221230 
    222231        def getListofVariables(self): 
     232                '''gets list of variables in the file''' 
    223233                variableList=self.stripunits(self.file.VNAME) 
    224234                return variableList 
    225235 
    226236        def setVariable(self,varname): 
     237                ''' sets the specified variable to be the selected variable''' 
    227238                vlist=self.getListofVariables() 
    228239                self.varstub=vlist.index(varname) 
    229240 
    230241        def getVariableAxes(self): 
     242                ''' Get axis names for a  variable ''' 
    231243                #hmm, now with Nasa Ames the Axis will be the same for all variables. 
    232244                #so just use the getListOfAxes function again 
     
    236248 
    237249        def getVariableAttribute(self,attName): 
     250                ''' get an attribute for a variable''' 
    238251                if attName =='units': 
    239252                        #strip the units (attribute) from the variable 
     
    249262 
    250263        def getDataForVar(self): 
     264            ''' get data for a  variable''' 
    251265            #NOTE TO SELF: 
    252266            #Review this function (and in fact all of nasa ames data interface...) 
    253                 if self.file.V == None: 
    254                         #print 'reading data....' 
    255                         self.file.readData() 
    256  
    257                 try: 
    258                     if type(self.file.V[1])==list: 
    259                         data = self.file.V[self.varstub] 
    260                 #else: 
    261                 #       data =self.file.X 
    262                 #       print data 
    263                     return data 
    264                 except: 
    265                     data = self.file.X 
    266                    # print data 
    267                     return data 
     267            if self.file.V == None: 
     268                    #print 'reading data....' 
     269                    self.file.readData() 
     270 
     271            try: 
     272                if type(self.file.V[1])==list: 
     273                    data = self.file.V[self.varstub] 
     274            #else: 
     275            #   data =self.file.X 
     276            #   print data 
     277                return data 
     278            except: 
     279                data = self.file.X 
     280                # print data 
     281                return data 
    268282 
    269283        def getArraySizeOfVar(self): 
    270         #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27 
    271  
    272                 dimlist=self.file.NX 
    273                 varsize =1 
    274                 for item in dimlist: 
    275                         varsize = varsize * item 
    276                         #print "VARSISZE" + str(varsize) 
    277                 return varsize 
     284            '''iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27''' 
     285 
     286            dimlist=self.file.NX 
     287            varsize =1 
     288            for item in dimlist: 
     289                    varsize = varsize * item 
     290                    #print "VARSISZE" + str(varsize) 
     291            return varsize 
    278292 
    279293        def getShapeOfVar(self): 
    280             #this should return a list. 
     294            '''this returns a list with the shape of the variable''' 
    281295            varShape = [] 
    282296            for item in self.file.NX: 
     
    285299 
    286300        def getLowLimits(self): 
    287                 lowlims = "" 
    288                 for i in range (0, len(self.file.NX)): 
    289                         #for now, assume low limit is always of form 1 1 1 .. 
    290                         lowlims =lowlims + str(1)  +' ' 
    291                 return lowlims 
     301            ''' gets low limits of the data''' 
     302            lowlims = "" 
     303            for i in range (0, len(self.file.NX)): 
     304                    #for now, assume low limit is always of form 1 1 1 .. 
     305                    lowlims =lowlims + str(1)  +' ' 
     306            return lowlims 
    292307 
    293308        def getHighLimits(self): 
    294                 highlims = "" 
    295                 for i in range (0, len(self.file.NX)): 
    296                         dimValue = self.file.NX[i] 
    297                         highlims =highlims  + str(dimValue) +' ' 
    298                 return highlims 
     309            ''' gets high limits of the data''' 
     310            highlims = "" 
     311            for i in range (0, len(self.file.NX)): 
     312                    dimValue = self.file.NX[i] 
     313                    highlims =highlims  + str(dimValue) +' ' 
     314            return highlims 
    299315 
    300316 
    301317        def stripunits(self,listtostrip): 
    302                 #strips units of measure from list 
    303                 #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
    304                 #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude'] 
    305                 cleanlist = [] 
    306                 for item in listtostrip: 
    307                         openbracket=string.find(item,'(') 
    308                         if openbracket != -1: 
    309                                 #if brackets exist, strip units. 
    310                                 item=item[:openbracket-1] 
    311                         cleanlist.append(item) 
    312                 return cleanlist 
     318            ''' strips units of measure from list 
     319            eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
     320            becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude']''' 
     321            cleanlist = [] 
     322            for item in listtostrip: 
     323                    openbracket=string.find(item,'(') 
     324                    if openbracket != -1: 
     325                            #if brackets exist, strip units. 
     326                            item=item[:openbracket-1] 
     327                    cleanlist.append(item) 
     328            return cleanlist 
    313329 
    314330        def getUnits(self,listwithunits): 
    315                 #gets units from list 
    316                 #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
    317                 #becomes ['hours', 'km', 'degrees', 'degrees'] 
    318                 unitlist=[] 
    319                 for item in listwithunits: 
    320                         openbracket=string.find(item,'(') 
    321                         item = item[openbracket+1:-1] 
    322                         unitlist.append(item) 
    323                 return unitlist 
     331            '''gets units from list 
     332            eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)'] 
     333            becomes ['hours', 'km', 'degrees', 'degrees']''' 
     334            unitlist=[] 
     335            for item in listwithunits: 
     336                    openbracket=string.find(item,'(') 
     337                    item = item[openbracket+1:-1] 
     338                    unitlist.append(item) 
     339            return unitlist 
    324340 
    325341        def getTimes(self): 
    326                 #This function attempts to determine the time axis and read the time data 
    327                 #it may well not manage it. 
    328                 axes = self.getListOfAxes() 
    329                 for axis in axes: 
    330                         if string.find(string.upper(axis),'TIME') != -1: 
    331                                 #found possible time axis. 
    332                                 self.setAxis(axis) 
    333                                 times=self.getDataForAxis() 
    334                                 break 
    335                         elif string.find(string.upper(axis),'SECONDS SINCE') != -1: 
    336                                 #found possible time axis. 
    337                                 self.setAxis(axis) 
    338                                 times=self.getDataForAxis() 
    339                                 break 
    340                         elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
    341                                 #found possible time axis. 
    342                                 self.setAxis(axis) 
    343                                 times=self.getDataForAxis() 
    344                                 break 
    345                         elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
    346                                 #found possible time axis. 
    347                                 self.setAxis(axis) 
    348                                 times=self.getDataForAxis() 
    349                                 break 
    350                 times=Numeric.array(times) 
    351                 return times 
     342            '''This function attempts to determine the time axis and read the time data 
     343            it may well not manage it.''' 
     344            axes = self.getListOfAxes() 
     345            for axis in axes: 
     346                if string.find(string.upper(axis),'TIME') != -1: 
     347                        #found possible time axis. 
     348                        self.setAxis(axis) 
     349                        times=self.getDataForAxis() 
     350                        break 
     351                elif string.find(string.upper(axis),'SECONDS SINCE') != -1: 
     352                        #found possible time axis. 
     353                        self.setAxis(axis) 
     354                        times=self.getDataForAxis() 
     355                        break 
     356                elif string.find(string.upper(axis),'HOURS SINCE') != -1: 
     357                        #found possible time axis. 
     358                        self.setAxis(axis) 
     359                        times=self.getDataForAxis() 
     360                        break 
     361                elif string.find(string.upper(axis),'DAYS SINCE') != -1: 
     362                        #found possible time axis. 
     363                        self.setAxis(axis) 
     364                        times=self.getDataForAxis() 
     365                        break 
     366            times=Numeric.array(times) 
     367            return times 
    352368 
    353369 
    354370 
    355371class cdunifInterface(AbstractDI): 
    356     #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib) 
     372    '''Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib)''' 
    357373 
    358374    def __init__(self): 
    359         #these are just temporary values until we can determine whether the 
    360         #file is netcdf pp or grib 
     375        '''these are just temporary values until we can determine whether the 
     376        file is netcdf pp or grib''' 
    361377        self.extractType='cdunifExtract' 
    362378        self.extractPrefix = '_cdunifextract_' 
    363379     
    364380    def openFile(self, filename): 
     381        ''' open file''' 
    365382        self._filename=filename 
    366383        self.file=cdms.open(filename) 
     
    383400            self.extractType = 'NetCDFExtract'  #okay this isn't true, but ok for testing 
    384401            self.extractPrefix = '_ncextract__'  
     402     
    385403    def getListOfAxes(self): 
     404        ''' returns list of dimensions/axes''' 
    386405        axes=self.file.dimensions.keys() 
    387406        return axes 
    388407 
    389408    def getSizeOfAxis(self,axis): 
     409        ''' returns size of axis''' 
    390410        axisSize=self.file.dimensions[axis] 
    391411        return axisSize 
    392412 
    393413    def getListofVariables(self): 
     414        ''' returns list of variables''' 
    394415        variableList=self.file.variables.keys() 
    395416 
     
    401422 
    402423    def setAxis(self,axis): 
     424        ''' set axis''' 
    403425        if not hasattr(self, 'file'): 
    404426            raise Exception, 'Could not open/find underlying file: %s  -  If you are the system maintainer check file paths and permissions'%self._filename 
     
    408430 
    409431    def getAxisAttribute(self, att): 
     432        ''' get attribute of set axis''' 
    410433        attValue=self.axisobj.attributes[att] 
    411434        return attValue 
    412435     
    413436    def getTimeUnits(self): 
     437        ''' get time units - only works if set axis is time...''' 
    414438        #this does the same as getAxisAttribute, but is a separate function as different formats handle time differently. 
    415439        return self.getAxisAttribute('units') 
    416440 
    417441    def getDataForAxis(self): 
     442        ''' get data for entire axis''' 
    418443        data = self.axisobj.getValue() 
    419444        return data 
    420445 
    421446    def setVariable(self,varname): 
     447        ''' sets variable ''' 
    422448        self.varobj=self.file.variables[varname] 
    423449 
    424450    def getVariableAxes(self): 
     451        ''' gets axes for set variable''' 
    425452        varAxesList=self.varobj.getAxisIds() 
    426453        return varAxesList 
    427454 
    428455    def getVariableAttribute(self,attName): 
     456        ''' gets requested attribute for set variable''' 
    429457        if attName == '_FillValue': 
    430458            try: 
     
    442470 
    443471    def getDataForVar(self): 
     472        ''' get data for set variable''' 
    444473        data = self.varobj.getValue() 
    445474        return data 
    446475     
    447476    def _fixLongitudeRequest(self, **kwargs): 
     477        ''' fixes problem of longitude requests taking different forms''' 
    448478        lonkey='longitude' 
    449479        if lonkey in kwargs.keys():   #this test needs to be much more robust...! 
     
    465495                 
    466496    def _componentTimes(self, times): 
     497        ''' handles time formats''' 
    467498        if type(times) is tuple: 
    468499            comptimes=[] 
     
    477508     
    478509    def getSubsetOfDataForVar(self, **kwargs):       
     510        ''' Main subsetting method. Kwargs contains dictionary of requested subset.''' 
    479511        #put any slicing indices aside for later and use names         
    480512        try: 
     
    523555     
    524556    def getArraySizeOfVar(self): 
    525     #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27 
     557        '''iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27''' 
    526558        var = self.varobj 
    527559        size = var.shape 
     
    532564 
    533565    def getShapeOfVar(self): 
     566        ''' get shape of set variable ''' 
    534567        varShape = [] 
    535568        for item in self.varobj.shape: 
     
    538571 
    539572    def getLowLimits(self): 
     573        ''' get gml low limits of set variable''' 
    540574        dimNames = self.varobj.getAxisIds() 
    541575        lowlims = "" 
     
    546580 
    547581    def getHighLimits(self): 
     582        ''' get gml high limits of set variable''' 
    548583        dimNames = self.varobj.getAxisIds() 
    549584        highlims = "" 
     
    555590     
    556591class cdmlInterface(cdunifInterface): 
    557     #this is more  or less the cdunif interface but a few methods have been overwritten 
     592    ''' this is more  or less the cdunif interface but a few methods have been overwritten to read CDML''' 
    558593    def __init__(self): 
    559594        #this all needs to be revisited in csml v2. 
     
    562597         
    563598    def getListOfAxes(self): 
     599        ''' get list of axis in file''' 
    564600        axes=self.file.axes.keys()  
    565601        return axes 
    566602 
    567603    def getSizeOfAxis(self,axis): 
     604        ''' get size of set axis''' 
    568605        axisSize=self.file.axes[axis].length 
    569606        return axisSize 
     
    571608 
    572609class RawFileInterface(AbstractDI): 
    573  
    574    def __init__(self): 
    575       self.extractType   = 'rawExtract' 
    576       self.extractPrefix = '_rawextract_' 
     610    ''' interface for raw file types''' 
     611    def __init__(self): 
     612        self.extractType   = 'rawExtract' 
     613        self.extractPrefix = '_rawextract_' 
    577614  
    578615  
    579    def openFile(self, filename): 
    580       self.file = open(filename, "rb") 
    581  
    582  
    583    def closeFile(self): 
    584       self.file.close() 
    585  
    586  
    587    # Read the data from the raw file into a multidimensional Numeric array 
    588    def readFile(self, **kwargs): 
     616    def openFile(self, filename): 
     617        self.file = open(filename, "rb") 
     618 
     619    def closeFile(self): 
     620            self.file.close() 
     621 
     622 
     623    # Read the data from the raw file into a multidimensional Numeric array 
     624    def readFile(self, **kwargs): 
    589625        # Determine the numeric type: 
    590626        if 'numericType' in kwargs: 
     
    623659    
    624660   # Return the fill value, if set, and transform if necessary: 
    625    def getFillValue(self): 
     661    def getFillValue(self): 
    626662      # Both fillValue and numericTransform attributes may or may 
    627663      # not exist... 
    628       try: 
    629          return self.numericTransform.solve( n = float(self.fillValue) ) 
    630       except AttributeError: 
    631          try: 
    632             return self.fillValue 
    633          except AttributeError: 
    634             return None 
     664        try: 
     665            return self.numericTransform.solve( n = float(self.fillValue) ) 
     666        except AttributeError: 
     667            try: 
     668                return self.fillValue 
     669            except AttributeError: 
     670                return None 
    635671 
    636672 
     
    638674   # duplication of code, just subset the entire array. (getSubset.. is 
    639675   # optimised for this case) 
    640    def getDataForVar(self): 
    641       return self.getSubsetOfDataForVar(lower = (0,)*len(self.data.shape), 
     676    def getDataForVar(self): 
     677        return self.getSubsetOfDataForVar(lower = (0,)*len(self.data.shape), 
    642678                                        upper = self.data.shape) 
    643679 
     
    651687   # rank of the original data: len(lower) == len(upper) == rank of file 
    652688   # 
    653    def getSubsetOfDataForVar(self, **kwargs): 
    654       # Assume subset parameters are passed as: lower=(0,0) upper=(512,512) 
    655       if 'lower' not in kwargs or 'upper' not in kwargs: 
    656          # Have not specified any subset parameters that we recognise, so raise 
    657          # an exception: 
    658          raise NotImplementedError("Only supports subsetting with lower+upper array indices") 
    659       elif not len(kwargs['lower']) == len(kwargs['upper']) == len(self.data.shape): 
    660          # Rank of subset is not the same as rank of full data array. so raise 
    661          # an exception: 
    662          raise NotImplementedError("Only supports subsets of same rank as full dataset") 
    663       elif Numeric.sometrue(Numeric.greater(kwargs['upper'], self.data.shape)): 
    664          # Requested upper bound of subset is beyond the size of the the full 
    665          # data array, so raise an exception 
    666          raise IndexError("Subset out of range") 
    667       elif Numeric.sometrue(Numeric.less( kwargs['upper'], Numeric.zeros(len(self.data.shape)))): 
    668          # Requested lower bound of subset is beyond the size of the the full 
    669          # data array, so raise an exception 
    670          raise IndexError("Subset out of range") 
    671       elif Numeric.sometrue(Numeric.less_equal(kwargs['upper'], kwargs['lower'])): 
    672          # lower bound <= upper_bound for at least one dimension, so raise an 
    673          # exception 
    674          raise IndexError("Upper bound less than lower bound") 
    675       elif tuple(kwargs['lower']) == (0,)*len(self.data.shape) and tuple(kwargs['upper']) == self.data.shape: 
    676          # Special case of requested subset == entire data file. 
    677          subset = self.data 
    678       else: 
    679          # We are okay to subset. 
    680  
    681          # I cant see any nice (and speedy) way of subsetting a Numeric 
    682          # array of arbitrary rank without the use of eval. By doing it 
    683          # this way, we can make use of the (possible) acceleration provided 
    684          # by Numeric/NumPy. 
    685          slices = [] 
    686          for i in range(len(self.data.shape)): 
    687             lower = int(kwargs['lower'][i]) 
    688             upper = int(kwargs['upper'][i])  
    689             slices.append(str(lower)+':'+str(upper)) 
    690          subset = eval("self.data["+','.join(slices)+"]") 
    691  
    692       # Attempt to perform the numericTransform on the data array, if we get 
    693       # AttributeError, it most likely means that numericTransform was not 
    694       # specified, so return the data as-is 
    695       try: 
    696          return self.numericTransform.solve( n = subset ) 
    697       except AttributeError: 
    698          return subset.copy() 
     689    def getSubsetOfDataForVar(self, **kwargs): 
     690        # Assume subset parameters are passed as: lower=(0,0) upper=(512,512) 
     691        if 'lower' not in kwargs or 'upper' not in kwargs: 
     692            # Have not specified any subset parameters that we recognise, so raise 
     693            # an exception: 
     694            raise NotImplementedError("Only supports subsetting with lower+upper array indices") 
     695        elif not len(kwargs['lower']) == len(kwargs['upper']) == len(self.data.shape): 
     696            # Rank of subset is not the same as rank of full data array. so raise 
     697            # an exception: 
     698            raise NotImplementedError("Only supports subsets of same rank as full dataset") 
     699        elif Numeric.sometrue(Numeric.greater(kwargs['upper'], self.data.shape)): 
     700            # Requested upper bound of subset is beyond the size of the the full 
     701            # data array, so raise an exception 
     702            raise IndexError("Subset out of range") 
     703        elif Numeric.sometrue(Numeric.less( kwargs['upper'], Numeric.zeros(len(self.data.shape)))): 
     704            # Requested lower bound of subset is beyond the size of the the full 
     705            # data array, so raise an exception 
     706            raise IndexError("Subset out of range") 
     707        elif Numeric.sometrue(Numeric.less_equal(kwargs['upper'], kwargs['lower'])): 
     708            # lower bound <= upper_bound for at least one dimension, so raise an 
     709            # exception 
     710            raise IndexError("Upper bound less than lower bound") 
     711        elif tuple(kwargs['lower']) == (0,)*len(self.data.shape) and tuple(kwargs['upper']) == self.data.shape: 
     712            # Special case of requested subset == entire data file. 
     713            subset = self.data 
     714        else: 
     715            # We are okay to subset. 
     716     
     717            # I cant see any nice (and speedy) way of subsetting a Numeric 
     718            # array of arbitrary rank without the use of eval. By doing it 
     719            # this way, we can make use of the (possible) acceleration provided 
     720            # by Numeric/NumPy. 
     721            slices = [] 
     722            for i in range(len(self.data.shape)): 
     723                lower = int(kwargs['lower'][i]) 
     724                upper = int(kwargs['upper'][i])  
     725                slices.append(str(lower)+':'+str(upper)) 
     726            subset = eval("self.data["+','.join(slices)+"]") 
     727     
     728        # Attempt to perform the numericTransform on the data array, if we get 
     729        # AttributeError, it most likely means that numericTransform was not 
     730        # specified, so return the data as-is 
     731        try: 
     732            return self.numericTransform.solve( n = subset ) 
     733        except AttributeError: 
     734            return subset.copy() 
    699735 
    700736 
    701737# Interface for reading data from image files. Requires PIL Image module. 
    702738class ImageFileInterface(RawFileInterface): 
    703    def __init__(self): 
    704       self.extractType   = 'imageExtract' 
    705       self.extractPrefix = '_imageextract_' 
     739    '''Interface for reading data from image files. Requires PIL Image module.''' 
     740    def __init__(self): 
     741        self.extractType   = 'imageExtract' 
     742        self.extractPrefix = '_imageextract_' 
    706743    
    707    def image2array(self,im): 
    708        #Adapted from code by Fredrik Lundh, http://www.pythonware.com  
    709        #http://effbot.org/zone/pil-numpy.htm 
    710         if im.mode not in ("L", "F"): 
    711             raise ValueError, "can only convert single-layer images" 
    712         if im.mode == "L": 
    713             a = Numeric.fromstring(im.tostring(), Numeric.UnsignedInt8) 
    714         else: 
    715             a = Numeric.fromstring(im.tostring(), Numeric.Float32) 
    716         a.shape = im.size[1], im.size[0] 
    717         return a 
    718  
    719    def openFile(self, filename): 
    720       self.file = Image.open(filename) 
    721  
    722    def closeFile(self): 
    723       self.file = None #...Image does not seem to have a close() method. 
    724  
    725    def readFile(self, **kwargs): 
    726       # Convert the image to a Numeric array 
     744    def image2array(self,im): 
     745        #Adapted from code by Fredrik Lundh, http://www.pythonware.com  
     746        #http://effbot.org/zone/pil-numpy.htm 
     747            if im.mode not in ("L", "F"): 
     748                raise ValueError, "can only convert single-layer images" 
     749            if im.mode == "L": 
     750                a = Numeric.fromstring(im.tostring(), Numeric.UnsignedInt8) 
     751            else: 
     752                a = Numeric.fromstring(im.tostring(), Numeric.Float32) 
     753            a.shape = im.size[1], im.size[0] 
     754            return a 
     755 
     756    def openFile(self, filename): 
     757        self.file = Image.open(filename) 
     758 
     759    def closeFile(self): 
     760        self.file = None #...Image does not seem to have a close() method. 
     761 
     762    def readFile(self, **kwargs): 
     763        # Convert the image to a Numeric array 
    727764       
    728       self.data=self.image2array(self.file) 
    729       #slower method: 
    730       #self.data = Numeric.array(self.file.getdata()) 
    731  
    732       if 'numericTransform' in kwargs: 
    733          # numericTransform was specified, so compile the expression: 
    734          self.numericTransform = NumericTransform.infixExpression(kwargs['numericTransform']) 
    735       if 'fillValue' in kwargs: 
    736          self.fillValue = kwargs['fillValue'] 
     765        self.data=self.image2array(self.file) 
     766        #slower method: 
     767        #self.data = Numeric.array(self.file.getdata()) 
     768 
     769        if 'numericTransform' in kwargs: 
     770            # numericTransform was specified, so compile the expression: 
     771            self.numericTransform = NumericTransform.infixExpression(kwargs['numericTransform']) 
     772        if 'fillValue' in kwargs: 
     773            self.fillValue = kwargs['fillValue'] 
    737774 
    738775class HDF5Interface(AbstractDI): 
    739     #Data Interface for HDF5 
     776    '''Data Interface for HDF5''' 
    740777    def __init__(self): 
    741778        self.extractType='hdfExtract' 
     
    743780     
    744781    def openFile(self, filename): 
    745         #some code to open the file 
     782        '''some code to open the file''' 
    746783        pass 
    747784 
    748785    def setAxis(self,axis): 
    749         #some code to set an axis to be queried, may not need to do much, depending on your format 
     786        '''some code to set an axis to be queried, may not need to do much, depending on your format''' 
    750787        pass 
    751788         
    752789    def getDataForAxis(self): 
    753         #some code to return the values for an axis 
     790        '''some code to return the values for an axis''' 
    754791        return data 
    755792 
    756793    def setVariable(self,varname): 
    757         #some code to set a variable to be queried, may not need to do much, depending on your format 
     794        '''some code to set a variable to be queried, may not need to do much, depending on your format''' 
    758795        pass 
    759796 
    760797    def getDataForVar(self): 
    761         #some code to return all values for a variable 
     798        '''some code to return all values for a variable''' 
    762799        return data 
    763800 
    764801    def getSubsetOfDataForVar(self, **kwargs): 
    765         #takes keyword args defining subset eg 
    766         #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0), ...) 
    767         #and returns a subset of data for tha variable  
     802        '''takes keyword args defining subset eg 
     803        subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0), ...) 
     804        and returns a subset of data for tha variable ''' 
    768805        return data 
    769806 
    770807    def closeFile(self): 
    771         #some code to close the file 
     808        '''some code to close the file''' 
    772809        pass 
Note: See TracChangeset for help on using the changeset viewer.