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

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

Added  csml:name to CSML Schema and Parser

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