source: TI02-CSML/trunk/csml/parser.py @ 2684

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/csml/parser.py@2684
Revision 2684, 54.9 KB checked in by domlowe, 14 years ago (diff)

tweaks to speed up parsing

Line 
1#import cElementTree as ET
2#import elementtree.ElementTree as etree
3try: #python 2.5
4    from xml.etree import ElementTree as etree
5except ImportError:
6    try:
7        # if you've installed it yourself it comes this way
8        import ElementTree as etree
9    except ImportError:
10        # if you've egged it this is the way it comes
11        from elementtree import ElementTree as etree
12
13try: #python 2.5
14    from xml.etree import cElementTree as ET
15except ImportError:
16    try:
17        # if you've installed it yourself it comes this way
18        import cElementTree as ET
19    except ImportError:
20        # if you've egged it this is the way it comes
21        from celementtree import cElementTree as ET
22
23import sys, traceback
24import csml
25'''CSML v2 Parser ''' 
26
27etree._namespace_map.update({'http://www.opengis.net/om': 'om', 'http://www.opengis.net/swe': 'swe',  'http://www.opengis.net/gml': 'gml','http://ndg.nerc.ac.uk/csml' : 'csml', 'http://www.w3.org/1999/xlink':'xlink'})
28
29nsCSML = 'http://ndg.nerc.ac.uk/csml'
30nsGML = 'http://www.opengis.net/gml'
31nsOM = 'http://www.opengis.net/om'
32nsXLINK = 'http://www.w3.org/1999/xlink'
33nsXML = 'http://ndg.nerc.ac.uk/csml'
34nsMOLES='http://ndg.nerc.ac.uk/moles'
35nsSWE='http://www.opengis.net/swe'
36
37MAINATTRIBUTELIST=[]
38
39def CSML(tag):
40    return "{"+nsCSML+"}"+tag
41
42def GML(tag):
43    return "{"+nsGML+"}"+tag
44
45def SWE(tag):
46    return "{"+nsSWE+"}"+tag
47
48def XLINK(tag):
49    return "{"+nsXLINK+"}"+tag
50
51def MOLES(tag):
52    return "{"+nsMOLES+"}"+tag
53
54
55def addchildren(obj, dict):
56    ''' merges (adds) dictionary to existing self.CHILDREN dictionary '''
57    dict1 = dict
58    if 'CHILDREN' in obj.__dict__:
59      dict2=obj.CHILDREN
60    else:
61      dict2={}
62    dict3={}
63    for item in dict1:
64        dict3[item] =dict1[item]
65    for item in dict2:
66        dict3[item] =dict2[item]
67    obj.CHILDREN=dict3
68   
69
70def addatts(obj, atts):
71  ''' merges self.ATTRIBUTES  of inherited classes'''
72  if 'ATTRIBUTES' in obj.__dict__:
73    for att in atts:
74        obj.ATTRIBUTES.append(att)
75        if att not in MAINATTRIBUTELIST:
76            MAINATTRIBUTELIST.append(att)
77  else:
78    obj.ATTRIBUTES=atts
79 
80
81def addelems(obj, elems):
82  ''' merges self.elems of inherited classes'''
83  if 'ELEMORDER' in obj.__dict__:
84    for elem in elems:
85        obj.ELEMORDER.append(elem)
86  else:
87    obj.ELEMORDER=elems
88
89
90#Some variable definitions: these things are often repeated so store in variables.
91FILEFORMATS=[CSML('NetCDFExtract'),CSML('NASAAmesExtract'), CSML('GRIBExtract'),CSML('CDMLExtract'), CSML('RawFileExtract'), CSML('ImageFileExtract'), CSML('AggregatedArray')]
92
93class csElement(object):
94    ''' main csElement class - all other elements inherit from this baseclass 
95    all the from/to XML conversion is done by this class'''
96   
97    def __init__(self, **kwargs):
98        for kw in kwargs:
99            self.__setattr__(kw, kwargs[kw])
100        if not hasattr(self, 'ATTRIBUTES'):
101            self.__dict__['ATTRIBUTES']=[]
102        if not hasattr(self, 'ELEMORDER'):
103            self.__dict__['ELEMORDER']=[]       
104        if not hasattr(self, 'CHILDREN'):
105            self.__dict__['CHILDREN']={}
106    #The __setattr__ and __getattribute__ special methods have been overridden.
107    #This is so that attributes can be called by their fully qualified name internally
108    #while being referenced by their short name externally.
109    # so 'id' and {'http://www.opengis.net/gml'}id always have the same value
110    #you can set either of them at any time and the other will be kept in sync.
111       
112    def __setattr__(self, name, value):
113        if CSML(name) in self.__dict__:
114            object.__setattr__(self, CSML(name), value)
115            object.__setattr__(self, name, value)
116        elif GML(name) in self.__dict__:       
117            object.__setattr__(self, GML(name), value)
118            object.__setattr__(self, name, value)
119        elif XLINK(name) in self.__dict__:       
120            object.__setattr__(self, XLINK(name), value)
121            object.__setattr__(self, name, value) 
122        else:
123            if 'ATTRIBUTES' in self.__dict__:
124                if CSML(name) in self.__dict__['ATTRIBUTES']:
125                    object.__setattr__(self, CSML(name), value)
126                    object.__setattr__(self, name, value)
127                elif GML(name) in self.__dict__['ATTRIBUTES']:
128                    object.__setattr__(self, GML(name), value)
129                    object.__setattr__(self, name, value)
130                elif XLINK(name) in self.__dict__['ATTRIBUTES']:
131                    object.__setattr__(self, XLINK(name), value)
132                    object.__setattr__(self, name, value)
133                elif name in self.__dict__['ATTRIBUTES']:
134                    object.__setattr__(self, name, value)
135                    try:
136                        name=name.split('}')[1]
137                    except IndexError:
138                        pass
139                    object.__setattr__(self, name, value)
140                else:
141                    object.__setattr__(self, name, value)
142            else:
143                    object.__setattr__(self, name, value)
144   
145    def __getattribute__(self, name):
146        if name in MAINATTRIBUTELIST:
147            if CSML(name) in object.__dict__:
148                return object.__getattribute__(self,CSML(name))
149            elif GML(name) in object.__dict__:
150                return object.__getattribute__(self,GML(name))
151            elif XLINK(name) in object.__dict__:
152                return object.__getattribute__(self,XLINK(name))
153            else:
154                return object.__getattribute__(self,name) 
155        else:
156            return object.__getattribute__(self,name)
157   
158    def __removeURI(self, qname):
159        try:
160            attname = qname.split('}')[1]
161        except IndexError:
162            attname = qname
163        return attname
164       
165    def _getSubstitutionType(self,tag):
166        return tag.split('}')[1]
167       
168   
169    def _getReverseSubsType(self, typename):
170        return typename
171   
172    def addChildElem(self, childname, childobj):
173        #sometimes you want to add a child element but don't know if there is one already. In which case you want to create a list of child objects.
174        if childname in self.__dict__:
175            currentattribute=getattr(self,childname)
176            if type(getattr(self,childname)) is list:
177                currentattribute.append(childobj)
178            else:
179                newlist=[currentattribute]
180                newlist.append(childobj)
181                setattr(self,childname, newlist)
182        else:
183            setattr(self,childname, childobj)
184
185    def toXML(self, csmlfrag, **kwargs):
186        #process self and convert to XML     
187        if 'CONTENT' in self.__dict__:
188            if self.CONTENT is not None: csmlfrag.text=self.CONTENT
189        if 'ATTRIBUTES' in self.__dict__:
190            for item in self.__dict__:
191                if item in self.ATTRIBUTES:                   
192                    csmlfrag.set(item, self.__dict__[item])
193    # self.CHILDREN (recursive - calls the toXML method of children
194        for child in self.ELEMORDER:
195            if not self.__dict__.has_key(child):
196                continue
197            appendLater=False
198            parserobjects=[]
199            if type(self.__dict__[child]) is list:
200                for a in self.__dict__[child]:
201                    parserobjects.append(a)
202            else:
203                parserobjects.append(self.__dict__[child])
204            parentfrag=None
205            if len(self.CHILDREN[child])>=3:
206                    ename2=self.CHILDREN[child][2]
207                    parentfrag=ET.Element(ename2)
208            for po in parserobjects:
209                if type(self.CHILDREN[child][0]) is not list:
210                    ename=self.CHILDREN[child][0]
211                else:
212                    ename = self._getReverseSubsType(type(po).__name__)
213                if len(self.CHILDREN[child])==3:
214                    frag=ET.Element(ename)
215                    po.toXML(frag)
216                    parentfrag.append(frag)
217                    appendLater=True
218                elif len(self.CHILDREN[child])>=4:
219                    if self.CHILDREN[child][3]==1:
220                        frag=ET.Element(ename)
221                        po.toXML(frag)
222                        parentfrag.append(frag)
223                        csmlfrag.append(parentfrag)
224                        parentfrag=ET.Element(parentfrag.tag)
225                        appendLater=False
226                else:
227                    frag=ET.Element(ename)
228                    try:
229                        po.toXML(frag)
230                    except:
231                        print 'PARSING ERROR - could not convert %s to XML'%frag
232                        print dir(ename)
233                        raise
234                    csmlfrag.append(frag)
235                    appendLater=True
236
237                if appendLater==True and parentfrag != None:             
238                    csmlfrag.append(parentfrag)   
239
240        return csmlfrag
241       
242    def fromXML(self,csmlfrag):
243        # deal with attributes, e.g. gml id's
244        if csmlfrag.text is not None:
245                self.CONTENT = csmlfrag.text
246        for item in csmlfrag.items():
247            if item[0] in self.ATTRIBUTES:
248                setattr(self, item[0], item[1])
249        #self.CHILDREN (recursive - calls the fromXML method of children
250        for frag in csmlfrag[:]:
251            #for each child element
252            #iterate through expected CHILDREN to find match
253            for child in self.CHILDREN:
254                if len(self.CHILDREN[child])>=3:
255                    ename = self.CHILDREN[child][2]
256                    ename2 = self.CHILDREN[child][0]
257                else:
258                    ename = self.CHILDREN[child][0] 
259                    ename2=None
260                #if there are options, then find the name that matches the frag
261                if ename2 is not None:
262                    if frag[:] != []:
263                        for subfrag in frag[:]:
264                            etype=None
265                            if type(ename2) is list:
266                                if subfrag.tag in ename2:
267                                    etype=self._getSubstitutionType(subfrag.tag)
268                            if subfrag.tag==ename2:
269                                etype=self.CHILDREN[child][1]
270                            if etype:
271                                childobj=eval(etype)()
272                                if len(self.CHILDREN[child])>=3:
273                                    if frag[:] != []:
274                                        childobj.fromXML(subfrag)
275                                else:
276                                    childobj.fromXML(frag)
277                                #set this object to be an attribute of the 'parent' (self) object
278                                if child in self.__dict__:
279                                    if type(self.__dict__[child]) is not list:
280                                        tmp=self.__dict__[child]
281                                        setattr(self, child, [tmp]) #convert to list
282                                    self.__dict__[child].append(childobj)
283                                else:
284                                    setattr(self, child, childobj)
285                else:
286                    etype=None
287                    if type(ename) is list:
288                        if frag.tag in ename:
289                            etype=self._getSubstitutionType(frag.tag)
290                    elif frag.tag==ename:
291                        etype=self.CHILDREN[child][1]
292                    if etype:
293                        childobj=eval(etype)()
294                        if len(self.CHILDREN[child])>=3:
295                            if frag[:] != []:
296                                childobj.fromXML(frag[0])
297                        else:
298                            childobj.fromXML(frag)
299                           
300                        #set this object to be an attribute of the 'parent' (self) object
301                        if child in self.__dict__:
302                            if type(self.__dict__[child]) is not list:
303                                tmp=self.__dict__[child]
304                                setattr(self, child, [tmp]) #convert to list
305                            self.__dict__[child].append(childobj)
306                        else:
307                            setattr(self, child, childobj)
308
309               
310   
311class AbstractGML(csElement):
312    def __init__(self, **kwargs):
313        a=[GML('id')]
314        addatts(self,a)
315        elems=['metaDataProperty', 'description','name']
316        addelems(self,elems)
317        children={elems[0]:[GML('metaDataProperty'),'csString'],elems[1]:[GML('description'),'csString'],elems[2]:[GML('name'),'csString']}
318        addchildren(self,children)
319        csElement.__init__(self,**kwargs)
320       
321class AssociationAttributeGroup(csElement):
322    def __init__(self, **kwargs):
323        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')] 
324        addatts(self,a)
325        csElement.__init__(self,**kwargs)
326       
327class csString(AssociationAttributeGroup, csElement):
328    def __init__(self, text=None,**kwargs):
329        #Needed so it can use xlink
330        addelems(self,[])
331        AssociationAttributeGroup.__init__(self,**kwargs)
332        if text != None:
333            if type(text) is not str:
334                text=str(text)
335            self.CONTENT=text
336        children={}
337        addchildren(self,children)
338        csElement.__init__(self,**kwargs)
339       
340class SRSReferenceGroup(csElement):
341    def __init__(self, **kwargs):
342        a =['srsName','srsDimension'] 
343        addatts(self,a)
344        csElement.__init__(self,**kwargs)
345               
346class SRSInformationGroup(csElement):
347    def __init__(self, **kwargs):
348        a =['uomLabels','axisLabels']
349        addatts(self,a)
350        csElement.__init__(self,**kwargs)
351       
352class ArrayDescriptor(csElement):
353    def __init__(self,**kwargs):
354        a=['id']
355        addatts(self,a)
356        elems=['arraySize', 'uom', 'numericType','regExpTransform','numericTransform']
357        addelems(self,elems)
358        children={elems[0]:[CSML('arraySize'), 'csString'], elems[1]:[CSML('uom'),'csString'], elems[2]:[CSML('numericType'),'csString'], elems[3]:[CSML('regExpTransform'),'csString'], elems[4]:[CSML('numericTransform'),'csString']}
359        addchildren(self,children)
360        csElement.__init__(self,**kwargs)
361               
362class GridEnvelope(AbstractGML,SRSReferenceGroup, csElement):
363    def __init__(self, **kwargs):
364        SRSReferenceGroup.__init__(self,**kwargs)
365        AbstractGML.__init__(self,**kwargs)
366        elems=['low', 'high']
367        addelems(self,elems)
368        children={elems[0]:[GML('low'), 'csString'],elems[1]:[GML('high'), 'csString']}
369        addchildren(self,children)
370        csElement.__init__(self,**kwargs)
371       
372class Envelope(AbstractGML,SRSReferenceGroup, csElement):
373    def __init__(self, **kwargs):
374        SRSReferenceGroup.__init__(self,**kwargs)
375        AbstractGML.__init__(self,**kwargs)
376        elems=['lowerCorner','upperCorner']
377        addelems(self,elems)
378        children={elems[0]:[GML('lowerCorner'), 'csString'],elems[1]:[GML('upperCorner'), 'csString']}
379        addchildren(self,children)
380        csElement.__init__(self,**kwargs)
381       
382class EnvelopeWithTimePeriod(Envelope):
383    def __init__(self, **kwargs):
384        Envelope.__init__(self,**kwargs)
385        elems=['beginPosition', 'endPosition']
386        addelems(self,elems)
387        children={elems[0]:[GML('beginPosition'), 'csString'], elems[1]:[GML('endPosition'), 'csString']}
388        addchildren(self,children)
389        csElement.__init__(self,**kwargs)
390
391class AbstractFeature(AbstractGML,csElement):
392    def __init__(self, **kwargs):
393        AbstractGML.__init__(self,**kwargs)
394        elems=['boundedBy']
395        addelems(self,elems)
396        #this pattern works but can only accept EnvelopeWithTimePeriod for the boundedBy,
397        #which is probably ok   
398        children={elems[0]:[GML('EnvelopeWithTimePeriod'), 'EnvelopeWithTimePeriod', GML('boundedBy')]}
399        addchildren(self,children)
400        csElement.__init__(self,**kwargs)
401       
402class AbstractFeatureCollection(AbstractFeature,csElement):
403    def __init__(self, **kwargs):
404        AbstractFeature.__init__(self,**kwargs)
405        csElement.__init__(self,**kwargs)
406       
407class DomainSet(AbstractGML,AssociationAttributeGroup,csElement):
408    def __init__(self, **kwargs):
409        AbstractGML.__init__(self,**kwargs)
410        addchildren(self,{})
411        csElement.__init__(self,**kwargs)
412       
413class AggregatedArray(ArrayDescriptor,csElement):
414    def __init__(self, **kwargs):
415        ArrayDescriptor.__init__(self,**kwargs)
416        elems=['aggType', 'aggIndex', 'components']
417        addelems(self,elems)
418        children={elems[0]:[CSML('aggType'),'csString'], elems[1]:[CSML('aggIndex'),'csString'],elems[2]:[FILEFORMATS, 'ArrayDescriptor',CSML('component')]}
419        addchildren(self,children)
420        csElement.__init__(self,**kwargs)
421#'component':[CSML:('component'), 'ArrayDescriptor', CSML('component')],
422
423class MeasureOrNullList(AbstractGML,AssociationAttributeGroup, csElement):
424    def __init__(self, **kwargs):
425        AbstractGML.__init__(self,**kwargs)
426        AssociationAttributeGroup.__init__(self,**kwargs)
427        elems=['insertedExtract']
428        addelems(self,elems)
429        #note insertedExtract is used in resolving xlinks and shouldn't be written to directly (except by the code which handles the xlink resolutions)
430        children={elems[0]:[FILEFORMATS,'FileExtract',CSML('insertedExtract')]}
431        addchildren(self,children)
432        a =['uom'] 
433        addatts(self,a)
434        csElement.__init__(self,**kwargs)
435       
436    def toXML(self,csmlfrag,**kwargs):
437        temp=None
438        if hasattr(self, 'insertedExtract'):         
439            temp=self.insertedExtract
440            del self.insertedExtract  #don't want to expose this in XML       
441        csmlfrag=csElement.toXML(self,csmlfrag, **kwargs)
442        if temp is not None:
443            self.insertedExtract=temp
444        return csmlfrag
445       
446       
447class CompositeValue(AbstractGML,csElement):
448    def __init__(self, **kwargs):
449        AbstractGML.__init__(self,**kwargs)
450        elems=['measures']
451        addelems(self,elems)
452        children={elems[0]:[GML('measure'),'csString',GML('valueComponents')]}
453        addchildren(self,children)
454        csElement.__init__(self,**kwargs)
455       
456class DataBlock(AbstractGML,csElement):
457    #THIS IS INCOMPLETE
458    def __init__(self, **kwargs):
459        AbstractGML.__init__(self,**kwargs)
460        elems=['doubleOrNullTupleList','rangeParameters']
461        addelems(self,elems)
462        children={elems[0]:[GML('doubleOrNullTupleList'),'csString'],elems[1]:[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
463        addchildren(self,children)
464        csElement.__init__(self,**kwargs)
465
466class ValueArray(AbstractGML, csElement):
467    def __init__(self, **kwargs):
468        AbstractGML.__init__(self,**kwargs)
469        elems=['valueComponent']
470        addelems(self,elems)
471        children=children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList', GML('valueComponent')]}
472        addchildren(self,children)
473        csElement.__init__(self,**kwargs)
474       
475    def toXML(self, csmlfrag, **kwargs):
476        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
477        #promote XLinks up from QuantityList
478        #this all done at the elementtree level
479       
480        for frag in csmlfrag:
481            if frag.tag ==GML('valueComponent'):
482                try:       
483                    frag.set(XLINK('href'),self.valueComponent.href)                               
484                    for subfrag in frag:   
485                        del subfrag.attrib[XLINK('href')]                                                             
486                except:
487                    pass
488                try:       
489                    frag.set(XLINK('show'),self.valueComponent.show)                               
490                    for subfrag in frag:   
491                        del subfrag.attrib[XLINK('show')]                                                             
492                except:
493                    pass
494                try:       
495                    frag.set(XLINK('role'),self.valueComponent.role)                               
496                    for subfrag in frag:   
497                        del subfrag.attrib[XLINK('role')]                                                             
498                except:
499                    pass
500                try:       
501                    frag.set(XLINK('arcrole'),self.valueComponent.arcrole)                               
502                    for subfrag in frag:   
503                        del subfrag.attrib[XLINK('arcrole')]                                                             
504                except:
505                    pass
506        return csmlfrag
507               
508    def fromXML(self, csmlfrag):   
509        #promote xlinks up a level to the  property element
510        for frag in csmlfrag:
511            if frag.tag == GML('valueComponent'):             
512                for att in ['href', 'show', 'role', 'arcrole']:
513                    try: 
514                        for subfrag in frag[:]:
515                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
516                    except:
517                        pass
518        csElement.fromXML(self, csmlfrag)       
519
520class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
521    def __init__(self, **kwargs):
522        AbstractGML.__init__(self,**kwargs)
523        AssociationAttributeGroup.__init__(self,**kwargs)
524        elems=['quantityList', 'dataBlock', 'arrayDescriptor', 'valueArray']
525        addelems(self,elems)
526        children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList'],        elems[1]:[GML('DataBlock'),'DataBlock'],elems[2]:[FILEFORMATS, 'ArrayDescriptor'],  elems[3]:[CSML('AggregatedArray'), 'AggregatedArray'],
527        elems[3]:[GML('ValueArray'),'ValueArray']}
528        addchildren(self,children)
529        csElement.__init__(self,**kwargs)
530       
531class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
532    def __init__(self, **kwargs):
533        AbstractGML.__init__(self,**kwargs)
534        SRSReferenceGroup.__init__(self,**kwargs)
535        elems=['pointMember','pointMembers']
536        addelems(self,elems)
537        children={elems[0]:[GML('pointMember'), 'csString'],elems[1]:[GML('pointMembers'), 'csString']}
538        addchildren(self,children)
539        csElement.__init__(self,**kwargs)
540       
541class Point(AbstractGML,SRSReferenceGroup,csElement):
542    def __init__(self, **kwargs):
543        AbstractGML.__init__(self,**kwargs)
544        SRSReferenceGroup.__init__(self,**kwargs)
545        elems=['pos','coordinates']
546        addelems(self,elems)
547        children={elems[0]:[GML('pos'), 'csString'],elems[1]:[GML('coordinates'), 'csString']}
548        addchildren(self,children)
549        csElement.__init__(self,**kwargs)
550       
551class PointDomain(DomainSet, MultiPoint,csElement):
552    def __init__(self, **kwargs):
553        DomainSet.__init__(self,**kwargs)
554        MultiPoint.__init__(self,**kwargs)
555        children={}
556        addchildren(self,children)
557        csElement.__init__(self,**kwargs)
558       
559class ProfileDomain(DomainSet, MultiPoint,csElement):
560    def __init__(self, **kwargs):
561        DomainSet.__init__(self,**kwargs)
562        MultiPoint.__init__(self,**kwargs)
563        children={}
564        addchildren(self,children)
565        csElement.__init__(self,**kwargs)
566
567
568class AbstractCoverage(AbstractFeature, csElement):
569    def __init__(self, **kwargs):
570        AbstractFeature.__init__(self,**kwargs)
571        csElement.__init__(self,**kwargs)
572       
573class AbstractDiscreteCoverage(AbstractCoverage, csElement):
574    def __init__(self, **kwargs):
575        AbstractCoverage.__init__(self,**kwargs)
576        addchildren(self,{})
577        csElement.__init__(self,**kwargs)
578       
579class Definition(AbstractGML):
580    def __init__(self, **kwargs):
581        AbstractGML.__init__(self,**kwargs)
582        addchildren(self,{})
583        csElement.__init__(self,**kwargs)
584       
585class Phenomenon(Definition,AssociationAttributeGroup):
586    def __init__(self, **kwargs):
587        Definition.__init__(self,**kwargs)
588        AssociationAttributeGroup.__init__(self,**kwargs)
589        children = {'':[CSML(''), '']}   
590        addchildren(self,children)
591        csElement.__init__(self,**kwargs)
592               
593class SpatialOrTemporalPositionList(AssociationAttributeGroup, AbstractGML,  csElement):
594    def __init__(self, **kwargs):
595        AbstractGML.__init__(self,**kwargs)
596        AssociationAttributeGroup.__init__(self,**kwargs)
597        elems=['coordinateList', 'timePositionList','insertedExtract']
598        addelems(self,elems)
599        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('insertedExtract')]}
600        addchildren(self,children)
601        csElement.__init__(self,**kwargs)
602   
603    def toXML(self,csmlfrag,**kwargs):
604        temp=None
605        if hasattr(self, 'insertedExtract'):
606            temp=self.insertedExtract
607            del self.insertedExtract  #don't want to expose this in XML       
608        csmlfrag=csElement.toXML(self,csmlfrag, **kwargs)
609        #This is mandatory even if empty when using xlink       
610        if not hasattr(self, 'timePositionList'):
611            if not hasattr(self, 'coordinateList'):
612                 if csmlfrag.get(XLINK('arcrole')) is not None:
613                    if csmlfrag.get(XLINK('arcrole')).split('#')[1] == 'timePositionList':
614                        ET.SubElement(csmlfrag, CSML('timePositionList'))
615                    elif csmlfrag.get(XLINK('arcrole')).split('#')[1] =='coordinateList':
616                        ET.SubElement(csmlfrag, CSML('coordinateList'))                       
617        if temp !=None:
618            self.insertedExtract=temp
619        return csmlfrag
620
621class GridOrdinateDescription(AbstractGML,csElement):
622    def __init__(self, **kwargs):
623        AbstractGML.__init__(self,**kwargs)
624        elems=['coordAxisLabel', 'coordAxisValues', 'gridAxesSpanned', 'sequenceRule']
625        addelems(self,elems)
626        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], elems[2]:[CSML('gridAxesSpanned'), 'csString'], elems[3]:[CSML('sequenceRule'),'SequenceRule']}
627        addchildren(self,children)
628        csElement.__init__(self,**kwargs)
629    def toXML(self, csmlfrag, **kwargs):
630        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
631        #promote XLinks up from SpatialOrTemporalPositionList       
632        #this all done at the elementtree level
633       
634        for frag in csmlfrag:
635            if frag.tag ==CSML('coordAxisValues'):
636                try:       
637                    frag.set(XLINK('href'),self.coordAxisValues.href)                               
638                    for subfrag in frag:   
639                        del subfrag.attrib[XLINK('href')]                                                             
640                except:
641                    pass
642                try:       
643                    frag.set(XLINK('show'),self.coordAxisValues.show)                               
644                    for subfrag in frag:   
645                        del subfrag.attrib[XLINK('show')]                                                             
646                except:
647                    pass
648                try:       
649                    frag.set(XLINK('role'),self.coordAxisValues.role)                               
650                    for subfrag in frag:   
651                        del subfrag.attrib[XLINK('role')]                                                             
652                except:
653                    pass
654                try:       
655                    frag.set(XLINK('arcrole'),self.coordAxisValues.arcrole)                               
656                    for subfrag in frag:   
657                        del subfrag.attrib[XLINK('arcrole')]                                                             
658                except:
659                    pass
660             
661
662        return csmlfrag
663   
664    def fromXML(self, csmlfrag):
665        #promote xlinks up a level to the coordAxisValues property element
666        for frag in csmlfrag:
667            if frag.tag == CSML('coordAxisValues'):             
668                for att in ['href', 'show', 'role', 'arcrole']:
669                    try: 
670                        for subfrag in frag[:]:
671                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
672                    except:
673                        pass
674               
675        csElement.fromXML(self, csmlfrag)
676
677           
678       
679class SequenceRule(csElement):
680    def __init__(self, **kwargs):
681        a=['axisOrder']
682        addatts(self,a)
683        children={}
684        addchildren(self,children)
685        csElement.__init__(self,**kwargs)
686       
687class GridPointDescription(AbstractGML,csElement):
688    def __init__(self, **kwargs):
689        AbstractGML.__init__(self,**kwargs)
690        elems=['posList', 'sequenceRule']
691        addelems(self,elems)
692        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
693        addchildren(self,children)
694        csElement.__init__(self,**kwargs)
695
696class TimePositionList(AbstractGML,csString,csElement):
697    def __init__(self, **kwargs):
698        AbstractGML.__init__(self,**kwargs)
699        csString.__init__(self, **kwargs)
700        elems=[]
701        addelems(self,elems)
702        a=['frame', 'calendarEraName','indeterminatePosition']
703        addatts(self,a)
704        addchildren(self,{})
705        csElement.__init__(self,**kwargs)
706
707class GridCoordinatesTable(AbstractGML,csElement):
708    def __init__(self,**kwargs):
709        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
710        <gml:ordinate>
711            <gml:GridOrdinateDescription>
712        </gml:ordinate>
713        <gml:ordinate>
714            <gml:GridOrdinateDescription>
715        </gml:ordinate>
716       
717        not as:
718        <gml:ordinate>
719            <gml:GridOrdinateDescription>
720            <gml:GridOrdinateDescription>
721        </gml:ordinate> '''
722        AbstractGML.__init__(self,**kwargs)
723        elems=['gridOrdinates' , 'gridPoints']
724        addelems(self,elems)
725        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
726        addchildren(self,children)
727        csElement.__init__(self,**kwargs)
728       
729class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
730    def __init__(self, **kwargs):
731        AbstractGML.__init__(self,**kwargs)
732        AssociationAttributeGroup.__init__(self,**kwargs)
733        SRSReferenceGroup.__init__(self,**kwargs)
734        SRSInformationGroup.__init__(self,**kwargs)
735        a=['dimension']
736        addatts(self,a)
737        elems=['limits', 'aLabels','axisName']
738        addelems(self, elems)
739        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
740        addchildren(self,children)
741        csElement.__init__(self,**kwargs)
742           
743class ReferenceableGrid(Grid, csElement):
744    def __init__(self, **kwargs):
745        Grid.__init__(self,**kwargs)
746        elems=['coordTransformTable']
747        addelems(self,elems)
748        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
749        addchildren(self,children)
750        csElement.__init__(self,**kwargs)
751
752class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
753    def __init__(self, **kwargs):
754        AbstractDiscreteCoverage.__init__(self,**kwargs)
755        elems=[referenceableGridDomain]
756        addelems(self,elems)
757        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
758        addchildren(self,children)
759        csElement.__init__(self,**kwargs)
760       
761class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
762    def __init__(self, **kwargs):
763        AbstractDiscreteCoverage.__init__(self,**kwargs)
764        elems=['alternatePointDomain','rangeSet','coverageFunction']
765        addelems(self,elems)
766        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
767        addchildren(self,children)
768        csElement.__init__(self,**kwargs)
769
770class ProfileCoverage(AbstractDiscreteCoverage, csElement):
771    def __init__(self, **kwargs):
772        AbstractDiscreteCoverage.__init__(self,**kwargs)
773        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
774        addelems(self,elems)
775        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
776        addchildren(self,children)
777        csElement.__init__(self,**kwargs)
778       
779class PointCoverage(AbstractDiscreteCoverage, csElement):
780    def __init__(self, **kwargs):
781        AbstractDiscreteCoverage.__init__(self,**kwargs)
782        elems=['pointDomain','rangeSet', 'coverageFunction']
783        addelems(self,elems)
784        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
785        addchildren(self,children)
786        csElement.__init__(self,**kwargs)
787       
788class TimeSeries(AbstractGML, csElement):
789    def __init__(self, **kwargs):
790        AbstractGML.__init__(self,**kwargs)
791        elems=['timePositionList']
792        addelems(self,elems)
793        children={elems[0]:[CSML('timePositionList'), 'csString']}
794        addchildren(self,children)
795        csElement.__init__(self,**kwargs)
796
797class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
798    def __init__(self, **kwargs):
799        AbstractDiscreteCoverage.__init__(self,**kwargs)
800        elems=['pointSeriesDomain','rangeSet','coverageFunction']
801        addelems(self,elems)
802        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
803        addchildren(self,children)
804        csElement.__init__(self,**kwargs)
805       
806class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
807    def __init__(self, **kwargs):
808        DomainSet.__init__(self,**kwargs)
809        ReferenceableGrid.__init__(self,**kwargs)
810        children={}
811        addchildren(self,children)
812        csElement.__init__(self,**kwargs)
813       
814class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
815    def __init__(self, **kwargs):
816        AbstractDiscreteCoverage.__init__(self,**kwargs)
817        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
818        addelems(self,elems)
819        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
820        addchildren(self,children)
821        csElement.__init__(self,**kwargs)
822       
823class SectionDomain(ReferenceableGrid, DomainSet, csElement):
824    def __init__(self, **kwargs):
825        DomainSet.__init__(self,**kwargs)
826        ReferenceableGrid.__init__(self,**kwargs)
827        children={}
828        addchildren(self,children)
829        csElement.__init__(self,**kwargs)
830       
831class SectionCoverage(AbstractDiscreteCoverage,csElement):
832    def __init__(self, **kwargs):
833        AbstractDiscreteCoverage.__init__(self,**kwargs)
834        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
835        addelems(self,elems)
836        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
837        addchildren(self,children)
838        csElement.__init__(self,**kwargs)
839       
840class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
841    def __init__(self, **kwargs):
842        DomainSet.__init__(self,**kwargs)
843        ReferenceableGrid.__init__(self,**kwargs)
844        children={}
845        addchildren(self,children)
846        csElement.__init__(self,**kwargs)
847       
848class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
849    def __init__(self, **kwargs):
850        AbstractDiscreteCoverage.__init__(self,**kwargs)
851        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
852        addelems(self,elems)
853        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
854        addchildren(self,children)
855        csElement.__init__(self,**kwargs)
856
857class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
858    def __init__(self, **kwargs):
859        DomainSet.__init__(self,**kwargs)
860        ReferenceableGrid.__init__(self,**kwargs)
861        children={}
862        addchildren(self,children)
863        csElement.__init__(self,**kwargs)
864       
865class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
866    def __init__(self, **kwargs):
867        AbstractDiscreteCoverage.__init__(self,**kwargs)
868        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
869        addelems(self,elems)
870        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
871        addchildren(self,children)
872        csElement.__init__(self,**kwargs)
873
874
875class GridSeriesDomain(ReferenceableGrid, csElement):
876    def __init__(self, **kwargs):
877        #DomainSet.__init__(self,**kwargs)
878        ReferenceableGrid.__init__(self,**kwargs)
879        children={}
880        addchildren(self,children)
881        csElement.__init__(self,**kwargs)
882
883class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
884    def __init__(self, **kwargs):
885        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
886        addelems(self,elems)
887        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
888        addchildren(self,children)
889        AbstractDiscreteCoverage.__init__(self,**kwargs)
890        csElement.__init__(self,**kwargs)
891
892class AlternatePointFeature(AbstractFeature, csElement):
893    def __init__(self, **kwargs):
894        AbstractFeature.__init__(self,**kwargs)
895        elems=['location', 'time', 'value','parameter']
896        addelems(self,elems)
897        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
898        addchildren(self,children)
899        csElement.__init__(self,**kwargs)
900
901class DirectPositionList(SRSReferenceGroup, csElement):
902    def __init__(self, **kwargs):
903        SRSReferenceGroup.__init__(self,**kwargs)
904        children=[]
905        addchildren(self,children)
906        csElement.__init__(self,**kwargs)
907       
908class PointFeature(AbstractFeature, csElement):
909    def __init__(self, **kwargs):
910        AbstractFeature.__init__(self,**kwargs)
911        elems=['location', 'time', 'value','parameter']
912        addelems(self,elems)
913        children={elems[0]:[CSML('location'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
914        addchildren(self,children)
915        csElement.__init__(self,**kwargs)
916
917class PointCollectionFeature(AbstractFeature, csElement):
918    def __init__(self, **kwargs):
919        AbstractFeature.__init__(self,**kwargs)
920        elems=['time', 'value', 'parameter']
921        addelems(self,elems)
922        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
923        addchildren(self,children)
924        csElement.__init__(self,**kwargs)
925
926
927class PointSeriesFeature(AbstractFeature, csElement):
928    def __init__(self, **kwargs):
929        AbstractFeature.__init__(self,**kwargs)
930        elems=['location','value','parameter']
931        addelems(self,elems)
932        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
933        addchildren(self,children)
934        csElement.__init__(self,**kwargs)
935
936
937class GridFeature(AbstractFeature, csElement):
938    def __init__(self, **kwargs):
939        AbstractFeature.__init__(self,**kwargs)
940        elems=['time', 'value', 'parameter']
941        addelems(self,elems)
942        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
943        addchildren(self,children)
944        csElement.__init__(self,**kwargs)
945
946class GridSeriesFeature(AbstractFeature, csElement):
947    def __init__(self, **kwargs):
948        AbstractFeature.__init__(self,**kwargs)
949        elems=['value','parameter']
950        addelems(self,elems)
951        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
952        addchildren(self,children)
953        csElement.__init__(self,**kwargs)
954
955class ProfileFeature(AbstractFeature, csElement):
956    def __init__(self, **kwargs):
957        AbstractFeature.__init__(self,**kwargs)
958        elems=['location', 'time','value', 'parameter']
959        addelems(self,elems)
960        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
961        addchildren(self,children)
962        csElement.__init__(self,**kwargs)
963
964class ProfileSeriesFeature(AbstractFeature, csElement):
965    def __init__(self, **kwargs):
966        AbstractFeature.__init__(self,**kwargs)
967        elems=['location', 'value', 'parameter']
968        addelems(self,elems)
969        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
970        addchildren(self,children)
971        csElement.__init__(self,**kwargs)
972
973class RaggedProfileSeriesFeature(AbstractFeature, csElement):
974    def __init__(self, **kwargs):
975        AbstractFeature.__init__(self,**kwargs)
976        elems=['location', 'profileLength', 'value', 'parameter']
977        addelems(self,elems)
978        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
979        addchildren(self,children)
980        csElement.__init__(self,**kwargs)
981
982class RaggedSectionFeature(AbstractFeature, csElement):
983    def __init__(self, **kwargs):
984        AbstractFeature.__init__(self,**kwargs)
985        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
986        addelems(self,elems)
987        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'csString'],elems[2]:[CSML('profileLength'),'csString'],elems[3]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[4]:[CSML('parameter'), 'Phenomenon']}
988        addchildren(self,children)
989        csElement.__init__(self,**kwargs)
990
991class SectionFeature(AbstractFeature, csElement):
992    def __init__(self, **kwargs):
993        AbstractFeature.__init__(self,**kwargs)
994        elems=['stationLocations', 'stationTimes','value', 'parameter']
995        addelems(self,elems)
996        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
997        addchildren(self,children)
998        csElement.__init__(self,**kwargs)
999
1000class ScanningRadarFeature(AbstractFeature, csElement):
1001    def __init__(self, **kwargs):
1002        AbstractFeature.__init__(self,**kwargs)
1003        elems=['elevation','value', 'parameter']
1004        addelems(self,elems)
1005        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
1006        addchildren(self,children)
1007        csElement.__init__(self,**kwargs)
1008
1009       
1010class SwathFeature(AbstractFeature, csElement):
1011    def __init__(self, **kwargs):
1012        AbstractFeature.__init__(self,**kwargs)
1013        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
1014        addelems(self,elems)
1015        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
1016        addchildren(self,children)
1017        csElement.__init__(self,**kwargs)
1018       
1019class TrajectoryFeature(AbstractFeature, csElement):
1020    def __init__(self, **kwargs):
1021        AbstractFeature.__init__(self,**kwargs)
1022        elems=['value', 'parameter']
1023        addelems(self,elems)
1024        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
1025        addchildren(self,children)
1026        csElement.__init__(self,**kwargs)
1027       
1028class FileList(AssociationAttributeGroup,csElement):
1029    def __init__(self,**kwargs):
1030        AssociationAttributeGroup.__init__(self,**kwargs)       
1031        a=['id']
1032        addatts(self,a)
1033        elems=['fileNames']
1034        addelems(self,elems)
1035        children= {elems[0]:[CSML('fileNames'), 'csString']}
1036        addchildren(self,children)
1037        csElement.__init__(self,**kwargs)
1038       
1039class FileExtract(ArrayDescriptor, csElement):
1040    def __init__(self,**kwargs):
1041        ArrayDescriptor.__init__(self,**kwargs)
1042        elems=['fileName', 'fileList', 'fileListXLINK']
1043        addelems(self,elems)
1044        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
1045        addchildren(self,children)
1046        csElement.__init__(self,**kwargs)
1047   
1048class NetCDFExtract(FileExtract, csElement):
1049    def __init__(self,**kwargs):
1050        FileExtract.__init__(self, **kwargs)
1051        elems=['variableName']
1052        addelems(self,elems)
1053        children={elems[0]:[CSML('variableName'), 'csString']}
1054        addchildren(self,children)
1055        csElement.__init__(self,**kwargs)
1056
1057class NASAAmesExtract(FileExtract, csElement):
1058    def __init__(self,**kwargs):
1059        FileExtract.__init__(self, **kwargs)
1060        elems=['variableName', 'index']
1061        addelems(self,elems)
1062        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
1063        addchildren(self,children)
1064        csElement.__init__(self,**kwargs)
1065
1066class RawFileExtract(FileExtract, csElement):
1067
1068   # Note: Unlike the other file extracts, this sets a self.dataInterface
1069   # attribute, which is used by the overridden getData to determine which
1070   # Data Interface is used to read the file. This is necessary because the
1071   # getUnknownDataInterface() method determines which DI to use based on
1072   # filename suffix (raw files could be called anything) or by inspecting
1073   # the file (raw files have no magic numbers or other markers that could
1074   # be used to unequivocally determine the file type).
1075   def __init__(self,**kwargs):
1076      FileExtract.__init__(self, **kwargs)
1077      elems=['endianness', 'fillValue']
1078      addelems(self,elems)
1079      children={elems[0]:[CSML('endianness'), 'csString'],elems[1]:[CSML('fillValue'), 'csString']}
1080      addchildren(self,children)
1081      csElement.__init__(self,**kwargs)
1082      self.dataInterface = csml.csmllibs.csmldataiface.RawFileInterface
1083 
1084class ImageFileExtract(RawFileExtract, csElement):
1085   def __init__(self,**kwargs):
1086      FileExtract.__init__(self, **kwargs)
1087      elems=['fillValue']
1088      addelems(self,elems)
1089      children={elems[0]:[CSML('fillValue'), 'csString']}
1090      addchildren(self,children)
1091      csElement.__init__(self,**kwargs)
1092      self.dataInterface = csml.csmllibs.csmldataiface.ImageFileInterface
1093   
1094
1095class SimpleCondition(csElement): 
1096    '''from moles'''
1097    def __init__(self,**kwargs):
1098        addatts(self, [])
1099        elems= ['dgAttributeAuthority', 'attrauthRole']
1100        addelems(self,elems)
1101        children={elems[0]:[MOLES('dgAttributeAuthority'), 'csString'],elems[1]:[MOLES('attrauthRole'), 'csString']}
1102        addchildren(self,children)
1103        csElement.__init__(self, **kwargs)
1104
1105
1106class ComplexCondition(csElement): 
1107    '''from moles (stub class)'''
1108    def __init__(self,**kwargs):
1109        addatts(self, [])
1110        elems= []
1111        addelems(self,elems)
1112        children={}
1113        addchildren(self,children)
1114        csElement.__init__(self, **kwargs)
1115
1116class DgSecurityCondition(csElement): 
1117    '''from moles'''
1118    def __init__(self,**kwargs):
1119        addatts(self, [])
1120        elems=['effect', 'conditionExplanationText', 'simpleCondition', 'complexCondition']
1121        addelems(self,elems)
1122        children={elems[0]:[MOLES('effect'), 'csString'],elems[1]:[MOLES('conditionExplanationText'),'csString'],elems[2]:[MOLES('simpleCondition'), 'SimpleCondition'],elems[3]:[MOLES('complexCondition'), 'ComplexCondition']}
1123        addchildren(self,children)
1124        csElement.__init__(self,**kwargs)
1125
1126class AccessControlPolicy(csElement):
1127    def __init__(self,**kwargs):
1128        addatts(self,[])
1129        elems=['accessControlPolicyURL', 'accessControlPolicyText', 'dgSecurityCondition']     
1130        addelems(self,elems)
1131        children={elems[0]:[CSML('accessControlPolicyURL'), 'csString'],elems[1]:[CSML('accessControlPolicyText'),'csString'],elems[2]:[CSML('dgSecurityCondition'), 'DgSecurityCondition']}
1132        addchildren(self,children)
1133        csElement.__init__(self,**kwargs)
1134       
1135class CSMLStorageDescriptor(csElement):
1136    def __init__(self,**kwargs):
1137        addatts(self,[])
1138        elems=['descriptors']
1139        addelems(self,elems)
1140        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray'), CSML('RawFileExtract')], 'FileExtract', CSML('descriptor'),1]}
1141        addchildren(self,children)
1142        csElement.__init__(self,**kwargs)
1143
1144class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
1145    def __init__(self,**kwargs):
1146        AbstractFeatureCollection.__init__(self,**kwargs)
1147        elems=['featureMembers']
1148        addelems(self,elems)
1149        children={elems[0]:[[CSML('GridFeature'), CSML('GridSeriesFeature'),CSML('PointFeature'),CSML('TrajectoryFeature'),CSML('ProfileFeature'),CSML('ProfileSeriesFeature'),CSML('RaggedProfileSeriesFeature'),CSML('RaggedSectionFeature'),CSML('SectionFeature'),CSML('ScanningRadarFeature'),CSML('PointSeriesFeature'),CSML('AlternatePointFeature')], 'AbstractFeature', CSML('featureMember'),1]}
1150        addchildren(self,children)
1151        csElement.__init__(self,**kwargs)
1152    def _getSubstitutionType(self,tag):
1153        if tag==CSML('GridFeature'):
1154            return 'GridFeature'
1155        elif tag==CSML('GridSeriesFeature'):
1156            return 'GridSeriesFeature'
1157        elif tag==CSML('PointFeature'):
1158            return 'PointFeature'
1159        elif tag==CSML('TrajectoryFeature'):
1160            return 'TrajectoryFeature'
1161        elif tag==CSML('PointSeriesFeature'):
1162            return 'PointSeriesFeature'
1163        elif tag==CSML('ProfileFeature'):
1164            return 'ProfileFeature'
1165        elif tag==CSML('ProfileSeriesFeature'):
1166            return 'ProfileSeriesFeature'
1167        elif tag==CSML('RaggedProfileSeriesFeature'):
1168            return 'RaggedProfileSeriesFeature'
1169        elif tag==CSML('RaggedSectionFeature'):
1170            return 'RaggedSectionFeature'
1171        elif tag==CSML('SectionFeature'):
1172            return 'SectionFeature'
1173        elif tag==CSML('ScanningRadarFeature'):
1174            return 'ScanningRadarFeature'
1175        elif tag==CSML('AlternatePointFeature'):
1176            return 'AlternatePointFeature'
1177        else: return 'AbstractFeature'
1178    def _getReverseSubsType(self, typename):
1179        if typename== 'GridFeature':
1180            return CSML('GridFeature')
1181        elif typename == 'GridSeriesFeature':
1182            return CSML('GridSeriesFeature')
1183        elif typename == 'PointSeriesFeature':
1184            return CSML('PointSeriesFeature')
1185        elif typename == 'ProfileFeature':
1186            return CSML('ProfileFeature')
1187        elif typename == 'ProfileSeriesFeature':
1188            return CSML('ProfileSeriesFeature')
1189        elif typename == 'SectionFeature':
1190            return CSML('SectionFeature')
1191        elif typename == 'ScanningRadarFeature':
1192            return CSML('ScanningRadarFeature')
1193        elif typename == 'RaggedSectionFeature':
1194            return CSML('RaggedSectionFeature')
1195        elif typename == 'RaggedProfileSeriesFeature':
1196            return CSML('RaggedProfileSeriesFeature')
1197        elif typename == 'PointFeature':
1198            return CSML('PointFeature')
1199        elif typename == 'TrajectoryFeature':
1200            return CSML('TrajectoryFeature')
1201        elif typename == 'AlternatePointFeature':
1202            return CSML('AlternatePointFeature')
1203        else: return CSML('AbstractFeature')
1204
1205       
1206class Dataset(csElement):   
1207    ''' Dataset class, needed as root of tree'''
1208    def __init__(self, **kwargs):
1209        a=['id']
1210        addatts(self,a)
1211        elems=['name','accessControlPolicy','featureCollection','storageDescriptor']
1212        addelems(self,elems)
1213        children = {elems[0]:[CSML('name') ,'csString'], elems[1]:[CSML('AccessControlPolicy') ,'AccessControlPolicy'], elems[2]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[3]:[CSML('CSMLStorageDescriptor'),'CSMLStorageDescriptor']}
1214        addchildren(self,children)
1215        csElement.__init__(self,**kwargs)
1216   
1217    def toXML(self):
1218        csmlfrag=ET.Element(CSML('Dataset'))
1219        csElement.toXML(self, csmlfrag)
1220        return csmlfrag
1221    #def _getSubstitutionType(self,tag): 
1222        #if tag==CSML('NetCDFExtract'):
1223            #return 'NetCDFExtract'
1224        #elif tag==CSML('NASAAmesExtract'):
1225            #return 'NASAAmesExtract'
1226        #else: return 'ArrayDescriptor'
1227    #def _getReverseSubsType(self, typename):
1228        #if typename== 'NetCDFExtract':
1229            #return CSML('NetCDFExtract')
1230        #elif typename == 'NASAAmesExtract':
1231            #return CSML('NASAAmesExtract')
1232        #else: return CSML('ArrayDescriptor')
1233       
1234        return typename
1235
1236   
1237def main():
1238    '''round trip for testing purposes:'''
1239    import parser_extra
1240    print '\n'
1241    #tree=ET.ElementTree(file='/home/dom/coapec/TESTocean.xml')
1242    tree=ET.ElementTree(file='/home/dom/coapec/COAPEC_500YrRun_wholerun_annual_atmos.xml')
1243    import time
1244    time1=time.time()
1245    ds=Dataset()
1246    ds.fromXML(tree.getroot()) 
1247    print 'time=',time.time()-time1
1248    csmltree=ds.toXML()   
1249    csmlout=parser_extra.PrettyPrint(csmltree)
1250    csmlout=parser_extra.removeInlineNS(csmlout)
1251    print 'time=',time.time()-time1
1252    #print '\n %s'% csmlout
1253    #for member in ds.featureCollection.members:
1254      #print dir(member.value)
1255       
1256
1257if __name__=='__main__':
1258    #import profile
1259    #profile.run('main()')
1260    main()
Note: See TracBrowser for help on using the repository browser.