← Back to branch summary

~toolpart/openobject-server/toolpart

« back to all changes in this revision

Viewing changes to bin/reportlab/lib/validators.py

  • Committer: pinky
  • Date: 2006-12-07 13:41:40 UTC
  • Revision ID: pinky-3f10ee12cea3c4c75cef44ab04ad33ef47432907
New trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bin/reportlab/lib/validators.py
 
1
#Copyright ReportLab Europe Ltd. 2000-2004
 
2
#see license.txt for license details
 
3
#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/lib/validators.py
 
4
__version__=''' $Id$ '''
 
5
"""
 
6
This module contains some standard verifying functions which can be
 
7
used in an attribute map.
 
8
"""
 
9
 
 
10
import string, sys
 
11
from types import *
 
12
_SequenceTypes = (ListType,TupleType)
 
13
_NumberTypes = (FloatType,IntType)
 
14
from reportlab.lib import colors
 
15
if sys.hexversion<0x2030000:
 
16
    True = 1
 
17
    False = 0
 
18
 
 
19
class Validator:
 
20
    "base validator class"
 
21
    def __call__(self,x):
 
22
        return self.test(x)
 
23
 
 
24
    def __str__(self):
 
25
        return getattr(self,'_str',self.__class__.__name__)
 
26
 
 
27
    def normalize(self,x):
 
28
        return x
 
29
 
 
30
    def normalizeTest(self,x):
 
31
        try:
 
32
            self.normalize(x)
 
33
            return True
 
34
        except:
 
35
            return False
 
36
 
 
37
class _isAnything(Validator):
 
38
    def test(self,x):
 
39
        return True
 
40
 
 
41
class _isNothing(Validator):
 
42
    def test(self,x):
 
43
        return False
 
44
 
 
45
class _isBoolean(Validator):
 
46
    if sys.hexversion>=0x2030000:
 
47
        def test(self,x):
 
48
            if type(x) in (IntType,BooleanType): return x in (0,1)
 
49
            return self.normalizeTest(x)
 
50
    else:
 
51
        def test(self,x):
 
52
            if type(x) is IntType: return x in (0,1)
 
53
            return self.normalizeTest(x)
 
54
 
 
55
    def normalize(self,x):
 
56
        if x in (0,1): return x
 
57
        try:
 
58
            S = string.upper(x)
 
59
        except:
 
60
            raise ValueError, 'Must be boolean'
 
61
        if S in ('YES','TRUE'): return True
 
62
        if S in ('NO','FALSE',None): return False
 
63
        raise ValueError, 'Must be boolean'
 
64
 
 
65
class _isString(Validator):
 
66
    def test(self,x):
 
67
        return type(x) is StringType
 
68
 
 
69
class _isNumber(Validator):
 
70
    def test(self,x):
 
71
        if type(x) in _NumberTypes: return True
 
72
        return self.normalizeTest(x)
 
73
 
 
74
    def normalize(self,x):
 
75
        try:
 
76
            return float(x)
 
77
        except:
 
78
            return int(x)
 
79
 
 
80
class _isInt(Validator):
 
81
    def test(self,x):
 
82
        if type(x) not in (IntType,StringType): return False
 
83
        return self.normalizeTest(x)
 
84
 
 
85
    def normalize(self,x):
 
86
        return int(x)
 
87
 
 
88
class _isNumberOrNone(_isNumber):
 
89
    def test(self,x):
 
90
        return x is None or isNumber(x)
 
91
 
 
92
    def normalize(self,x):
 
93
        if x is None: return x
 
94
        return _isNumber.normalize(x)
 
95
 
 
96
class _isListOfNumbersOrNone(Validator):
 
97
    "ListOfNumbersOrNone validator class."
 
98
    def test(self, x):
 
99
        if x is None: return True
 
100
        return isListOfNumbers(x)
 
101
 
 
102
class _isListOfShapes(Validator):
 
103
    "ListOfShapes validator class."
 
104
    def test(self, x):
 
105
        from reportlab.graphics.shapes import Shape
 
106
        if type(x) in _SequenceTypes:
 
107
            answer = 1
 
108
            for element in x:
 
109
                if not isinstance(x, Shape):
 
110
                    answer = 0
 
111
            return answer
 
112
        else:
 
113
            return False
 
114
 
 
115
class _isListOfStringsOrNone(Validator):
 
116
    "ListOfStringsOrNone validator class."
 
117
 
 
118
    def test(self, x):
 
119
        if x is None: return True
 
120
        return isListOfStrings(x)
 
121
 
 
122
class _isTransform(Validator):
 
123
    "Transform validator class."
 
124
    def test(self, x):
 
125
        if type(x) in _SequenceTypes:
 
126
            if len(x) == 6:
 
127
                for element in x:
 
128
                    if not isNumber(element):
 
129
                        return False
 
130
                return True
 
131
            else:
 
132
                return False
 
133
        else:
 
134
            return False
 
135
 
 
136
class _isColor(Validator):
 
137
    "Color validator class."
 
138
    def test(self, x):
 
139
        return isinstance(x, colors.Color)
 
140
 
 
141
class _isColorOrNone(Validator):
 
142
    "ColorOrNone validator class."
 
143
    def test(self, x):
 
144
        if x is None: return True
 
145
        return isColor(x)
 
146
 
 
147
class _isValidChild(Validator):
 
148
    "ValidChild validator class."
 
149
    def test(self, x):
 
150
        """Is this child allowed in a drawing or group?
 
151
        I.e. does it descend from Shape or UserNode?
 
152
        """
 
153
 
 
154
        from reportlab.graphics.shapes import UserNode, Shape
 
155
        return isinstance(x, UserNode) or isinstance(x, Shape)
 
156
 
 
157
class _isValidChildOrNone(_isValidChild):
 
158
    def test(self,x):
 
159
        return _isValidChild.test(self,x) or x is None
 
160
 
 
161
class _isCallable(Validator):
 
162
    def test(self, x):
 
163
        return callable(x)
 
164
 
 
165
class OneOf(Validator):
 
166
    """Make validator functions for list of choices.
 
167
 
 
168
    Usage:
 
169
    f = reportlab.lib.validators.OneOf('happy','sad')
 
170
    or
 
171
    f = reportlab.lib.validators.OneOf(('happy','sad'))
 
172
    f('sad'),f('happy'), f('grumpy')
 
173
    (1,1,0)
 
174
    """
 
175
    def __init__(self, enum,*args):
 
176
        if type(enum) in [ListType,TupleType]:
 
177
            if args!=():
 
178
                raise ValueError, "Either all singleton args or a single sequence argument"
 
179
            self._enum = tuple(enum)+args
 
180
        else:
 
181
            self._enum = (enum,)+args
 
182
 
 
183
    def test(self, x):
 
184
        return x in self._enum
 
185
 
 
186
class SequenceOf(Validator):
 
187
    def __init__(self,elemTest,name=None,emptyOK=1, NoneOK=0, lo=0,hi=0x7fffffff):
 
188
        self._elemTest = elemTest
 
189
        self._emptyOK = emptyOK
 
190
        self._NoneOK = NoneOK
 
191
        self._lo, self._hi = lo, hi
 
192
        if name: self._str = name
 
193
 
 
194
    def test(self, x):
 
195
        if type(x) not in _SequenceTypes:
 
196
            if x is None: return self._NoneOK
 
197
            return False
 
198
        if x==[] or x==():
 
199
            return self._emptyOK
 
200
        elif not self._lo<=len(x)<=self._hi: return False
 
201
        for e in x:
 
202
            if not self._elemTest(e): return False
 
203
        return True
 
204
 
 
205
class EitherOr(Validator):
 
206
    def __init__(self,tests,name=None):
 
207
        if type(tests) not in _SequenceTypes: tests = (tests,)
 
208
        self._tests = tests
 
209
        if name: self._str = name
 
210
 
 
211
    def test(self, x):
 
212
        for t in self._tests:
 
213
            if t(x): return True
 
214
        return False
 
215
 
 
216
class NoneOr(Validator):
 
217
    def __init__(self,elemTest,name=None):
 
218
        self._elemTest = elemTest
 
219
        if name: self._str = name
 
220
 
 
221
    def test(self, x):
 
222
        if x is None: return True
 
223
        return self._elemTest(x)
 
224
 
 
225
class isInstanceOf(Validator):
 
226
    def __init__(self,klass=None):
 
227
        self._klass = klass
 
228
    def test(self,x):
 
229
        return isinstance(x,self._klass)
 
230
 
 
231
isBoolean = _isBoolean()
 
232
isString = _isString()
 
233
isNumber = _isNumber()
 
234
isInt = _isInt()
 
235
isNoneOrInt = NoneOr(isInt,'isNoneOrInt')
 
236
isNumberOrNone = _isNumberOrNone()
 
237
isTextAnchor = OneOf('start','middle','end','boxauto')
 
238
isListOfNumbers = SequenceOf(isNumber,'isListOfNumbers')
 
239
isListOfNumbersOrNone = _isListOfNumbersOrNone()
 
240
isListOfShapes = _isListOfShapes()
 
241
isListOfStrings = SequenceOf(isString,'isListOfStrings')
 
242
isListOfStringsOrNone = _isListOfStringsOrNone()
 
243
isTransform = _isTransform()
 
244
isColor = _isColor()
 
245
isListOfColors = SequenceOf(isColor,'isListOfColors')
 
246
isColorOrNone = _isColorOrNone()
 
247
isShape = isValidChild = _isValidChild()
 
248
isNoneOrShape = isValidChildOrNone = _isValidChildOrNone()
 
249
isAnything = _isAnything()
 
250
isNothing = _isNothing()
 
251
isXYCoord = SequenceOf(isNumber,lo=2,hi=2,emptyOK=0)
 
252
isBoxAnchor = OneOf('nw','n','ne','w','c','e','sw','s','se', 'autox', 'autoy')
 
253
isNoneOrString = NoneOr(isString,'NoneOrString')
 
254
isNoneOrListOfNoneOrStrings=SequenceOf(isNoneOrString,'isNoneOrListOfNoneOrStrings',NoneOK=1)
 
255
isListOfNoneOrString=SequenceOf(isNoneOrString,'isListOfNoneOrString',NoneOK=0)
 
256
isNoneOrListOfNoneOrNumbers=SequenceOf(isNumberOrNone,'isNoneOrListOfNoneOrNumbers',NoneOK=1)
 
257
isCallable = _isCallable()
 
258
isStringOrCallable=EitherOr((isString,isCallable),'isStringOrCallable')
 
259
isStringOrCallableOrNone=NoneOr(isStringOrCallable,'isStringOrCallableNone')
 
260
isStringOrNone=NoneOr(isString,'isStringOrNone')