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

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

changing elementtree imports to handle python 2.5, 2.4 + eggs

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