source: TI02-CSML/branches/csml-cdms2/parser.py @ 3599

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/branches/csml-cdms2/parser.py@7833
Revision 3599, 56.9 KB checked in by domlowe, 13 years ago (diff)

added .twoD attribute to CRS sytems in catalogue - returns 2D element of nD systems if defined e.g. EPSG:4326

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