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

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

Correct ordering of csml elements in parser

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