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

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

various fixes to profile subsetting

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