Python裝飾器實例(1):參數合法性驗證

python是不帶靜態檢查的動態語言，有時候須要在調用函數時保證參數合法。檢查參數合法性是一個顯著的切面場景，各個函數均可能有這個需求。但另外一方面，參數合法性是否是應該由調用方來保證比較好也是一個須要結合實際才能回答的問題，總之雙方約定好，不要都不檢查或者都檢查就能夠了。下面這個模塊用於在函數上使用裝飾器進行參數的合法性驗證。

你能夠直接執行這個模塊進行測試，若是徹底沒有輸出則表示經過。你也能夠找到幾個以_test開頭的函數，全部的測試用例都包含在這幾個函數中。使用方法參見模塊文檔和測試用例

#!/usr/bin/env 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

'''

 

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, varargname, kwname,

                                    varargs, keywords)

         

        def wrapper(*callvarargs, **callkeywords):

            dctCallArgs = _getcallargs(args, varargname, kwname,

                                       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, varargname, kwname, varargs, 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, attr, {}))

     

    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'), 

              (False, None))

 

    #檢查名爲x的參數是否爲int類型：

    @validParam(x=int)

    def foo2(s, x): pass

    _unittest(foo2, 

              (True, 1, 2), 

              (False, 's', 's'))

     

    #驗證多個參數：

    @validParam(int, int)

    def foo3(s, x): pass

    _unittest(foo3, 

              (True, 1, 2), 

              (False, 's', 2))

     

    #指定參數名驗證：

    @validParam(int, s=str)

    def foo4(i, s): pass

    _unittest(foo4, 

              (True, 1, 'a'), 

              (False, 's', 1))

     

    #針對*和**參數編寫的驗證器將驗證這些參數包含的每一個元素：

    @validParam(varargs=int)

    def foo5(*varargs): pass

    _unittest(foo5,

              (True, 1, 2, 3, 4, 5),

              (False, '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, True, s='a', a=1, b=2)

 

 

def _test2_condition():

    #驗證一個10到20之間的整數：

    @validParam(i=(int, '10<x<20'))

    def foo1(x, i): pass

    _unittest(foo1, 

              (True, 1, 11), 

              (False, 1, 'a'), 

              (False, 1, 1))

     

    #驗證一個長度小於20的字符串：

    @validParam(s=(str, 'len(x)<20'))

    def foo2(a, s): pass

    _unittest(foo2, 

              (True, 1, 'a'), 

              (False, 1, 1), 

              (False, 1, '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, 

              (True, Student(18)), 

              (False, 1), 

              (False, Student(20)))

     

    #驗證一個由數字組成的字符串：

    @validParam(s=(str, r'/^\d*$/'))

    def foo4(s): pass

    _unittest(foo4, 

              (True, '1234'), 

              (False, 1), 

              (False, 'a1234'))

 

 

def _test3_nullok():

    @validParam(i=nullOk(int))

    def foo1(i): pass

    _unittest(foo1, 

              (True, 1), 

              (False, 'a'), 

              (True, None))

     

    @validParam(i=nullOk(int, '10<x<20'))

    def foo2(i): pass

    _unittest(foo2, 

              (True, 11), 

              (False, 'a'), 

              (True, None), 

              (False, 1))

 

 

def _test4_multitype():

    @validParam(s=multiType(int, str))

    def foo1(s): pass

    _unittest(foo1, 

              (True, 1),

              (True, 'a'),

              (False, None),

              (False, 1.1))

     

    @validParam(s=multiType((int, 'x>20'), nullOk(str, '/^\d+$/')))

    def foo2(s): pass

    _unittest(foo2, 

              (False, 1),

              (False, 'a'),

              (True, None),

              (False, 1.1),

              (True, 21),

              (True, '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()