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
            
        # Check for integrity
        self.checkLayerSRS(index)

        # Traverse subsidiary layers
        sublayer = getElementsByName(top, 'Layer')
        for l in sublayer:
            self.peekLayers(l, index)


    def checkLayerSRS(self, index):
        """
        Checks the integrity of the underlying XML data.

        This is done by comparing the <SRS> elements with the
        calculated list from the BoundingBox elements.

        index -- position in the layers array to check
        """

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

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

        equal = True
        # Check for same number of elements
        if len(calculated) != len(specified):
            equal = False

        # Loop through all elements for existance
        for elm in calculated:
            if elm not in specified:
                equal = False

        if not equal:
            if self.srs_discrepancies is None:
                self.srs_discrepancies = []
            if 'name' in self.layers[index]:
                id = "name:%s" % self.layers[index]['name']
            else:
                id = "title:%s" % self.layers[index]['title']
            self.srs_discrepancies.append(id)


    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.

        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 'bbox' in self.layers[pivot]:
                for srs in self.layers[pivot]['bbox'].keys():
                    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	# Check for integrity
187	self.checkLayerSRS(index)
188
189	# Traverse subsidiary layers
190	sublayer = getElementsByName(top, 'Layer')
191	for l in sublayer:
192	self.peekLayers(l, index)
193
194
195	def checkLayerSRS(self, index):
196	"""
197	Checks the integrity of the underlying XML data.
198
199	This is done by comparing the <SRS> elements with the
200	calculated list from the BoundingBox elements.
201
202	index -- position in the layers array to check
203	"""
204
205	pivot = index
206	calculated = []
207	while pivot != -1:
208	if 'bbox' in self.layers[pivot]:
209	for srs in self.layers[pivot]['bbox'].keys():
210	if srs not in calculated:
211	calculated.append(srs)
212	pivot = self.layers[pivot]['parent']
213
214	pivot = index
215	specified = []
216	while pivot != -1:
217	if 'srs' in self.layers[pivot]:
218	for srs in self.layers[pivot]['srs']:
219	if srs not in specified:
220	specified.append(srs)
221	pivot = self.layers[pivot]['parent']
222
223	equal = True
224	# Check for same number of elements
225	if len(calculated) != len(specified):
226	equal = False
227
228	# Loop through all elements for existance
229	for elm in calculated:
230	if elm not in specified:
231	equal = False
232
233	if not equal:
234	if self.srs_discrepancies is None:
235	self.srs_discrepancies = []
236	if 'name' in self.layers[index]:
237	id = "name:%s" % self.layers[index]['name']
238	else:
239	id = "title:%s" % self.layers[index]['title']
240	self.srs_discrepancies.append(id)
241
242
243	def getTitle(self):
244	"""
245	Returns the main title of the WMS object.
246
247	If no title is provided in the capabilities, an empty string
248	is returned.
249	"""
250	if self.title is None:
251	return ''
252	else:
253	return self.title
254
255
256	def getAbstract(self):
257	"""
258	Returns the abstract of the WMS object.
259
260	If no abstract is provided in the capabilities, an empty
261	string is returned.
262	"""
263	if self.abstract is None:
264	return ''
265	else:
266	return self.abstract
267
268
269	def getFees(self):
270	"""
271	Returns the fees information of the WMS object.
272
273	If no information is provided in the capabilities or if it is
274	set to 'none', an empty string is returned.
275	"""
276	if self.fees is None:
277	return ''
278	else:
279	return self.fees
280
281
282	def getAccessConstraints(self):
283	"""
284	Returns information about access constraints for the WMS object.
285
286	If no information is provided in the capabilities or if it is
287	set to 'none', an empty string is returned.
288	"""
289	if self.access is None:
290	return ''
291	else:
292	return self.access
293
294
295	def getFormats(self):
296	"""
297	Returns a list of supported output formats.
298
299	These are used in the GetMap request. This method will
300	default to 'image/jpeg' if no format is recognised in XML
301	Capabilities, assuming that JPEG will always be supported on
302	the server side.
303	"""
304	if self.formats is None:
305	return ['image/jpeg']
306	else:
307	return self.formats
308
309	def getLayers(self):
310	"""
311	Returns a list of layer names.
312
313	Only named layers will be returned, since a layer may have a
314	title but doesn't have to have a name associated to it as
315	well. If no layers were found, an empty list is returned.
316	"""
317	result = []
318	for layer in self.layers:
319	if 'name' in layer:
320	result.append(layer['name'])
321
322	return result
323
324
325	def getSRS(self):
326	"""
327	Returns the root list of spatial reference systems (SRS).
328
329	This list is taken from the root layer. Those SRS are common
330	to all subsidiary layers. If no SRS are common to all layers,
331	an empty list is returned. If no layers were detected, an
332	empty list is returned as well.
333	"""
334	if len(self.layers) == 0:
335	return []
336
337	# index 0 denotes the root layer by design
338	if 'srs' in self.layers[0].keys():
339	return self.layers[0]['srs']
340
341
342	def getLayerTitle(self, name):
343	"""
344	Returns the title of the named layer.
345
346	If no such title or no such layer exists, an empty string is
347	returned.
348	"""
349	for layer in self.layers:
350	if 'name' in layer:
351	if layer['name'] == name:
352	if 'title' in layer:
353	return layer['title']
354
355	return ''
356
357
358	def getLayerSRS(self, name):
359	"""
360	Returns a list of spacial reference systems (SRS).
361
362	The SRS are specified by the European Petroleum Survey Group
363	(EPSG). There should be at least one SRS per layer, though.
364	The prefix 'EPSG:' will be stripped. If none exists, an empty
365	list is returned.
366
367	The specification [OGC 01-068r3] says about inheritance of
368	SRS:
369
370	- Every layer is available in one or more SRS (or in an
371	undefined SRS)
372
373	- Geographic information whose SRS is undefined
374	(e.g. digitised historical maps) shall use 'NONE'
375	(case-sensitive). This implementation does not support
376	this.
377
378	- Every layer shall have at least one SRS element that is
379	either stated explicitly or inherited from a parent layer.
380
381	- The root layer element shall include a sequence of zero or
382	more SRS elements listing all SRS which are common for to
383	all subsidiary layers.
384
385	- Layers may optionally add to the global SRS list, or to the
386	list inherited from a parent layer.
387
388	This implementation returns the list of SRS for the given
389	layer, calculated by looking at BoundingBoxes defined in the
390	named layer and all layers higher in the hierarchy up to the
391	root layer which weren't overwritten.
392	"""
393	for i in range(len(self.layers)):
394	if 'name' in self.layers[i]:
395	if self.layers[i]['name'] == name:
396	pivot = i
397	break
398	else:
399	return []
400
401	result = []
402	while pivot != -1:
403	if 'bbox' in self.layers[pivot]:
404	for srs in self.layers[pivot]['bbox'].keys():
405	if srs not in result:
406	result.append(srs)
407	pivot = self.layers[pivot]['parent']
408
409	return result
410
411
412	def getLayerLatLonBBox(self, name):
413	"""
414	Returns a dictionary of the LatLonBoundingBox.
415
416	... for the named layer if it exists. The SRS is always
417	EPSG:4326 per convention. There should be at least one,
418	though, inherited from the root layer at least. If none
419	exists, the value None is returned.
420	"""
421	for layer in self.layers:
422	if 'name' in layer:
423	if layer['name'] == name:
424	if 'llbbox' in layer:
425	return layer['llbbox']
426	else:
427	# No LatLonBoundingBox found in current layer,
428	# so traverse the hierarchy upwards and check
429	# again until there is one.
430	pivot = layer
431	while pivot['parent'] != -1:
432	pivot = self.layers[pivot['parent']]
433	if 'llbbox' in pivot:
434	return pivot['llbbox']
435
436	return None
437
438
439	def getLayerBBox(self, name, srs):
440	"""
441	Returns a dictionary of the BoundingBox.
442
443	If no such BoundingBox exists, None is returned.
444
445	The specification [OGC 01-068r3] says about BoundingBoxes:
446
447	- Layers may have zero or more BoundingBox elements what are
448	either stated explicitly or inherited from a parent layer.
449
450	- A layer may have multiple BoundingBox elements, but each one
451	shall state a different SRS.
452
453	- A layer inherits any BoundingBoxes defined by its
454	parents.
455
456	- A BoundingBox inherited from the parent layer for a
457	particular SRS is replaced by any declaration for the same
458	SRS in the current layer.
459
460	- A BoundingBox in the child layer for a new SRS which is not
461	already declared by the parent, is added to the list of
462	BoundingBoxes for the child layer.
463
464	- A single layer shall not contain more than one BoundingBox
465	element for the same SRS.
466	"""
467	for layer in self.layers:
468	if 'name' in layer:
469	if layer['name'] == name:
470	if 'bbox' in layer:
471	if srs in layer['bbox']:
472	return layer['bbox'][srs]
473
474	# No BoundingBox for the given SRS found in
475	# current layer, so traverse the hierarchy upwards
476	# and check again until there is one.
477	pivot = layer
478	while pivot['parent'] != -1:
479	pivot = self.layers[pivot['parent']]
480	if 'bbox' in pivot:
481	if srs in pivot['bbox']:
482	return pivot['bbox'][srs]
483
484	return None
485
486
487	def isQueryable(self, name):
488	"""
489	Returns the value of the queryable attribute of a layer.
490
491	This attribute denotes whether this layer can be queried
492	through the GetFeatureInfo request. The default value is 0.
493
494	The specification [OGC 01-068r3] this attribute can be
495	inherited.
496	"""
497
498	for layer in self.layers:
499	if 'name' in layer:
500	if layer['name'] == name:
501	try:
502	return layer['queryable']
503	except KeyError:
504	# No attribute in this layer, so traverse the
505	# hierarchy upwards
506	pivot = layer
507	while pivot['parent'] != -1:
508	pivot = self.layers[pivot['parent']]
509	if 'queryable' in pivot:
510	return pivot['queryable']
511	return 0
512
513
514	def get_srs_discrepancies(self):
515	"""
516	Returns a list of layer identifications where the denoted SRS
517	values differ from the calculated ones through BoundingBox
518	elements.
519	"""
520	return self.srs_discrepancies
521
522
523	if __name__ == "__main__":
524	print "This module cannot be executed standalone."
525
526	import os
527
528	try:
529	f = open("test/sample.xml", "r")
530	except IOError:
531	try:
532	f = open(os.path.dirname(__file__) + "/test/sample.xml", "r")
533	except IOError:
534	print "Cannot open sample.xml for reading"
535
536	if f is not None:
537	sample = f.read();
538	f.close()
539
540	ina = WMSCapabilitiesParser()
541	ina.grok(sample)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision