MapProxy 2.1.0__py3-none-any.whl

mapproxy/tilefilter.py

@@ -0,0 +1,61 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010, 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.
+
+"""
+Filter for tiles (watermark, etc.)
+"""
+
+from mapproxy.image.message import WatermarkImage
+
+
+def create_watermark_filter(conf, context, **kw):
+    text = conf['watermark'].get('text', '')
+    opacity = conf['watermark'].get('opacity')
+    font_size = conf['watermark'].get('font_size')
+    spacing = conf['watermark'].get('spacing')
+    font_color = conf['watermark'].get('color')
+    if spacing not in ('wide', None):
+        raise ValueError('unsupported watermark spacing: %r' % spacing)
+    if text != '':
+        return watermark_filter(text, opacity=opacity, font_size=font_size,
+                                spacing=spacing, font_color=font_color)
+
+
+def watermark_filter(text, opacity=None, spacing=None, font_size=None, font_color=None):
+    """
+    Returns a tile filter that adds a watermark to the tiles.
+    :param text: watermark text
+    """
+    def _watermark_filter(tile):
+        placement = tile_watermark_placement(tile.coord, spacing == 'wide')
+        wimg = WatermarkImage(text, image_opts=tile.source.image_opts,
+                              placement=placement, opacity=opacity, font_size=font_size,
+                              font_color=font_color)
+        tile.source = wimg.draw(img=tile.source, in_place=False)
+        return tile
+    return _watermark_filter
+
+
+def tile_watermark_placement(coord, double_spacing=False):
+    if not double_spacing:
+        if coord[1] % 2 == 0:
+            return 'c'
+        else:
+            return 'b'
+
+    if coord[1] % 2 != coord[0] % 2:
+        return 'c'
+
+    return None

mapproxy/util/async_.py

@@ -0,0 +1,229 @@
+# 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.
+
+try:
+    import Queue
+except ImportError:
+    import queue as Queue
+
+import sys
+import threading
+
+from mapproxy.config import base_config
+from mapproxy.config import local_base_config
+
+import logging
+
+MAX_MAP_ASYNC_THREADS = 20
+
+log_system = logging.getLogger('mapproxy.system')
+
+
+class AsyncResult(object):
+    def __init__(self, result=None, exception=None):
+        self.result = result
+        self.exception = exception
+
+    def __repr__(self):
+        return "<AsyncResult result='%s' exception='%s'>" % (
+            self.result, self.exception)
+
+
+def _result_iter(results, use_result_objects=False):
+    for result in results:
+        if use_result_objects:
+            exception = None
+            if (isinstance(result, tuple) and len(result) == 3 and
+                    isinstance(result[1], Exception)):
+                exception = result
+                result = None
+            yield AsyncResult(result, exception)
+        else:
+            yield result
+
+
+class ThreadWorker(threading.Thread):
+    def __init__(self, task_queue, result_queue):
+        threading.Thread.__init__(self)
+        self.task_queue = task_queue
+        self.result_queue = result_queue
+        self.base_config = base_config()
+
+    def run(self):
+        with local_base_config(self.base_config):
+            while True:
+                task = self.task_queue.get()
+                if task is None:
+                    self.task_queue.task_done()
+                    break
+                exec_id, func, args = task
+                try:
+                    result = func(*args)
+                except Exception:
+                    result = sys.exc_info()
+                self.result_queue.put((exec_id, result))
+                self.task_queue.task_done()
+
+
+def _consume_queue(queue):
+    """
+    Get all items from queue.
+    """
+    while not queue.empty():
+        try:
+            queue.get(block=False)
+            queue.task_done()
+        except Queue.Empty:
+            pass
+
+
+class ThreadPool(object):
+    def __init__(self, size=4):
+        self.pool_size = size
+        self.task_queue = Queue.Queue()
+        self.result_queue = Queue.Queue()
+        self.pool = None
+
+    def map_each(self, func_args, raise_exceptions):
+        """
+        args should be a list of function arg tuples.
+        map_each calls each function with the given arg.
+        """
+        if self.pool_size < 2:
+            for func, arg in func_args:
+                try:
+                    yield func(*arg)
+                except Exception:
+                    yield sys.exc_info()
+            return
+
+        self.pool = self._init_pool()
+
+        i = 0
+        for i, (func, arg) in enumerate(func_args):
+            self.task_queue.put((i, func, arg))
+
+        results = {}
+
+        next_result = 0
+        for value in self._get_results(next_result, results, raise_exceptions):
+            yield value
+            next_result += 1
+
+        self.task_queue.join()
+        for value in self._get_results(next_result, results, raise_exceptions):
+            yield value
+            next_result += 1
+
+        self.shutdown()
+
+    def _single_call(self, func, args, use_result_objects):
+        try:
+            result = func(*args)
+        except Exception:
+            if not use_result_objects:
+                raise
+            result = sys.exc_info()
+        return _result_iter([result], use_result_objects)
+
+    def map(self, func, *args, **kw):
+        return list(self.imap(func, *args, **kw))
+
+    def imap(self, func, *args, **kw):
+        use_result_objects = kw.get('use_result_objects', False)
+        if len(args[0]) == 1:
+            return self._single_call(func, next(iter(zip(*args))), use_result_objects)
+        return _result_iter(self.map_each([(func, arg) for arg in zip(*args)], raise_exceptions=not use_result_objects),
+                            use_result_objects)
+
+    def starmap(self, func, args, **kw):
+        use_result_objects = kw.get('use_result_objects', False)
+        if len(args[0]) == 1:
+            return self._single_call(func, args[0], use_result_objects)
+
+        return _result_iter(self.map_each([(func, arg) for arg in args], raise_exceptions=not use_result_objects),
+                            use_result_objects)
+
+    def starcall(self, args, **kw):
+        def call(func, *args):
+            return func(*args)
+        return self.starmap(call, args, **kw)
+
+    def _get_results(self, next_result, results, raise_exceptions):
+        for i, value in self._fetch_results(raise_exceptions):
+            if i == next_result:
+                yield value
+                next_result += 1
+                while next_result in results:
+                    yield results.pop(next_result)
+                    next_result += 1
+            else:
+                results[i] = value
+
+    def _fetch_results(self, raise_exceptions):
+        while not self.task_queue.empty() or not self.result_queue.empty():
+            task_result = self.result_queue.get()
+            if (raise_exceptions and isinstance(task_result[1], tuple) and
+                    len(task_result[1]) == 3 and
+                    isinstance(task_result[1][1], Exception)):
+                self.shutdown(force=True)
+                exc_class, exc, tb = task_result[1]
+                raise exc.with_traceback(tb)
+            yield task_result
+
+    def shutdown(self, force=False):
+        """
+        Send shutdown sentinel to all executor threads. If `force` is True,
+        clean task_queue and result_queue.
+        """
+
+        if force:
+            _consume_queue(self.task_queue)
+            _consume_queue(self.result_queue)
+        for _ in range(self.pool_size):
+            self.task_queue.put(None)
+
+    def _init_pool(self):
+        if self.pool_size < 2:
+            return []
+        pool = []
+        for _ in range(self.pool_size):
+            t = ThreadWorker(self.task_queue, self.result_queue)
+            t.daemon = True
+            t.start()
+            pool.append(t)
+        return pool
+
+
+def imap(func, *args):
+    pool = ThreadPool(min(len(args[0]), MAX_MAP_ASYNC_THREADS))
+    return pool.imap(func, *args)
+
+
+def starmap(func, args):
+    pool = ThreadPool(min(len(args[0]), MAX_MAP_ASYNC_THREADS))
+    return pool.starmap(func, args)
+
+
+def starcall(args):
+    pool = ThreadPool(min(len(args[0]), MAX_MAP_ASYNC_THREADS))
+    return pool.starcall(args)
+
+
+def run_non_blocking(func, args, kw={}):
+    return func(*args, **kw)
+
+
+Pool = ThreadPool

mapproxy/util/collections.py

@@ -0,0 +1,134 @@
+# 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 __future__ import absolute_import
+from collections import deque
+from itertools import islice
+
+
+class LRU(object):
+    """
+    Least Recently Used dictionary.
+
+    Stores `size` key-value pairs. Removes last used key-value
+    when dict is full.
+
+
+    This LRU was developed for sizes <1000.
+    Set new: O(1)
+    Get/Set existing: O(1) newest to O(n) for oldest entry
+    Contains: O(1)
+    """
+
+    def __init__(self, size=100):
+        self.size = size
+        self.values = {}
+        self.last_used = deque()
+
+    def get(self, key, default=None):
+        if key not in self.values:
+            return default
+        else:
+            return self[key]
+
+    def __repr__(self):
+        last_values = []
+        for k in islice(self.last_used, 10):
+            last_values.append((k, self.values[k]))
+
+        return '<LRU size=%d values=%s%s>' % (
+            self.size, repr(last_values)[:-1],
+            ', ...]' if len(self) > 10 else ']')
+
+    def __getitem__(self, key):
+        result = self.values[key]
+        try:
+            self.last_used.remove(key)
+        except ValueError:
+            pass
+        self.last_used.appendleft(key)
+        return result
+
+    def __setitem__(self, key, value):
+        if key in self.values:
+            try:
+                self.last_used.remove(key)
+            except ValueError:
+                pass
+        self.last_used.appendleft(key)
+        self.values[key] = value
+
+        while len(self.values) > self.size:
+            del self.values[self.last_used.pop()]
+
+    def __len__(self):
+        return len(self.values)
+
+    def __delitem__(self, key):
+        if key in self.values:
+            try:
+                self.last_used.remove(key)
+            except ValueError:
+                pass
+        del self.values[key]
+
+    def __contains__(self, key):
+        return key in self.values
+
+
+class ImmutableDictList(object):
+    """
+    A dictionary where each item can also be accessed by the
+    integer index of the initial position.
+
+    >>> d = ImmutableDictList([('foo', 23), ('bar', 24)])
+    >>> d['bar']
+    24
+    >>> d[0], d[1]
+    (23, 24)
+    """
+
+    def __init__(self, items):
+        self._names = []
+        self._values = {}
+        for name, value in items:
+            self._values[name] = value
+            self._names.append(name)
+
+    def __getitem__(self, name):
+        if isinstance(name, str):
+            return self._values[name]
+        else:
+            return self._values[self._names[name]]
+
+    def __contains__(self, name):
+        try:
+            self[name]
+            return True
+        except KeyError:
+            return False
+
+    def __len__(self):
+        return len(self._values)
+
+    def __str__(self):
+        values = []
+        for name in self._names:
+            values.append('%s: %s' % (name, self._values[name]))
+        return '[%s]' % (', '.join(values),)
+
+    def iteritems(self):
+        for idx in self._names:
+            yield idx, self._values[idx]