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.

        - 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	joey	2133	# 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	joey	2144	- A server which has the ability to transform data to
389			different SRSes may choose not to provide an explicit
390			BoundingBox for every possible SRS available for each Layer.
391			Thus the list of <SRS> elements are authoritative.
392
393	joey	2133	This implementation returns the list of SRS for the given
394			layer, calculated by looking at BoundingBoxes defined in the
395			named layer and all layers higher in the hierarchy up to the
396			root layer which weren't overwritten.
397			"""
398			for i in range(len(self.layers)):
399			if 'name' in self.layers[i]:
400			if self.layers[i]['name'] == name:
401			pivot = i
402			break
403			else:
404			return []
405
406			result = []
407			while pivot != -1:
408	joey	2144	if 'srs' in self.layers[pivot]:
409			for srs in self.layers[pivot]['srs']:
410	joey	2133	if srs not in result:
411			result.append(srs)
412			pivot = self.layers[pivot]['parent']
413
414			return result
415
416
417			def getLayerLatLonBBox(self, name):
418			"""
419			Returns a dictionary of the LatLonBoundingBox.
420
421			... for the named layer if it exists. The SRS is always
422			EPSG:4326 per convention. There should be at least one,
423			though, inherited from the root layer at least. If none
424			exists, the value None is returned.
425			"""
426			for layer in self.layers:
427			if 'name' in layer:
428			if layer['name'] == name:
429			if 'llbbox' in layer:
430			return layer['llbbox']
431			else:
432			# No LatLonBoundingBox found in current layer,
433			# so traverse the hierarchy upwards and check
434			# again until there is one.
435			pivot = layer
436			while pivot['parent'] != -1:
437			pivot = self.layers[pivot['parent']]
438			if 'llbbox' in pivot:
439			return pivot['llbbox']
440
441			return None
442
443
444			def getLayerBBox(self, name, srs):
445			"""
446			Returns a dictionary of the BoundingBox.
447
448			If no such BoundingBox exists, None is returned.
449
450			The specification [OGC 01-068r3] says about BoundingBoxes:
451
452			- Layers may have zero or more BoundingBox elements what are
453			either stated explicitly or inherited from a parent layer.
454
455			- A layer may have multiple BoundingBox elements, but each one
456			shall state a different SRS.
457
458			- A layer inherits any BoundingBoxes defined by its
459			parents.
460
461			- A BoundingBox inherited from the parent layer for a
462			particular SRS is replaced by any declaration for the same
463			SRS in the current layer.
464
465			- A BoundingBox in the child layer for a new SRS which is not
466			already declared by the parent, is added to the list of
467			BoundingBoxes for the child layer.
468
469			- A single layer shall not contain more than one BoundingBox
470			element for the same SRS.
471			"""
472			for layer in self.layers:
473			if 'name' in layer:
474			if layer['name'] == name:
475			if 'bbox' in layer:
476			if srs in layer['bbox']:
477			return layer['bbox'][srs]
478
479			# No BoundingBox for the given SRS found in
480			# current layer, so traverse the hierarchy upwards
481			# and check again until there is one.
482			pivot = layer
483			while pivot['parent'] != -1:
484			pivot = self.layers[pivot['parent']]
485			if 'bbox' in pivot:
486			if srs in pivot['bbox']:
487			return pivot['bbox'][srs]
488
489			return None
490
491
492			def isQueryable(self, name):
493			"""
494			Returns the value of the queryable attribute of a layer.
495
496			This attribute denotes whether this layer can be queried
497			through the GetFeatureInfo request. The default value is 0.
498
499			The specification [OGC 01-068r3] this attribute can be
500			inherited.
501			"""
502
503			for layer in self.layers:
504			if 'name' in layer:
505			if layer['name'] == name:
506			try:
507			return layer['queryable']
508			except KeyError:
509			# No attribute in this layer, so traverse the
510			# hierarchy upwards
511			pivot = layer
512			while pivot['parent'] != -1:
513			pivot = self.layers[pivot['parent']]
514			if 'queryable' in pivot:
515			return pivot['queryable']
516			return 0
517
518
519			def get_srs_discrepancies(self):
520			"""
521			Returns a list of layer identifications where the denoted SRS
522			values differ from the calculated ones through BoundingBox
523			elements.
524			"""
525			return self.srs_discrepancies
526
527
528			if __name__ == "__main__":
529			print "This module cannot be executed standalone."
530
531			import os
532
533			try:
534			f = open("test/sample.xml", "r")
535			except IOError:
536			try:
537			f = open(os.path.dirname(__file__) + "/test/sample.xml", "r")
538			except IOError:
539			print "Cannot open sample.xml for reading"
540
541			if f is not None:
542			sample = f.read();
543			f.close()
544
545			ina = WMSCapabilitiesParser()
546			ina.grok(sample)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision