Python装饰器使用实例：验证参数合法性

# -*- coding: UTF-8 -*-
 
'''
@summary: 验证器
该模块提供了一个装饰器用于验证参数是否合法，使用方法为：
 
from validator import validParam,nullOk,multiType
 
@validParam(i=int)
def foo(i):
  return i+1
 
编写验证器：
 
1. 仅验证类型：
@validParam(type,...)
例如：
检查第一个位置的参数是否为int类型：
@validParam(int)
检查名为x的参数是否为int类型：
@validParam(x=int)
 
验证多个参数：
@validParam(int,int)
指定参数名验证：
@validParam(int,s=str)
 
针对*和**参数编写的验证器将验证这些参数实际包含的每个元素：
@validParam(varargs=int)
def foo(*varargs): pass
 
@validParam(kws=int)
def foo7(s,**kws): pass
 
2. 带有条件的验证：
@validParam((type,condition),...)
其中，condition是一个表达式字符串，使用x引用待验证的对象；
根据bool(表达式的值)判断是否通过验证，若计算表达式时抛出异常，视为失败。
例如：
验证一个10到20之间的整数：
@validParam(i=(int,'10<x<20'))
验证一个长度小于20的字符串：
@validParam(s=(str,'len(x)<20'))
验证一个年龄小于20的学生：
@validParam(stu=(Student,'x.age<20'))
 
另外，如果类型是字符串，condition还可以使用斜杠开头和结尾表示正则表达式匹配。
验证一个由数字组成的字符串：
@validParam(s=(str,'/^d*$/'))
 
3. 以上验证方式默认为当值是None时验证失败。如果None是合法的参数，可以使用nullOk()。
nullOk()接受一个验证条件作为参数。
例如：
@validParam(i=nullOk(int))
@validParam(i=nullOk((int,'10<x<20')))
也可以简写为：
@validParam(i=nullOk(int,'10<x<20'))
 
4. 如果参数有多个合法的类型，可以使用multiType()。
multiType()可接受多个参数，每个参数都是一个验证条件。
例如：
@validParam(s=multiType(int,str))
@validParam(s=multiType((int,'x>20'),nullOk(str,'/^d+$/')))
 
5. 如果有更复杂的验证需求，还可以编写一个函数作为验证函数传入。
这个函数接收待验证的对象作为参数，根据bool(返回值)判断是否通过验证，抛出异常视为失败。
例如：
def validFunction(x):
  return isinstance(x,int) and x>0
@validParam(i=validFunction)
def foo(i): pass
 
这个验证函数等价于：
@validParam(i=(int,'x>0'))
def foo(i): pass
 
 
@author: HUXI
@since: 2011-3-22
@change: 
'''
 
import inspect
import re
 
class ValidateException(Exception): pass
 
 
def validParam(*varargs,**keywords):
  '''验证参数的装饰器。'''
   
  varargs = map(_toStardardCondition,varargs)
  keywords = dict((k,_toStardardCondition(keywords[k]))
          for k in keywords)
   
  def generator(func):
    args,varargname,kwname = inspect.getargspec(func)[:3]
    dctValidator = _getcallargs(args,kwname,varargs,keywords)
     
    def wrapper(*callvarargs,**callkeywords):
      dctCallArgs = _getcallargs(args,callvarargs,callkeywords)
       
      k,item = None,None
      try:
        for k in dctValidator:
          if k == varargname:
            for item in dctCallArgs[k]:
              assert dctValidator[k](item)
          elif k == kwname:
            for item in dctCallArgs[k].values():
              assert dctValidator[k](item)
          else:
            item = dctCallArgs[k]
            assert dctValidator[k](item)
      except:
        raise ValidateException,

            ('%s() parameter validation fails,param: %s,value: %s(%s)'
            % (func.func_name,k,item,item.__class__.__name__))
       
      return func(*callvarargs,**callkeywords)
     
    wrapper = _wrapps(wrapper,func)
    return wrapper
   
  return generator
 
 
def _toStardardCondition(condition):
  '''将各种格式的检查条件转换为检查函数'''
   
  if inspect.isclass(condition):
    return lambda x: isinstance(x,condition)
   
  if isinstance(condition,(tuple,list)):
    cls,condition = condition[:2]
    if condition is None:
      return _toStardardCondition(cls)
     
    if cls in (str,unicode) and condition[0] == condition[-1] == '/':
      return lambda x: (isinstance(x,cls)
               and re.match(condition[1:-1],x) is not None)
     
    return lambda x: isinstance(x,cls) and eval(condition)
   
  return condition
 
 
def nullOk(cls,condition=None):
  '''这个函数指定的检查条件可以接受None值'''
   
  return lambda x: x is None or _toStardardCondition((cls,condition))(x)
 
 
def multiType(*conditions):
  '''这个函数指定的检查条件只需要有一个通过'''
   
  lstValidator = map(_toStardardCondition,conditions)
  def validate(x):
    for v in lstValidator:
      if v(x):
        return True
  return validate
 
 
def _getcallargs(args,keywords):
  '''获取调用时的各参数名-值的字典'''
   
  dctArgs = {}
  varargs = tuple(varargs)
  keywords = dict(keywords)
   
  argcount = len(args)
  varcount = len(varargs)
  callvarargs = None
   
  if argcount <= varcount:
    for n,argname in enumerate(args):
      dctArgs[argname] = varargs[n]
     
    callvarargs = varargs[-(varcount-argcount):]
   
  else:
    for n,var in enumerate(varargs):
      dctArgs[args[n]] = var
     
    for argname in args[-(argcount-varcount):]:
      if argname in keywords:
        dctArgs[argname] = keywords.pop(argname)
     
    callvarargs = ()
   
  if varargname is not None:
    dctArgs[varargname] = callvarargs
   
  if kwname is not None:
    dctArgs[kwname] = keywords
   
  dctArgs.update(keywords)
  return dctArgs
 
 
def _wrapps(wrapper,wrapped):
  '''复制元数据'''
   
  for attr in ('__module__','__name__','__doc__'):
    setattr(wrapper,attr,getattr(wrapped,attr))
  for attr in ('__dict__',):
    getattr(wrapper,attr).update(getattr(wrapped,{}))
   
  return wrapper
 
 
#===============================================================================
# 测试
#===============================================================================
 
 
def _unittest(func,*cases):
  for case in cases:
    _functest(func,*case)
   
 
def _functest(func,isCkPass,*args,**kws):
  if isCkPass:
    func(*args,**kws)
  else:
    try:
      func(*args,**kws)
      assert False
    except ValidateException:
      pass
 
def _test1_simple():
  #检查第一个位置的参数是否为int类型：
  @validParam(int)
  def foo1(i): pass
  _unittest(foo1,(True,1),(False,'s'),None))
 
  #检查名为x的参数是否为int类型：
  @validParam(x=int)
  def foo2(s,x): pass
  _unittest(foo2,1,2),'s','s'))
   
  #验证多个参数：
  @validParam(int,int)
  def foo3(s,x): pass
  _unittest(foo3,2))
   
  #指定参数名验证：
  @validParam(int,s=str)
  def foo4(i,s): pass
  _unittest(foo4,'a'),1))
   
  #针对*和**参数编写的验证器将验证这些参数包含的每个元素：
  @validParam(varargs=int)
  def foo5(*varargs): pass
  _unittest(foo5,2,3,4,5),'a',1))
   
  @validParam(kws=int)
  def foo6(**kws): pass
  _functest(foo6,True,a=1,b=2)
  _functest(foo6,False,a='a',b=2)
   
  @validParam(kws=int)
  def foo7(s,**kws): pass
  _functest(foo7,s='a',b=2)
 
 
def _test2_condition():
  #验证一个10到20之间的整数：
  @validParam(i=(int,'10<x<20'))
  def foo1(x,i): pass
  _unittest(foo1,11),1))
   
  #验证一个长度小于20的字符串：
  @validParam(s=(str,'len(x)<20'))
  def foo2(a,s): pass
  _unittest(foo2,'a'*20))
   
  #验证一个年龄小于20的学生：
  class Student(object):
    def __init__(self,age): self.age=age
   
  @validParam(stu=(Student,'x.age<20'))
  def foo3(stu): pass
  _unittest(foo3,Student(18)),Student(20)))
   
  #验证一个由数字组成的字符串：
  @validParam(s=(str,r'/^d*$/'))
  def foo4(s): pass
  _unittest(foo4,'1234'),'a1234'))
 
 
def _test3_nullok():
  @validParam(i=nullOk(int))
  def foo1(i): pass
  _unittest(foo1,None))
   
  @validParam(i=nullOk(int,'10<x<20'))
  def foo2(i): pass
  _unittest(foo2,None),1))
 
 
def _test4_multitype():
  @validParam(s=multiType(int,str))
  def foo1(s): pass
  _unittest(foo1,1.1))
   
  @validParam(s=multiType((int,'/^d+$/')))
  def foo2(s): pass
  _unittest(foo2,1.1),21),'21'))
 
def _main():
  d = globals()
  from types import FunctionType
  print
  for f in d:
    if f.startswith('_test'):
      f = d[f]
      if isinstance(f,FunctionType):
        f()
 
if __name__ == '__main__':
  _main()