source: TI02-CSML/branches/csml-pml/parser.py @ 2460

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/branches/csml-pml/parser.py@2460
Revision 2460, 55.6 KB checked in by mggr, 13 years ago (diff)

(mggr committing for mhen): ongoing development

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('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       
415class CompositeValue(AbstractGML,csElement):
416    def __init__(self, **kwargs):
417        AbstractGML.__init__(self,**kwargs)
418        elems=['measures']
419        addelems(self,elems)
420        children={elems[0]:[GML('measure'),'csString',GML('valueComponents')]}
421        addchildren(self,children)
422        csElement.__init__(self,**kwargs)
423       
424class DataBlock(AbstractGML,csElement):
425    #THIS IS INCOMPLETE
426    def __init__(self, **kwargs):
427        AbstractGML.__init__(self,**kwargs)
428        elems=['doubleOrNullTupleList','rangeParameters']
429        addelems(self,elems)
430        children={elems[0]:[GML('doubleOrNullTupleList'),'csString'],elems[1]:[GML('CompositeValue'), 'CompositeValue', GML('rangeParameters')]}
431        addchildren(self,children)
432        csElement.__init__(self,**kwargs)
433
434class ValueArray(AbstractGML, csElement):
435    def __init__(self, **kwargs):
436        AbstractGML.__init__(self,**kwargs)
437        elems=['valueComponent']
438        addelems(self,elems)
439        children=children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList', GML('valueComponent')]}
440        addchildren(self,children)
441        csElement.__init__(self,**kwargs)
442       
443    def toXML(self, csmlfrag, **kwargs):
444        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
445        #promote XLinks up from QuantityList
446        #this all done at the elementtree level
447       
448        for frag in csmlfrag:
449            if frag.tag ==GML('valueComponent'):
450                try:       
451                    frag.set(XLINK('href'),self.valueComponent.href)                               
452                    for subfrag in frag:   
453                        del subfrag.attrib[XLINK('href')]                                                             
454                except:
455                    pass
456                try:       
457                    frag.set(XLINK('show'),self.valueComponent.show)                               
458                    for subfrag in frag:   
459                        del subfrag.attrib[XLINK('show')]                                                             
460                except:
461                    pass
462                try:       
463                    frag.set(XLINK('role'),self.valueComponent.role)                               
464                    for subfrag in frag:   
465                        del subfrag.attrib[XLINK('role')]                                                             
466                except:
467                    pass
468                try:       
469                    frag.set(XLINK('arcrole'),self.valueComponent.arcrole)                               
470                    for subfrag in frag:   
471                        del subfrag.attrib[XLINK('arcrole')]                                                             
472                except:
473                    pass
474        return csmlfrag
475               
476    def fromXML(self, csmlfrag):   
477        #promote xlinks up a level to the  property element
478        for frag in csmlfrag:
479            if frag.tag == GML('valueComponent'):             
480                for att in ['href', 'show', 'role', 'arcrole']:
481                    try: 
482                        for subfrag in frag[:]:
483                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
484                    except:
485                        pass
486        csElement.fromXML(self, csmlfrag)       
487
488class RangeSet(AbstractGML,AssociationAttributeGroup,csElement):
489    def __init__(self, **kwargs):
490        AbstractGML.__init__(self,**kwargs)
491        AssociationAttributeGroup.__init__(self,**kwargs)
492        elems=['quantityList', 'dataBlock', 'arrayDescriptor', 'valueArray']
493        addelems(self,elems)
494        children={elems[0]:[GML('QuantityList'), 'MeasureOrNullList'],        elems[1]:[GML('DataBlock'),'DataBlock'],elems[2]:[FILEFORMATS, 'ArrayDescriptor'],  elems[3]:[CSML('AggregatedArray'), 'AggregatedArray'],
495        elems[3]:[GML('ValueArray'),'ValueArray']}
496        addchildren(self,children)
497        csElement.__init__(self,**kwargs)
498       
499class MultiPoint(AbstractGML, SRSReferenceGroup,csElement):
500    def __init__(self, **kwargs):
501        AbstractGML.__init__(self,**kwargs)
502        SRSReferenceGroup.__init__(self,**kwargs)
503        elems=['pointMember','pointMembers']
504        addelems(self,elems)
505        children={elems[0]:[GML('pointMember'), 'csString'],elems[1]:[GML('pointMembers'), 'csString']}
506        addchildren(self,children)
507        csElement.__init__(self,**kwargs)
508       
509class Point(AbstractGML,SRSReferenceGroup,csElement):
510    def __init__(self, **kwargs):
511        AbstractGML.__init__(self,**kwargs)
512        SRSReferenceGroup.__init__(self,**kwargs)
513        elems=['pos','coordinates']
514        addelems(self,elems)
515        children={elems[0]:[GML('pos'), 'csString'],elems[1]:[GML('coordinates'), 'csString']}
516        addchildren(self,children)
517        csElement.__init__(self,**kwargs)
518       
519class PointDomain(DomainSet, MultiPoint,csElement):
520    def __init__(self, **kwargs):
521        DomainSet.__init__(self,**kwargs)
522        MultiPoint.__init__(self,**kwargs)
523        children={}
524        addchildren(self,children)
525        csElement.__init__(self,**kwargs)
526       
527class ProfileDomain(DomainSet, MultiPoint,csElement):
528    def __init__(self, **kwargs):
529        DomainSet.__init__(self,**kwargs)
530        MultiPoint.__init__(self,**kwargs)
531        children={}
532        addchildren(self,children)
533        csElement.__init__(self,**kwargs)
534
535
536class AbstractCoverage(AbstractFeature, csElement):
537    def __init__(self, **kwargs):
538        AbstractFeature.__init__(self,**kwargs)
539        csElement.__init__(self,**kwargs)
540       
541class AbstractDiscreteCoverage(AbstractCoverage, csElement):
542    def __init__(self, **kwargs):
543        AbstractCoverage.__init__(self,**kwargs)
544        addchildren(self,{})
545        csElement.__init__(self,**kwargs)
546       
547class Definition(AbstractGML):
548    def __init__(self, **kwargs):
549        AbstractGML.__init__(self,**kwargs)
550        addchildren(self,{})
551        csElement.__init__(self,**kwargs)
552       
553class Phenomenon(Definition,AssociationAttributeGroup):
554    def __init__(self, **kwargs):
555        Definition.__init__(self,**kwargs)
556        AssociationAttributeGroup.__init__(self,**kwargs)
557        children = {'':[CSML(''), '']}   
558        addchildren(self,children)
559        csElement.__init__(self,**kwargs)
560               
561class SpatialOrTemporalPositionList(AssociationAttributeGroup, AbstractGML,  csElement):
562    def __init__(self, **kwargs):
563        AbstractGML.__init__(self,**kwargs)
564        AssociationAttributeGroup.__init__(self,**kwargs)
565        elems=['coordinateList', 'timePositionList','insertedExtract']
566        addelems(self,elems)
567        children={elems[0]:[CSML('coordinateList'),'csString'], elems[1]:[CSML('timePositionList'),'TimePositionList'],elems[2]:[FILEFORMATS,'FileExtract',CSML('insertedExtract')]}
568        addchildren(self,children)
569        csElement.__init__(self,**kwargs)
570   
571    def toXML(self,csmlfrag,**kwargs):
572        csmlfrag=csElement.toXML(self,csmlfrag, **kwargs)
573        #This is mandatory even if empty when using xlink       
574        if not hasattr(self, 'timePositionList'):
575            if not hasattr(self, 'coordinateList'):
576                 if csmlfrag.get(XLINK('arcrole')) is not None:
577                    if csmlfrag.get(XLINK('arcrole')).split('#')[1] == 'timePositionList':
578                        ET.SubElement(csmlfrag, CSML('timePositionList'))
579                    elif csmlfrag.get(XLINK('arcrole')).split('#')[1] =='coordinateList':
580                        ET.SubElement(csmlfrag, CSML('coordinateList'))                       
581        return csmlfrag
582
583class GridOrdinateDescription(AbstractGML,csElement):
584    def __init__(self, **kwargs):
585        AbstractGML.__init__(self,**kwargs)
586        elems=['coordAxisLabel', 'coordAxisValues', 'gridAxesSpanned', 'sequenceRule']
587        addelems(self,elems)
588        children={elems[0]:[CSML('coordAxisLabel'), 'csString'], elems[1]:[CSML('SpatialOrTemporalPositionList'),'SpatialOrTemporalPositionList',CSML('coordAxisValues')], elems[2]:[CSML('gridAxesSpanned'), 'csString'], elems[3]:[CSML('sequenceRule'),'SequenceRule']}
589        addchildren(self,children)
590        csElement.__init__(self,**kwargs)
591    def toXML(self, csmlfrag, **kwargs):
592        csmlfrag=AbstractGML.toXML(self, csmlfrag,**kwargs)
593        #promote XLinks up from SpatialOrTemporalPositionList       
594        #this all done at the elementtree level
595       
596        for frag in csmlfrag:
597            if frag.tag ==CSML('coordAxisValues'):
598                try:       
599                    frag.set(XLINK('href'),self.coordAxisValues.href)                               
600                    for subfrag in frag:   
601                        del subfrag.attrib[XLINK('href')]                                                             
602                except:
603                    pass
604                try:       
605                    frag.set(XLINK('show'),self.coordAxisValues.show)                               
606                    for subfrag in frag:   
607                        del subfrag.attrib[XLINK('show')]                                                             
608                except:
609                    pass
610                try:       
611                    frag.set(XLINK('role'),self.coordAxisValues.role)                               
612                    for subfrag in frag:   
613                        del subfrag.attrib[XLINK('role')]                                                             
614                except:
615                    pass
616                try:       
617                    frag.set(XLINK('arcrole'),self.coordAxisValues.arcrole)                               
618                    for subfrag in frag:   
619                        del subfrag.attrib[XLINK('arcrole')]                                                             
620                except:
621                    pass
622             
623
624        return csmlfrag
625   
626    def fromXML(self, csmlfrag):
627        #promote xlinks up a level to the coordAxisValues property element
628        for frag in csmlfrag:
629            if frag.tag == CSML('coordAxisValues'):             
630                for att in ['href', 'show', 'role', 'arcrole']:
631                    try: 
632                        for subfrag in frag[:]:
633                            subfrag.set(XLINK(att),frag.attrib[XLINK(att)])     
634                    except:
635                        pass
636               
637        csElement.fromXML(self, csmlfrag)
638
639           
640       
641class SequenceRule(csElement):
642    def __init__(self, **kwargs):
643        a=['axisOrder']
644        addatts(self,a)
645        children={}
646        addchildren(self,children)
647        csElement.__init__(self,**kwargs)
648       
649class GridPointDescription(AbstractGML,csElement):
650    def __init__(self, **kwargs):
651        AbstractGML.__init__(self,**kwargs)
652        elems=['posList', 'sequenceRule']
653        addelems(self,elems)
654        children={elems[0]:[CSML('posList'),'csString'],elems[1]:[CSML('sequenceRule'),'SequenceRule']}
655        addchildren(self,children)
656        csElement.__init__(self,**kwargs)
657
658class TimePositionList(AbstractGML,csString,csElement):
659    def __init__(self, **kwargs):
660        AbstractGML.__init__(self,**kwargs)
661        csString.__init__(self, **kwargs)
662        elems=[]
663        addelems(self,elems)
664        a=['frame', 'calendarEraName','indeterminatePosition']
665        addatts(self,a)
666        addchildren(self,{})
667        csElement.__init__(self,**kwargs)
668
669class GridCoordinatesTable(AbstractGML,csElement):
670    def __init__(self,**kwargs):
671        '''the additional value '1' in the children dictionary is used to signify that the elements must be nested as:
672        <gml:ordinate>
673            <gml:GridOrdinateDescription>
674        </gml:ordinate>
675        <gml:ordinate>
676            <gml:GridOrdinateDescription>
677        </gml:ordinate>
678       
679        not as:
680        <gml:ordinate>
681            <gml:GridOrdinateDescription>
682            <gml:GridOrdinateDescription>
683        </gml:ordinate> '''
684        AbstractGML.__init__(self,**kwargs)
685        elems=['gridOrdinates' , 'gridPoints']
686        addelems(self,elems)
687        children={elems[0]:[CSML('GridOrdinateDescription'), 'GridOrdinateDescription',CSML('gridOrdinate'),1], elems[1]:[CSML('GridPointDescription'),'GridPointDescription',CSML('gridPoints')]}
688        addchildren(self,children)
689        csElement.__init__(self,**kwargs)
690       
691class Grid(AbstractGML, AssociationAttributeGroup, SRSInformationGroup, SRSReferenceGroup, csElement):
692    def __init__(self, **kwargs):
693        AbstractGML.__init__(self,**kwargs)
694        AssociationAttributeGroup.__init__(self,**kwargs)
695        SRSReferenceGroup.__init__(self,**kwargs)
696        SRSInformationGroup.__init__(self,**kwargs)
697        a=['dimension']
698        addatts(self,a)
699        elems=['limits', 'aLabels','axisName']
700        addelems(self, elems)
701        children = {elems[1]:[CSML('axisLabels'),'csString'],elems[2]:[CSML('axisName'),'csString'], elems[0]:[GML('GridEnvelope'),'GridEnvelope',CSML('limits')]}
702        addchildren(self,children)
703        csElement.__init__(self,**kwargs)
704           
705class ReferenceableGrid(Grid, csElement):
706    def __init__(self, **kwargs):
707        Grid.__init__(self,**kwargs)
708        elems=['coordTransformTable']
709        addelems(self,elems)
710        children={elems[0]:[CSML('GridCoordinatesTable'), 'GridCoordinatesTable', CSML('coordTransformTable')]}
711        addchildren(self,children)
712        csElement.__init__(self,**kwargs)
713
714class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
715    def __init__(self, **kwargs):
716        AbstractDiscreteCoverage.__init__(self,**kwargs)
717        elems=[referenceableGridDomain]
718        addelems(self,elems)
719        children={elems[0]:[CSML('ReferenceableGrid'),'ReferenceableGrid' ,CSML('referenceableGridDomain') ]}
720        addchildren(self,children)
721        csElement.__init__(self,**kwargs)
722       
723class AlternatePointCoverage(AbstractDiscreteCoverage, csElement):
724    def __init__(self, **kwargs):
725        AbstractDiscreteCoverage.__init__(self,**kwargs)
726        elems=['alternatePointDomain','rangeSet','coverageFunction']
727        addelems(self,elems)
728        children={elems[0]:[GML('Point'),'Point', CSML('alternatePointDomain')], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
729        addchildren(self,children)
730        csElement.__init__(self,**kwargs)
731
732class ProfileCoverage(AbstractDiscreteCoverage, csElement):
733    def __init__(self, **kwargs):
734        AbstractDiscreteCoverage.__init__(self,**kwargs)
735        elems=['profileDomain', 'rangeSet' ,'coverageFunction']
736        addelems(self,elems)
737        children={elems[0]:[CSML('ProfileDomain'),'ProfileDomain' ,CSML('profileDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
738        addchildren(self,children)
739        csElement.__init__(self,**kwargs)
740       
741class PointCoverage(AbstractDiscreteCoverage, csElement):
742    def __init__(self, **kwargs):
743        AbstractDiscreteCoverage.__init__(self,**kwargs)
744        elems=['pointDomain','rangeSet', 'coverageFunction']
745        addelems(self,elems)
746        children={elems[0]:[CSML('PointDomain'),'PointDomain' ,CSML('pointDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
747        addchildren(self,children)
748        csElement.__init__(self,**kwargs)
749       
750class TimeSeries(AbstractGML, csElement):
751    def __init__(self, **kwargs):
752        AbstractGML.__init__(self,**kwargs)
753        elems=['timePositionList']
754        addelems(self,elems)
755        children={elems[0]:[CSML('timePositionList'), 'csString']}
756        addchildren(self,children)
757        csElement.__init__(self,**kwargs)
758
759class PointSeriesCoverage(AbstractDiscreteCoverage, csElement):
760    def __init__(self, **kwargs):
761        AbstractDiscreteCoverage.__init__(self,**kwargs)
762        elems=['pointSeriesDomain','rangeSet','coverageFunction']
763        addelems(self,elems)
764        children={elems[0]:[CSML('TimeSeries'),'TimeSeries' ,CSML('pointSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
765        addchildren(self,children)
766        csElement.__init__(self,**kwargs)
767       
768class ProfileSeriesDomain(ReferenceableGrid, DomainSet, csElement):
769    def __init__(self, **kwargs):
770        DomainSet.__init__(self,**kwargs)
771        ReferenceableGrid.__init__(self,**kwargs)
772        children={}
773        addchildren(self,children)
774        csElement.__init__(self,**kwargs)
775       
776class ProfileSeriesCoverage(AbstractDiscreteCoverage,csElement):
777    def __init__(self, **kwargs):
778        AbstractDiscreteCoverage.__init__(self,**kwargs)
779        elems=['profileSeriesDomain', 'rangeSet', 'coverageFunction']
780        addelems(self,elems)
781        children={elems[0]:[CSML('ProfileSeriesDomain'),'ProfileSeriesDomain' ,CSML('profileSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
782        addchildren(self,children)
783        csElement.__init__(self,**kwargs)
784       
785class SectionDomain(ReferenceableGrid, DomainSet, csElement):
786    def __init__(self, **kwargs):
787        DomainSet.__init__(self,**kwargs)
788        ReferenceableGrid.__init__(self,**kwargs)
789        children={}
790        addchildren(self,children)
791        csElement.__init__(self,**kwargs)
792       
793class SectionCoverage(AbstractDiscreteCoverage,csElement):
794    def __init__(self, **kwargs):
795        AbstractDiscreteCoverage.__init__(self,**kwargs)
796        elems=['sectionDomain', 'rangeSet' , 'coverageFunction']
797        addelems(self,elems)
798        children={elems[0]:[CSML('SectionDomain'),'SectionDomain' ,CSML('sectionDomain') ],elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
799        addchildren(self,children)
800        csElement.__init__(self,**kwargs)
801       
802class TrajectoryDomain(ReferenceableGrid, DomainSet, csElement):
803    def __init__(self, **kwargs):
804        DomainSet.__init__(self,**kwargs)
805        ReferenceableGrid.__init__(self,**kwargs)
806        children={}
807        addchildren(self,children)
808        csElement.__init__(self,**kwargs)
809       
810class TrajectoryCoverage(AbstractDiscreteCoverage,csElement):
811    def __init__(self, **kwargs):
812        AbstractDiscreteCoverage.__init__(self,**kwargs)
813        elems=['trajectoryDomain', 'rangeSet', 'coverageFunction']
814        addelems(self,elems)
815        children={elems[0]:[CSML('TrajectoryDomain'),'TrajectoryDomain' ,CSML('trajectoryDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
816        addchildren(self,children)
817        csElement.__init__(self,**kwargs)
818
819class ScanningRadarDomain(ReferenceableGrid, DomainSet, csElement):
820    def __init__(self, **kwargs):
821        DomainSet.__init__(self,**kwargs)
822        ReferenceableGrid.__init__(self,**kwargs)
823        children={}
824        addchildren(self,children)
825        csElement.__init__(self,**kwargs)
826       
827class ScanningRadarCoverage(AbstractDiscreteCoverage,csElement):
828    def __init__(self, **kwargs):
829        AbstractDiscreteCoverage.__init__(self,**kwargs)
830        elems=['scanningRadarDomain', 'rangeSet','coverageFunction']
831        addelems(self,elems)
832        children={elems[0]:[CSML('ScanningRadarDomain'),'ScanningRadarDomain' ,CSML('scanningRadarDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
833        addchildren(self,children)
834        csElement.__init__(self,**kwargs)
835
836
837class GridSeriesDomain(ReferenceableGrid, csElement):
838    def __init__(self, **kwargs):
839        #DomainSet.__init__(self,**kwargs)
840        ReferenceableGrid.__init__(self,**kwargs)
841        children={}
842        addchildren(self,children)
843        csElement.__init__(self,**kwargs)
844
845class GridSeriesCoverage(AbstractDiscreteCoverage,csElement):
846    def __init__(self, **kwargs):
847        elems=['gridSeriesDomain', 'rangeSet', 'coverageFunction']
848        addelems(self,elems)
849        children={elems[0]:[CSML('GridSeriesDomain'),'GridSeriesDomain' ,CSML('gridSeriesDomain') ], elems[1]:[GML('rangeSet'), 'RangeSet'],elems[2]:[GML('coverageFunction'),'csString']}
850        addchildren(self,children)
851        AbstractDiscreteCoverage.__init__(self,**kwargs)
852        csElement.__init__(self,**kwargs)
853
854class AlternatePointFeature(AbstractFeature, csElement):
855    def __init__(self, **kwargs):
856        AbstractFeature.__init__(self,**kwargs)
857        elems=['location', 'time', 'value','parameter']
858        addelems(self,elems)
859        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('AlternatePointCoverage'), 'AlternatePointCoverage', CSML('value')],elems[3]:[CSML('parameter'), 'Phenomenon']}
860        addchildren(self,children)
861        csElement.__init__(self,**kwargs)
862
863class DirectPositionList(SRSReferenceGroup, csElement):
864    def __init__(self, **kwargs):
865        SRSReferenceGroup.__init__(self,**kwargs)
866        children=[]
867        addchildren(self,children)
868        csElement.__init__(self,**kwargs)
869       
870class PointFeature(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'), 'DirectPositionList'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('PointCoverage'), 'PointCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
876        addchildren(self,children)
877        csElement.__init__(self,**kwargs)
878
879class PointCollectionFeature(AbstractFeature, csElement):
880    def __init__(self, **kwargs):
881        AbstractFeature.__init__(self,**kwargs)
882        elems=['time', 'value', 'parameter']
883        addelems(self,elems)
884        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('MultiPointCoverage'), 'MultiPointCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
885        addchildren(self,children)
886        csElement.__init__(self,**kwargs)
887
888
889class PointSeriesFeature(AbstractFeature, csElement):
890    def __init__(self, **kwargs):
891        AbstractFeature.__init__(self,**kwargs)
892        elems=['location','value','parameter']
893        addelems(self,elems)
894        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('PointSeriesCoverage'), 'PointSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
895        addchildren(self,children)
896        csElement.__init__(self,**kwargs)
897
898
899class GridFeature(AbstractFeature, csElement):
900    def __init__(self, **kwargs):
901        AbstractFeature.__init__(self,**kwargs)
902        elems=['time', 'value', 'parameter']
903        addelems(self,elems)
904        children={elems[0]:[CSML('time'), 'csString'], elems[1]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
905        addchildren(self,children)
906        csElement.__init__(self,**kwargs)
907
908class GridSeriesFeature(AbstractFeature, csElement):
909    def __init__(self, **kwargs):
910        AbstractFeature.__init__(self,**kwargs)
911        elems=['value','parameter']
912        addelems(self,elems)
913        children={elems[0]:[CSML('GridSeriesCoverage'), 'GridSeriesCoverage', CSML('value')],elems[1]:[CSML('parameter'), 'Phenomenon']}
914        addchildren(self,children)
915        csElement.__init__(self,**kwargs)
916
917class ProfileFeature(AbstractFeature, csElement):
918    def __init__(self, **kwargs):
919        AbstractFeature.__init__(self,**kwargs)
920        elems=['location', 'time','value', 'parameter']
921        addelems(self,elems)
922        children={elems[0]:[CSML('location'), 'csString'],elems[1]:[CSML('time'), 'csString'], elems[2]:[CSML('ProfileCoverage'), 'ProfileCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
923        addchildren(self,children)
924        csElement.__init__(self,**kwargs)
925
926class ProfileSeriesFeature(AbstractFeature, csElement):
927    def __init__(self, **kwargs):
928        AbstractFeature.__init__(self,**kwargs)
929        elems=['location', 'value', 'parameter']
930        addelems(self,elems)
931        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
932        addchildren(self,children)
933        csElement.__init__(self,**kwargs)
934
935class RaggedProfileSeriesFeature(AbstractFeature, csElement):
936    def __init__(self, **kwargs):
937        AbstractFeature.__init__(self,**kwargs)
938        elems=['location', 'profileLength', 'value', 'parameter']
939        addelems(self,elems)
940        children={elems[0]:[CSML('location'), 'csString'], elems[1]:[CSML('profileLength'), 'csString'],elems[2]:[CSML('ProfileSeriesCoverage'), 'ProfileSeriesCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
941        addchildren(self,children)
942        csElement.__init__(self,**kwargs)
943
944class RaggedSectionFeature(AbstractFeature, csElement):
945    def __init__(self, **kwargs):
946        AbstractFeature.__init__(self,**kwargs)
947        elems=['stationLocations', 'stationTimes', 'profileLength' 'value','parameter']
948        addelems(self,elems)
949        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']}
950        addchildren(self,children)
951        csElement.__init__(self,**kwargs)
952
953class SectionFeature(AbstractFeature, csElement):
954    def __init__(self, **kwargs):
955        AbstractFeature.__init__(self,**kwargs)
956        elems=['stationLocations', 'stationTimes','value', 'parameter']
957        addelems(self,elems)
958        children={elems[0]:[CSML('stationLocations'), 'csString'], elems[1]:[CSML('stationTimes'), 'TimePositionList'],elems[2]:[CSML('SectionCoverage'), 'SectionCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
959        addchildren(self,children)
960        csElement.__init__(self,**kwargs)
961
962class ScanningRadarFeature(AbstractFeature, csElement):
963    def __init__(self, **kwargs):
964        AbstractFeature.__init__(self,**kwargs)
965        elems=['elevation','value', 'parameter']
966        addelems(self,elems)
967        children={elems[0]:[CSML('elevation'), 'csString'], elems[1]:[CSML('ScanningRadarCoverage'), 'ScanningRadarCoverage', CSML('value')], elems[2]:[CSML('parameter'), 'Phenomenon']}
968        addchildren(self,children)
969        csElement.__init__(self,**kwargs)
970
971       
972class SwathFeature(AbstractFeature, csElement):
973    def __init__(self, **kwargs):
974        AbstractFeature.__init__(self,**kwargs)
975        elems=['eqCrossLon', 'eqCrossTime', 'value', 'parameter']
976        addelems(self,elems)
977        children={elems[0]:[CSML('eqCrossLon'), 'csString'],elems[1]:[CSML('eqCrossTime'), 'csString'], elems[2]:[CSML('ReferenceableGridCoverage'), 'ReferenceableGridCoverage', CSML('value')], elems[3]:[CSML('parameter'), 'Phenomenon']}
978        addchildren(self,children)
979        csElement.__init__(self,**kwargs)
980       
981class TrajectoryFeature(AbstractFeature, csElement):
982    def __init__(self, **kwargs):
983        AbstractFeature.__init__(self,**kwargs)
984        elems=['value', 'parameter']
985        addelems(self,elems)
986        children={elems[0]:[CSML('TrajectoryCoverage'), 'TrajectoryCoverage', CSML('value')], elems[1]:[CSML('parameter'), 'Phenomenon']}
987        addchildren(self,children)
988        csElement.__init__(self,**kwargs)
989       
990class FileList(AssociationAttributeGroup,csElement):
991    def __init__(self,**kwargs):
992        AssociationAttributeGroup.__init__(self,**kwargs)       
993        a=['id']
994        addatts(self,a)
995        elems=['fileNames']
996        addelems(self,elems)
997        children= {elems[0]:[CSML('fileNames'), 'csString']}
998        addchildren(self,children)
999        csElement.__init__(self,**kwargs)
1000       
1001class FileExtract(ArrayDescriptor, csElement):
1002    def __init__(self,**kwargs):
1003        ArrayDescriptor.__init__(self,**kwargs)
1004        elems=['fileName', 'fileList', 'fileListXLINK']
1005        addelems(self,elems)
1006        children= {elems[0]:[CSML('fileName'), 'csString'],  elems[1]:[CSML('FileList'), 'FileList', CSML('fileList')],elems[2]:[CSML('fileList'), 'csString']}
1007        addchildren(self,children)
1008        csElement.__init__(self,**kwargs)
1009   
1010class NetCDFExtract(FileExtract, csElement):
1011    def __init__(self,**kwargs):
1012        FileExtract.__init__(self, **kwargs)
1013        elems=['variableName']
1014        addelems(self,elems)
1015        children={elems[0]:[CSML('variableName'), 'csString']}
1016        addchildren(self,children)
1017        csElement.__init__(self,**kwargs)
1018
1019class NASAAmesExtract(FileExtract, csElement):
1020    def __init__(self,**kwargs):
1021        FileExtract.__init__(self, **kwargs)
1022        elems=['variableName', 'index']
1023        addelems(self,elems)
1024        children={elems[0]:[CSML('variableName'), 'csString'],elems[1]:[CSML('index'),'csString']}
1025        addchildren(self,children)
1026        csElement.__init__(self,**kwargs)
1027
1028class RawFileExtract(FileExtract, csElement):
1029
1030   # Note: Unlike the other file extracts, this sets a self.dataInterface
1031   # attribute, which is used by the overridden getData to determine which
1032   # Data Interface is used to read the file. This is necessary because the
1033   # getUnknownDataInterface() method determines which DI to use based on
1034   # filename suffix (raw files could be called anything) or by inspecting
1035   # the file (raw files have no magic numbers or other markers that could
1036   # be used to unequivocally determine the file type).
1037   def __init__(self,**kwargs):
1038      FileExtract.__init__(self, **kwargs)
1039      elems=['endianness', 'fillValue']
1040      addelems(self,elems)
1041      children={elems[0]:[CSML('endianness'), 'csString'],elems[1]:[CSML('fillValue'), 'csString']}
1042      addchildren(self,children)
1043      csElement.__init__(self,**kwargs)
1044      self.dataInterface = csml.csmllibs.csmldataiface.RawFileInterface
1045
1046
1047   # raw and image extracts need access to metadata defined in the CSML to
1048   # correctly read the file. This method overrides the FileExtract getData()
1049   # method making use of the readFile() DI method to pass this metadata to
1050   # the data interface.
1051   # TODO: This should probably be moved outside parser.py, possibly into
1052   # API/ops_FileExtract
1053   def getData(self,  fileposition=None,**kwargs):
1054       #file position defines the position of the filename if a list of filenames exists
1055       #**kwargs can hold subsetting request.
1056       
1057
1058       if fileposition is not None:
1059           file = self.fileList.fileNames.CONTENT.split()[fileposition]
1060       else:
1061           file = self.fileName.CONTENT
1062     
1063       # Determine metadata required to correctly read and process the
1064       # raw file:
1065       meta = {}
1066       meta['dimensions'] = map(int, self.arraySize.CONTENT.split())
1067       if self.numericTransform:
1068          meta['numericTransform'] = self.numericTransform.CONTENT.strip()
1069       if self.endianness:
1070          meta['endianness'] = self.endianness.CONTENT.strip()
1071       if self.fillValue:
1072          meta['fillValue'] = self.fillValue.CONTENT.strip()
1073       if self.numericType:
1074          type = self.numericType.CONTENT.strip()
1075          if type == 'float':
1076             meta['signedness'] = 'signed'
1077             meta['type']       = 'float'
1078             meta['depth']      = 32
1079          elif type == 'double':
1080             meta['signedness'] = 'signed'
1081             meta['type']       = 'float'
1082             meta['depth']      = 64
1083          elif type[0:4] == 'uint':
1084             meta['signedness'] = 'unsigned'
1085             meta['type']       = 'int'
1086             meta['depth']      = int(type[4:])
1087          elif type[0:3] == 'int':
1088             meta['signedness'] = 'signed'
1089             meta['type']       = 'int'
1090             meta['depth']      = int(type[3:])
1091
1092       if self.dataInterface:
1093          DI = self.dataInterface()
1094       else:
1095          DI = csml.csmllibs.csmldataiface.DataInterface()
1096          DI = DI.getUnknownInterfaceType(file)
1097
1098       DI.openFile(file)
1099       DI.readFile(**meta)
1100       if kwargs:
1101          print 'subsetting'
1102          data = DI.getSubsetOfDataForVar(**kwargs)
1103       else:
1104          print 'non subsetting'
1105          data = DI.getDataForVar()
1106       fillValue = DI.getFillValue()
1107       DI.closeFile()
1108       return data, fillValue, None, None
1109
1110
1111class ImageFileExtract(FileExtract, csElement):
1112   def __init__(self,**kwargs):
1113      FileExtract.__init__(self, **kwargs)
1114      elems=['fillValue']
1115      addelems(self,elems)
1116      children={elems[0]:[CSML('fillValue'), 'csString']}
1117      addchildren(self,children)
1118      csElement.__init__(self,**kwargs)
1119      self.dataInterface = csml.csmllibs.csmldataiface.ImageFileInterface
1120      self.getData = RawFileExtract.getData
1121
1122class SimpleCondition(csElement): 
1123    '''from moles'''
1124    def __init__(self,**kwargs):
1125        addatts(self, [])
1126        elems= ['dgAttributeAuthority', 'attrauthRole']
1127        addelems(self,elems)
1128        children={elems[0]:[MOLES('dgAttributeAuthority'), 'csString'],elems[1]:[MOLES('attrauthRole'), 'csString']}
1129        addchildren(self,children)
1130        csElement.__init__(self, **kwargs)
1131
1132
1133class ComplexCondition(csElement): 
1134    '''from moles (stub class)'''
1135    def __init__(self,**kwargs):
1136        addatts(self, [])
1137        elems= []
1138        addelems(self,elems)
1139        children={}
1140        addchildren(self,children)
1141        csElement.__init__(self, **kwargs)
1142
1143class DgSecurityCondition(csElement): 
1144    '''from moles'''
1145    def __init__(self,**kwargs):
1146        addatts(self, [])
1147        elems=['effect', 'conditionExplanationText', 'simpleCondition', 'complexCondition']
1148        addelems(self,elems)
1149        children={elems[0]:[MOLES('effect'), 'csString'],elems[1]:[MOLES('conditionExplanationText'),'csString'],elems[2]:[MOLES('simpleCondition'), 'SimpleCondition'],elems[3]:[MOLES('complexCondition'), 'ComplexCondition']}
1150        addchildren(self,children)
1151        csElement.__init__(self,**kwargs)
1152
1153class AccessControlPolicy(csElement):
1154    def __init__(self,**kwargs):
1155        addatts(self,[])
1156        elems=['accessControlPolicyURL', 'accessControlPolicyText', 'dgSecurityCondition']     
1157        addelems(self,elems)
1158        children={elems[0]:[CSML('accessControlPolicyURL'), 'csString'],elems[1]:[CSML('accessControlPolicyText'),'csString'],elems[2]:[MOLES('dgSecurityCondition'), 'DgSecurityCondition']}
1159        addchildren(self,children)
1160        csElement.__init__(self,**kwargs)
1161       
1162class CSMLStorageDescriptor(csElement):
1163    def __init__(self,**kwargs):
1164        addatts(self,[])
1165        elems=['descriptors']
1166        addelems(self,elems)
1167        children={elems[0]:[[CSML('NetCDFExtract'),CSML('AggregatedArray')], 'FileExtract', CSML('descriptor'),1]}
1168        addchildren(self,children)
1169        csElement.__init__(self,**kwargs)
1170
1171class CSMLFeatureCollection(AbstractFeatureCollection,csElement,):
1172    def __init__(self,**kwargs):
1173        AbstractFeatureCollection.__init__(self,**kwargs)
1174        elems=['featureMembers']
1175        addelems(self,elems)
1176        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]}
1177        addchildren(self,children)
1178        csElement.__init__(self,**kwargs)
1179    def _getSubstitutionType(self,tag):
1180        if tag==CSML('GridFeature'):
1181            return 'GridFeature'
1182        elif tag==CSML('GridSeriesFeature'):
1183            return 'GridSeriesFeature'
1184        elif tag==CSML('PointFeature'):
1185            return 'PointFeature'
1186        elif tag==CSML('TrajectoryFeature'):
1187            return 'TrajectoryFeature'
1188        elif tag==CSML('PointSeriesFeature'):
1189            return 'PointSeriesFeature'
1190        elif tag==CSML('ProfileFeature'):
1191            return 'ProfileFeature'
1192        elif tag==CSML('ProfileSeriesFeature'):
1193            return 'ProfileSeriesFeature'
1194        elif tag==CSML('RaggedProfileSeriesFeature'):
1195            return 'RaggedProfileSeriesFeature'
1196        elif tag==CSML('RaggedSectionFeature'):
1197            return 'RaggedSectionFeature'
1198        elif tag==CSML('SectionFeature'):
1199            return 'SectionFeature'
1200        elif tag==CSML('ScanningRadarFeature'):
1201            return 'ScanningRadarFeature'
1202        elif tag==CSML('AlternatePointFeature'):
1203            return 'AlternatePointFeature'
1204        else: return 'AbstractFeature'
1205    def _getReverseSubsType(self, typename):
1206        if typename== 'GridFeature':
1207            return CSML('GridFeature')
1208        elif typename == 'GridSeriesFeature':
1209            return CSML('GridSeriesFeature')
1210        elif typename == 'PointSeriesFeature':
1211            return CSML('PointSeriesFeature')
1212        elif typename == 'ProfileFeature':
1213            return CSML('ProfileFeature')
1214        elif typename == 'ProfileSeriesFeature':
1215            return CSML('ProfileSeriesFeature')
1216        elif typename == 'SectionFeature':
1217            return CSML('SectionFeature')
1218        elif typename == 'ScanningRadarFeature':
1219            return CSML('ScanningRadarFeature')
1220        elif typename == 'RaggedSectionFeature':
1221            return CSML('RaggedSectionFeature')
1222        elif typename == 'RaggedProfileSeriesFeature':
1223            return CSML('RaggedProfileSeriesFeature')
1224        elif typename == 'PointFeature':
1225            return CSML('PointFeature')
1226        elif typename == 'TrajectoryFeature':
1227            return CSML('TrajectoryFeature')
1228        elif typename == 'AlternatePointFeature':
1229            return CSML('AlternatePointFeature')
1230        else: return CSML('AbstractFeature')
1231
1232       
1233class Dataset(csElement):   
1234    ''' Dataset class, needed as root of tree'''
1235    def __init__(self, **kwargs):
1236        a=['id']
1237        addatts(self,a)
1238        elems=['accessControlPolicy','featureCollection','storageDescriptor']
1239        addelems(self,elems)
1240        children = {elems[0]:[CSML('AccessControlPolicy') ,'AccessControlPolicy'], elems[1]:[CSML('CSMLFeatureCollection') ,'CSMLFeatureCollection'],elems[2]:[CSML('CSMLStorageDescriptor'), 'CSMLStorageDescriptor']}
1241        addchildren(self,children)
1242        csElement.__init__(self,**kwargs)
1243   
1244    def toXML(self):
1245        csmlfrag=ET.Element(CSML('Dataset'))
1246        csElement.toXML(self, csmlfrag)
1247        return csmlfrag
1248    #def _getSubstitutionType(self,tag): 
1249        #if tag==CSML('NetCDFExtract'):
1250            #return 'NetCDFExtract'
1251        #elif tag==CSML('NASAAmesExtract'):
1252            #return 'NASAAmesExtract'
1253        #else: return 'ArrayDescriptor'
1254    #def _getReverseSubsType(self, typename):
1255        #if typename== 'NetCDFExtract':
1256            #return CSML('NetCDFExtract')
1257        #elif typename == 'NASAAmesExtract':
1258            #return CSML('NASAAmesExtract')
1259        #else: return CSML('ArrayDescriptor')
1260       
1261        return typename
1262
1263   
1264def main():
1265    '''round trip for testing purposes:'''
1266    import parser_extra
1267   
1268    print '\n'
1269    #tree=ET.ElementTree(file='testfiles/gridseries/testout.xml')
1270    tree=ET.ElementTree(file='testfiles/gridseries/securitytest.xml')
1271    ds=Dataset()
1272    ds.fromXML(tree.getroot())
1273    csmltree=ds.toXML()
1274   
1275    csmlout=parser_extra.PrettyPrint(csmltree)
1276    csmlout=parser_extra.removeInlineNS(csmlout)
1277    print '\n %s'% csmlout
1278    #for member in ds.featureCollection.members:
1279      #print dir(member.value)
1280       
1281
1282if __name__=='__main__':
1283    main()
Note: See TracBrowser for help on using the repository browser.