MapProxy 2.1.0__py3-none-any.whl

mapproxy/client/tile.py

@@ -0,0 +1,158 @@
+# 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.
+
+from mapproxy.client.http import retrieve_image
+
+
+class TileClient(object):
+    def __init__(self, url_template, http_client=None, grid=None):
+        self.url_template = url_template
+        self.http_client = http_client
+        self.grid = grid
+
+    def get_tile(self, tile_coord, format=None):
+        url = self.url_template.substitute(tile_coord, format, self.grid)
+        if self.http_client:
+            return self.http_client.open_image(url)
+        else:
+            return retrieve_image(url)
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.url_template)
+
+
+class TileURLTemplate(object):
+    """
+    >>> t = TileURLTemplate('http://foo/tiles/%(z)s/%(x)d/%(y)s.png')
+    >>> t.substitute((7, 4, 3))
+    'http://foo/tiles/3/7/4.png'
+
+    >>> t = TileURLTemplate('http://foo/tiles/%(z)s/%(x)d/%(y)s.png')
+    >>> t.substitute((7, 4, 3))
+    'http://foo/tiles/3/7/4.png'
+
+    >>> t = TileURLTemplate('http://foo/tiles/%(tc_path)s.png')
+    >>> t.substitute((7, 4, 3))
+    'http://foo/tiles/03/000/000/007/000/000/004.png'
+
+    >>> t = TileURLTemplate('http://foo/tms/1.0.0/%(tms_path)s.%(format)s')
+    >>> t.substitute((7, 4, 3))
+    'http://foo/tms/1.0.0/3/7/4.png'
+
+    >>> t = TileURLTemplate('http://foo/tms/1.0.0/lyr/%(tms_path)s.%(format)s')
+    >>> t.substitute((7, 4, 3), 'jpeg')
+    'http://foo/tms/1.0.0/lyr/3/7/4.jpeg'
+
+    """
+
+    def __init__(self, template, format='png'):
+        self.template = template
+        self.format = format
+        self.with_quadkey = True if '%(quadkey)' in template else False
+        self.with_tc_path = True if '%(tc_path)' in template else False
+        self.with_tms_path = True if '%(tms_path)' in template else False
+        self.with_arcgiscache_path = True if '%(arcgiscache_path)' in template else False
+        self.with_bbox = True if '%(bbox)' in template else False
+
+    def substitute(self, tile_coord, format=None, grid=None):
+        x, y, z = tile_coord
+        data = dict(x=x, y=y, z=z)
+        data['format'] = format or self.format
+        if self.with_quadkey:
+            data['quadkey'] = quadkey(tile_coord)
+        if self.with_tc_path:
+            data['tc_path'] = tilecache_path(tile_coord)
+        if self.with_tms_path:
+            data['tms_path'] = tms_path(tile_coord)
+        if self.with_arcgiscache_path:
+            data['arcgiscache_path'] = arcgiscache_path(tile_coord)
+        if self.with_bbox:
+            data['bbox'] = bbox(tile_coord, grid)
+
+        return self.template % data
+
+    def __repr__(self):
+        return '%s(%r, format=%r)' % (
+            self.__class__.__name__, self.template, self.format)
+
+
+def tilecache_path(tile_coord):
+    """
+    >>> tilecache_path((1234567, 87654321, 9))
+    '09/001/234/567/087/654/321'
+    """
+    x, y, z = tile_coord
+    parts = ("%02d" % z,
+             "%03d" % int(x / 1000000),
+             "%03d" % (int(x / 1000) % 1000),
+             "%03d" % (int(x) % 1000),
+             "%03d" % int(y / 1000000),
+             "%03d" % (int(y / 1000) % 1000),
+             "%03d" % (int(y) % 1000))
+    return '/'.join(parts)
+
+
+def quadkey(tile_coord):
+    """
+    >>> quadkey((0, 0, 1))
+    '0'
+    >>> quadkey((1, 0, 1))
+    '1'
+    >>> quadkey((1, 2, 2))
+    '21'
+    """
+    x, y, z = tile_coord
+    quadKey = ""
+    for i in range(z, 0, -1):
+        digit = 0
+        mask = 1 << (i-1)
+        if (x & mask) != 0:
+            digit += 1
+        if (y & mask) != 0:
+            digit += 2
+        quadKey += str(digit)
+    return quadKey
+
+
+def tms_path(tile_coord):
+    """
+    >>> tms_path((1234567, 87654321, 9))
+    '9/1234567/87654321'
+    """
+    return '%d/%d/%d' % (tile_coord[2], tile_coord[0], tile_coord[1])
+
+
+def arcgiscache_path(tile_coord):
+    """
+    >>> arcgiscache_path((1234567, 87654321, 9))
+    'L09/R05397fb1/C0012d687'
+    """
+    return 'L%02d/R%08x/C%08x' % (tile_coord[2], tile_coord[1], tile_coord[0])
+
+
+def bbox(tile_coord, grid):
+    """
+    >>> from mapproxy.grid import tile_grid
+    >>> grid = tile_grid(4326, bbox=(0, -15, 10, -5))
+    >>> bbox((0, 0, 0), grid)
+    '0.00000000,-15.00000000,10.00000000,-5.00000000'
+    >>> bbox((0, 0, 1), grid)
+    '0.00000000,-15.00000000,5.00000000,-10.00000000'
+
+    >>> grid = tile_grid(4326, bbox=(0, -15, 10, -5), origin='nw')
+    >>> bbox((0, 0, 1), grid)
+    '0.00000000,-10.00000000,5.00000000,-5.00000000'
+    """
+    return '%.8f,%.8f,%.8f,%.8f' % grid.tile_bbox(tile_coord)

mapproxy/client/wms.py

@@ -0,0 +1,255 @@
+# 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.
+
+"""
+WMS clients for maps and information.
+"""
+import sys
+
+from mapproxy.request.base import split_mime_type
+from mapproxy.layer import InfoQuery
+from mapproxy.source import SourceError
+from mapproxy.client.http import HTTPClient
+from mapproxy.srs import make_lin_transf, SRS, SupportedSRS
+from mapproxy.image import ImageSource
+from mapproxy.image.opts import ImageOptions
+from mapproxy.featureinfo import create_featureinfo_doc
+
+import logging
+log = logging.getLogger('mapproxy.source.wms')
+
+
+class WMSClient(object):
+    def __init__(self, request_template, http_client=None,
+                 http_method=None, lock=None, fwd_req_params=None):
+        self.request_template = request_template
+        self.http_client = http_client or HTTPClient()
+        self.http_method = http_method
+        self.lock = lock
+        self.fwd_req_params = fwd_req_params or set()
+
+    def retrieve(self, query, format):
+        log.debug(query)
+        if self.http_method == 'POST':
+            request_method = 'POST'
+        elif self.http_method == 'GET':
+            request_method = 'GET'
+        else:  # 'AUTO'
+            if 'sld_body' in self.request_template.params:
+                request_method = 'POST'
+            else:
+                request_method = 'GET'
+
+        if request_method == 'POST':
+            url, data = self._query_data(query, format)
+            if isinstance(data, str):
+                data = data.encode('utf-8')
+        else:
+            url = self._query_url(query, format)
+            data = None
+
+        if self.lock:
+            with self.lock():
+                resp = self.http_client.open(url, data=data)
+        else:
+            resp = self.http_client.open(url, data=data)
+        self._check_resp(resp, url)
+        return resp
+
+    def _check_resp(self, resp, url):
+        if not resp.headers.get('Content-type', 'image/').startswith('image/'):
+            # log response depending on content-type
+            if resp.headers['Content-type'].startswith(('text/', 'application/vnd.ogc')):
+                log_size = 8000  # larger xml exception
+            else:
+                log_size = 100  # image?
+            data = resp.read(log_size+1)
+
+            truncated = ''
+            if len(data) == log_size+1:
+                data = data[:-1]
+                truncated = ' [output truncated]'
+
+            if sys.version_info >= (3, 5, 0):
+                data = data.decode('utf-8', 'backslashreplace')
+            else:
+                data = data.decode('ascii', 'ignore')
+
+            log.warning("no image returned from source WMS: {}, response was: '{}'{}".format(url, data, truncated))
+            raise SourceError('no image returned from source WMS: %s' % (url, ))
+
+    def _query_url(self, query, format):
+        return self._query_req(query, format).complete_url
+
+    def _query_data(self, query, format):
+        req = self._query_req(query, format)
+        return req.url.rstrip('?'), req.query_string
+
+    def _query_req(self, query, format):
+        req = self.request_template.copy()
+        req.params.bbox = query.bbox
+        req.params.size = query.size
+        req.params.srs = query.srs.srs_code
+        req.params.format = format
+        req.params.update(query.dimensions_for_params(self.fwd_req_params))
+        return req
+
+    def combined_client(self, other, query):
+        """
+        Return a new WMSClient that combines this request with the `other`. Returns
+        ``None`` if the clients are not combinable (e.g. different URLs).
+        """
+        if self.request_template.url != other.request_template.url:
+            return None
+
+        new_req = self.request_template.copy()
+        new_req.params.layers = new_req.params.layers + other.request_template.params.layers
+
+        return WMSClient(new_req, http_client=self.http_client,
+                         http_method=self.http_method, fwd_req_params=self.fwd_req_params)
+
+
+class WMSInfoClient(object):
+    def __init__(self, request_template, supported_srs=None, http_client=None):
+        self.request_template = request_template
+        self.http_client = http_client or HTTPClient()
+        if not supported_srs and self.request_template.params.srs is not None:
+            supported_srs = SupportedSRS([SRS(self.request_template.params.srs)])
+        self.supported_srs = supported_srs
+
+    def get_info(self, query):
+        if self.supported_srs and query.srs not in self.supported_srs:
+            query = self._get_transformed_query(query)
+        resp = self._retrieve(query)
+
+        # use from template if available
+        info_format = self.request_template.params.get('info_format')
+        if not info_format:
+            # otherwise from response
+            info_format = resp.headers.get('Content-type', None)
+        if not info_format:
+            # otherwise from query
+            info_format = query.info_format
+        return create_featureinfo_doc(resp.read(), info_format)
+
+    def _get_transformed_query(self, query):
+        """
+        Handle FI requests for unsupported SRS.
+        """
+        req_srs = query.srs
+        req_bbox = query.bbox
+        req_coord = make_lin_transf((0, 0, query.size[0], query.size[1]), req_bbox)(query.pos)
+
+        info_srs = self.supported_srs.best_srs(req_srs)
+        info_bbox = req_srs.transform_bbox_to(info_srs, req_bbox)
+        # calculate new info_size to keep square pixels after transform_bbox_to
+        info_aratio = (info_bbox[3] - info_bbox[1])/(info_bbox[2] - info_bbox[0])
+        info_size = query.size[0], int(info_aratio*query.size[0])
+
+        info_coord = req_srs.transform_to(info_srs, req_coord)
+        info_pos = make_lin_transf((info_bbox), (0, 0, info_size[0], info_size[1]))(info_coord)
+        info_pos = int(round(info_pos[0])), int(round(info_pos[1]))
+
+        info_query = InfoQuery(
+            bbox=info_bbox,
+            size=info_size,
+            srs=info_srs,
+            pos=info_pos,
+            info_format=query.info_format,
+            feature_count=query.feature_count,
+        )
+        return info_query
+
+    def _retrieve(self, query):
+        url = self._query_url(query)
+        return self.http_client.open(url)
+
+    def _query_url(self, query):
+        req = self.request_template.copy()
+        req.params.bbox = query.bbox
+        req.params.size = query.size
+        req.params.pos = query.pos
+        if query.feature_count:
+            req.params['feature_count'] = query.feature_count
+        req.params['query_layers'] = req.params['layers']
+        if 'info_format' not in req.params and query.info_format:
+            req.params['info_format'] = query.info_format
+        if not req.params.format:
+            req.params.format = query.format or 'image/png'
+        req.params.srs = query.srs.srs_code
+
+        return req.complete_url
+
+
+class WMSLegendClient(object):
+    def __init__(self, request_template, http_client=None):
+        self.request_template = request_template
+        self.http_client = http_client or HTTPClient()
+
+    def get_legend(self, query):
+        resp = self._retrieve(query)
+        format = split_mime_type(query.format)[1]
+        self._check_resp(resp, format)
+        if format == 'json':
+            return resp
+        else:
+            return ImageSource(resp, image_opts=ImageOptions(format=format))
+
+    def _retrieve(self, query):
+        url = self._query_url(query)
+        return self.http_client.open(url)
+
+    def _check_resp(self, resp, request_format):
+        if request_format == 'json':
+            if not resp.headers.get('Content-type') == 'application/json':
+                raise SourceError('no json returned from source WMS')
+        else:
+            if not resp.headers.get('Content-type', 'image/').startswith('image/'):
+                raise SourceError('no image returned from source WMS')
+
+    def _query_url(self, query):
+        req = self.request_template.copy()
+        if not req.params.format:
+            if query.format == 'json':
+                req.params.format = 'application/json'
+            else:
+                req.params.format = query.format or 'image/png'
+        if query.scale:
+            req.params['scale'] = query.scale
+        return req.complete_url
+
+    @property
+    def identifier(self):
+        return (self.request_template.url, self.request_template.params.layer)
+
+
+class WMSLegendURLClient(object):
+    def __init__(self, static_url, http_client=None):
+        self.url = static_url
+        self.http_client = http_client or HTTPClient()
+
+    def get_legend(self, query):
+        resp = self.http_client.open(self.url)
+        format = split_mime_type(query.format)[1]
+        self._check_resp(resp)
+        return ImageSource(resp, image_opts=ImageOptions(format=format))
+
+    def _check_resp(self, resp):
+        if not resp.headers.get('Content-type', 'image/').startswith('image/'):
+            raise SourceError('no image returned from static LegendURL')
+
+    @property
+    def identifier(self):
+        return (self.url, None)

mapproxy/compat/image.py

@@ -0,0 +1,86 @@
+# 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.
+
+import warnings
+
+__all__ = ['Image', 'ImageColor', 'ImageDraw', 'ImageFont', 'ImagePalette',
+           'ImageChops', 'quantize']
+
+try:
+    import PIL
+    from PIL import Image, ImageColor, ImageDraw, ImageFont, ImagePalette, ImageChops, ImageMath
+    from PIL.TiffImagePlugin import ImageFileDirectory_v2, TiffTags
+    # prevent pyflakes warnings
+    Image, ImageColor, ImageDraw, ImageFont, ImagePalette, ImageChops, ImageMath
+    ImageFileDirectory_v2, TiffTags
+    PIL_VERSION = getattr(PIL, '__version__') or getattr(PIL, 'PILLOW_VERSION')
+    PIL_VERSION_TUPLE = tuple(int(i) for i in PIL_VERSION.split("."))
+except ImportError:
+    # allow MapProxy to start without PIL (for tilecache only).
+    # issue warning and raise ImportError on first use of
+    # a function that requires PIL
+    warnings.warn('PIL is not available')
+
+    class NoPIL(object):
+        def __getattr__(self, name):
+            if name.startswith('__'):
+                raise AttributeError()
+            raise ImportError('PIL is not available')
+    ImageDraw = ImageFont = ImagePalette = ImageChops = NoPIL()
+    # add some dummy stuff required on import/load time
+    Image = NoPIL()
+    Image.NEAREST = Image.BILINEAR = Image.BICUBIC = 1
+    Image.Image = NoPIL
+    ImageColor = NoPIL()
+    ImageFileDirectory_v2 = NoPIL()
+    TiffTags = NoPIL()
+    ImageMath = NoPIL()
+    ImageColor.getrgb = lambda x: x
+    PIL_VERSION = None
+
+
+def has_alpha_composite_support():
+    return hasattr(Image, 'alpha_composite')
+
+
+def transform_uses_center():
+    # transformation behavior changed with Pillow 3.4 to use pixel centers
+    # https://github.com/python-pillow/Pillow/commit/5232361718bae0f0ccda76bfd5b390ebf9179b18
+    if not PIL_VERSION or PIL_VERSION.startswith(('1.', '2.', '3.0', '3.1', '3.2', '3.3')):
+        return False
+    return True
+
+
+def quantize_pil(img, colors=256, alpha=False, defaults=None):
+    if hasattr(Image, 'FASTOCTREE'):
+        if not alpha:
+            img = img.convert('RGB')
+        img = img.quantize(colors, Image.FASTOCTREE)
+    else:
+        if alpha:
+            img.load()  # split might fail if image is not loaded
+            alpha = img.split()[3]
+            img = img.convert('RGB').convert('P', palette=Image.ADAPTIVE, colors=colors-1)
+            mask = Image.eval(alpha, lambda a: 255 if a <= 128 else 0)
+            img.paste(255, mask)
+            if defaults is not None:
+                defaults['transparency'] = 255
+        else:
+            img = img.convert('RGB').convert('P', palette=Image.ADAPTIVE, colors=colors)
+
+    return img
+
+
+quantize = quantize_pil

mapproxy/config/__init__.py

@@ -0,0 +1,22 @@
+# 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.
+
+from mapproxy.config.config import (
+    base_config, abspath, load_base_config, load_default_config,
+    finish_base_config, Options, local_base_config,
+)
+
+__all__ = ['base_config', 'abspath', 'load_base_config', 'load_default_config',
+           'finish_base_config', 'Options', 'local_base_config']