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

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

ordering code actually working properly now

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