Changeset 1490


Ignore:
Timestamp:
06/09/06 14:13:03 (13 years ago)
Author:
domlowe
Message:

Finished moving around modules.

Location:
TI02-CSML/trunk
Files:
2 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/csml/API/ops_Dataset.py

    r1485 r1490  
    11''' ops_Dataset  contains operations for root Dataset class''' 
    2 #from API import * 
     2 
    33import codecs 
    44import csml.csmllibs.xmlEncoding 
  • TI02-CSML/trunk/csml/csmllibs/csmlbuilder.py

    r1483 r1490  
    1  
    2  
    3 import xml.dom.ext 
    4 from xml.dom.minidom import parseString 
    5 from cElementTree import tostring 
    6 #import csmllibs 
    7  
    8  
    9 import sys 
    10  
     1import csml 
    112 
    123#Class for building the csml document.  
    13  
    14  
    154class csmlBuilder(object): 
    165    #this class contains all the method calls to create and populate a csmldoc 
     
    5140        ########### The Dataset  ############## 
    5241        #Create an Empty Dataset 
    53         self.ds = csmllibs.Parser.Dataset() 
     42        self.ds = csml.parser.Dataset() 
    5443        #Set gml:id attribute of dataset to be equal to the directory name. (may want to rethink this later) 
    5544        setattr(self.ds,'id',self.directory) 
     
    6857        strCodespace = 'http://ndg/nerc/ac/uk/NDGData' 
    6958        strGmlDescription = 'Dataset for directory ' + self.directory 
    70         self.ds.metaDataProperty=[csmllibs.Parser.MetaDataProperty(href=strMetaDataProperty)] 
    71         self.ds.name=csmllibs.Parser.Name( codeSpace=strCodespace, val=[self.directory]) 
    72         self.ds.description=csmllibs.Parser.Description(strGmlDescription) 
     59        self.ds.metaDataProperty=[csml.parser.MetaDataProperty(href=strMetaDataProperty)] 
     60        self.ds.name=csml.parser.Name( codeSpace=strCodespace, val=[self.directory]) 
     61        self.ds.description=csml.parser.Description(strGmlDescription) 
    7362     
    7463    def createCSML(self): 
    7564        print "Create CSML" 
    7665        #create an empty csml document and dataset tag 
    77         self.csml, self.ds_element = csmllibs.csmlmeta.createDataset() 
     66        self.csml, self.ds_element = csml.csmllibs.csmlmeta.createDataset() 
    7867        #add gml metadata elements 
    79         self.csml, self.ds_element = csmllibs.csmlmeta.addGMLMetadata(self.csml, self.directory, self.ds_element) 
     68        self.csml, self.ds_element = csml.csmllibs.csmlmeta.addGMLMetadata(self.csml, self.directory, self.ds_element) 
    8069 
    8170    def createFeatureFileMap(self): 
    8271        print "Create FFMAP" 
    8372         #    print "creating filemap" 
    84         fmm = csmllibs.csmlfiles.FileMapMaker(self.directory, self.csmlfeaturetype) 
     73        fmm = csml.csmllibs.csmlfiles.FileMapMaker(self.directory, self.csmlfeaturetype) 
    8574        if self.mapping=='onetomany': 
    8675            self.ffmap = fmm.onetomany() 
     
    9281    def makeFileExtracts(self): 
    9382        print "make FEs" 
    94         feBuilder =csmllibs.csmlfileextracts.fileExtractBuilder( self.ds, self.ffmap, self.timedimension) 
     83        feBuilder =csml.csmllibs.csmlfileextracts.fileExtractBuilder( self.ds, self.ffmap, self.timedimension) 
    9584        self.ds = feBuilder.dataset_element 
    9685        self.extractType = feBuilder.extractType 
     
    9988    def createFeatureCollection(self): 
    10089        #creates empty feature collection (list) 
    101         self.gml_FeatureCollection = csmllibs.Parser.FeatureCollection() 
     90        self.gml_FeatureCollection = csml.parser.FeatureCollection() 
    10291  
    10392    def createFeatures(self): 
     
    10796        if not hasattr(self, 'extractDictionary'): 
    10897            self.extractDictionary=None 
    109         thefeatures = csmllibs.csmlfeaturetypes.featureBuilder( self.ds,self.gml_FeatureCollection, self.ffmap, self.extractDictionary,self.timedimension, self.timestorage, self.spatialstorage,self.valuestorage) 
     98        thefeatures = csml.csmllibs.csmlfeaturetypes.featureBuilder( self.ds,self.gml_FeatureCollection, self.ffmap, self.extractDictionary,self.timedimension, self.timestorage, self.spatialstorage,self.valuestorage) 
    11099        #self.csml = thefeatures.csml 
    111100        self.ds=thefeatures.ds_element 
     
    117106        print "Creating CSML document and saving file" 
    118107        #call the toXML method of the Dataset object: 
    119         csml = self.ds.toXML() 
     108        csmlf = self.ds.toXML() 
    120109        #parse and pretty print csml 
    121         self.strCSML =csmllibs.parser_extra.PrettyPrint(csml) 
     110        
     111        self.strCSML = csml.parser_extra.PrettyPrint(csmlf) 
    122112        #tidy up elementtree style namespaces 
    123         self.strCSML=csmllibs.parser_extra.removeInlineNS(self.strCSML) 
     113        self.strCSML= csml.parser_extra.removeInlineNS(self.strCSML) 
    124114        #open file, write to it. 
    125115        f = open(self.outputfile, "w") 
  • TI02-CSML/trunk/csml/csmllibs/csmlfeaturetypes.py

    r1483 r1490  
    77#************************************************************************************** 
    88 
    9 #import csmllibs 
     9import csml.csmllibs 
    1010import sys 
    1111 
     
    6363    def _getFilesAndTimes(self): 
    6464        #TODO try and speed up csmllibs.csmltime.getFileTimeList 
    65         OrderedFileTimeList,self.caltype,self.units = csmllibs.csmltime.getFileTimeList(self.listOfFiles,self.timedim) 
     65        OrderedFileTimeList,self.caltype,self.units = csml.csmllibs.csmltime.getFileTimeList(self.listOfFiles,self.timedim) 
    6666        #build strings to hold times/filenames for current gridseriesfeature 
    6767        self.timeString ='' 
     
    7676        #returns an empty parser file extract object of the correct type. 
    7777        if self.extractType=='NetCDFExtract': 
    78             fe = csmllibs.Parser.NetCDFExtract() 
     78            fe = csml.parser.NetCDFExtract() 
    7979        if self.extractType=='NASAAmesExtract': 
    80             fe = csmllibs.Parser.NASAAmesExtract() 
     80            fe = csml.parser.NASAAmesExtract() 
    8181        if self.extractType=='GRIBExtract': 
    82             fe = csmllibs.Parser.GRIBExtract() 
     82            fe = csml.parser.GRIBExtract() 
    8383        if self.extractType=='PPExtract': 
    84             fe = csmllibs.Parser.PPExtract() 
     84            fe = csml.parser.PPExtract() 
    8585        return fe 
    8686         
     
    9393            self._getFilesAndTimes() 
    9494            #Open representative file and create feature members: 
    95             DI = csmllibs.csmldataiface.DataInterface() 
     95            DI = csml.csmllibs.csmldataiface.DataInterface() 
    9696            DI=DI.getUnknownInterfaceType(self.repfilename) 
    9797            DI.openFile(self.repfilename) 
     
    105105                    #it's an axis or bounds not a feature, try next variable 
    106106                    continue 
    107                 GridSeriesFeature_element=csmllibs.Parser.GridSeriesFeature() 
     107                GridSeriesFeature_element=csml.parser.GridSeriesFeature() 
    108108                GridSeriesFeature_element.id=str(allVarNames[i]) 
    109109                desc = self._getDescriptiveName(DI) 
    110                 GridSeriesFeature_element.description=csmllibs.Parser.Description(desc) 
     110                GridSeriesFeature_element.description=csml.parser.Description(desc) 
    111111                #DOMAIN 
    112                 gsDomain=csmllibs.Parser.GridSeriesDomain() 
     112                gsDomain=csml.parser.GridSeriesDomain() 
    113113                #DOMAIN REFERENCE 
    114                 tpl=csmllibs.Parser.TimePositionList() 
     114                tpl=csml.parser.TimePositionList() 
    115115                if self.timestorage =='inline': 
    116116                    tpl.timePositions=self.timeString 
     
    118118                else: 
    119119                    # do something to create a single extract for the times (from the representative file). 
    120                     tpl.timePositions = csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split()))  
     120                    tpl.timePositions = csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split()))  
    121121                    tpl.frame='%s:%s'%(self.caltype,self.units) 
    122122                gsDomain.domainReference=tpl 
    123                 grid=csmllibs.Parser.Grid() 
     123                grid=csml.parser.Grid() 
    124124                #COVERAGE FUNCTION 
    125                 mr =csmllibs.Parser.MappingRule(csmllibs.csmlextra.getMappingRule(len(dimNames))) 
     125                mr =csml.parser.MappingRule(csml.csmllibs.csmlextra.getMappingRule(len(dimNames))) 
    126126                GridSeriesFeature_element.coverageFunction=mr  
    127127                #RANGESET 
     
    132132                    # if units attribute doesn't exist: 
    133133                    strUom ="dimensionless or units not determined" 
    134                 rs=csmllibs.Parser.RangeSet() 
     134                rs=csml.parser.RangeSet() 
    135135                if self.valuestorage=='inline': 
    136136                    #TO DO, store the rangeset inline - use Datablock class??? 
     
    138138                else: 
    139139                    #store the rangeSet as an aggregatedArray 
    140                     aa=csmllibs.Parser.AggregatedArray() 
     140                    aa=csml.parser.AggregatedArray() 
    141141                    aa.arraySize=[] 
    142142                    aa.arraySize.append(arrSz) 
     
    159159                grid.srsDimension=str(numSpDims) 
    160160                grid.dimension=str(numSpDims) 
    161                 ge =csmllibs.Parser.GridEnvelope(low=DI.getLowLimits(), high=DI.getHighLimits()) 
     161                ge =csml.parser.GridEnvelope(low=DI.getLowLimits(), high=DI.getHighLimits()) 
    162162                grid.limits=ge 
    163163                #add an axisName element(s) for  each spatial dimension. 
     
    171171                    grid.ordinates=[] 
    172172                    for i in range (1, len(dimNames)): 
    173                         ord=csmllibs.Parser.GridOrdinateDescription() 
     173                        ord=csml.parser.GridOrdinateDescription() 
    174174                        ord.gridAxesSpanned='dim' + str(i) 
    175                         ord.sequenceRule=csmllibs.csmlextra.getSeqRule(len(dimNames)) 
     175                        ord.sequenceRule=csml.csmllibs.csmlextra.getSeqRule(len(dimNames)) 
    176176                        dimName=dimNames[len(dimNames)-i] 
    177177                        ord.definesAxis=dimName 
     
    185185                            #store inline 
    186186                             DI.setAxis(dimName) 
    187                              ord.axisValues=csmllibs.csmlextra.cleanString(str(DI.getDataForAxis())) 
     187                             ord.axisValues=csml.csmllibs.csmlextra.cleanString(str(DI.getDataForAxis())) 
    188188                        grid.ordinates.append(ord) 
    189189                    grid.axisNames=axes 
     
    199199            self.repfilename,self.listOfFiles=self._populateListOfFiles(repfile) 
    200200            self._getFilesAndTimes() 
    201             DI = csmllibs.csmldataiface.DataInterface() 
     201            DI = csml.csmllibs.csmldataiface.DataInterface() 
    202202            DI=DI.getUnknownInterfaceType(self.repfilename) 
    203203            DI.openFile(self.repfilename) 
     
    211211            #Create features: 
    212212            for i in range (0, numFeatures): 
    213                 PointSeriesFeature_element=csmllibs.Parser.PointSeriesFeature() 
     213                PointSeriesFeature_element=csml.parser.PointSeriesFeature() 
    214214                if str(allVarNames[i]).upper() in ['ERROR FLAG', 'ERROR']: #might need to extend this list 
    215215                    break 
    216216                PointSeriesFeature_element.id=str(allVarNames[i]) 
    217217                desc=self._getDescriptiveName(DI) 
    218                 PointSeriesFeature_element.description=csmllibs.Parser.Description(desc) 
     218                PointSeriesFeature_element.description=csml.parser.Description(desc) 
    219219                #DOMAIN 
    220                 psDomain=csmllibs.Parser.PointSeriesDomain() 
    221                 t=csmllibs.Parser.Trajectory() 
     220                psDomain=csml.parser.PointSeriesDomain() 
     221                t=csml.parser.Trajectory() 
    222222                t.srsName='urn:EPSG:geographicCRS:4326' #TO Do 
    223                 t.locations =csmllibs.Parser.DirectPositionList(vals='1 1') 
     223                t.locations =csml.parser.DirectPositionList(vals='1 1') 
    224224                 
    225225                if self.timestorage =='inline': 
    226                     tpl =csmllibs.Parser.TimePositionList() 
     226                    tpl =csml.parser.TimePositionList() 
    227227                    tpl.timePositions=self.timeString 
    228228                    tpl.frame='%s:%s'%(self.caltype,self.units) 
     
    230230                else: 
    231231                    # do something to create a single extract for the times (from the representative file). 
    232                     tpl.timePositions = csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split()))  
     232                    tpl.timePositions = csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split()))  
    233233                    tpl.frame='%s:%s'%(self.caltype,self.units) 
    234234                 
     
    246246#                 tplist = csmllibs.Parser.TimePositionList(timePositions=fextract) 
    247247#                 t.times=tplist                                                                     
    248                 filenames=csmllibs.csmlextra.cleanString(str(self.listOfFiles)) 
     248                filenames=csml.csmllibs.csmlextra.cleanString(str(self.listOfFiles)) 
    249249                psDomain.domainReference=t 
    250250                #RANGESET 
     
    259259                except: 
    260260                    measuredvalues = ' could not get values ' 
    261                 rs=csmllibs.Parser.RangeSet() 
     261                rs=csml.parser.RangeSet() 
    262262                if self.valuestorage=='inline': 
    263263                    #encode inline 
    264                     rs.quantityList=csmllibs.Parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                          
     264                    rs.quantityList=csml.parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                          
    265265                else: 
    266266                    #create a file extract link  
     
    268268                    #TODO this needs to be able to handle inline, use VALUESTORAGE to determine which to use: 
    269269                    self.extractType=DI.extractType 
    270                     fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,allVarNames[i],arraySize) 
    271                     qlist = csmllibs.Parser.MeasureOrNullList(val=fextract) 
     270                    fextract=csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,allVarNames[i],arraySize) 
     271                    qlist = csml.parser.MeasureOrNullList(val=fextract) 
    272272                    rs.quantityList=qlist 
    273273                PointSeriesFeature_element.rangeSet=rs 
  • TI02-CSML/trunk/csml/csmllibs/csmlfileextracts.py

    r1483 r1490  
    33#!/usr/bin/env python 
    44import os 
    5 #import csmllibs 
     5import csml.parser 
     6import csml.csmllibs 
    67import sys 
    78class fileExtractBuilder(object): 
     
    6869    #need to incorporate check that a file extract of the same name doesn't already exist. 
    6970    if extractType=='NASAAmesExtract': 
    70         arrayDescriptor=csmllibs.Parser.NASAAmesExtract() 
     71        arrayDescriptor=csml.parser.NASAAmesExtract() 
    7172    if extractType=='NetCDFExtract': 
    7273        arrayDescriptor=csmllibs.Parser.NetCDFExtract() 
  • TI02-CSML/trunk/csml/csmllibs/csmlfiles.py

    r1483 r1490  
    33#import csmllibs 
    44import sys 
     5import csmllibs.csmldirectory 
    56 
    67 
  • TI02-CSML/trunk/csml/csmllibs/csmltime.py

    r1483 r1490  
    1010#************************************************************************************** 
    1111 
    12 #import cdms 
    13 #import csmllibs 
     12import csml.csmllibs 
    1413import datetime 
    1514import sys 
     
    4847        #***************************************************************************************** 
    4948        FileTimeList = []  #list to hold the filesnames and corrsponding times 
    50         DI=csmllibs.csmldataiface.DataInterface() 
     49        DI=csml.csmllibs.csmldataiface.DataInterface() 
    5150        #grab any (first) file                   
    5251        DI=DI.getUnknownInterfaceType(filelist[0]) 
Note: See TracChangeset for help on using the changeset viewer.