rrr at ronadam
Aug 20, 2006, 3:12 AM
Post #1 of 1
(35 views)
Permalink
|
Sometimes it's good to check things while working on them. This seems
like a good way to do that.
You could probably put these in a module and just import them.
from validators import *
I'm interested if anyone can think of ways to improve this further.
Each validator consists of an assertion with an error message if the
assertion fails.
The validator arguments can include an extra argument to check the
return value. Less than the number of arguments is ok. Any unspecified
arguments are not checked. Use Any to not check previous arguments in a
list. (see the examples at the end)
Cheers,
Ron
# ------------- Some Simple Validators.
def Any(arg): pass
def IsNumber(arg):
assert type(arg) in (int, long, float), \
"%r is not a number" % arg
def IsInt(arg):
assert type(arg) in (int, long), \
"%r is not an Int" % arg
def IsFloat(arg):
assert isinstance(arg, float), \
"%r is not a flaot" % arg
def IsLong(arg):
assert isinstance(arg, long), \
"%r is not a long integer" % arg
def IsString(arg):
assert type(arg) in (str, unicode), \
"%r is not a string type" % arg
def InRange(start, stop):
def inrange(arg):
assert start <= arg <= stop, \
"%r is not in range %r through %r" % (arg, start, stop)
return inrange
def InSet(list_):
s = set(list_)
def inset(arg):
assert arg in s, \
"%r is not in %r" % (arg, s)
return inset
def LessThan(value):
def lessthan(arg):
assert arg < value, \
"%r is not less than %r." % (arg, value)
return lessthan
def MoreThan(value):
def morethan(arg):
assert arg > value, \
"%r is not more than %r." % (arg, value)
return morethan
def IsEven(arg):
assert arg % 2 == 0, \
"%r is not even" % arg
def IsOdd(arg):
assert arg % 2 == 1, \
"%r is not odd" % arg
def IsPositive(arg):
assert arg >= 0, \
"%r is not positive" % arg
def IsNegative(arg):
assert arg < 0, \
"%r is not negative" % arg
def IsTrue(arg):
assert arg is True, \
"%r is not True" % arg
def IsFalse(arg):
assert arg is False, \
"%r is not False" % arg
# ----------------- The validator decorator.
def validate(*types):
""" check arguments + return value against types given.
"""
def check_accepts(f):
def new_f(*args, **kwds):
assert len(types) <= len(args)+1, \
"Validators exceed arg count + return value."
for (a, t) in zip(args, types):
t(a)
result = f(*args, **kwds)
if len(types)>len(args):
types[-1](result)
return result
new_f.func_name = f.func_name
return new_f
return check_accepts
# -------------- Examples to play around with.
@validate(Any, IsInt, IsEven)
def add(a, b):
return a + b
@validate(InRange(1,6), InRange(1,6), LessThan(19))
def mul(a, b):
return a * b
# they stack too
@validate(IsInt, IsInt)
@validate(MoreThan(10),LessThan(10))
@validate(Any, IsPositive)
def sub(a, b):
return a - b
@validate(IsString, IsString)
def addstr(a, b):
return a + b
print add(3.0, 5)
print mul(3, 6)
print sub(11, 9)
print addstr('Hello ', 'World')
--
http://mail.python.org/mailman/listinfo/python-list
|
