source: TI02-CSML/branches/CSML2/csParser.py @ 1746

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/branches/CSML2/csParser.py@1746
Revision 1746, 10.9 KB checked in by domlowe, 14 years ago (diff)

deleting old comment

Line 
1import cElementTree as ET
2import elementtree.ElementTree as etree
3import csml.parser_extra
4
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
10       
11
12nsCSML = 'http://ndg.nerc.ac.uk/csml'
13nsGML = 'http://www.opengis.net/gml'
14nsOM = 'http://www.opengis.net/om'
15nsXLINK = 'http://www.w3.org/1999/xlink'
16nsXML = 'http://ndg.nerc.ac.uk/csml'
17nsMOLES='http://ndg.nerc.ac.uk/moles'
18nsSWE='http://www.opengis.net/swe'
19   
20def myQName(uri,tag):
21    return "{"+uri+"}"+tag
22
23def CSML(tag):
24    return myQName(nsCSML,tag)
25
26def GML(tag):
27    return myQName(nsGML,tag)
28
29def SWE(tag):
30    return myQName(nsSWE,tag)
31
32def XLINK(tag):
33    return myQName(nsXLINK,tag)
34
35def inherit(dict1, dict2):
36    '''merges (adds) two dictionary objects, used in attribute 'inheritance.'''
37    dict3={}
38    for item in dict1:
39        dict3[item] =dict1[item]
40    for item in dict2:
41        dict3[item] =dict2[item]
42    return dict3
43
44class csElement(object):
45    ''' main csElement class - all other elements inherit from this baseclass 
46    all the from/to XML conversion is done by this class'''
47   
48    def __init__(self, **kwargs):
49        if not hasattr(self, 'ATTRIBUTES'):
50            self.ATTRIBUTES=[]
51           
52       
53    def __removeURI(self, qname):
54        try:
55            attname = qname.split('}')[1]
56        except IndexError:
57            attname = qname
58        return attname
59       
60    def _getSubstitutionType(self,tag):
61        pass #stub
62   
63    def _getReverseSubsType(self, typename):
64        pass #stub
65   
66    def toXML(self, csmlfrag):
67    #process self... and convert  to XML
68        if hasattr(self, 'CONTENT'):
69                if self.CONTENT is not None: csmlfrag.text=self.CONTENT
70        if hasattr(self, 'ATTRIBUTES'):
71            for item in self.__dict__:
72                if item in self.ATTRIBUTES:
73                    csmlfrag.set(item, self.__dict__[item])
74         #but probably need to handle the case where GML attributes are set without namespace
75         #to allow for  use of classname(id = 'blah')
76            for item in self.__dict__:
77                if GML(item) in self.ATTRIBUTES:
78                    csmlfrag.set(GML(item), self.__dict__[item])       
79    # self.CHILDREN (recursive - calls the toXML method of children
80        for att in self.__dict__:
81            if att not in ['ATTRIBUTES', 'CHILDREN', 'CONTENT']:
82                for child in self.CHILDREN:
83                    if child == att:                       
84                        #found a match.
85                        if type(self.CHILDREN[child][0]) is not list:
86                            ename=self.CHILDREN[child][0]#Element Name
87                        etype = self.CHILDREN[child][1] #Element Type
88                        if type(self.__dict__[att])  is list:
89                            for item in self.__dict__[att]:
90                                ename = self._getReverseSubsType(type(item).__name__)
91                                frag=ET.Element(ename)
92                                item.toXML(frag)
93                                csmlfrag.append(frag)
94                        elif len(self.CHILDREN[child])==3:
95                            ename2=self.CHILDREN[child][2]
96                            parentfrag=ET.Element(ename)
97                            frag=ET.Element(ename2)
98                            self.__dict__[att].toXML(frag)
99                            parentfrag.append(frag)
100                            csmlfrag.append(parentfrag)
101                            print 'ENAMES'
102                            print ename
103                            print ename2
104                        else:
105                            frag=ET.Element(ename)
106                            self.__dict__[att].toXML(frag)
107                            csmlfrag.append(frag)
108                           
109                           
110        return csmlfrag
111       
112    def fromXML(self,csmlfrag):
113        ######## output for testing purposes ###############
114        #if hasattr(self, 'CHILDREN'):
115            #print "ELEMENT %s"%csmlfrag.tag
116            #for child in self.CHILDREN:
117                #print child       
118         #######################################
119        # deal with attributes, e.g. gml id's
120        if csmlfrag.text is not None:
121                self.CONTENT = csmlfrag.text
122        for item in csmlfrag.items():
123            if item[0] in self.ATTRIBUTES:
124                setattr(self, item[0], item[1])
125        # self.CHILDREN (recursive - calls the fromXML method of children
126        for frag in csmlfrag[:]:
127            for child in self.CHILDREN:
128                ename = self.CHILDREN[child][0] #Element Name                   
129                if frag.tag == ename:
130                    etype = self.CHILDREN[child][1]
131                    #Element Type                    #elem = ET.Element(ename)
132                    childobj=eval(etype)()
133                    childobj.fromXML(frag)
134                    if hasattr(self, child):
135                        if type(self.__dict__[child]) is not list:
136                            tmp=self.__dict__[child]
137                            setattr(self, child, [tmp]) #convert to list
138                        self.__dict__[child].append(childobj)
139                    else:
140                        setattr(self, child, childobj)
141                if type(ename) is list: # e.g. FeatureCollection where it can be GridFeature, PointFeature etc..
142                    if frag.tag in ename:
143                        etype=self._getSubstitutionType(frag.tag)
144                        childobj=eval(etype)()
145                    childobj.fromXML(frag)
146                    if hasattr(self, child):
147                        if type(self.__dict__[child]) is not list:
148                            tmp=self.__dict__[child]
149                            setattr(self, child, [tmp]) #convert to list
150                        self.__dict__[child].append(childobj)
151                    else:
152                        setattr(self, child, childobj)
153               
154class csString(csElement):
155    pass
156
157class AbstractGML(csElement):
158    def __init__(self, **kwargs):
159        a=[GML('id'), GML('description'), GML('name'), 'MetaDataProperty']
160        if hasattr(self, 'ATTRIBUTES'):
161            for att in a:
162                self.ATTRIBUTES.append(att)
163        else:
164            self.ATTRIBUTES=a
165
166class AssociationAttributeGroup(csElement):
167    def __init__(self, **kwargs):
168        a =[XLINK('href'),XLINK('role'), XLINK('arcrole'),XLINK('title'), XLINK('show'), XLINK('actuate')] 
169        if hasattr(self, 'ATTRIBUTES'):
170            for att in a:
171                self.ATTRIBUTES.append(att)
172        else:
173            self.ATTRIBUTES=a
174
175class AbstractFeature(AbstractGML,csElement):
176    def __init__(self, **kwargs):
177        AbstractGML.__init__(self,**kwargs)
178        self.CHILDREN={'boundedBy':[GML('boundedBy'), 'Envelope']}
179
180class AbstractFeatureCollection(AbstractFeature,csElement):
181    def __init__(self, **kwargs):
182        AbstractFeature.__init__(self,**kwargs)
183        self.CHILDREN=inherit(self.CHILDREN,{'members':[[CSML('GridFeature'),CSML('PointFeature')], 'AbstractFeature']})
184 
185class domainSet(AbstractGML,AssociationAttributeGroup,csElement):
186    def __init__(self, **kwargs):
187        AbstractGML.__init__(self,**kwargs)
188        self.CHILDREN={}
189
190class referenceableGridDomain(domainSet):
191    def __init__(self, **kwargs):
192        domainSet.__init__(self,**kwargs)
193        self.CHILDREN={}
194
195class AbstractCoverage(AbstractFeature, csElement):
196    def __init__(self, **kwargs):
197        AbstractFeature.__init__(self,**kwargs)
198        #self.CHILDREN={}
199       
200class AbstractDiscreteCoverage(AbstractCoverage, csElement):
201    def __init__(self, **kwargs):
202        AbstractCoverage.__init__(self,**kwargs)
203        self.CHILDREN={}
204       
205class ReferenceableGridCoverage(AbstractDiscreteCoverage, csElement):
206    def __init__(self, **kwargs):
207        AbstractDiscreteCoverage.__init__(self,**kwargs)
208        self.CHILDREN = inherit(self.CHILDREN,{'referenceableGridDomain':[CSML('referenceableGridDomain'), 'referenceableGridDomain']})
209   
210class Definition(AbstractGML):
211    def __init__(self, **kwargs):
212        AbstractGML.__init__(self,**kwargs)
213        self.CHILDREN = {} 
214
215class Phenomenon(Definition,AssociationAttributeGroup):
216    def __init__(self, **kwargs):
217        Definition.__init__(self,**kwargs)
218        AssociationAttributeGroup.__init__(self,**kwargs)
219        self.CHILDREN = {'':[CSML(''), '']}   
220
221       
222class GridFeature(AbstractFeature, csElement):
223    def __init__(self, **kwargs):
224        AbstractFeature.__init__(self,**kwargs)
225        self.CHILDREN=inherit(self.CHILDREN,{'time':[CSML('time'), 'csString'], 'value':[CSML('value'), 'ReferenceableGridCoverage', CSML('ReferenceableGridCoverage')], 'parameter':[CSML('parameter'), 'Phenomenon']})
226
227class AbstractFileExtract(AbstractGML, csElement):
228    def __init__(self,**kwargs):
229        AbstractGML.__init__(self,**kwargs)
230        self.CHILDREN = {'fileName':[CSML('fileName'), 'csString']}
231
232class NetCDFExtract(AbstractFileExtract, csElement):
233    def __init__(self,**kwargs):
234        AbstractFileExtract.__init__(self, **kwargs)
235        self.CHILDREN = inherit(self.CHILDREN,{'variableName':[CSML('variableName'), 'csString']})
236        #use inherit() when inheriting CHILDREN attribute to extend rather than replace
237
238class FeatureCollection(AbstractFeatureCollection,csElement):
239    def __init__(self,**kwargs):
240        AbstractFeatureCollection.__init__(self,**kwargs)
241    def _getSubstitutionType(self,tag):
242        if tag==CSML('GridFeature'):
243            return 'GridFeature'
244        elif tag==CSML('PointFeature'):
245            return 'PointFeature'
246        else: return 'AbstractFeature'
247    def _getReverseSubsType(self, typename):
248        if typename== 'GridFeature':
249            return CSML('GridFeature')
250        elif typename == 'PointFeature':
251            return CSML('PointFeature')
252        else: return CSML('AbstractFeature')
253
254       
255class Dataset(AbstractGML, csElement):   
256    ''' Dataset class, needed as root of tree'''
257    def __init__(self, **kwargs):
258        AbstractGML.__init__(self,**kwargs)
259        self.CHILDREN = {'ncExtract':[CSML('NetCDFExtract'), 'NetCDFExtract'], 'featureCollection':[CSML('featureCollection'),'FeatureCollection']}
260    def toXML(self):
261        csmlfrag=ET.Element(CSML('Dataset'))
262        csElement.toXML(self, csmlfrag)
263        return csmlfrag
264
265def main():
266    '''round trip for testing purposes:'''
267    print '\n'
268    tree=ET.ElementTree(file='test.xml')
269    ds=Dataset()
270    ds.fromXML(tree.getroot())
271    csmltree=ds.toXML()
272    #print csmltree
273    csmlout=csml.parser_extra.PrettyPrint(csmltree)
274    csmlout=csml.parser_extra.removeInlineNS(csmlout)
275    print '\n %s'% csmlout
276    #print dir(csmlout)
277
278    #test writing a document from scratch:
279   
280
281if __name__=='__main__':
282    main()
Note: See TracBrowser for help on using the repository browser.