Gecko [ www.leshallesdegournay.geraud-market.com ]

Name	Size	Permission	Date
Babel-1.3-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-09-10 19:30
Beaker-1.5.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
Jinja2-2.7.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-09-10 19:32
Mako-0.7.3-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
Paste-1.7.5.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
Tempita-0.5.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
_dummy_thread	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
_markupbase	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
_thread	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
alembic	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
alembic-0.8.3-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
argparse-1.2.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
babel	[ DIR ]	drwxr-xr-x	2024-09-10 19:30
beaker	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
builtins	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
chardet	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
chardet-2.3.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
clquota	[ DIR ]	drwxr-xr-x	2020-07-15 23:39
clselect	[ DIR ]	drwxr-xr-x	2020-07-15 23:39
clselector	[ DIR ]	drwxr-xr-x	2020-07-15 23:39
contextlib2-0.5.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
copyreg	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
dateutil	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
docopt-0.6.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:01
future	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
future-0.17.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
html	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
http	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
jinja2	[ DIR ]	drwxr-xr-x	2024-09-10 19:32
jsonschema	[ DIR ]	drwxr-xr-x	2019-12-10 21:24
jsonschema-2.6.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2019-12-10 21:24
libfuturize	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
libpasteurize	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
lvemanager	[ DIR ]	drwxr-xr-x	2020-07-15 23:39
lvestats	[ DIR ]	drwxr-xr-x	2020-07-15 23:39
mako	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
nose	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
nose-1.3.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
past	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
paste	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
pip	[ DIR ]	drwxr-xr-x	2023-12-11 23:31
pip-20.2.4.dist-info	[ DIR ]	drwxr-xr-x	2023-12-11 23:31
pkg_resources	[ DIR ]	drwxr-xr-x	2023-12-11 23:32
python_dateutil-1.4.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
python_editor-0.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
pytz	[ DIR ]	drwxr-xr-x	2017-07-03 23:01
queue	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
raven	[ DIR ]	drwxr-xr-x	2018-01-15 23:40
raven-6.3.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2018-01-15 23:39
repoze	[ DIR ]	drwxr-xr-x	2019-12-10 21:24
repoze.lru-0.6-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2019-12-10 21:24
reprlib	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
requests	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
requests-2.10.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
schema-0.3.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:01
setuptools	[ DIR ]	drwxr-xr-x	2023-12-11 23:35
setuptools-36.3.0.post20231113.dist-info	[ DIR ]	drwxr-xr-x	2023-12-11 23:32
socketserver	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
svgwrite	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
svgwrite-1.1.5-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
tempita	[ DIR ]	drwxr-xr-x	2017-07-03 23:07
tkinter	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
urllib3	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
urllib3-1.15.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2018-05-29 23:45
winreg	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
xmlrpc	[ DIR ]	drwxr-xr-x	2020-03-17 21:54
Paste-1.7.5.1-py2.7-nspkg.pth	304 B	-rw-r--r--	2016-08-01 21:39
PySocks-1.5.7-py2.7.egg-info	322 B	-rw-r--r--	2016-11-17 09:09
argparse.py	85.73 KB	-rw-r--r--	2011-03-31 23:43
argparse.pyc	66.17 KB	-rw-r--r--	2015-07-22 22:48
argparse.pyo	66.01 KB	-rw-r--r--	2015-07-22 22:48
clhooklib.pyc	3.05 KB	-rw-r--r--	2020-01-21 22:38
contextlib2.py	14.48 KB	-rw-r--r--	2016-07-31 05:42
contextlib2.pyc	15.63 KB	-rw-r--r--	2016-10-07 14:30
contextlib2.pyo	15.63 KB	-rw-r--r--	2016-10-07 14:30
docopt.py	19.48 KB	-rw-r--r--	2014-06-16 13:14
docopt.pyc	24.09 KB	-rw-r--r--	2015-12-28 14:49
docopt.pyo	23.87 KB	-rw-r--r--	2015-12-28 14:49
easy_install.py	126 B	-rw-r--r--	2023-11-13 22:10
easy_install.pyc	328 B	-rw-r--r--	2023-11-13 22:10
easy_install.pyo	328 B	-rw-r--r--	2023-11-13 22:10
editor.py	2.49 KB	-rwxr-xr-x	2015-08-26 09:39
editor.pyc	3.49 KB	-rw-r--r--	2016-08-01 21:06
editor.pyo	3.49 KB	-rw-r--r--	2016-08-01 21:06
lprettytable.py	23.29 KB	-rw-r--r--	2015-07-22 22:10
lprettytable.pyc	19.24 KB	-rw-r--r--	2015-07-22 22:10
lprettytable.pyo	19.1 KB	-rw-r--r--	2015-07-22 22:10
pyparsing-1.5.6-py2.7.egg-info	670 B	-rw-r--r--	2015-07-22 22:25
pyparsing.py	151.79 KB	-rw-r--r--	2015-07-22 22:25
pyparsing.pyc	149.94 KB	-rw-r--r--	2015-07-22 22:25
pyparsing.pyo	149.94 KB	-rw-r--r--	2015-07-22 22:25
pytz-2012d-py2.7.egg-info	22.76 KB	-rw-r--r--	2015-07-22 22:23
repoze.lru-0.6-py2.7-nspkg.pth	307 B	-rw-r--r--	2017-03-17 14:46
schema.py	6.06 KB	-rw-r--r--	2014-04-28 22:11
schema.pyc	8.33 KB	-rw-r--r--	2015-12-28 14:43
schema.pyo	8.25 KB	-rw-r--r--	2015-12-28 14:43
six-1.9.0-py2.7.egg-info	1.39 KB	-rw-r--r--	2017-09-12 11:58
six.py	28.97 KB	-rw-r--r--	2015-01-02 17:33
six.pyc	30 KB	-rw-r--r--	2017-09-12 11:58
six.pyo	30 KB	-rw-r--r--	2017-09-12 11:58
socks.py	29.25 KB	-rw-r--r--	2016-05-21 23:54
socks.pyc	25.09 KB	-rw-r--r--	2016-11-17 09:09
socks.pyo	25.09 KB	-rw-r--r--	2016-11-17 09:09
sockshandler.py	2.84 KB	-rw-r--r--	2016-05-21 23:54
sockshandler.pyc	4.63 KB	-rw-r--r--	2016-11-17 09:09
sockshandler.pyo	4.63 KB	-rw-r--r--	2016-11-17 09:09
typing-3.5.3.0-py2.7.egg-info	1.45 KB	-rw-r--r--	2017-02-16 13:24
typing.py	63.37 KB	-rw-r--r--	2017-01-01 03:57
typing.pyc	77.21 KB	-rw-r--r--	2017-02-16 13:24
typing.pyo	76.57 KB	-rw-r--r--	2017-02-16 13:24

Rename

__version__ = '0.3.1'

class SchemaError(Exception):

"""Error during Schema validation."""

def __init__(self, autos, errors):
        self.autos = autos if type(autos) is list else [autos]
        self.errors = errors if type(errors) is list else [errors]
        Exception.__init__(self, self.code)

@property
    def code(self):
        def uniq(seq):
            seen = set()
            seen_add = seen.add
            return [x for x in seq if x not in seen and not seen_add(x)]
        a = uniq(i for i in self.autos if i is not None)
        e = uniq(i for i in self.errors if i is not None)
        if e:
            return '\n'.join(e)
        return '\n'.join(a)

class And(object):

def __init__(self, *args, **kw):
        self._args = args
        assert list(kw) in (['error'], [])
        self._error = kw.get('error')

def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__,
                           ', '.join(repr(a) for a in self._args))

def validate(self, data):
        for s in [Schema(s, error=self._error) for s in self._args]:
            data = s.validate(data)
        return data

class Or(And):

def validate(self, data):
        x = SchemaError([], [])
        for s in [Schema(s, error=self._error) for s in self._args]:
            try:
                return s.validate(data)
            except SchemaError as _x:
                x = _x
        raise SchemaError(['%r did not validate %r' % (self, data)] + x.autos,
                          [self._error] + x.errors)

class Use(object):

def __init__(self, callable_, error=None):
        assert callable(callable_)
        self._callable = callable_
        self._error = error

def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self._callable)

def validate(self, data):
        try:
            return self._callable(data)
        except SchemaError as x:
            raise SchemaError([None] + x.autos, [self._error] + x.errors)
        except BaseException as x:
            f = self._callable.__name__
            raise SchemaError('%s(%r) raised %r' % (f, data, x), self._error)

def priority(s):
    """Return priority for a give object."""
    if type(s) in (list, tuple, set, frozenset):
        return 6
    if type(s) is dict:
        return 5
    if hasattr(s, 'validate'):
        return 4
    if issubclass(type(s), type):
        return 3
    if callable(s):
        return 2
    else:
        return 1

class Schema(object):

def __init__(self, schema, error=None):
        self._schema = schema
        self._error = error

def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self._schema)

def validate(self, data):
        s = self._schema
        e = self._error
        if type(s) in (list, tuple, set, frozenset):
            data = Schema(type(s), error=e).validate(data)
            return type(s)(Or(*s, error=e).validate(d) for d in data)
        if type(s) is dict:
            data = Schema(dict, error=e).validate(data)
            new = type(data)()  # new - is a dict of the validated values
            x = None
            coverage = set()  # non-optional schema keys that were matched
            # for each key and value find a schema entry matching them, if any
            sorted_skeys = list(sorted(s, key=priority))
            for key, value in data.items():
                valid = False
                skey = None
                for skey in sorted_skeys:
                    svalue = s[skey]
                    try:
                        nkey = Schema(skey, error=e).validate(key)
                    except SchemaError:
                        pass
                    else:
                        try:
                            nvalue = Schema(svalue, error=e).validate(value)
                        except SchemaError as _x:
                            x = _x
                            raise
                        else:
                            coverage.add(skey)
                            valid = True
                            break
                if valid:
                    new[nkey] = nvalue
                elif skey is not None:
                    if x is not None:
                        raise SchemaError(['invalid value for key %r' % key] +
                                          x.autos, [e] + x.errors)
            coverage = set(k for k in coverage if type(k) is not Optional)
            required = set(k for k in s if type(k) is not Optional)
            if coverage != required:
                raise SchemaError('missed keys %r' % (required - coverage), e)
            if len(new) != len(data):
                wrong_keys = set(data.keys()) - set(new.keys())
                s_wrong_keys = ', '.join('%r' % k for k in sorted(wrong_keys))
                raise SchemaError('wrong keys %s in %r' % (s_wrong_keys, data),
                                  e)
            return new
        if hasattr(s, 'validate'):
            try:
                return s.validate(data)
            except SchemaError as x:
                raise SchemaError([None] + x.autos, [e] + x.errors)
            except BaseException as x:
                raise SchemaError('%r.validate(%r) raised %r' % (s, data, x),
                                  self._error)
        if issubclass(type(s), type):
            if isinstance(data, s):
                return data
            else:
                raise SchemaError('%r should be instance of %r' % (data, s), e)
        if callable(s):
            f = s.__name__
            try:
                if s(data):
                    return data
            except SchemaError as x:
                raise SchemaError([None] + x.autos, [e] + x.errors)
            except BaseException as x:
                raise SchemaError('%s(%r) raised %r' % (f, data, x),
                                  self._error)
            raise SchemaError('%s(%r) should evaluate to True' % (f, data), e)
        if s == data:
            return data
        else:
            raise SchemaError('%r does not match %r' % (s, data), e)

class Optional(Schema):

"""Marker for an optional part of Schema."""