MapProxy 1.16.1__py3-none-any.whl

mapproxy/config_template/base_config/mapproxy.yaml

@@ -0,0 +1,60 @@
+# -------------------------------
+# MapProxy example configuration.
+# -------------------------------
+#
+# This is a minimal MapProxy configuration.
+# See full_example.yaml and the documentation for more options.
+#
+
+# Starts the following services:
+# Demo:
+#     http://localhost:8080/demo
+# WMS:
+#     capabilities: http://localhost:8080/service?REQUEST=GetCapabilities
+# WMTS:
+#     capabilities: http://localhost:8080/wmts/1.0.0/WMTSCapabilities.xml
+#     first tile: http://localhost:8080/wmts/osm/webmercator/0/0/0.png
+# Tile service (compatible with OSM/etc.)
+#     first tile: http://localhost:8080/tiles/osm/webmercator/0/0/0.png
+# TMS:
+#     note: TMS is not compatible with OSM/Google Maps/etc.
+#     first tile: http://localhost:8080/tms/1.0.0/osm/webmercator/0/0/0.png
+# KML:
+#     initial doc: http://localhost:8080/kml/osm/webmercator
+
+services:
+  demo:
+  tms:
+    use_grid_names: true
+    # origin for /tiles service
+    origin: 'nw'
+  kml:
+      use_grid_names: true
+  wmts:
+  wms:
+    md:
+      title: MapProxy WMS Proxy
+      abstract: This is a minimal MapProxy example.
+
+layers:
+  - name: osm
+    title: Omniscale OSM WMS - osm.omniscale.net
+    sources: [osm_cache]
+
+caches:
+  osm_cache:
+    grids: [webmercator]
+    sources: [osm_wms]
+
+sources:
+  osm_wms:
+    type: wms
+    req:
+      url: https://maps.omniscale.net/v2/demo/style.default/service?
+      layers: osm
+
+grids:
+    webmercator:
+        base: GLOBAL_WEBMERCATOR
+
+globals:

mapproxy/config_template/base_config/seed.yaml

@@ -0,0 +1,27 @@
+# ---------------------------------------
+# MapProxy example seeding configuration.
+# ---------------------------------------
+#
+# This is a minimal MapProxy seeding configuration.
+# See full_seed_example.yaml and the documentation for more options.
+#
+
+seeds:
+  myseed1:
+    caches: [osm_cache]
+    # grids: []
+    # coverages: []
+    levels:
+      to: 10
+    refresh_before:
+      time: 2013-10-10T12:35:00
+
+cleanups:
+  myclean1:
+    caches: [osm_cache]
+    remove_before:
+      days: 14
+    levels:
+        from: 11
+
+coverages:

mapproxy/exception.py

@@ -0,0 +1,142 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Service exception handling (WMS exceptions, XML, in_image, etc.).
+"""
+from mapproxy.response import Response
+from mapproxy.compat.modules import escape
+
+class RequestError(Exception):
+    """
+    Exception for all request related errors.
+    
+    :ivar internal: True if the error was an internal error, ie. the request itself
+                    was valid (e.g. the source server is unreachable
+    """
+    def __init__(self, message, code=None, request=None, internal=False, status=None):
+        Exception.__init__(self, message)
+        self.msg = message
+        self.code = code
+        self.request = request
+        self.internal = internal
+        self.status = status
+    
+    def render(self):
+        """
+        Return a response with the rendered exception.
+        The rendering is delegated to the ``exception_handler`` that issued
+        the ``RequestError``.
+        
+        :rtype: `Response`
+        """
+        if self.request is not None:
+            handler = self.request.exception_handler
+            resp = handler.render(self)
+        elif self.status is not None:
+            resp = Response(self.msg, status=self.status)
+        else:
+            resp = Response('internal error: %s' % self.msg, status=500)
+        resp.cache_headers(no_cache=True)
+        return resp
+    
+    def __str__(self):
+        return 'RequestError("%s", code=%r, request=%r)' % (self.msg, self.code,
+                                                            self.request)
+
+
+class ExceptionHandler(object):
+    """
+    Base class for exception handler.
+    """
+    def render(self, request_error):
+        """
+        Return a response with the rendered exception.
+        
+        :param request_error: the exception to render
+        :type request_error: `RequestError`
+        :rtype: `Response`
+        """
+        raise NotImplementedError()
+
+def _not_implemented(*args, **kw):
+    raise NotImplementedError()
+
+class XMLExceptionHandler(ExceptionHandler):
+    """
+    Mixin class for tempita-based template renderer.
+    """
+    template_file = None
+    """The filename of the tempita xml template"""
+    
+    content_type = None
+    """
+    The mime type of the exception response (use this or mimetype).
+    The content_type is sent as defined here.
+    """
+    
+    status_code = 200
+    """
+    The HTTP status code.
+    """
+    
+    status_codes = {}
+    """
+    Mapping of exceptionCodes to status_codes. If not defined
+    status_code is used.
+    """
+    
+    mimetype = None
+    """
+    The mime type of the exception response. (use this or content_type).
+    A character encoding might be added to the mimetype (like text/xml;charset=UTF-8) 
+    """
+    
+    template_func = _not_implemented
+    """
+    Function that returns the named template.
+    """
+    
+    def render(self, request_error):
+        """
+        Render the template of this exception handler. Passes the 
+        ``request_error.msg`` and ``request_error.code`` to the template.
+        
+        :type request_error: `RequestError`
+        """
+        status_code = self.status_codes.get(request_error.code, self.status_code)
+        # escape &<> in error message (e.g. URL params)
+        msg = escape(request_error.msg)
+        result = self.template.substitute(exception=msg,
+                                          code=request_error.code)
+        return Response(result, mimetype=self.mimetype, content_type=self.content_type,
+                        status=status_code)
+    
+    @property
+    def template(self):
+        """
+        The template for this ExceptionHandler.
+        """
+        return self.template_func(self.template_file)
+
+class PlainExceptionHandler(ExceptionHandler):
+    mimetype = 'text/plain'
+    status_code = 404
+
+    def render(self, request_error):
+        if request_error.internal:
+            self.status_code = 500
+        return Response(request_error.msg, status=self.status_code,
+                        mimetype=self.mimetype)

mapproxy/featureinfo.py

@@ -0,0 +1,252 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2011 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+import json
+
+from functools import reduce
+from io import StringIO
+
+from mapproxy.compat import string_type, PY2, BytesIO, iteritems
+
+try:
+    from lxml import etree, html
+
+    has_xslt_support = True
+    etree, html  # prevent pyflakes warning
+except ImportError:
+    has_xslt_support = False
+    etree = html = None
+
+
+class FeatureInfoDoc(object):
+    content_type = None
+
+    def as_etree(self):
+        raise NotImplementedError()
+
+    def as_string(self):
+        raise NotImplementedError()
+
+
+class TextFeatureInfoDoc(FeatureInfoDoc):
+    info_type = "text"
+
+    def __init__(self, content):
+        self.content = content
+
+    def as_string(self):
+        return self.content
+
+    @classmethod
+    def combine(cls, docs):
+        result_content = [doc.as_string() for doc in docs]
+        return cls(b"\n".join(result_content))
+
+
+class XMLFeatureInfoDoc(FeatureInfoDoc):
+    info_type = "xml"
+    defaultEncoding = "UTF-8"
+
+    def __init__(self, content):
+        if isinstance(content, (string_type, bytes)):
+            self._str_content = content
+            self._etree = None
+        else:
+            self._str_content = None
+            if hasattr(content, "getroottree"):
+                content = content.getroottree()
+            self._etree = content
+            assert hasattr(content, "getroot"), "expected etree like object"
+
+    def as_string(self):
+        if self._str_content is None:
+            self._str_content = self._serialize_etree()
+        return self._str_content
+
+    def as_etree(self):
+        if self._etree is None:
+            self._etree = self._parse_content()
+        return self._etree
+
+    def _serialize_etree(self):
+        encoding = self._etree.docinfo.encoding if \
+            self._etree.docinfo.encoding else self.defaultEncoding
+        return etree.tostring(self._etree, encoding=encoding, xml_declaration=False)
+
+    def _parse_content(self):
+        doc = as_io(self._str_content)
+        return etree.parse(doc)
+
+    @classmethod
+    def combine(cls, docs):
+        if etree is None:
+            return TextFeatureInfoDoc.combine(docs)
+        doc = docs.pop(0)
+        result_tree = copy.deepcopy(doc.as_etree())
+        for doc in docs:
+            tree = doc.as_etree()
+            result_tree.getroot().extend(tree.getroot().iterchildren())
+
+        return cls(result_tree)
+
+
+class HTMLFeatureInfoDoc(XMLFeatureInfoDoc):
+    info_type = "html"
+
+    def _parse_content(self):
+        root = html.document_fromstring(self._str_content)
+        return root
+
+    def _serialize_etree(self):
+        return html.tostring(self._etree)
+
+    @classmethod
+    def combine(cls, docs):
+        if etree is None:
+            return TextFeatureInfoDoc.combine(docs)
+
+        doc = docs.pop(0)
+        result_tree = copy.deepcopy(doc.as_etree())
+
+        for doc in docs:
+            tree = doc.as_etree()
+
+            try:
+                body = tree.body.getchildren()
+            except IndexError:
+                body = tree.getchildren()
+            result_tree.body.extend(body)
+
+        return cls(result_tree)
+
+
+class JSONFeatureInfoDoc(FeatureInfoDoc):
+    info_type = "json"
+
+    def __init__(self, content):
+        self.content = content
+
+    def as_string(self):
+        return self.content
+
+    @classmethod
+    def combine(cls, docs):
+        contents = []
+        for d in docs:
+            content = d.content
+            if not isinstance(content, string_type):
+                content = content.decode('UTF-8')
+            contents.append(json.loads(content))
+        combined = reduce(lambda a, b: merge_dict(a, b), contents)
+        return cls(json.dumps(combined))
+
+
+def merge_dict(base, other):
+    """
+    Return `base` dict with values from `conf` merged in.
+    """
+    for k, v in iteritems(other):
+        if k not in base:
+            base[k] = v
+        else:
+            if isinstance(base[k], dict):
+                merge_dict(base[k], v)
+            elif isinstance(base[k], list):
+                base[k].extend(v)
+            else:
+                base[k] = v
+    return base
+
+
+def create_featureinfo_doc(content, info_format):
+    info_type = featureinfo_type(info_format)
+    if info_type == "xml":
+        return XMLFeatureInfoDoc(content)
+    if info_type == "html":
+        return HTMLFeatureInfoDoc(content)
+    if info_type == "json":
+        return JSONFeatureInfoDoc(content)
+
+    return TextFeatureInfoDoc(content)
+
+def featureinfo_type(info_format):
+    info_format = info_format.split(";", 1)[
+        0
+    ].strip()  # remove mime options like charset
+    if info_format in ("text/xml", "application/xml",
+                       "application/gml+xml", "application/vnd.ogc.gml"):
+        return "xml"
+    if info_format == "text/html":
+        return "html"
+    if info_format == "application/json":
+        return "json"
+
+    return "text"
+
+
+class XSLTransformer(object):
+
+    def __init__(self, xsltscript, info_format=None):
+        self.xsltscript = xsltscript
+        self.info_type = featureinfo_type(info_format or "text/xml")
+
+    def transform(self, input_doc):
+        input_tree = input_doc.as_etree()
+        xslt_tree = etree.parse(self.xsltscript)
+        transform = etree.XSLT(xslt_tree)
+        output_tree = transform(input_tree)
+        if self.info_type == "html":
+            return HTMLFeatureInfoDoc(output_tree)
+        else:
+            return XMLFeatureInfoDoc(output_tree)
+
+    __call__ = transform
+
+
+def as_io(doc):
+    if PY2:
+        return BytesIO(doc)
+    else:
+        if isinstance(doc, str):
+            return StringIO(doc)
+        else:
+            return BytesIO(doc)
+
+
+def combine_docs(docs, transformer=None):
+    """
+    Combine multiple FeatureInfoDocs.
+
+    Combines as text, if the type of the docs differ.
+    Otherwise the type specifix combine is called.
+
+    Returns the combined document and the info_type (text, xml or json).
+    info_type is None if the output is transformed, as the type is dependent on the
+    transformer.
+    """
+    if len(set(d.info_type for d in docs)) > 1:
+        # more then one info_type, combine as plain text
+        doc = TextFeatureInfoDoc.combine(docs)
+        infotype = "text"
+    else:
+        # all same type, combine with type specific handler
+        infotype = docs[0].info_type
+        doc = docs[0].combine(docs)
+
+        if transformer:
+            doc = transformer(doc)
+            infotype = None # defined by transformer
+    return doc.as_string(), infotype