From 196461dda1bb5c9aa4d2e1a01d65539c092119c0 Mon Sep 17 00:00:00 2001 From: aaronsw Date: Thu, 28 Nov 2002 20:36:51 +0000 Subject: [PATCH] removing unused btemplate.py --- btemplate.py | 528 --------------------------------------------------- 1 file changed, 528 deletions(-) delete mode 100644 btemplate.py diff --git a/btemplate.py b/btemplate.py deleted file mode 100644 index 038a1ac..0000000 --- a/btemplate.py +++ /dev/null @@ -1,528 +0,0 @@ -# This file is licensed under the GNU Lesser General Public License v2.1. -# originally written for Mojo Nation by Bram Cohen, based on an earlier -# version by Bryce Wilcox -# The authors disclaim all liability for any damages resulting from -# any use of this software. - -import types - -def string_template(thing, verbose): - if type(thing) != types.StringType: - raise ValueError, "not a string" - -st = string_template - -def exact_length(l): - def func(s, verbose, l = l): - if type(s) != types.StringType: - raise ValueError, 'should have been string' - if len(s) != l: - raise ValueError, 'wrong length, should have been ' + str(l) + ' was ' + str(len(s)) - return func - -class MaxDepth: - def __init__(self, max_depth, template = None): - assert max_depth >= 0 - self.max_depth = max_depth - self.template = template - - def get_real_template(self): - assert self.template is not None, 'You forgot to set the template!' - if self.max_depth == 0: - return fail_too_deep - self.max_depth -= 1 - try: - return compile_inner(self.template) - finally: - self.max_depth += 1 - - def __repr__(self): - if hasattr(self, 'p'): - return '...' - try: - self.p = 1 - return 'MaxDepth(' + str(self.max_depth) + ', ' + `self.template` + ')' - finally: - del self.p - -def fail_too_deep(thing, verbose): - raise ValueError, 'recursed too deep' - -class ListMarker: - def __init__(self, template): - self.template = template - - def get_real_template(self): - return compile_list_template(self.template) - - def __repr__(self): - return 'ListMarker(' + `self.template` + ')' - -def compile_list_template(template): - def func(thing, verbose, template = compile_inner(template)): - if type(thing) not in (types.ListType, types.TupleType): - raise ValueError, 'not a list' - if verbose: - try: - for i in xrange(0, len(thing)): - template(thing[i], 1) - except ValueError, e: - reason = 'mismatch at index ' + str(i) + ': ' + str(e) - raise ValueError, reason - else: - for i in thing: - template(i, 0) - return func - -class ValuesMarker: - def __init__(self, template, t2 = string_template): - self.template = template - self.t2 = t2 - - def get_real_template(self): - return compile_values_template(self.template, self.t2) - - def __repr__(self): - return 'ValuesMarker(' + `self.template` + ')' - -def compile_values_template(template, t2): - def func(thing, verbose, template = compile_inner(template), - t2 = compile_inner(t2)): - if type(thing) != types.DictType: - raise ValueError, 'not a dict' - if verbose: - try: - for key, val in thing.items(): - template(val, 1) - t2(key, 1) - except ValueError, e: - raise ValueError, 'mismatch in key ' + `key` + ': ' + str(e) - else: - for key, val in thing.items(): - template(val, 0) - t2(key, 0) - return func - -compilers = {} - -def compile_string_template(template): - assert type(template) is types.StringType - def func(thing, verbose, template = template): - if thing != template: - raise ValueError, "didn't match string" - return func - -compilers[types.StringType] = compile_string_template - -def int_template(thing, verbose): - if type(thing) not in (types.IntType, types.LongType): - raise ValueError, 'thing not of integer type' - -def nonnegative_int_template(thing, verbose): - if type(thing) not in (types.IntType, types.LongType): - raise ValueError, 'thing not of integer type' - if thing < 0: - raise ValueError, 'thing less than zero' - -def positive_int_template(thing, verbose): - if type(thing) not in (types.IntType, types.LongType): - raise ValueError, 'thing not of integer type' - if thing <= 0: - raise ValueError, 'thing less than or equal to zero' - -def compile_int_template(s): - assert s in (-1, 0, 1) - if s == -1: - return int_template - elif s == 0: - return nonnegative_int_template - else: - return positive_int_template - -compilers[types.IntType] = compile_int_template -compilers[types.LongType] = compile_int_template - -def compile_slice(template): - assert type(template) is types.SliceType - assert template.step is None - assert template.stop is not None - start = template.start - if start is None: - start = 0 - def func(thing, verbose, start = start, stop = template.stop): - if type(thing) not in (types.IntType, types.LongType): - raise ValueError, 'not an int' - if thing < start: - raise ValueError, 'thing too small' - if thing >= stop: - raise ValueError, 'thing too large' - return func - -compilers[types.SliceType] = compile_slice - -class OptionMarker: - def __init__(self, template): - self.option_template = template - - def __repr__(self): - return 'OptionMarker(' + `self.option_template` + ')' - -def compile_dict_template(template): - assert type(template) is types.DictType - agroup = [] - bgroup = [] - cgroup = [] - optiongroup = [] - for key, value in template.items(): - if hasattr(value, 'option_template'): - optiongroup.append((key, compile_inner(value.option_template))) - elif type(value) is types.StringType: - agroup.append((key, compile_inner(value))) - elif type(value) in (types.IntType, types.LongType, types.SliceType): - bgroup.append((key, compile_inner(value))) - else: - cgroup.append((key, compile_inner(value))) - def func(thing, verbose, required = agroup + bgroup + cgroup, optional = optiongroup): - if type(thing) is not types.DictType: - raise ValueError, 'not a dict' - try: - for key, template in required: - if not thing.has_key(key): - raise ValueError, 'key not present' - template(thing[key], verbose) - for key, template in optional: - if thing.has_key(key): - template(thing[key], verbose) - except ValueError, e: - if verbose: - reason = 'mismatch in key ' + `key` + ': ' + str(e) - raise ValueError, reason - else: - raise - return func - -compilers[types.DictType] = compile_dict_template - -def none_template(thing, verbose): - if thing is not None: - raise ValueError, 'thing was not None' - -compilers[types.NoneType] = lambda template: none_template - -def compile_or_template(template): - assert type(template) in (types.ListType, types.TupleType) - def func(thing, verbose, templ = [compile_inner(x) for x in template]): - if verbose: - failure_reason = ('did not match any of the ' + - str(len(templ)) + ' possible templates;') - for i in xrange(len(templ)): - try: - templ[i](thing, 1) - return - except ValueError, reason: - failure_reason += (' failed template at index ' + - str(i) + ' because (' + str(reason) + ')') - raise ValueError, failure_reason - else: - for i in templ: - try: - i(thing, 0) - return - except ValueError: - pass - raise ValueError, "did not match any possible templates" - return func - -compilers[types.ListType] = compile_or_template -compilers[types.TupleType] = compile_or_template - -def compile_inner(template): - while hasattr(template, 'get_real_template'): - template = template.get_real_template() - if callable(template): - return template - return compilers[type(template)](template) - -def compile_template(template): - def func(thing, verbose = None, t = compile_inner(template), s = `template`): - if verbose is not None: - t(thing, verbose) - return - try: - t(thing, 0) - except ValueError: - try: - t(thing, 1) - assert 0 - except ValueError, reason: - raise ValueError, 'failed template check because: (' + str(reason) + ') target was: (' + `thing` + ') template was: (' + s + ')' - return func - - - -###### -import unittest - -class TestBTemplate(unittest.TestCase): - - def test_slice(self): - f = compile_template(slice(4)) - f(0) - f(3L) - try: - f(-1) - assert 0 - except ValueError: - pass - try: - f(4L) - assert 0 - except ValueError: - pass - try: - f('a') - assert 0 - except ValueError: - pass - - f = compile_template(slice(-2, 3)) - f(-2L) - f(2) - try: - f(-3L) - assert 0 - except ValueError: - pass - try: - f(3) - assert 0 - except ValueError: - pass - try: - f('a') - assert 0 - except ValueError: - pass - - def test_int(self): - f = compile_template(0) - f(0) - f(1L) - try: - f(-1) - assert 0 - except ValueError: - pass - try: - f('a') - assert 0 - except ValueError: - pass - - f = compile_template(-1) - f(0) - f(1) - f(-1L) - try: - f('a') - assert 0 - except ValueError: - pass - - f = compile_template(1) - try: - f(0) - assert 0 - except ValueError: - pass - f(1) - try: - f(-1) - assert 0 - except ValueError: - pass - try: - f('a') - assert 0 - except ValueError: - pass - - def test_none(self): - f = compile_template(None) - f(None) - try: - f(0) - assert 0 - except ValueError: - pass - - def test_string(self): - f = compile_template('a') - f('a') - try: - f('b') - assert 0 - except ValueError: - pass - try: - f(0) - assert 0 - except ValueError: - pass - - def test_generic_string(self): - f = compile_template(st) - f('a') - try: - f(0) - assert 0 - except ValueError: - pass - - def test_values(self): - vt = compile_template(ValuesMarker('a', exact_length(1))) - vt({}) - vt({'x': 'a'}) - try: - vt(3) - assert 0 - except ValueError: - pass - try: - vt({'x': 'b'}) - assert 0 - except ValueError: - pass - try: - vt({'xx': 'a'}) - assert 0 - except ValueError: - pass - - def test_list(self): - f = compile_template(ListMarker('a')) - f(['a']) - f(('a', 'a')) - try: - f(('a', 'b')) - assert 0 - except ValueError: - pass - try: - f(('b', 'a')) - assert 0 - except ValueError: - pass - try: - f('a') - assert 0 - except ValueError: - pass - - def test_or(self): - f = compile_template(['a', 'b']) - f('a') - f('b') - try: - f('c') - assert 0 - except ValueError: - pass - - f = compile_template(('a', 'b')) - f('a') - f('b') - try: - f('c') - assert 0 - except ValueError: - pass - - def test_dict(self): - f = compile_template({'a': 'b', 'c': OptionMarker('d')}) - try: - f({}) - assert 0 - except ValueError: - pass - f({'a': 'b'}) - try: - f({'a': 'e'}) - assert 0 - except ValueError: - pass - try: - f({'c': 'd'}) - assert 0 - except ValueError: - pass - f({'a': 'b', 'c': 'd'}) - try: - f({'a': 'e', 'c': 'd'}) - assert 0 - except ValueError: - pass - try: - f({'c': 'f'}) - assert 0 - except ValueError: - pass - try: - f({'a': 'b', 'c': 'f'}) - assert 0 - except ValueError: - pass - try: - f({'a': 'e', 'c': 'f'}) - assert 0 - except ValueError: - pass - try: - f(None) - assert 0 - except ValueError: - pass - - def test_other_func(self): - def check3(thing, verbose): - if thing != 3: - raise ValueError - f = compile_template(check3) - f(3) - try: - f(4) - assert 0 - except ValueError: - pass - - def test_max_depth(self): - md = MaxDepth(2) - t = {'a': OptionMarker(ListMarker(md))} - md.template = t - f = compile_template(md) - f({'a': [{'a': []}]}) - f({'a': [{'a': []}]}) - try: - f({'a': [{'a': [{}]}]}) - assert 0 - except ValueError: - pass - try: - f({'a': [{'a': [{}]}]}) - assert 0 - except ValueError: - pass - f({'a': [{'a': []}]}) - try: - f({'a': [{'a': [{}]}]}) - assert 0 - except ValueError: - pass - - def test_use_compiled(self): - x = compile_template('a') - y = compile_template(ListMarker(x)) - y(['a']) - -if __name__ == "__main__": - unittest.main() -- 2.39.5