MapProxy 1.16.1__py3-none-any.whl

mapproxy/util/ext/dictspec/test/test_validator.py

@@ -0,0 +1,274 @@
+# -:- encoding: utf8 -:-
+# Copyright (c) 2011, Oliver Tonnhofer <olt@omniscale.de>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+from __future__ import absolute_import
+
+import unittest
+
+from ..validator import validate, ValidationError, SpecError
+from ..spec import required, one_of, number, recursive, type_spec, anything
+from mapproxy.compat import string_type
+
+def raises(exception):
+    def wrapper(f):
+        def _wrapper(self):
+            try:
+                f(self)
+            except exception:
+                pass
+            else:
+                raise AssertionError('expected exception %s', exception)
+    return wrapper
+
+class TestSimpleDict(unittest.TestCase):
+    def test_validate_simple_dict(self):
+        spec = {'hello': 1, 'world': True}
+        validate(spec, {'hello': 34, 'world': False})
+
+    @raises(ValidationError)
+    def test_invalid_key(self):
+        spec = {'world': True}
+        validate(spec, {'world_foo': False})
+
+    def test_empty_data(self):
+        spec = {'world': 1}
+        validate(spec, {})
+
+    @raises(ValidationError)
+    def test_invalid_value(self):
+        spec = {'world': 1}
+        validate(spec, {'world_foo': False})
+
+    @raises(ValidationError)
+    def test_missing_required_key(self):
+        spec = {required('world'): 1}
+        validate(spec, {})
+
+    def test_valid_one_of(self):
+        spec = {'hello': one_of(1, bool())}
+        validate(spec, {'hello': 129})
+        validate(spec, {'hello': True})
+
+    @raises(ValidationError)
+    def test_invalid_one_of(self):
+        spec = {'hello': one_of(1, False)}
+        validate(spec, {'hello': []})
+
+    def test_instances_and_types(self):
+        spec = {'str()': str(), 'string_type': string_type, 'int': int, 'int()': int()}
+        validate(spec, {'str()': 'str', 'string_type': u'☃', 'int': 1, 'int()': 1})
+
+
+class TestLists(unittest.TestCase):
+    def test_list(self):
+        spec = [1]
+        validate(spec, [1, 2, 3, 4, -9])
+
+    def test_empty_list(self):
+        spec = [1]
+        validate(spec, [])
+
+    @raises(ValidationError)
+    def test_invalid_item(self):
+        spec = [1]
+        validate(spec, [1, 'hello'])
+
+class TestNumber(unittest.TestCase):
+    def check_valid(self, spec, data):
+        validate(spec, data)
+
+    def test_numbers(self):
+        spec = number()
+        for i in (0, 1, 23e999, int(10e20), 23.1, -0.0000000001):
+            self.check_valid(spec, i)
+
+class TestNested(unittest.TestCase):
+    def check_valid(self, spec, data):
+        validate(spec, data)
+
+    def check_invalid(self, spec, data):
+        try:
+            validate(spec, data)
+        except ValidationError:
+            pass
+        else:
+            assert False, "expected ValidationError"
+
+    def test_dict(self):
+        spec = {
+            'globals': {
+                'image': {
+                    'format': {
+                        'png': {
+                            'mode': 'RGB',
+                        }
+                    },
+                },
+                'cache': {
+                    'base_dir': '/path/to/foo'
+                }
+            }
+        }
+
+        self.check_valid(spec, {'globals': {'image': {'format': {'png': {'mode': 'P'}}}}})
+        self.check_valid(spec, {'globals': {'image': {'format': {'png': {'mode': 'P'}}},
+                                                   'cache': {'base_dir': '/somewhere'}}})
+        self.check_invalid(spec, {'globals': {'image': {'foo': {'png': {'mode': 'P'}}}}})
+        self.check_invalid(spec, {'globals': {'image': {'png': {'png': {'mode': 1}}}}})
+
+
+    def test_errors_in_unicode_keys(self):
+        # should not raise UnicodeEncodeError
+        spec = {
+            anything(): str(),
+        }
+        self.check_invalid(spec, {u'globalü': 12})
+
+class TestRecursive(unittest.TestCase):
+    def test(self):
+        spec = recursive({'hello': str(), 'more': recursive()})
+        validate(spec, {'hello': 'world', 'more': {'hello': 'foo', 'more': {'more': {}}}})
+
+    def test_multiple(self):
+        spec = {'a': recursive({'hello': str(), 'more': recursive()}), 'b': recursive({'foo': recursive()})}
+        validate(spec, {'b': {'foo': {'foo': {}}}})
+        validate(spec, {'a': {'hello': 'world', 'more': {'hello': 'foo', 'more': {'more': {}}}}})
+        validate(spec, {'b': {'foo': {'foo': {}}},
+                        'a': {'hello': 'world', 'more': {'hello': 'foo', 'more': {'more': {}}}}})
+    @raises(SpecError)
+    def test_without_spec(self):
+        spec = {'a': recursive()}
+        validate(spec, {'a': {'a': {}}})
+
+class TestTypeSpec(unittest.TestCase):
+    def test(self):
+        spec = type_spec('type', {'foo': {'alpha': str()}, 'bar': {'one': 1, 'two': str()}})
+        validate(spec, {'type': 'foo', 'alpha': 'yes'})
+        validate(spec, {'type': 'bar', 'one': 2})
+
+    def test_missing_type(self):
+        spec = type_spec('type', {'foo': {'alpha': str()}, 'bar': {'one': 1, 'two': str()}})
+        try:
+            validate(spec, {'alpha': 'yes'})
+        except ValidationError as ex:
+            assert "'type' not in ." in ex.errors[0]
+        else:
+            assert False
+
+    def test_unknown_type(self):
+        spec = type_spec('type', {'foo': {'alpha': str()}, 'bar': {'one': 1, 'two': str()}})
+        try:
+            validate(spec, {'type': 'baz', 'alpha': 'yes'})
+        except ValidationError as ex:
+            assert "unknown type value 'baz' in ." in ex.errors[0], ex
+        else:
+            assert False
+
+    def test_no_type_dict(self):
+        spec = {'dict': type_spec('type', {'foo': {'alpha': str()}, 'bar': {'one': 1, 'two': str()}})}
+        try:
+            validate(spec, {'dict': None})
+        except ValidationError as ex:
+            assert "dict is empty" in ex.errors[0], ex
+        else:
+            assert False
+
+
+class TestErrors(unittest.TestCase):
+    def test_invalid_types(self):
+        spec = {'str': str, 'str()': str(), 'string_type': string_type, '1': 1, 'int': int}
+        try:
+            validate(spec, {'str': 1, 'str()': 1, 'string_type': 1, '1': 'a', 'int': 'int'})
+        except ValidationError as ex:
+            ex.errors.sort()
+            assert ex.errors[0] == "'a' in 1 not of type int"
+            assert ex.errors[1] == "'int' in int not of type int"
+            assert ex.errors[2] == '1 in str not of type str'
+            assert ex.errors[3] == '1 in str() not of type str'
+            assert ex.errors[4] in (
+                '1 in string_type not of type basestring', #PY2
+                '1 in string_type not of type str') #PY3
+        else:
+            assert False
+
+    def test_invalid_key(self):
+        spec = {'world': {'europe': {}}}
+        try:
+            validate(spec, {'world': {'europe': {'germany': 1}}})
+        except ValidationError as ex:
+            assert 'world.europe' in str(ex)
+        else:
+            assert False
+
+    def test_invalid_list_item(self):
+        spec = {'numbers': [number()]}
+        try:
+            validate(spec, {'numbers': [1, 2, 3, 'foo']})
+        except ValidationError as ex:
+            assert 'numbers[3] not of type number' in str(ex), str(ex)
+        else:
+            assert False
+
+    def test_multiple_invalid_list_items(self):
+        spec = {'numbers': [number()]}
+        try:
+            validate(spec, {'numbers': [1, True, 3, 'foo']})
+        except ValidationError as ex:
+            assert '2 validation errors' in str(ex), str(ex)
+            assert 'numbers[1] not of type number' in ex.errors[0]
+            assert 'numbers[3] not of type number' in ex.errors[1]
+        else:
+            assert False
+
+    def test_error_in_non_string_key(self):
+        spec = {1: bool()}
+        try:
+            validate(spec, {1: 'not a bool'})
+        except ValidationError as ex:
+            assert "'not a bool' in 1 not of type bool" in ex.errors[0]
+        else:
+            assert False
+
+    def test_error_in_non_string_key_with_anything_key_spec(self):
+        spec = {anything(): bool()}
+        try:
+            validate(spec, {1: 'not a bool'})
+        except ValidationError as ex:
+            assert "'not a bool' in 1 not of type bool" in ex.errors[0]
+        else:
+            assert False
+
+def test_one_of_with_custom_types():
+    # test for fixed validation of one_of specs with values that are
+    # not lists or dicts (e.g. recursive)
+    spec = one_of([str], recursive({required('foo'): string_type}))
+    validate(spec, ['foo', 'bar'])
+    validate(spec, {'foo': 'bar'})
+    try:
+        validate(spec, {'nofoo': 'bar'})
+    except ValidationError as ex:
+        assert "missing 'foo'" in ex.errors[0]
+    else:
+        assert False
+
+if __name__ == '__main__':
+    unittest.main()
+

mapproxy/util/ext/dictspec/validator.py

@@ -0,0 +1,189 @@
+# Copyright (c) 2011, Oliver Tonnhofer <olt@omniscale.de>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+import re
+from contextlib import contextmanager
+
+from .spec import required, one_of, anything, recursive
+from mapproxy.compat import iteritems, iterkeys, text_type
+
+class Context(object):
+    def __init__(self):
+        self.recurse_spec = None
+        self.obj_pos = []
+
+    def push(self, spec):
+        self.obj_pos.append(spec)
+
+    def pop(self):
+        return self.obj_pos.pop()
+
+    @contextmanager
+    def pos(self, spec):
+        self.push(spec)
+        yield
+        self.pop()
+
+    @property
+    def current_pos(self):
+        return ''.join(self.obj_pos).lstrip('.') or '.'
+
+def validate(spec, data):
+    """
+    Validate `data` against `spec`.
+    """
+    return Validator(spec).validate(data)
+
+class ValidationError(TypeError):
+    def __init__(self, msg, errors=None, informal_only=False):
+        TypeError.__init__(self, msg)
+        self.informal_only = informal_only
+        self.errors = errors or []
+
+class SpecError(TypeError):
+    pass
+
+class Validator(object):
+    def __init__(self, spec, fail_fast=False):
+        """
+        :params fail_fast: True if it should raise on the first error
+        """
+        self.context = Context()
+        self.complete_spec = spec
+        self.raise_first_error = fail_fast
+        self.errors = False
+        self.messages = []
+
+    def validate(self, data):
+        self._validate_part(self.complete_spec, data)
+
+        if self.messages:
+            if len(self.messages) == 1:
+                raise ValidationError(self.messages[0], self.messages, informal_only=not self.errors)
+            else:
+                raise ValidationError('found %d validation errors.' % len(self.messages), self.messages,
+                    informal_only=not self.errors)
+
+    def _validate_part(self, spec, data):
+        if hasattr(spec, 'subspec'):
+            try:
+                spec = spec.subspec(data, self.context)
+            except ValueError as ex:
+                return self._handle_error(str(ex))
+
+        if isinstance(spec, recursive):
+            if spec.spec:
+                self.context.recurse_spec = spec.spec
+                self._validate_part(spec.spec, data)
+                self.context.recurse_spec = None
+                return
+            else:
+                spec = self.context.recurse_spec
+                if spec is None:
+                    raise SpecError('found recursive() outside recursive spec')
+
+        if isinstance(spec, anything):
+            return
+
+        if data is None:
+            data = {}
+
+        if isinstance(spec, one_of):
+            # check if at least one spec type matches
+            for subspec in spec.specs:
+                if type_matches(subspec, data):
+                    self._validate_part(subspec, data)
+                    return
+            else:
+                return self._handle_error("%r in %s not of any type %s" %
+                    (data, self.context.current_pos, ', '.join(map(type_str, spec.specs))))
+        elif not type_matches(spec, data):
+            return self._handle_error("%r in %s not of type %s" %
+                (data, self.context.current_pos, type_str(spec)))
+
+        # recurse in dicts and lists
+        if isinstance(spec, dict):
+            self._validate_dict(spec, data)
+        elif isinstance(spec, list):
+            self._validate_list(spec, data)
+
+    def _validate_dict(self, spec, data):
+        accept_any_key = False
+        any_key_spec = None
+        for k in iterkeys(spec):
+            if isinstance(k, required):
+                if k not in data:
+                    self._handle_error("missing '%s', not in %s" %
+                        (k, self.context.current_pos))
+            if isinstance(k, anything):
+                accept_any_key = True
+                any_key_spec = spec[k]
+
+        for k, v in iteritems(data):
+            if accept_any_key:
+                with self.context.pos('.' + text_type(k)):
+                    self._validate_part(any_key_spec, v)
+
+            else:
+                if k not in spec:
+                    self._handle_error("unknown '%s' in %s" %
+                        (k, self.context.current_pos), info_only=True)
+                    continue
+                with self.context.pos('.' + text_type(k)):
+                    self._validate_part(spec[k], v)
+
+    def _validate_list(self, spec, data):
+        if not len(spec) == 1:
+            raise SpecError('lists support only one type, got: %s' % spec)
+        for i, v in enumerate(data):
+            with self.context.pos('[%d]' % i):
+                self._validate_part(spec[0], v)
+
+    def _handle_error(self, msg, info_only=False):
+        if not info_only:
+            self.errors = True
+        if self.raise_first_error and not info_only:
+            raise ValidationError(msg)
+        self.messages.append(msg)
+
+def type_str(spec):
+    if not isinstance(spec, type):
+        spec = type(spec)
+
+    match = re.match(r"<type '(\w+)'>", str(spec))
+    if match:
+        return match.group(1)
+
+    match = re.match(r"<class '([\w._]+)'>", str(spec))
+    if match:
+        return match.group(1).split('.')[-1]
+
+    return str(type)
+
+def type_matches(spec, data):
+    if hasattr(spec, 'compare_type'):
+        return spec.compare_type(data)
+    if isinstance(spec, type):
+        spec_type = spec
+    else:
+        spec_type = type(spec)
+    return isinstance(data, spec_type)
+

mapproxy/util/ext/local.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+"""
+This module implements context-local objects.
+
+This is a partial version of werkzeug/local.py containing only Local and
+StackLocal.
+
+Last update: 2011-03-15 9ada59c958b2edbb9739fb55a6b32ef4a97dac07
+
+:copyright: (c) 2010 by the Werkzeug Team, see AUTHORS for more details.
+:license: BSD, see LICENSE for more details.
+"""
+try:
+    from greenlet import getcurrent as get_current_greenlet
+except ImportError: # pragma: no cover
+    try:
+        from py.magic import greenlet
+        get_current_greenlet = greenlet.getcurrent
+        del greenlet
+    except Exception:
+        # catch all, py.* fails with so many different errors.
+        get_current_greenlet = int
+try:
+    from _thread import get_ident as get_current_thread, allocate_lock
+except ImportError: # pragma: no cover
+    try:
+        from thread import get_ident as get_current_thread, allocate_lock
+    except ImportError: # pragma: no cover
+        from dummy_thread import get_ident as get_current_thread, allocate_lock
+
+
+# get the best ident function.  if greenlets are not installed we can
+# safely just use the builtin thread function and save a python methodcall
+# and the cost of calculating a hash.
+if get_current_greenlet is int: # pragma: no cover
+    get_ident = get_current_thread
+else:
+    get_ident = lambda: (get_current_thread(), get_current_greenlet())
+
+
+def release_local(local):
+    """Releases the contents of the local for the current context.
+    This makes it possible to use locals without a manager.
+
+    Example::
+
+        >>> loc = Local()
+        >>> loc.foo = 42
+        >>> release_local(loc)
+        >>> hasattr(loc, 'foo')
+        False
+
+    With this function one can release :class:`Local` objects as well
+    as :class:`StackLocal` objects.  However it is not possible to
+    release data held by proxies that way, one always has to retain
+    a reference to the underlying local object in order to be able
+    to release it.
+
+    .. versionadded:: 0.6.1
+    """
+    local.__release_local__()
+
+
+class Local(object):
+    __slots__ = ('__storage__', '__lock__', '__ident_func__')
+
+    def __init__(self):
+        object.__setattr__(self, '__storage__', {})
+        object.__setattr__(self, '__lock__', allocate_lock())
+        object.__setattr__(self, '__ident_func__', get_ident)
+
+    def __iter__(self):
+        return self.__storage__.iteritems()
+
+    def __call__(self, proxy):
+        """Create a proxy for a name."""
+        return LocalProxy(self, proxy)
+
+    def __release_local__(self):
+        self.__storage__.pop(self.__ident_func__(), None)
+
+    def __getattr__(self, name):
+        try:
+            return self.__storage__[self.__ident_func__()][name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __setattr__(self, name, value):
+        ident = self.__ident_func__()
+        self.__lock__.acquire()
+        try:
+            storage = self.__storage__
+            if ident in storage:
+                storage[ident][name] = value
+            else:
+                storage[ident] = {name: value}
+        finally:
+            self.__lock__.release()
+
+    def __delattr__(self, name):
+        try:
+            del self.__storage__[self.__ident_func__()][name]
+        except KeyError:
+            raise AttributeError(name)
+
+
+class LocalStack(object):
+    """This class works similar to a :class:`Local` but keeps a stack
+    of objects instead.  This is best explained with an example::
+
+        >>> ls = LocalStack()
+        >>> ls.push(42)
+        [42]
+        >>> ls.top
+        42
+        >>> ls.push(23)
+        [42, 23]
+        >>> ls.top
+        23
+        >>> ls.pop()
+        23
+        >>> ls.top
+        42
+
+    They can be force released by using a :class:`LocalManager` or with
+    the :func:`release_local` function but the correct way is to pop the
+    item from the stack after using.  When the stack is empty it will
+    no longer be bound to the current context (and as such released).
+
+    By calling the stack without arguments it returns a proxy that resolves to
+    the topmost item on the stack.
+
+    .. versionadded:: 0.6.1
+    """
+
+    def __init__(self):
+        self._local = Local()
+        self._lock = allocate_lock()
+
+    def __release_local__(self):
+        self._local.__release_local__()
+
+    def _get__ident_func__(self):
+        return self._local.__ident_func__
+    def _set__ident_func__(self, value):
+        object.__setattr__(self._local, '__ident_func__', value)
+    __ident_func__ = property(_get__ident_func__, _set__ident_func__)
+    del _get__ident_func__, _set__ident_func__
+
+    def __call__(self):
+        def _lookup():
+            rv = self.top
+            if rv is None:
+                raise RuntimeError('object unbound')
+            return rv
+        return LocalProxy(_lookup)
+
+    def push(self, obj):
+        """Pushes a new item to the stack"""
+        self._lock.acquire()
+        try:
+            rv = getattr(self._local, 'stack', None)
+            if rv is None:
+                self._local.stack = rv = []
+            rv.append(obj)
+            return rv
+        finally:
+            self._lock.release()
+
+    def pop(self):
+        """Removes the topmost item from the stack, will return the
+        old value or `None` if the stack was already empty.
+        """
+        self._lock.acquire()
+        try:
+            stack = getattr(self._local, 'stack', None)
+            if stack is None:
+                return None
+            elif len(stack) == 1:
+                release_local(self._local)
+                return stack[-1]
+            else:
+                return stack.pop()
+        finally:
+            self._lock.release()
+
+    @property
+    def top(self):
+        """The topmost item on the stack.  If the stack is empty,
+        `None` is returned.
+        """
+        try:
+            return self._local.stack[-1]
+        except (AttributeError, IndexError):
+            return None
+