Extensions/wms/parser.py

# Copyright (c) 2004 by Intevation GmbH
# Authors:
# Martin Schulze <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""
Inspect WMS Capabilities for later processing.

Information should only be retrieved with the proper get*() methods.

class WMSCapabilitiesParser:
    __init__()

    grok(string)

    getTitle()
    getAbstract()
    getFees()
    getAccessConstraints()
    getFormats()
    getLayers()
    getSRS()

    getLayerTitle(layer)
    getLayerSRS(layer)
    getLayerLatLonBBox(layer)
    getLayerBBox(layer, srs)

    isQueryable(layer)

    get_srs_discrepancies()
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import xml.dom.minidom

from domutils import getElementsByName, getElementByName

class WMSCapabilitiesParser:
    """
    Thuban class to parse capabilities supplied as large string.

    This class provides methods to parse and retrieve particular
    information from the WMS capabilities XML.  Information should
    only be extracted by the respective get*() methods.
    """

    layers = None
    title = None
    abstract = None
    fees = None
    access = None
    formats = None
    srs_discrepancies = None


    def __init__(self):
        """
        Initialises an instance in this class.
        """

        # Note that we must not initialise internal variables of the
        # class in a mutable way or it will be shared among all
        # instances.  None is immutable, [] is not.
        layers = []


    def grok(self, data):
        """
        Parses the XML response to a WMS GetCapabilities request.

        Internal datastructure of the class will be filled.
        Information should only be retrieved with the respective
        get*() methods.
        """
        root = xml.dom.minidom.parseString(data).documentElement

        # Extract the title
        foo = getElementByName(getElementByName(root, 'Service'), 'Title')
        if foo:
            self.title = foo.childNodes[0].data
        
        # Extract the abstract
        foo = getElementByName(getElementByName(root, 'Service'), 'Abstract')
        if foo and len(foo.childNodes[0].data):
            self.abstract = foo.childNodes[0].data
        
        # Extract fees information
        foo = getElementByName(getElementByName(root, 'Service'), 'Fees')
        if foo and len(foo.childNodes[0].data) \
               and lower(foo.childNodes[0].data) != 'none':
            self.fees = foo.childNodes[0].data
        
        # Extract access information
        foo = getElementByName(getElementByName(root, 'Service'),
                               'AccessConstraints')
        if foo and len(foo.childNodes[0].data) \
               and lower(foo.childNodes[0].data) != 'none':
            self.access = foo.childNodes[0].data
        
        # Extract output format information
        foo = getElementsByName(
            getElementByName(getElementByName(getElementByName(
            root, 'Capability'), 'Request'), 'GetMap'), 'Format')
        self.formats = map((lambda i: i.childNodes[0].data), foo)

        # Extract layer names
        self.layers = []
        self.peekLayers(getElementByName(getElementByName(
            root, 'Capability'), 'Layer'), -1)


    def peekLayers(self, top, parent):
        """
        Inspect the provided DOM fragment referenced as top.

        This method will inspect all included layers and traverse the
        tree recursively in order to fill the internal datastructure.

        Note that SRS other than EPSG:* are not yet supported,
        especially there is no support for AUTO and NONE.
        """

        index = len (self.layers)
        self.layers.append({})
        self.layers[index]['parent'] = parent

        for foo in top.attributes.keys():
            if foo == 'queryable':
                self.layers[index]['queryable'] \
                    = int(top.attributes.get(foo).nodeValue)

        foo = getElementByName(top, 'Title')
        if foo and len(foo.childNodes[0].data):
            self.layers[index]['title'] = foo.childNodes[0].data

        foo = getElementByName(top, 'Name')
        if foo and len(foo.childNodes[0].data):
            self.layers[index]['name'] = foo.childNodes[0].data

        # These values are only used for an integrity check
        for foo in getElementsByName(top, 'SRS'):
            for srs in foo.childNodes[0].data.split(" "):
                if srs[0:5] == 'EPSG:':
                    srs = srs[5:]
                try:
                    self.layers[index]['srs'].append(srs)
                except KeyError:
                    self.layers[index]['srs'] = [srs]

        foo = getElementByName(top, 'LatLonBoundingBox')
        if foo is not None:
            self.layers[index]['llbbox'] = {}
            for corner in ['minx', 'miny', 'maxx', 'maxy']:
                self.layers[index]['llbbox'][corner] \
                    = foo.attributes.get(corner).nodeValue

        boxes = getElementsByName(top, 'BoundingBox')
        if boxes != []:
            self.layers[index]['bbox'] = {}
        for foo in boxes:
            srs = foo.attributes.get('SRS').nodeValue
            if srs[0:5] == 'EPSG:':
                srs = srs[5:]
            self.layers[index]['bbox'][srs] = {}
            for corner in ['minx', 'miny', 'maxx', 'maxy']:
                self.layers[index]['bbox'][srs][corner] \
                    = foo.attributes.get(corner).nodeValue
            
        # Traverse subsidiary layers
        sublayer = getElementsByName(top, 'Layer')
        for l in sublayer:
            self.peekLayers(l, index)


    def getTitle(self):
        """
        Returns the main title of the WMS object.

        If no title is provided in the capabilities, an empty string
        is returned.
        """
        if self.title is None:
            return ''
        else:
            return self.title


    def getAbstract(self):
        """
        Returns the abstract of the WMS object.

        If no abstract is provided in the capabilities, an empty
        string is returned.
        """
        if self.abstract is None:
            return ''
        else:
            return self.abstract


    def getFees(self):
        """
        Returns the fees information of the WMS object.

        If no information is provided in the capabilities or if it is
        set to 'none', an empty string is returned.
        """
        if self.fees is None:
            return ''
        else:
            return self.fees


    def getAccessConstraints(self):
        """
        Returns information about access constraints for the WMS object.

        If no information is provided in the capabilities or if it is
        set to 'none', an empty string is returned.
        """
        if self.access is None:
            return ''
        else:
            return self.access


    def getFormats(self):
        """
        Returns a list of supported output formats.

        These are used in the GetMap request.  This method will
        default to 'image/jpeg' if no format is recognised in XML
        Capabilities, assuming that JPEG will always be supported on
        the server side.
        """
        if self.formats is None:
            return ['image/jpeg']
        else:
            return self.formats

    def getLayers(self):
        """
        Returns a list of layer names.

        Only named layers will be returned, since a layer may have a
        title but doesn't have to have a name associated to it as
        well.  If no layers were found, an empty list is returned.
        """
        result = []
        for layer in self.layers:
            if 'name' in layer:
                result.append(layer['name'])

        return result


    def getSRS(self):
        """
        Returns the root list of spatial reference systems (SRS).

        This list is taken from the root layer.  Those SRS are common
        to all subsidiary layers.  If no SRS are common to all layers,
        an empty list is returned.  If no layers were detected, an
        empty list is returned as well.
        """
        if len(self.layers) == 0:
            return []

        # index 0 denotes the root layer by design
        if 'srs' in self.layers[0].keys():
            return self.layers[0]['srs']


    def getLayerTitle(self, name):
        """
        Returns the title of the named layer.

        If no such title or no such layer exists, an empty string is
        returned.
        """
        for layer in self.layers:
            if 'name' in layer:
                if layer['name'] == name:
                    if 'title' in layer:
                        return layer['title']

        return ''


    def getLayerSRS(self, name):
        """
        Returns a list of spacial reference systems (SRS).

        The SRS are specified by the European Petroleum Survey Group
        (EPSG).  There should be at least one SRS per layer, though.
        The prefix 'EPSG:' will be stripped.  If none exists, an empty
        list is returned.

        The specification [OGC 01-068r3] says about inheritance of
        SRS:

        - Every layer is available in one or more SRS (or in an
          undefined SRS)

        - Geographic information whose SRS is undefined
          (e.g. digitised historical maps) shall use 'NONE'
          (case-sensitive).  This implementation does not support
          this.

        - Every layer shall have at least one SRS element that is
          either stated explicitly or inherited from a parent layer.

        - The root layer element shall include a sequence of zero or
          more SRS elements listing all SRS which are common for to
          all subsidiary layers.

        - Layers may optionally add to the global SRS list, or to the
          list inherited from a parent layer.

        - A server which has the ability to transform data to
          different SRSes may choose not to provide an explicit
          BoundingBox for every possible SRS available for each Layer.
          Thus the list of <SRS> elements are authoritative.

        This implementation returns the list of SRS for the given
        layer, calculated by looking at BoundingBoxes defined in the
        named layer and all layers higher in the hierarchy up to the
        root layer which weren't overwritten.
        """
        for i in range(len(self.layers)):
            if 'name' in self.layers[i]:
                if self.layers[i]['name'] == name:
                    pivot = i
                    break
        else:
            return []

        result = []
        while pivot != -1:
            if 'srs' in self.layers[pivot]:
                for srs in self.layers[pivot]['srs']:
                    if srs not in result:
                        result.append(srs)
            pivot = self.layers[pivot]['parent']

        return result


    def getLayerLatLonBBox(self, name):
        """
        Returns a dictionary of the LatLonBoundingBox.

        ... for the named layer if it exists.  The SRS is always
        EPSG:4326 per convention.  There should be at least one,
        though, inherited from the root layer at least.  If none
        exists, the value None is returned.
        """
        for layer in self.layers:
            if 'name' in layer:
                if layer['name'] == name:
                    if 'llbbox' in layer:
                        return layer['llbbox']
                    else:
                        # No LatLonBoundingBox found in current layer,
                        # so traverse the hierarchy upwards and check
                        # again until there is one.
                        pivot = layer
                        while pivot['parent'] != -1:
                            pivot = self.layers[pivot['parent']]
                            if 'llbbox' in pivot:
                                return pivot['llbbox']

        return None


    def getLayerBBox(self, name, srs):
        """
        Returns a dictionary of the BoundingBox.

        If no such BoundingBox exists, None is returned.

        The specification [OGC 01-068r3] says about BoundingBoxes:

        - Layers may have zero or more BoundingBox elements what are
          either stated explicitly or inherited from a parent layer.

        - A layer may have multiple BoundingBox elements, but each one
          shall state a different SRS.

        - A layer inherits any BoundingBoxes defined by its
          parents.

        - A BoundingBox inherited from the parent layer for a
          particular SRS is replaced by any declaration for the same
          SRS in the current layer.

        - A BoundingBox in the child layer for a new SRS which is not
          already declared by the parent, is added to the list of
          BoundingBoxes for the child layer.

        - A single layer shall not contain more than one BoundingBox
          element for the same SRS.
        """
        for layer in self.layers:
            if 'name' in layer:
                if layer['name'] == name:
                    if 'bbox' in layer:
                        if srs in layer['bbox']:
                            return layer['bbox'][srs]
                    
                    # No BoundingBox for the given SRS found in
                    # current layer, so traverse the hierarchy upwards
                    # and check again until there is one.
                    pivot = layer
                    while pivot['parent'] != -1:
                        pivot = self.layers[pivot['parent']]
                        if 'bbox' in pivot:
                            if srs in pivot['bbox']:
                                return pivot['bbox'][srs]

        return None


    def isQueryable(self, name):
        """
        Returns the value of the queryable attribute of a layer.

        This attribute denotes whether this layer can be queried
        through the GetFeatureInfo request.  The default value is 0.

        The specification [OGC 01-068r3] this attribute can be
        inherited.
        """

        for layer in self.layers:
            if 'name' in layer:
                if layer['name'] == name:
                    try:
                        return layer['queryable']
                    except KeyError:
                        # No attribute in this layer, so traverse the
                        # hierarchy upwards
                        pivot = layer
                        while pivot['parent'] != -1:
                            pivot = self.layers[pivot['parent']]
                            if 'queryable' in pivot:
                                return pivot['queryable']
        return 0


    def get_srs_discrepancies(self):
        """
        Returns a list of layer identifications where the denoted SRS
        values differ from the calculated ones through BoundingBox
        elements.
        """
        return self.srs_discrepancies


if __name__ == "__main__":
    print "This module cannot be executed standalone."

    import os

    try:
        f = open("test/sample.xml", "r")
    except IOError:
        try:
            f = open(os.path.dirname(__file__) + "/test/sample.xml", "r")
        except IOError:
            print "Cannot open sample.xml for reading"

    if f is not None:
        sample = f.read();
        f.close()
        
        ina = WMSCapabilitiesParser()
        ina.grok(sample)
1	# Copyright (c) 2004 by Intevation GmbH
2	# Authors:
3	# Martin Schulze <[email protected]>
4	#
5	# This program is free software; you can redistribute it and/or modify
6	# it under the terms of the GNU General Public License as published by
7	# the Free Software Foundation; either version 2 of the License, or
8	# (at your option) any later version.
9	#
10	# This program is distributed in the hope that it will be useful,
11	# but WITHOUT ANY WARRANTY; without even the implied warranty of
12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	# GNU General Public License for more details.
14	#
15	# You should have received a copy of the GNU General Public License
16	# along with this program; if not, write to the Free Software
17	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19	"""
20	Inspect WMS Capabilities for later processing.
21
22	Information should only be retrieved with the proper get*() methods.
23
24	class WMSCapabilitiesParser:
25	__init__()
26
27	grok(string)
28
29	getTitle()
30	getAbstract()
31	getFees()
32	getAccessConstraints()
33	getFormats()
34	getLayers()
35	getSRS()
36
37	getLayerTitle(layer)
38	getLayerSRS(layer)
39	getLayerLatLonBBox(layer)
40	getLayerBBox(layer, srs)
41
42	isQueryable(layer)
43
44	get_srs_discrepancies()
45	"""
46
47	__version__ = "$Revision$"
48	# $Source$
49	# $Id$
50
51	import xml.dom.minidom
52
53	from domutils import getElementsByName, getElementByName
54
55	class WMSCapabilitiesParser:
56	"""
57	Thuban class to parse capabilities supplied as large string.
58
59	This class provides methods to parse and retrieve particular
60	information from the WMS capabilities XML. Information should
61	only be extracted by the respective get*() methods.
62	"""
63
64	layers = None
65	title = None
66	abstract = None
67	fees = None
68	access = None
69	formats = None
70	srs_discrepancies = None
71
72
73	def __init__(self):
74	"""
75	Initialises an instance in this class.
76	"""
77
78	# Note that we must not initialise internal variables of the
79	# class in a mutable way or it will be shared among all
80	# instances. None is immutable, [] is not.
81	layers = []
82
83
84	def grok(self, data):
85	"""
86	Parses the XML response to a WMS GetCapabilities request.
87
88	Internal datastructure of the class will be filled.
89	Information should only be retrieved with the respective
90	get*() methods.
91	"""
92	root = xml.dom.minidom.parseString(data).documentElement
93
94	# Extract the title
95	foo = getElementByName(getElementByName(root, 'Service'), 'Title')
96	if foo:
97	self.title = foo.childNodes[0].data
98
99	# Extract the abstract
100	foo = getElementByName(getElementByName(root, 'Service'), 'Abstract')
101	if foo and len(foo.childNodes[0].data):
102	self.abstract = foo.childNodes[0].data
103
104	# Extract fees information
105	foo = getElementByName(getElementByName(root, 'Service'), 'Fees')
106	if foo and len(foo.childNodes[0].data) \
107	and lower(foo.childNodes[0].data) != 'none':
108	self.fees = foo.childNodes[0].data
109
110	# Extract access information
111	foo = getElementByName(getElementByName(root, 'Service'),
112	'AccessConstraints')
113	if foo and len(foo.childNodes[0].data) \
114	and lower(foo.childNodes[0].data) != 'none':
115	self.access = foo.childNodes[0].data
116
117	# Extract output format information
118	foo = getElementsByName(
119	getElementByName(getElementByName(getElementByName(
120	root, 'Capability'), 'Request'), 'GetMap'), 'Format')
121	self.formats = map((lambda i: i.childNodes[0].data), foo)
122
123	# Extract layer names
124	self.layers = []
125	self.peekLayers(getElementByName(getElementByName(
126	root, 'Capability'), 'Layer'), -1)
127
128
129	def peekLayers(self, top, parent):
130	"""
131	Inspect the provided DOM fragment referenced as top.
132
133	This method will inspect all included layers and traverse the
134	tree recursively in order to fill the internal datastructure.
135
136	Note that SRS other than EPSG:* are not yet supported,
137	especially there is no support for AUTO and NONE.
138	"""
139
140	index = len (self.layers)
141	self.layers.append({})
142	self.layers[index]['parent'] = parent
143
144	for foo in top.attributes.keys():
145	if foo == 'queryable':
146	self.layers[index]['queryable'] \
147	= int(top.attributes.get(foo).nodeValue)
148
149	foo = getElementByName(top, 'Title')
150	if foo and len(foo.childNodes[0].data):
151	self.layers[index]['title'] = foo.childNodes[0].data
152
153	foo = getElementByName(top, 'Name')
154	if foo and len(foo.childNodes[0].data):
155	self.layers[index]['name'] = foo.childNodes[0].data
156
157	# These values are only used for an integrity check
158	for foo in getElementsByName(top, 'SRS'):
159	for srs in foo.childNodes[0].data.split(" "):
160	if srs[0:5] == 'EPSG:':
161	srs = srs[5:]
162	try:
163	self.layers[index]['srs'].append(srs)
164	except KeyError:
165	self.layers[index]['srs'] = [srs]
166
167	foo = getElementByName(top, 'LatLonBoundingBox')
168	if foo is not None:
169	self.layers[index]['llbbox'] = {}
170	for corner in ['minx', 'miny', 'maxx', 'maxy']:
171	self.layers[index]['llbbox'][corner] \
172	= foo.attributes.get(corner).nodeValue
173
174	boxes = getElementsByName(top, 'BoundingBox')
175	if boxes != []:
176	self.layers[index]['bbox'] = {}
177	for foo in boxes:
178	srs = foo.attributes.get('SRS').nodeValue
179	if srs[0:5] == 'EPSG:':
180	srs = srs[5:]
181	self.layers[index]['bbox'][srs] = {}
182	for corner in ['minx', 'miny', 'maxx', 'maxy']:
183	self.layers[index]['bbox'][srs][corner] \
184	= foo.attributes.get(corner).nodeValue
185
186	# Traverse subsidiary layers
187	sublayer = getElementsByName(top, 'Layer')
188	for l in sublayer:
189	self.peekLayers(l, index)
190
191
192	def getTitle(self):
193	"""
194	Returns the main title of the WMS object.
195
196	If no title is provided in the capabilities, an empty string
197	is returned.
198	"""
199	if self.title is None:
200	return ''
201	else:
202	return self.title
203
204
205	def getAbstract(self):
206	"""
207	Returns the abstract of the WMS object.
208
209	If no abstract is provided in the capabilities, an empty
210	string is returned.
211	"""
212	if self.abstract is None:
213	return ''
214	else:
215	return self.abstract
216
217
218	def getFees(self):
219	"""
220	Returns the fees information of the WMS object.
221
222	If no information is provided in the capabilities or if it is
223	set to 'none', an empty string is returned.
224	"""
225	if self.fees is None:
226	return ''
227	else:
228	return self.fees
229
230
231	def getAccessConstraints(self):
232	"""
233	Returns information about access constraints for the WMS object.
234
235	If no information is provided in the capabilities or if it is
236	set to 'none', an empty string is returned.
237	"""
238	if self.access is None:
239	return ''
240	else:
241	return self.access
242
243
244	def getFormats(self):
245	"""
246	Returns a list of supported output formats.
247
248	These are used in the GetMap request. This method will
249	default to 'image/jpeg' if no format is recognised in XML
250	Capabilities, assuming that JPEG will always be supported on
251	the server side.
252	"""
253	if self.formats is None:
254	return ['image/jpeg']
255	else:
256	return self.formats
257
258	def getLayers(self):
259	"""
260	Returns a list of layer names.
261
262	Only named layers will be returned, since a layer may have a
263	title but doesn't have to have a name associated to it as
264	well. If no layers were found, an empty list is returned.
265	"""
266	result = []
267	for layer in self.layers:
268	if 'name' in layer:
269	result.append(layer['name'])
270
271	return result
272
273
274	def getSRS(self):
275	"""
276	Returns the root list of spatial reference systems (SRS).
277
278	This list is taken from the root layer. Those SRS are common
279	to all subsidiary layers. If no SRS are common to all layers,
280	an empty list is returned. If no layers were detected, an
281	empty list is returned as well.
282	"""
283	if len(self.layers) == 0:
284	return []
285
286	# index 0 denotes the root layer by design
287	if 'srs' in self.layers[0].keys():
288	return self.layers[0]['srs']
289
290
291	def getLayerTitle(self, name):
292	"""
293	Returns the title of the named layer.
294
295	If no such title or no such layer exists, an empty string is
296	returned.
297	"""
298	for layer in self.layers:
299	if 'name' in layer:
300	if layer['name'] == name:
301	if 'title' in layer:
302	return layer['title']
303
304	return ''
305
306
307	def getLayerSRS(self, name):
308	"""
309	Returns a list of spacial reference systems (SRS).
310
311	The SRS are specified by the European Petroleum Survey Group
312	(EPSG). There should be at least one SRS per layer, though.
313	The prefix 'EPSG:' will be stripped. If none exists, an empty
314	list is returned.
315
316	The specification [OGC 01-068r3] says about inheritance of
317	SRS:
318
319	- Every layer is available in one or more SRS (or in an
320	undefined SRS)
321
322	- Geographic information whose SRS is undefined
323	(e.g. digitised historical maps) shall use 'NONE'
324	(case-sensitive). This implementation does not support
325	this.
326
327	- Every layer shall have at least one SRS element that is
328	either stated explicitly or inherited from a parent layer.
329
330	- The root layer element shall include a sequence of zero or
331	more SRS elements listing all SRS which are common for to
332	all subsidiary layers.
333
334	- Layers may optionally add to the global SRS list, or to the
335	list inherited from a parent layer.
336
337	- A server which has the ability to transform data to
338	different SRSes may choose not to provide an explicit
339	BoundingBox for every possible SRS available for each Layer.
340	Thus the list of <SRS> elements are authoritative.
341
342	This implementation returns the list of SRS for the given
343	layer, calculated by looking at BoundingBoxes defined in the
344	named layer and all layers higher in the hierarchy up to the
345	root layer which weren't overwritten.
346	"""
347	for i in range(len(self.layers)):
348	if 'name' in self.layers[i]:
349	if self.layers[i]['name'] == name:
350	pivot = i
351	break
352	else:
353	return []
354
355	result = []
356	while pivot != -1:
357	if 'srs' in self.layers[pivot]:
358	for srs in self.layers[pivot]['srs']:
359	if srs not in result:
360	result.append(srs)
361	pivot = self.layers[pivot]['parent']
362
363	return result
364
365
366	def getLayerLatLonBBox(self, name):
367	"""
368	Returns a dictionary of the LatLonBoundingBox.
369
370	... for the named layer if it exists. The SRS is always
371	EPSG:4326 per convention. There should be at least one,
372	though, inherited from the root layer at least. If none
373	exists, the value None is returned.
374	"""
375	for layer in self.layers:
376	if 'name' in layer:
377	if layer['name'] == name:
378	if 'llbbox' in layer:
379	return layer['llbbox']
380	else:
381	# No LatLonBoundingBox found in current layer,
382	# so traverse the hierarchy upwards and check
383	# again until there is one.
384	pivot = layer
385	while pivot['parent'] != -1:
386	pivot = self.layers[pivot['parent']]
387	if 'llbbox' in pivot:
388	return pivot['llbbox']
389
390	return None
391
392
393	def getLayerBBox(self, name, srs):
394	"""
395	Returns a dictionary of the BoundingBox.
396
397	If no such BoundingBox exists, None is returned.
398
399	The specification [OGC 01-068r3] says about BoundingBoxes:
400
401	- Layers may have zero or more BoundingBox elements what are
402	either stated explicitly or inherited from a parent layer.
403
404	- A layer may have multiple BoundingBox elements, but each one
405	shall state a different SRS.
406
407	- A layer inherits any BoundingBoxes defined by its
408	parents.
409
410	- A BoundingBox inherited from the parent layer for a
411	particular SRS is replaced by any declaration for the same
412	SRS in the current layer.
413
414	- A BoundingBox in the child layer for a new SRS which is not
415	already declared by the parent, is added to the list of
416	BoundingBoxes for the child layer.
417
418	- A single layer shall not contain more than one BoundingBox
419	element for the same SRS.
420	"""
421	for layer in self.layers:
422	if 'name' in layer:
423	if layer['name'] == name:
424	if 'bbox' in layer:
425	if srs in layer['bbox']:
426	return layer['bbox'][srs]
427
428	# No BoundingBox for the given SRS found in
429	# current layer, so traverse the hierarchy upwards
430	# and check again until there is one.
431	pivot = layer
432	while pivot['parent'] != -1:
433	pivot = self.layers[pivot['parent']]
434	if 'bbox' in pivot:
435	if srs in pivot['bbox']:
436	return pivot['bbox'][srs]
437
438	return None
439
440
441	def isQueryable(self, name):
442	"""
443	Returns the value of the queryable attribute of a layer.
444
445	This attribute denotes whether this layer can be queried
446	through the GetFeatureInfo request. The default value is 0.
447
448	The specification [OGC 01-068r3] this attribute can be
449	inherited.
450	"""
451
452	for layer in self.layers:
453	if 'name' in layer:
454	if layer['name'] == name:
455	try:
456	return layer['queryable']
457	except KeyError:
458	# No attribute in this layer, so traverse the
459	# hierarchy upwards
460	pivot = layer
461	while pivot['parent'] != -1:
462	pivot = self.layers[pivot['parent']]
463	if 'queryable' in pivot:
464	return pivot['queryable']
465	return 0
466
467
468	def get_srs_discrepancies(self):
469	"""
470	Returns a list of layer identifications where the denoted SRS
471	values differ from the calculated ones through BoundingBox
472	elements.
473	"""
474	return self.srs_discrepancies
475
476
477	if __name__ == "__main__":
478	print "This module cannot be executed standalone."
479
480	import os
481
482	try:
483	f = open("test/sample.xml", "r")
484	except IOError:
485	try:
486	f = open(os.path.dirname(__file__) + "/test/sample.xml", "r")
487	except IOError:
488	print "Cannot open sample.xml for reading"
489
490	if f is not None:
491	sample = f.read();
492	f.close()
493
494	ina = WMSCapabilitiesParser()
495	ina.grok(sample)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision