MapProxy 2.1.0__py3-none-any.whl

mapproxy/config/config.py

@@ -0,0 +1,213 @@
+# 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.
+
+"""
+System-wide configuration.
+"""
+import os
+import copy
+import contextlib
+from mapproxy.util.yaml import load_yaml_file
+from mapproxy.util.ext.local import LocalStack
+
+
+class Options(dict):
+    """
+    Dictionary with attribute style access.
+
+    >>> o = Options(bar='foo')
+    >>> o.bar
+    'foo'
+    """
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, dict.__repr__(self))
+
+    def __getattr__(self, name):
+        if name in self:
+            return self[name]
+        else:
+            raise AttributeError(name)
+
+    __setattr__ = dict.__setitem__
+
+    def __delattr__(self, name):
+        if name in self:
+            del self[name]
+        else:
+            raise AttributeError(name)
+
+    def update(self, other=None, **kw):
+        if other is not None:
+            if hasattr(other, 'iteritems'):
+                it = other.iteritems()
+            elif hasattr(other, 'items'):
+                it = other.items()
+            else:
+                it = iter(other)
+        else:
+            it = iter(kw)
+        for key, value in it:
+            if key in self and isinstance(self[key], Options):
+                self[key].update(value)
+            else:
+                self[key] = value
+
+    def __deepcopy__(self, memo):
+        return Options(copy.deepcopy(list(self.items()), memo))
+
+
+_config = LocalStack()
+
+
+def base_config():
+    """
+    Returns the context-local system-wide configuration.
+    """
+    config = _config.top
+    if config is None:
+        import warnings
+        warnings.warn("calling un-configured base_config",
+                      DeprecationWarning, stacklevel=2)
+        config = load_default_config()
+        config.conf_base_dir = os.getcwd()
+        finish_base_config(config)
+        _config.push(config)
+    return config
+
+
+@contextlib.contextmanager
+def local_base_config(conf):
+    """
+    Temporarily set the global configuration (mapproxy.config.base_config).
+
+    The global mapproxy.config.base_config object is thread-local and
+    is set per-request in the MapProxyApp. Use `local_base_config` to
+    set base_config outside of a request context (e.g. system loading
+    or seeding).
+    """
+    import mapproxy.config.config
+    mapproxy.config.config._config.push(conf)
+    try:
+        yield
+    finally:
+        mapproxy.config.config._config.pop()
+
+
+def _to_options_map(mapping):
+    if isinstance(mapping, dict):
+        opt = Options()
+        for key, value in mapping.items():
+            opt[key] = _to_options_map(value)
+        return opt
+    elif isinstance(mapping, list):
+        return [_to_options_map(m) for m in mapping]
+    else:
+        return mapping
+
+
+def abspath(path, base_path=None):
+    """
+    Convert path to absolute path. Uses ``conf_base_dir`` as base, if
+    path is relative and ``base_path`` is not set.
+    """
+    if base_path:
+        return os.path.abspath(os.path.join(base_path, path))
+    return os.path.join(base_config().conf_base_dir, path)
+
+
+def finish_base_config(bc=None):
+    bc = bc or base_config()
+    if 'srs' in bc:
+        # build union of default axis_order_xx_ and the user configured axis_order_xx
+        default_ne = bc.srs.axis_order_ne_
+        default_en = bc.srs.axis_order_en_
+        # remove from default to allow overwrites
+        default_ne.difference_update(set(bc.srs.axis_order_en))
+        default_en.difference_update(set(bc.srs.axis_order_ne))
+        bc.srs.axis_order_ne = default_ne.union(set(bc.srs.axis_order_ne))
+        bc.srs.axis_order_en = default_en.union(set(bc.srs.axis_order_en))
+        if 'proj_data_dir' in bc.srs:
+            bc.srs.proj_data_dir = os.path.join(bc.conf_base_dir, bc.srs.proj_data_dir)
+
+    if 'wms' in bc:
+        bc.wms.srs = set(bc.wms.srs)
+
+    if 'conf_base_dir' in bc:
+        if 'cache' in bc:
+            if 'base_dir' in bc.cache:
+                bc.cache.base_dir = os.path.join(bc.conf_base_dir, bc.cache.base_dir)
+            if 'lock_dir' in bc.cache:
+                bc.cache.lock_dir = os.path.join(bc.conf_base_dir, bc.cache.lock_dir)
+
+
+def load_base_config(config_file=None, clear_existing=False):
+    """
+    Load system wide base configuration.
+
+    :param config_file: the file name of the mapproxy.yaml configuration.
+                        if ``None``, load the internal proxylib/default.yaml conf
+    :param clear_existing: if ``True`` remove the existing configuration settings,
+                           else overwrite the settings.
+    """
+
+    if config_file is None:
+        from mapproxy.config import defaults
+        config_dict = {}
+        for k, v in defaults.__dict__.items():
+            if k.startswith('_'):
+                continue
+            config_dict[k] = v
+        conf_base_dir = os.getcwd()
+        load_config(base_config(), config_dict=config_dict, clear_existing=clear_existing)
+    else:
+        conf_base_dir = os.path.abspath(os.path.dirname(config_file))
+        load_config(base_config(), config_file=config_file, clear_existing=clear_existing)
+
+    bc = base_config()
+    finish_base_config(bc)
+
+    bc.conf_base_dir = conf_base_dir
+
+
+def load_default_config():
+    from mapproxy.config import defaults
+    config_dict = {}
+    for k, v in defaults.__dict__.items():
+        if k.startswith('_'):
+            continue
+        config_dict[k] = v
+
+    default_conf = Options()
+    load_config(default_conf, config_dict=config_dict)
+    return default_conf
+
+
+def load_config(config, config_file=None, config_dict=None, clear_existing=False):
+    if clear_existing:
+        for key in list(config.keys()):
+            del config[key]
+
+    if config_dict is None:
+        config_dict = load_yaml_file(config_file)
+
+    defaults = _to_options_map(config_dict)
+
+    if defaults:
+        for key, value in defaults.items():
+            if key in config and hasattr(config[key], 'update'):
+                config[key].update(value)
+            else:
+                config[key] = value

mapproxy/config/coverage.py

@@ -0,0 +1,108 @@
+# 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 re
+
+from mapproxy.srs import SRS
+from mapproxy.config import abspath
+from mapproxy.util.geom import (
+    load_datasource,
+    load_ogr_datasource,
+    load_polygons,
+    load_expire_tiles,
+    require_geom_support,
+    build_multipolygon,
+)
+from mapproxy.util.coverage import (
+    coverage,
+    diff_coverage,
+    union_coverage,
+    intersection_coverage,
+)
+
+
+bbox_string_re = re.compile(r'[-+]?\d*.?\d+,[-+]?\d*.?\d+,[-+]?\d*.?\d+,[-+]?\d*.?\d+')
+
+
+def load_coverage(conf, base_path=None):
+    clip = False
+    if 'clip' in conf:
+        clip = conf['clip']
+
+    if 'union' in conf:
+        parts = []
+        for cov in conf['union']:
+            parts.append(load_coverage(cov))
+        return union_coverage(parts, clip=clip)
+    elif 'intersection' in conf:
+        parts = []
+        for cov in conf['intersection']:
+            parts.append(load_coverage(cov))
+        return intersection_coverage(parts, clip=clip)
+    elif 'difference' in conf:
+        parts = []
+        for cov in conf['difference']:
+            parts.append(load_coverage(cov))
+        return diff_coverage(parts, clip=clip)
+    elif 'ogr_datasource' in conf:
+        require_geom_support()
+        srs = conf['ogr_srs']
+        datasource = conf['ogr_datasource']
+        if not re.match(r'^\w{2,}:', datasource):
+            # looks like a file and not PG:, MYSQL:, etc
+            # make absolute path
+            datasource = abspath(datasource, base_path=base_path)
+        where = conf.get('ogr_where', None)
+        geom = load_ogr_datasource(datasource, where)
+        bbox, geom = build_multipolygon(geom, simplify=True)
+    elif 'polygons' in conf:
+        require_geom_support()
+        srs = conf['polygons_srs']
+        geom = load_polygons(abspath(conf['polygons'], base_path=base_path))
+        bbox, geom = build_multipolygon(geom, simplify=True)
+    elif 'bbox' in conf:
+        srs = conf.get('bbox_srs') or conf['srs']
+        bbox = conf['bbox']
+        if isinstance(bbox, str):
+            bbox = [float(x) for x in bbox.split(',')]
+        geom = None
+    elif 'datasource' in conf:
+        require_geom_support()
+        datasource = conf['datasource']
+        srs = conf['srs']
+        if isinstance(datasource, (list, tuple)):
+            bbox = datasource
+            geom = None
+        elif bbox_string_re.match(datasource):
+            bbox = [float(x) for x in datasource.split(',')]
+            geom = None
+        else:
+            if not re.match(r'^\w{2,}:', datasource):
+                # looks like a file and not PG:, MYSQL:, etc
+                # make absolute path
+                datasource = abspath(datasource, base_path=base_path)
+            where = conf.get('where', None)
+            geom = load_datasource(datasource, where)
+            bbox, geom = build_multipolygon(geom, simplify=True)
+    elif 'expire_tiles' in conf:
+        require_geom_support()
+        filename = abspath(conf['expire_tiles'])
+        geom = load_expire_tiles(filename)
+        _, geom = build_multipolygon(geom, simplify=False)
+        return coverage(geom, SRS(3857))
+    else:
+        return None
+
+    return coverage(geom or bbox, SRS(srs), clip=clip)

mapproxy/config/defaults.py

@@ -0,0 +1,102 @@
+# 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.
+
+server = ['wms', 'tms', 'kml']
+
+wms = dict(
+    image_formats=['image/png', 'image/jpeg', 'image/gif', 'image/GeoTIFF', 'image/tiff'],
+    srs=set(['EPSG:4326', 'EPSG:4258', 'CRS:84', 'EPSG:900913', 'EPSG:3857']),
+    strict=False,
+    request_parser='default',
+    client_request='default',
+    concurrent_layer_renderer=1,
+    max_output_pixels=4000*4000,
+)
+debug_mode = False
+
+background = dict(
+    url="https://tile.openstreetmap.org/{z}/{x}/{y}.png"
+)
+
+srs = dict(
+    # user sets
+    axis_order_ne=set(),
+    axis_order_en=set(),
+    # default sets, both will be combined in config:load_base_config
+    axis_order_ne_=set(['EPSG:4326', 'EPSG:4258', 'EPSG:31466', 'EPSG:31467', 'EPSG:31468']),
+    axis_order_en_=set(['CRS:84', 'EPSG:900913', 'EPSG:25831', 'EPSG:25832', 'EPSG:25833']),
+)
+
+image = dict(
+    # nearest, bilinear, bicubic
+    resampling_method='bicubic',
+    jpeg_quality=90,
+    stretch_factor=1.15,
+    max_shrink_factor=4.0,
+    paletted=True,
+    transparent_color_tolerance=5,
+    font_dir=None,
+)
+# number of concurrent requests to a tile source
+
+
+services_conf = 'services.yaml'
+log_conf = 'log.ini'
+
+# directory with mapproxy/service/templates/* files
+template_dir = None
+
+cache = dict(
+    base_dir='./cache_data',
+    lock_dir='./cache_data/tile_locks',
+    max_tile_limit=500,
+    concurrent_tile_creators=2,
+    meta_size=(4, 4),
+    meta_buffer=80,
+    minimize_meta_requests=False,
+    link_single_color_images=False,
+    sqlite_timeout=30,
+)
+
+grid = dict(
+    tile_size=(256, 256),
+)
+
+grids = dict(
+    GLOBAL_GEODETIC=dict(
+        srs='EPSG:4326', origin='sw', name='GLOBAL_GEODETIC'
+    ),
+    GLOBAL_MERCATOR=dict(
+        srs='EPSG:900913', origin='sw', name='GLOBAL_MERCATOR'
+    ),
+    GLOBAL_WEBMERCATOR=dict(
+        srs='EPSG:3857', origin='nw', name='GLOBAL_WEBMERCATOR'
+    )
+)
+
+tiles = dict(
+    expires_hours=72,
+)
+
+http = dict(
+    ssl_ca_certs=None,
+    ssl_no_cert_checks=False,
+    client_timeout=60,
+    concurrent_requests=0,
+    method='AUTO',
+    access_control_allow_origin='*',
+    hide_error_details=True,
+    manage_cookies=False,
+)