source: TI02-CSML/trunk/newparser/Parser.py @ 655

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/newparser/Parser.py@655
Revision 655, 40.6 KB checked in by domlowe, 14 years ago (diff)

Point Feature complete, Namespaces fixed, EnvelopeWithTimeFeature? & boundedBy added

Line 
1#!/usr/bin/env python
2
3from cElementTree import *
4import sys
5from UserString import MutableString
6
7# NOTES
8# ~~~~~
9#
10# (1) Testing existence in cElementTree.
11# ElementTree structures evaluate as false unless they have child elements:
12#
13# >>> b=Element('blah')
14# >>> dump(b)
15# <blah />
16# >>> if b: print 'non-null'
17#
18# >>> b.append(Element('moreblah'))
19# >>> dump(b)
20# <blah><moreblah /></blah>
21# >>> if b: print 'non-null'
22#
23# non-null
24#
25#
26# For this reason, existence tests should always be done as:
27#
28# >>> b=Element('blah')
29# >>> if b is not None: print 'non-null'
30#
31# non-null
32#
33# (2) Namesmape processing
34# Everything is namespace qualified in ElementTree.
35# The module provides a utility class QName(uri,tag) with QName().text providing
36# the text representation "{uri}tag" used by ElementTree. Instead, a lightweight
37# equivalent function myQName(uri,tag) has been defined here to do the
38# same thing. Also, CSML(tag), GML(tag), XLINK(tag) provide even shorter cuts.
39#
40# (3) Mandatory elements
41# The basic pattern used in the toXML() method here is to look for those
42# attributes of the class that are expected and add to the XML fragment under
43# construction. Where those attributes are mandatory, however, (i.e. UML
44# multiplicity one), the test is not performed - they are assumed to exist.
45# This eliminates an 'if' statement, but will geneate an error if they don't
46# exist.
47
48nsCSML = 'http://ndg.nerc.ac.uk/csml'
49nsGML = 'http://www.opengis.net/gml'
50nsOM = 'http://www.opengis.net/om'
51nsXLINK = 'http://www.w3.org/1999/xlink'
52nsXML = 'http://ndg.nerc.ac.uk/csml'
53
54def myQName(uri,tag):
55    return "{"+uri+"}"+tag
56
57def CSML(tag):
58    return myQName(nsCSML,tag)
59
60def GML(tag):
61    return myQName(nsGML,tag)
62
63def XLINK(tag):
64    return myQName(nsXLINK,tag)
65
66def XML(tag):
67    return myQName(nsXML.tag)
68
69def checkArrayAttrib(obj,attrib):
70    if not hasattr(obj,attrib) or not isinstance(getattr(obj,attrib),list):
71        setattr(obj,attrib,[])
72
73##class TemplateClass(Base):
74##    def __init__(self,myarg=None,*args,**kwargs):
75##        Base.__init__(self,*args,**kwargs)
76##        # code specific to TemplateClass
77##    def fromXML(self,csmlFrag):
78##        Base.fromXML(self,csmlFrag)
79##        # code specific to TemplateClass
80##    def toXML(self,csmlFrag):
81##        csmlFrag = Base.toXML(self,csmlFrag)
82##        # code specific to TemplateClass
83##        return csmlFrag
84
85class MetaDataProperty:
86    """Class representing metadata property (gmlBase.xsd)
87
88    MetaDataProperty:
89     +href: URI
90    """
91    def __init__(self,href=None):
92        if href:
93            self.href = href
94    def fromXML(self,csmlFrag):
95        if csmlFrag.attrib.has_key(XLINK('href')):
96            #print "METADATA PROPERTY FOUND"
97            #print (csmlFrag.attrib[XLINK('href')])
98            self.href = csmlFrag.attrib[XLINK('href')]
99    def toXML(self,csmlFrag):
100        if hasattr(self,'href'):
101            csmlFrag.attrib[XLINK('href')] = self.href
102        return csmlFrag
103
104class Description(MutableString):
105    """Class representing a GML description element
106    Description(string):
107    """
108    def __init__(self,val=''):
109        MutableString.__init__(self,val)
110    def fromXML(self,csmlFrag):
111        self.data = csmlFrag.text
112    def toXML(self,csmlFrag):
113        csmlFrag.text = self.data
114        return csmlFrag
115
116class Name(MutableString):
117    """Class representing a GML name element
118
119    Name(string):
120     +codeSpace[0..1]: anyURI
121    """
122    def __init__(self,val='',codeSpace=None):
123        MutableString.__init__(self,val)
124        if codeSpace:
125            self.codeSpace = codeSpace
126    def fromXML(self,csmlFrag):
127        self.data = csmlFrag.text
128#Andrew:
129## For some reason, namespace on 'codeSpace' attribute not being picked up...
130##        if csmlFrag.attrib.has_key(GML('codeSpace')):
131##            self.codeSpace = csmlFrag.attrib[GML('codeSpace')]
132#Dominic:
133##  I think this is because it has no explicit namespace in the XML doc eg.: <gml:name codeSpace="http://ndg.nerc....
134## unlike say: gml:id which has the gml: prefix explicitly e.g. <gml:UnitDefinition gml:id="psu">
135
136        if csmlFrag.attrib.has_key('codeSpace'):
137            self.codeSpace = csmlFrag.attrib['codeSpace']
138    def toXML(self,csmlFrag):
139        csmlFrag.text = self.data
140        if hasattr(self,'codeSpace'):
141##            csmlFrag.attrib[GML('codeSpace')] = self.codeSpace
142            csmlFrag.attrib['codeSpace'] = self.codeSpace
143        return csmlFrag
144
145class AbstractGML:
146    """Base abstract GML type
147
148    AbstractGML:
149     +id[0..1]: ID
150     +metaDataProperty[0..*]: MetaDataProperty
151     +description[0..1]: Description
152     +name[0..*]: Name
153    """
154    def __init__(self,gmlid=None,metaDataProperty=[],description=None,name=[]):
155        if gmlid:
156            self.id = gmlid
157        if metaDataProperty:
158            self.metaDataProperty = metaDataProperty
159        if description:
160            self.description = description
161        if name:
162            self.name = name
163    def fromXML(self,csmlFrag):
164        if csmlFrag.attrib.has_key(GML('id')):
165            self.id = csmlFrag.attrib[GML('id')]
166        for frag in csmlFrag.getchildren():
167            if frag.tag == GML('metaDataProperty'):
168                checkArrayAttrib(self,'metaDataProperty')
169                self.metaDataProperty.append(MetaDataProperty())
170                self.metaDataProperty[-1].fromXML(frag)
171            elif frag.tag == GML('description'):
172                self.description = Description()
173                self.description.fromXML(frag)
174            elif frag.tag == GML('name'):
175                checkArrayAttrib(self,'name')
176                self.name.append(Name())
177                self.name[-1].fromXML(frag)
178    def toXML(self,csmlFrag):
179        if hasattr(self,'id'):
180            csmlFrag.attrib[GML('id')] = self.id
181        if hasattr(self,'metaDataProperty'):
182            for md in self.metaDataProperty:
183                frag = Element(GML('metaDataProperty'))
184                frag = MetaDataProperty.toXML(md,frag)
185                csmlFrag.append(frag)
186        if hasattr(self,'description'):
187            frag = Element(GML('description'))
188            frag = Description.toXML(self.description,frag)
189            csmlFrag.append(frag)
190        if hasattr(self,'name'):
191            for name in self.name:
192                frag = Element(GML('name'))
193                frag = Name.toXML(name,frag)
194                csmlFrag.append(frag)
195        return csmlFrag
196
197class UnitDefinitions:
198    def __init__(self):
199        pass
200    def fromXML(self,csmlFrag):
201        pass
202    def toXML(self,csmlFrag):
203        return csmlFrag
204
205class ReferenceSystemDefinitions:
206    def __init__(self):
207        pass
208    def fromXML(self,csmlFrag):
209        pass
210    def toXML(self,csmlFrag):
211        return csmlFrag
212
213class PhenomenonDefinitions:
214    def __init__(self):
215        pass
216    def fromXML(self,csmlFrag):
217        pass
218    def toXML(self,csmlFrag):
219        return csmlFrag
220
221class AbstractArrayDescriptor(AbstractGML):
222    """Base abstract class for CSML array descriptors
223
224    AbstractArrayDescriptor(AbstractGML):
225     +arraySize[1..*]: int
226     +uom[0..1]: anyURI
227     +numericType[0..1]: string
228     +regExpTransform[0..1]: string
229     +numericTransform[0..1]: string
230    """
231    def __init__(self,arraySize=None,uom=None,numericType=None,
232                 regExpTransform=None,numericTransform=None,*args,**kwargs):
233        AbstractGML.__init__(self,*args,**kwargs)
234        if arraySize:
235            self.arraySize = arraySize
236        if uom:
237            self.uom = uom
238        if numericType:
239            self.numericType = numericType
240        if regExpTransform:
241            self.regExpTransform = regExpTransform
242        if numericTransform:
243            self.numericTransform = numericTransform
244    def fromXML(self,csmlFrag):
245        AbstractGML.fromXML(self,csmlFrag)
246        for frag in csmlFrag.getchildren():
247            if frag.tag == CSML('arraySize'):
248                self.arraySize = map(int,frag.text.split())
249            elif frag.tag == CSML('uom'):
250                self.uom = frag.text
251            elif frag.tag == CSML('numericType'):
252                self.numericType = frag.text
253            elif frag.tag == CSML('regExpTransform'):
254                self.regExpTransform = frag.text
255            elif frag.tag == CSML('numericTransform'):
256                self.numericTransform = frag.text
257    def toXML(self,csmlFrag):
258        csmlFrag = AbstractGML.toXML(self,csmlFrag)
259        if hasattr(self,'arraySize'):
260            frag = Element(CSML('arraySize'))
261            frag.text = ' '.join(map(str,self.arraySize))
262            csmlFrag.append(frag)
263        if hasattr(self,'uom'):
264            frag = Element(CSML('uom'))
265            frag.text = self.uom
266            csmlFrag.append(frag)
267        if hasattr(self,'numericType'):
268            frag = Element(CSML('numericType'))
269            frag.text  = self.numericType
270            csmlFrag.append(frag)
271        if hasattr(self,'regExpTransform'):
272            frag = Element(CSML('regExpTransform'))
273            frag.text = self.regExpTransform
274            csmlFrag.append(frag)
275        if hasattr(self,'numericTransform'):
276            frag = Element(CSML('numericTransform'))
277            frag.text = self.numericTransform
278            csmlFrag.append(frag)
279        return csmlFrag
280
281class AggregatedArray(AbstractArrayDescriptor):
282    """CSML class for aggregated array
283
284    AggregatedArray(AbstractArrayDescriptor):
285     +aggType: string
286     +aggIndex: int
287     +component[1..*]: AbstractArrayDescriptor
288    """
289    def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs):
290        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
291        if aggType:
292            self.aggType = aggType
293        if aggIndex:
294            self.aggIndex = aggIndex
295        if component:
296            self.component = component
297    def fromXML(self,csmlFrag):
298        AbstractArrayDescriptor.fromXML(self,csmlFrag)
299        for frag in csmlFrag.getchildren():
300            if frag.tag == CSML('aggType'):
301                self.aggType = frag.text
302            elif frag.tag == CSML('aggIndex'):
303                self.aggIndex = int(frag.text)
304            elif frag.tag == CSML('component'):
305                checkArrayAttrib(self,'component')
306                componentFrag = frag[0]
307                if componentFrag.tag == CSML('AggregatedArray'):
308                    self.component.append(AggregatedArray())
309                elif componentFrag.tag == CSML('InlineArray'):
310                    self.component.append(InlineArray())
311                elif componentFrag.tag == CSML('ArrayGenerator'):
312                    self.component.append(ArrayGenerator())
313                elif componentFrag.tag == CSML('NASAAmesExtract'):
314                    self.component.append(NASAAmesExtract())
315                elif componentFrag.tag == CSML('NetCDFExtract'):
316                    self.component.append(NetCDFExtract())
317                elif componentFrag.tag == CSML('GRIBExtract'):
318                    self.component.append(GRIBExtract())
319##                else:
320##                    raise Exception('Unexpected element: "'+componentFrag.tag+'"')
321                self.component[-1].fromXML(componentFrag)
322    def toXML(self,csmlFrag):
323        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
324        if hasattr(self,'aggType'):
325            frag = Element(CSML('aggType'))
326            frag.text = self.aggType
327            csmlFrag.append(frag)
328        if hasattr(self,'aggIndex'):
329            frag = Element(CSML('aggIndex'))
330            frag.text = str(self.aggIndex)
331            csmlFrag.append(frag)
332        if hasattr(self,'component'):
333            compFrag = Element(CSML('component'))
334            for comp in self.component:
335                if isinstance(comp,AggregatedArray):
336                    frag = Element(CSML('AggregatedArray'))
337                    frag = AggregatedArray.toXML(comp,frag)
338                elif isinstance(comp,InlineArray):
339                    frag = Element(CSML('InlineArray'))
340                    frag = InlineArray.toXML(comp,frag)
341                elif isinstance(comp,ArrayGenerator):
342                    frag = Element(CSML('ArrayGenerator'))
343                    frag = ArrayGenerator.toXML(comp,frag)
344                elif isinstance(comp,NASAAmesExtract):
345                    frag = Element(CSML('NASAAmesExtract'))
346                    frag = NASAAmesExtract.toXML(comp,frag)
347                elif isinstance(comp,NetCDFExtract):
348                    frag = Element(CSML('NetCDFExtract'))
349                    frag = NetCDFExtract.toXML(comp,frag)
350                elif isinstance(comp,GRIBExtract):
351                    frag = Element(CSML('GRIBExtract'))
352                    frag = NASAAmesExtract.toXML(comp,frag)
353                compFrag.append(frag)
354            csmlFrag.append(compFrag)
355        return csmlFrag
356
357class InlineArray(AbstractArrayDescriptor):
358    pass
359
360class ArrayGenerator(AbstractArrayDescriptor):
361    pass
362
363class AbstractFileExtract(AbstractArrayDescriptor):
364    """Base abstract clas for CSML file array extract
365
366    AbstractFileExtract(AbstractArrayDescriptor):
367     +fileName: string
368    """
369    def __init__(self,fileName=None,*args,**kwargs):
370        AbstractArrayDescriptor.__init__(self,*args,**kwargs)
371        if fileName:
372            self.fileName = fileName
373    def fromXML(self,csmlFrag):
374        AbstractArrayDescriptor.fromXML(self,csmlFrag)
375        for frag in csmlFrag.getchildren():
376            if frag.tag == CSML('fileName'):
377                self.fileName = frag.text
378##        else:
379##            raise Exception('Unexpected element: "'+frag.tag+'"')
380    def toXML(self,csmlFrag):
381        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag)
382        frag = Element(CSML('fileName'))
383        frag.text = self.fileName
384        csmlFrag.append(frag)
385        return csmlFrag
386
387class NASAAmesExtract(AbstractFileExtract):
388    """CSML class for NASA Ames file extract
389
390    NASAAmesExtract(AbstractFileExtract):
391     +variableName: string
392     +index[0..1]: int
393    """
394    def __init__(self,variableName=None,index=None,*args,**kwargs):
395        AbstractFileExtract.__init__(self,*args,**kwargs)
396        if variableName:
397            self.variableName = variableName
398        if index:
399            self.index = index
400    def fromXML(self,csmlFrag):
401        AbstractFileExtract.fromXML(self,csmlFrag)
402        for frag in csmlFrag.getchildren():
403            if frag.tag == CSML('variableName'):
404                self.variableName = frag.text
405            elif frag.tag == CSML('index'):
406                self.index = int(frag.text)
407##            else:
408##                raise Exception('Unexpected element: "'+frag.tag+'"')
409    def toXML(self,csmlFrag):
410        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
411        frag = Element(CSML('variableName'))
412        frag.text = self.variableName
413        csmlFrag.append(frag)
414        if hasattr(self,'index'):
415            frag = Element(CSML('index'))
416            frag.text = str(self.index)
417            csmlFrag.append(frag)
418        return csmlFrag
419
420class NetCDFExtract(AbstractFileExtract):
421    """CSML class for netCDF file extract
422
423    NetCDFExtract(AbstractFileExtract):
424     +variableName: string
425    """
426    def __init__(self,variableName=None,*args,**kwargs):
427        AbstractFileExtract.__init__(self,*args,**kwargs)
428        if variableName:
429            self.variableName = variableName
430    def fromXML(self,csmlFrag):
431        AbstractFileExtract.fromXML(self,csmlFrag)
432        for frag in csmlFrag.getchildren():
433            if frag.tag == CSML('variableName'):
434                self.variableName = frag.text
435##        else:
436##            raise Exception('Unexpected element: "'+frag.tag+'"')
437    def toXML(self,csmlFrag):
438        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
439        frag = Element(CSML('variableName'))
440        frag.text = self.variableName
441        csmlFrag.append(frag)
442        return csmlFrag
443
444class GRIBExtract(AbstractFileExtract):
445    """CSML class for GRIB file extract
446
447    GRIBExtract(AbstractFileExtract):
448     +parameterCode: int
449     +recordNumber[0..1]: int
450     +fileOffset[0..1]: int
451    """
452    def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None,
453                 *args,**kwargs):
454        AbstractFileExtract.__init__(self,*args,**kwargs)
455        if parameterCode:
456            self.parameterCode = parameterCode
457        if recordNumber:
458            self.recordNumber = recordNumber
459        if fileOffset:
460            self.fileOffset = fileOffset
461    def fromXML(self,csmlFrag):
462        AbstractFileExtract.fromXML(self,csmlFrag)
463        for frag in csmlFrag.getchildren():
464            if frag.tag == CSML('parameterCode'):
465                self.parameterCode = int(frag.text)
466            elif frag.tag == CSML('recordNumber'):
467                self.recordNumber = int(frag.text)
468            elif frag.tag == CSML('fileOffset'):
469                self.fileOffset = int(frag.text)
470##            else:
471##                raise Exception('Unexpected element: "'+frag.tag+'"')
472    def toXML(self,csmlFrag):
473        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag)
474        frag = Element(CSML('parameterCode'))
475        frag.text = str(self.parameterCode)
476        csmlFrag.append(frag)
477        if hasattr(self,'recordNumber'):
478            frag = Element(CSML('recordNumber'))
479            frag.text = str(self.recordNumber)
480            csmlFrag.append(frag)
481        if hasattr(self,'fileOffset'):
482            frag = Element(CSML('fileOffset'))
483            frag.text = str(self.fileOffset)
484            csmlFrag.append(frag)
485        return csmlFrag
486
487class AbstractDiscreteCoverage(AbstractGML):
488     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes
489    #GML AbstractDiscreteCoverage Class
490   
491    def __init__(self,*args,**kwargs):
492        AbstractGML.__init__(self,*args,**kwargs)
493    def fromXML(self,csmlFrag):
494        AbstractGML.fromXML(self,csmlFrag)
495    def toXML(self,csmlFrag):
496        AbstractGML.toXML(self,csmlFrag)
497        return csmlFrag
498       
499class AbstractCoverageFeature(AbstractDiscreteCoverage):
500    #CSML Abstract Coverage FT class
501    #     AbstractCoverageFeature():
502    #       +gml:boundedBy[0..*]: AbstractFeature
503    #       +csml:_Domain
504    #       + gml:rangeSet
505    #       + gml:coverageFunction[0..*]
506    #       + parameter:om:PhenomenonPropertyType
507    def __init__(self,boundedBy=None,_Domain=None,rangeSet=None, coverageFunction=None, parameter=None, *args,**kwargs):
508        AbstractDiscreteCoverage.__init__(self,*args,**kwargs)
509        if boundedBy:
510            self.boundedBy=boundedBy
511        if _Domain:
512            self._Domain=_Domain
513        if rangeSet:
514            self.rangeSet=rangeSet
515        if coverageFunction:
516            self.coverageFunction=coverageFunction
517        if parameter:
518            self.parameter=parameter
519    def fromXML(self,csmlFrag):
520        AbstractDiscreteCoverage.fromXML(self,csmlFrag)
521        for frag in csmlFrag.getchildren():
522            if frag.tag == GML('boundedBy'):
523                #hmmm check this one is right.
524                checkArrayAttrib(self,'boundedBy')
525                self.boundedBy.append(frag.text)
526            if frag.tag == CSML('_Domain'):
527                self._Domain = _Domain()
528                self._Domain.fromXML(frag)
529    def toXML(self,csmlFrag):
530        AbstractDiscreteCoverage.toXML(self,csmlFrag)
531        return csmlFrag
532
533
534
535
536class AbstractStaticCoverageFeature(AbstractCoverageFeature):
537    #CSML Abstract Static Coverage FT class
538    def __init__(self,*args,**kwargs):
539        AbstractCoverageFeature.__init__(self,*args,**kwargs)
540    def fromXML(self,csmlFrag):
541        AbstractCoverageFeature.fromXML(self,csmlFrag)
542    def toXML(self,csmlFrag):
543        AbstractCoverageFeature.toXML(self,csmlFrag)
544        return csmlFrag
545
546class AbstractDomain:
547    #CSML AbstractDomain class
548    #   AbstractDomain()
549    #   +csml:domainReference
550    #   +csml:domainComplement [0...1]
551       
552    def __init__(self,domainReference,domainComplement, *args,**kwargs):
553        if domainReference:
554            self.domainReference=domainReference
555        if domainComplement:
556            self.domainComplement=domainComplement
557    def fromXML(self,csmlFrag):
558        for frag in csmlFrag.getchildren():
559            if frag.tag == CSML('domainReference'):
560                self.domainReference = domainReference()
561                self.domainReference.fromXML(frag)
562            if frag.tag == CSML('domainComplement'):
563                self.domainComplement = frag.text
564    def toXML(self,csmlFrag):
565        if hasattr(self,'domainReference'):
566            frag = Element(CSML('domainReference'))
567            domainReference.toXML(self.domainReference,frag)
568            csmlFrag.append(frag)
569        if hasattr(self,'domainComplement'):
570             frag = Element(CSML('domainComplement'))
571             domainComplement.toXML(self.domainComplement,frag)
572             csmlFrag.append(frag)
573        return csmlFrag
574
575class boundedBy:
576    #CSML boundedBy class
577   
578    # boundedBy()
579    # +gml:EnvelopeWithTimePeriod
580   
581    def __init__(self,EnvelopeWithTimePeriod=None):
582        if EnvelopeWithTimePeriod:
583            self.EnvelopeWithTimePeriod=EnvelopeWithTimePeriod()
584    def fromXML(self, csmlFrag):
585        for frag in csmlFrag.getchildren():
586            if frag.tag == GML ('EnvelopeWithTimePeriod'):
587                self.EnvelopeWithTimePeriod=EnvelopeWithTimePeriod()
588                EnvelopeWithTimePeriod.fromXML(self.EnvelopeWithTimePeriod,frag)
589    def toXML(self,csmlFrag):
590        if hasattr(self, 'EnvelopeWithTimePeriod'):
591            frag = Element(GML('EnvelopeWithTimePeriod'))
592            EnvelopeWithTimePeriod.toXML(self.EnvelopeWithTimePeriod, frag)
593            csmlFrag.append(frag)
594        return csmlFrag
595   
596class EnvelopeWithTimePeriod:
597    # CSML EnvelopeWithTimePeriod class
598    # EnvelopeWithTimePeriod():
599        # +gml:lowerCorner
600        # +gml:upperCorner
601        # +gml:timePosition [2] ?
602       
603    def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None):
604        if srsName:
605            self.srsName=srsName
606        if lowerCorner:
607            self.lowerCorner=lowerCorner
608        if upperCorner:
609            self.upperCorner=upperCorner
610        if timePosition:
611            self.timePosition=timePosition
612        if timePosition2:
613            self.timePosition2=timePosition2
614    def fromXML(self,csmlFrag):
615        for frag in csmlFrag.getchildren():
616            if frag.attrib.has_key('srsName'):
617                self.srsName=frag.attrib['srsName']
618            if frag.tag == GML('lowerCorner'):
619                self.lowerCorner=frag.text
620            if frag.tag == GML('upperCorner'):
621                self.upperCorner=frag.text
622            if frag.tag == GML('timePosition'):
623                if hasattr(self, 'timePosition'):
624                    self.timePosition2=frag.text
625                else:
626                    self.timePosition=frag.text
627    def toXML(self,csmlFrag):
628        if hasattr(self,'srsName'):
629            csmlFrag.attrib['srsName'] = self.srsName
630        if hasattr(self,'lowerCorner'):
631            frag=Element(GML('lowerCorner'))
632            frag.text=self.lowerCorner
633            csmlFrag.append(frag)
634        if hasattr(self,'upperCorner'):
635            frag=Element(GML('upperCorner'))
636            frag.text=self.upperCorner
637            csmlFrag.append(frag)
638        if hasattr(self,'timePosition'):
639            frag=Element(GML('timePosition'))
640            frag.text=self.timePosition
641            csmlFrag.append(frag)
642        if hasattr(self,'timePosition2'):
643            frag=Element(GML('timePosition'))
644            frag.text=self.timePosition2
645            csmlFrag.append(frag)
646        return csmlFrag
647class Position:
648    def __init__(self,srsName=None,axisLabels=None,uomLabels=None):
649        if srsName:
650            self.srsName=srsName
651        if axisLabels:
652            self.axisLabels=axisLabels
653        if uomLabels:
654            self.uomLabels=uomLabels
655    def fromXML(self,csmlFrag):
656        if csmlFrag.attrib.has_key('srsName'):           
657            self.srsName = csmlFrag.attrib['srsName']
658        if csmlFrag.attrib.has_key('axisLabels'):
659            self.axisLabels = csmlFrag.attrib['axisLabels']
660            if csmlFrag.attrib.has_key('uomLabels'):
661                self.uomLabels = csmlFrag.attrib['uomLabels']
662        for frag in csmlFrag.getchildren():
663            print frag.tag
664            if frag.tag==CSML('location'):
665                self.location=frag.text
666            if frag.tag==CSML('time'):
667                self.time=frag.text
668    def toXML(self,csmlFrag):
669        if hasattr(self,'uomLabels'):
670            csmlFrag.attrib['uomLabels'] = self.uomLabels
671        if hasattr(self,'axisLabels'):
672            csmlFrag.attrib['axisLabels'] = self.axisLabels
673        if hasattr(self,'srsName'):
674            csmlFrag.attrib['srsName'] = self.srsName
675        if hasattr(self,'location'):
676            frag = Element(CSML('location'))
677            frag.text=self.location
678            csmlFrag.append(frag)
679        if hasattr(self,'time'):
680            frag = Element(CSML('time'))
681            frag.text=self.time
682            csmlFrag.append(frag)
683        return csmlFrag
684
685class rangeSet:
686    def __init__(self,QuantityList=None, uom=None):
687        if QuantityList:
688            self.QuantityList=QuantityList
689        if uom:
690            self.uom=uom
691    def fromXML(self,csmlFrag):
692        for frag in csmlFrag.getchildren():
693            if frag.tag==GML('QuantityList'):
694                self.QuantityList=frag.text
695                if frag.attrib.has_key('uom'):
696                    self.uom = frag.attrib['uom']
697    def toXML(self, csmlFrag):
698        if hasattr(self,'QuantityList'):
699            frag = Element(GML('QuantityList'))
700            frag.text=self.QuantityList
701        if hasattr(self,'uom'):
702             frag.attrib['uom'] = self.uom
703        csmlFrag.append(frag)
704        return csmlFrag
705
706
707class domainReference:
708    def __init__(self):
709        pass
710    def fromXML(self,csmlFrag):
711        for frag in csmlFrag.getchildren():
712            if frag.tag==CSML('Position'):
713                self.Position=Position()
714                self.Position.fromXML(frag)
715
716    def toXML(self,csmlFrag):
717        if hasattr(self,'Position'):
718             frag = Element(CSML('Position'))
719             Position.toXML(self.Position,frag)
720             csmlFrag.append(frag)
721        return csmlFrag
722
723class domainComplement:
724    def __init__(self):
725        pass
726    def fromXML(self,csmlFrag):
727        pass
728    def toXML(self,csmlFrag):
729        return csmlFrag
730   
731class PointDomain(AbstractDomain):
732    def __init__(self):
733        pass
734class ProfileDomain(AbstractDomain):
735    def __init__(self):
736        pass
737class GridDomain(AbstractDomain):
738    def __init__(self):
739        pass
740class PointSeriesDomain(AbstractDomain):
741    def __init__(self):
742        pass 
743class ProfileSeriesDomain(AbstractDomain):
744    def __init__(self):
745        pass
746class GridSeriesDomain(AbstractDomain):
747    def __init__(self):
748        pass
749   
750   
751           
752class PointFeature(AbstractStaticCoverageFeature):
753#TODO:
754
755#Fiinish rangeSet, parameter and coverageFunction (23/02/06)
756           
757           
758    #CSML PointFeature class
759    #       PointFeature(AbstractStaticCoverageFeatureType):
760    #      +PointDomain
761    #      +gml:rangeSet
762    #      +gml:coverageFunction[0..*]
763    #      +parameter:om:PhenomenonPropertyType
764    def __init__(self,PointDomain=None,rangeSet=None,coverageFunction=None, parameter=None,*args,**kwargs):
765        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs)
766
767        if PointDomain:
768            self.PointDomain=PointDomain
769        if rangeSet:
770            self.rangeSet=rangeSet
771        if coverageFunction:
772            self.coverageFunction=coverageFunction
773        if parameter:
774            self.parameter=parameter
775    def fromXML(self,csmlFrag):
776        AbstractStaticCoverageFeature.fromXML(self,csmlFrag)
777
778        for frag in csmlFrag.getchildren():
779            if frag.tag == CSML('PointDomain'):
780                self.PointDomain = PointDomain()
781                self.PointDomain.fromXML(frag)
782            if frag.tag == GML('rangeSet'):
783                self.rangeSet=rangeSet()
784                self.rangeSet.fromXML(frag)
785            if frag.tag == CSML('parameter'):
786                self.parameter = frag.text
787                print frag.attrib
788                if frag.attrib.has_key(XLINK('href')):
789                    self.href = frag.attrib[XLINK('href')]
790
791# #             if frag.tag == GML('coverageFunction'):
792#                 checkArrayAttrib(self,'coverageFunction')
793#                 self.coverageFunction.append(frag.text)
794##        else:
795##            raise Exception('Unexpected element: "'+frag.tag+'"')
796    def toXML(self,csmlFrag):
797        AbstractStaticCoverageFeature.toXML(self,csmlFrag)
798        if hasattr(self,'PointDomain'):
799             frag = Element(CSML('PointDomain'))
800             PointDomain.toXML(self.PointDomain,frag)
801             csmlFrag.append(frag)
802        if hasattr(self,'rangeSet'):
803             frag = Element(GML('rangeSet'))
804             rangeSet.toXML(self.rangeSet,frag)
805             csmlFrag.append(frag)
806        if hasattr(self,'parameter'):
807             frag = Element(CSML('parameter'))
808             frag.text=self.parameter
809             csmlFrag.append(frag)
810        if hasattr(self,'href'):
811             frag.attrib[XLINK('href')] = self.href
812        csmlFrag.append(frag)
813        return csmlFrag
814
815class ProfileFeature:
816    def __init__(self):
817        pass
818    def fromXML(self,csmlFrag):
819        pass
820    def toXML(self,csmlFrag):
821        return csmlFrag
822class GridFeature:
823    def __init__(self):
824        pass
825    def fromXML(self,csmlFrag):
826        pass
827    def toXML(self,csmlFrag):
828        return csmlFrag
829class PointSeriesFeature:
830    def __init__(self):
831        pass
832    def fromXML(self,csmlFrag):
833        pass
834    def toXML(self,csmlFrag):
835        return csmlFrag
836class ProfileSeriesFeature:
837    def __init__(self):
838        pass
839    def fromXML(self,csmlFrag):
840        pass
841    def toXML(self,csmlFrag):
842        return csmlFrag
843class GridSeriesFeature:
844    def __init__(self):
845        pass
846    def fromXML(self,csmlFrag):
847        pass
848    def toXML(self,csmlFrag):
849        return csmlFrag
850class TrajectoryFeature:
851    def __init__(self):
852        pass
853    def fromXML(self,csmlFrag):
854        pass
855    def toXML(self,csmlFrag):
856        return csmlFrag
857   
858class AbstractFeature(AbstractGML):
859    def __init__(self):
860        pass
861    def fromXML(self,csmlFrag):
862        AbstractGML.fromXML(self,csmlFrag)
863    def toXML(self,csmlFrag):
864        AbstractGML.toXML(self,csmlFrag)
865        return csmlFrag
866
867
868
869class AbstractFeatureCollection(AbstractFeature):
870    """GML AbstractFeatureCollection class
871
872    AbstractFeatureCollection(AbstractFeature):
873     +featureMember[0..*]: AbstractFeature
874     +featureMembers[0..1]: FeatureArray
875    """
876    def __init__(self,members=[]):
877        if members:
878            self.members=members
879    def fromXML(self,csmlFrag):
880        AbstractFeature.fromXML(self,csmlFrag)
881        for frag in csmlFrag.getchildren():
882            if frag.tag == GML('featureMember'):
883                checkArrayAttrib(self,'members')
884                featureFrag = frag.getchildren()[0]
885                if featureFrag.tag == CSML('PointFeature'):
886                    self.members.append(PointFeature())
887                    self.members[-1].fromXML(featureFrag)
888                if featureFrag.tag == CSML('ProfileFeature'):
889                    self.members.append(ProfileFeature())
890                    self.members[-1].fromXML(featureFrag)
891                if featureFrag.tag == CSML('GridFeature'):
892                    self.members.append(GridFeature())
893                    self.members[-1].fromXML(featureFrag)
894                if featureFrag.tag == CSML('PointSeriesFeature'):
895                    self.members.append(PointSeriesFeature())
896                    self.members[-1].fromXML(featureFrag)
897                if featureFrag.tag == CSML('ProfileSeriesFeature'):
898                    self.members.append(ProfileSeriesFeature())
899                    self.members[-1].fromXML(featureFrag)
900                if featureFrag.tag == CSML('GridSeriesFeature'):
901                    self.members.append(GridSeriesFeature())
902                    self.members[-1].fromXML(featureFrag)
903                if featureFrag.tag == CSML('TrajectoryFeature'):
904                    self.members.append(TrajectoryFeature())
905                    self.members[-1].fromXML(featureFrag)
906    def toXML(self,csmlFrag):
907        AbstractFeature.toXML(self,csmlFrag)
908        i=0
909        for member in self.members:
910            if isinstance(member,PointFeature):
911                superFrag=Element(GML('FeatureMember'))
912                frag=Element(CSML('PointFeature'))
913                PointFeature.toXML(self.members[i],frag)
914                superFrag.append(frag)
915                csmlFrag.append(superFrag)
916            if isinstance(member,ProfileFeature):
917                superFrag=Element(GML('FeatureMember'))
918                frag=Element(CSML('ProfileFeature'))
919                ProfileFeature.toXML(self.members[i],frag)
920                superFrag.append(frag)
921                csmlFrag.append(superFrag)
922            if isinstance(member,GridFeature):
923                superFrag=Element(GML('FeatureMember'))
924                frag=Element(CSML('GridFeature'))
925                GridFeature.toXML(self.members[i],frag)
926                superFrag.append(frag)
927                csmlFrag.append(superFrag)
928            if isinstance(member,PointSeriesFeature):
929                superFrag=Element(GML('FeatureMember'))
930                frag=Element(CSML('PointSeriesFeature'))
931                PointSeriesFeature.toXML(self.members[i],frag)
932                superFrag.append(frag)
933                csmlFrag.append(superFrag)
934            if isinstance(member,ProfileSeriesFeature):
935                superFrag=Element(GML('FeatureMember'))
936                frag=Element(CSML('ProfileSeriesFeature'))
937                ProfileSeriesFeature.toXML(self.members[i],frag)
938                superFrag.append(frag)
939                csmlFrag.append(superFrag)
940            if isinstance(member,GridSeriesFeature):
941                superFrag=Element(GML('FeatureMember'))
942                frag=Element(CSML('GridSeriesFeature'))
943                GridSeriesFeature.toXML(self.members[i],frag)
944                superFrag.append(frag)
945                csmlFrag.append(superFrag)
946            if isinstance(member,TrajectoryFeature):
947                superFrag=Element(GML('FeatureMember'))
948                frag=Element(CSML('TrajectoryFeature'))
949                TrajectoryFeature.toXML(self.members[i],frag)
950                superFrag.append(frag)
951                csmlFrag.append(superFrag)
952            i=i+1
953       
954        return csmlFrag
955
956class FeatureCollection(AbstractFeatureCollection):
957    """GML FeatureCollection class
958        FeatureCollection()
959        +boundedBy[1]
960        +FeatureMembers[0..*]
961    """
962    def __init__(self,boundedBy=None):
963        if boundedBy:
964            self.boundedBy=boundedBy
965    def fromXML(self,csmlFrag):
966        for frag in csmlFrag.getchildren():
967            if frag.tag == GML('boundedBy'):
968                self.boundedBy=boundedBy()
969                boundedBy.fromXML(self.boundedBy,frag)
970        AbstractFeatureCollection.fromXML(self,csmlFrag)
971    def toXML(self,csmlFrag):
972        if hasattr(self,'boundedBy'):
973            frag = Element(GML('boundedBy'))
974            boundedBy.toXML(self.boundedBy, frag)
975            csmlFrag.append(frag)
976        AbstractFeatureCollection.toXML(self,csmlFrag)
977        return csmlFrag
978
979class Dataset(AbstractGML):
980    """CSML Dataset class
981
982    Dataset(AbstractGML):
983     +unitDefinitions[0..*]: UnitDefinitions
984     +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions
985     +phenomenonDefinitions[0..1]: PhenomenonDefinitions
986     +arrayDescriptors[0..*]: AbstractArrayDescriptor
987     +featureCollection[0..1]: FeatureCollection
988    """
989    def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None,
990                 phenomenonDefinitions=None,arrayDescriptors=[],
991                 featureCollection=None,*args,**kwargs):
992        AbstractGML.__init__(self,*args,**kwargs)
993        if unitDefinitions:
994            self.unitDefinitions = unitDefinitions
995        if referenceSystemDefinitions:
996            self.referenceSystemDefinitions = referenceSystemDefinitions
997        if phenomenonDefinitions:
998            self.phenomenonDefinitions = phenomenonDefinitions
999        if arrayDescriptors:
1000            self.arrayDescriptors = arrayDescriptors
1001        if featureCollection:
1002            self.featureCollection = featureCollection
1003    def fromXML(self,csmlFrag):
1004        AbstractGML.fromXML(self,csmlFrag)
1005        for frag in csmlFrag.getchildren():
1006            if frag.tag == CSML('UnitDefinitions'):
1007                self.unitDefinitions = UnitDefinitions()
1008                self.unitDefinitions.fromXML(frag)
1009            elif frag.tag == CSML('ReferenceSystemDefinitions'):
1010                self.referenceSystemDefinitions = ReferenceSystemDefinitions()
1011                self.referenceSystemDefinitions.fromXML(frag)
1012            elif frag.tag == CSML('PhenomenonDefinitions'):
1013                self.phenomenonDefinitions = PhenomenonDefinitions()
1014                self.phenomenonDefinitions.fromXML(frag)
1015            elif frag.tag == GML('FeatureCollection'):
1016                self.featureCollection = FeatureCollection()
1017                self.featureCollection.fromXML(frag)
1018            elif frag.tag == CSML('AggregatedArray'):
1019                checkArrayAttrib(self,'arrayDescriptors')
1020                self.arrayDescriptors.append(AggregatedArray())
1021                self.arrayDescriptors[-1].fromXML(frag)
1022            elif frag.tag == CSML('InlineArray'):
1023                checkArrayAttrib(self,'arrayDescriptors')
1024                self.arrayDescriptors.append(InlineArray())
1025                self.arrayDescriptors[-1].fromXML(frag)
1026            elif frag.tag == CSML('ArrayGenerator'):
1027                checkArrayAttrib(self,'arrayDescriptors')
1028                self.arrayDescriptors.append(ArrayGenerator())
1029                self.arrayDescriptors[-1].fromXML(frag)
1030            elif frag.tag == CSML('NASAAmesExtract'):
1031                checkArrayAttrib(self,'arrayDescriptors')
1032                self.arrayDescriptors.append(NASAAmesExtract())
1033                self.arrayDescriptors[-1].fromXML(frag)
1034            elif frag.tag == CSML('NetCDFExtract'):
1035                checkArrayAttrib(self,'arrayDescriptors')
1036                self.arrayDescriptors.append(NetCDFExtract())
1037                self.arrayDescriptors[-1].fromXML(frag)
1038            elif frag.tag == CSML('GRIBExtract'):
1039                checkArrayAttrib(self,'arrayDescriptors')
1040                self.arrayDescriptors.append(GRIBExtract())
1041                self.arrayDescriptors[-1].fromXML(frag)
1042##            else:
1043##                raise Exception('Unexpected element: "'+frag.tag+'"')
1044    def toXML(self,csmlFrag=None):
1045        if csmlFrag is None:
1046            csmlFrag = Element('Dataset')
1047        csmlFrag = AbstractGML.toXML(self,csmlFrag)
1048        if hasattr(self,'unitDefinitions'):
1049            frag = Element(CSML('UnitDefinitions'))
1050            frag = UnitDefinitions.toXML(self.unitDefinitions,frag)
1051            csmlFrag.append(frag)
1052        if hasattr(self,'referenceSystemDefinitions'):
1053            frag = Element(CSML('ReferenceSystemDefinitions'))
1054            frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag)
1055            csmlFrag.append(frag)
1056        if hasattr(self,'phenomenonDefinitions'):
1057            frag = Element(CSML('PhenomenonDefinitions'))
1058            frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag)
1059            csmlFrag.append(frag)
1060        if hasattr(self,'arrayDescriptors'):
1061            for arrayDesc in self.arrayDescriptors:
1062                if isinstance(arrayDesc,AggregatedArray):
1063                    frag = Element(CSML('AggregatedArray'))
1064                    frag = AggregatedArray.toXML(arrayDesc,frag)
1065                elif isinstance(arrayDesc,InlineArray):
1066                    frag = Element(CSML('InlineArray'))
1067                    frag = InlineArray.toXML(arrayDesc,frag)
1068                elif isinstance(arrayDesc,ArrayGenerator):
1069                    frag = Element(CSML('ArrayGenerator'))
1070                    frag = ArrayGenerator.toXML(arrayDesc,frag)
1071                elif isinstance(arrayDesc,NASAAmesExtract):
1072                    frag = Element(CSML('NASAAmesExtract'))
1073                    frag = NASAAmesExtract.toXML(arrayDesc,frag)
1074                elif isinstance(arrayDesc,NetCDFExtract):
1075                    frag = Element(CSML('NetCDFExtract'))
1076                    frag = NetCDFExtract.toXML(arrayDesc,frag)
1077                elif isinstance(arrayDesc,GRIBExtract):
1078                    frag = Element(CSML('GRIBExtract'))
1079                    frag = GRIBExtract.toXML(arrayDesc,frag)
1080                csmlFrag.append(frag)
1081        if hasattr(self,'featureCollection'):
1082            frag = Element(GML('FeatureCollection'))
1083            frag = FeatureCollection.toXML(self.featureCollection,frag)
1084            csmlFrag.append(frag)
1085            #csmlFrag=fixNameSpaces(csmlFrag)
1086        return csmlFrag
Note: See TracBrowser for help on using the repository browser.