« back to all changes in this revision
Viewing changes to bzrlib/util/configobj/validate.py
- browse files at revision 1474
- compare with another revision
- compare with revision 2594
- download diff
- download tarball
- view history from revision 1474
- Committer: Robert Collins
- Date: 2005-10-20 04:08:12 UTC
- mfrom: (1185.12.68)
- Revision ID: robertc@robertcollins.net-20051020040812-fecd1bc32aa3478e
Merge from Aaron Bentley.
- files added:
- bzrlib/selftest/test_command.py
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files modified:
- NEWS
added
removed
bzrlib/util/configobj/validate.py
1
# validate.py
2
# A Validator object
3
# Copyright (C) 2005 Michael Foord, Mark Andrews, Nicola Larosa
4
# E-mail: fuzzyman AT voidspace DOT org DOT uk
5
# mark AT la-la DOT com
6
# nico AT tekNico DOT net
7
8
# This software is licensed under the terms of the BSD license.
9
# http://www.voidspace.org.uk/documents/BSD-LICENSE.txt
10
# Basically you're free to copy, modify, distribute and relicense it,
11
# So long as you keep a copy of the license with it.
12
13
# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
14
# For information about bugfixes, updates and support, please join the
15
# ConfigObj mailing list:
16
# http://lists.sourceforge.net/lists/listinfo/configobj-develop
17
# Comments, suggestions and bug reports welcome.
18
19
"""
20
The Validator object is used to check that supplied values
21
conform to a specification.
22
23
The value can be supplied as a string - e.g. from a config file.
24
In this case the check will also *convert* the value to
25
the required type. This allows you to add validation
26
as a transparent layer to access data stored as strings.
27
The validation checks that the data is correct *and*
28
converts it to the expected type.
29
30
Some standard checks are provided for basic data types.
31
Additional checks are easy to write. They can be
32
provided when the ``Validator`` is instantiated or
33
added afterwards.
34
35
The standard functions work with the following basic data types :
36
37
* integers
38
* floats
39
* booleans
40
* strings
41
* ip_addr
42
43
plus lists of these datatypes
44
45
Adding additional checks is done through coding simple functions.
46
47
The full set of standard checks are :
48
49
* 'integer': matches integer values (including negative)
50
Takes optional 'min' and 'max' arguments : ::
51
52
integer()
53
integer(3, 9) # any value from 3 to 9
54
integer(min=0) # any positive value
55
integer(max=9)
56
57
* 'float': matches float values
58
Has the same parameters as the integer check.
59
60
* 'boolean': matches boolean values - ``True`` or ``False``
61
Acceptable string values for True are :
62
true, on, yes, 1
63
Acceptable string values for False are :
64
false, off, no, 0
65
66
Any other value raises an error.
67
68
* 'ip_addr': matches an Internet Protocol address, v.4, represented
69
by a dotted-quad string, i.e. '1.2.3.4'.
70
71
* 'string': matches any string.
72
Takes optional keyword args 'min' and 'max'
73
to specify min and max lengths of the string.
74
75
* 'list': matches any list.
76
Takes optional keyword args 'min', and 'max' to specify min and
77
max sizes of the list.
78
79
* 'int_list': Matches a list of integers.
80
Takes the same arguments as list.
81
82
* 'float_list': Matches a list of floats.
83
Takes the same arguments as list.
84
85
* 'bool_list': Matches a list of boolean values.
86
Takes the same arguments as list.
87
88
* 'ip_addr_list': Matches a list of IP addresses.
89
Takes the same arguments as list.
90
91
* 'string_list': Matches a list of strings.
92
Takes the same arguments as list.
93
94
* 'mixed_list': Matches a list with different types in
95
specific positions. List size must match
96
the number of arguments.
97
98
Each position can be one of :
99
'integer', 'float', 'ip_addr', 'string', 'boolean'
100
101
So to specify a list with two strings followed
102
by two integers, you write the check as : ::
103
104
mixed_list('string', 'string', 'integer', 'integer')
105
106
* 'pass': This check matches everything ! It never fails
107
and the value is unchanged.
108
109
It is also the default if no check is specified.
110
111
* 'option': This check matches any from a list of options.
112
You specify this check with : ::
113
114
option('option 1', 'option 2', 'option 3')
115
"""
116
117
__docformat__ = "restructuredtext en"
118
119
__version__ = '0.2.0'
120
121
__revision__ = '$Id: validate.py 123 2005-09-08 08:54:28Z fuzzyman $'
122
123
__all__ = (
124
'__version__',
125
'dottedQuadToNum',
126
'numToDottedQuad',
127
'ValidateError',
128
'VdtUnknownCheckError',
129
'VdtParamError',
130
'VdtTypeError',
131
'VdtValueError',
132
'VdtValueTooSmallError',
133
'VdtValueTooBigError',
134
'VdtValueTooShortError',
135
'VdtValueTooLongError',
136
'VdtMissingValue',
137
'Validator',
138
'is_integer',
139
'is_float',
140
'is_bool',
141
'is_list',
142
'is_ip_addr',
143
'is_string',
144
'is_int_list',
145
'is_bool_list',
146
'is_float_list',
147
'is_string_list',
148
'is_ip_addr_list',
149
'is_mixed_list',
150
'is_option',
151
'__docformat__',
152
)
153
154
import sys
155
INTP_VER = sys.version_info[:2]
156
if INTP_VER < (2, 2):
157
raise RuntimeError("Python v.2.2 or later needed")
158
159
import re
160
StringTypes = (str, unicode)
161
162
# Python pre 2.2.1 doesn't have bool
163
try:
164
bool
165
except NameError:
166
def bool(val):
167
"""Simple boolean equivalent function. """
168
if val:
169
return 1
170
else:
171
return 0
172
173
def dottedQuadToNum(ip):
174
"""
175
Convert decimal dotted quad string to long integer
176
177
>>> dottedQuadToNum('1 ')
178
1L
179
>>> dottedQuadToNum(' 1.2')
180
16777218L
181
>>> dottedQuadToNum(' 1.2.3 ')
182
16908291L
183
>>> dottedQuadToNum('1.2.3.4')
184
16909060L
185
>>> dottedQuadToNum('1.2.3. 4')
186
Traceback (most recent call last):
187
ValueError: Not a good dotted-quad IP: 1.2.3. 4
188
>>> dottedQuadToNum('255.255.255.255')
189
4294967295L
190
>>> dottedQuadToNum('255.255.255.256')
191
Traceback (most recent call last):
192
ValueError: Not a good dotted-quad IP: 255.255.255.256
193
"""
194
195
# import here to avoid it when ip_addr values are not used
196
import socket, struct
197
198
try:
199
return struct.unpack('!L',
200
socket.inet_aton(ip.strip()))[0]
201
except socket.error:
202
# bug in inet_aton, corrected in Python 2.3
203
if ip.strip() == '255.255.255.255':
204
return 0xFFFFFFFFL
205
else:
206
raise ValueError('Not a good dotted-quad IP: %s' % ip)
207
return
208
209
def numToDottedQuad(num):
210
"""
211
Convert long int to dotted quad string
212
213
>>> numToDottedQuad(-1L)
214
Traceback (most recent call last):
215
ValueError: Not a good numeric IP: -1
216
>>> numToDottedQuad(1L)
217
'0.0.0.1'
218
>>> numToDottedQuad(16777218L)
219
'1.0.0.2'
220
>>> numToDottedQuad(16908291L)
221
'1.2.0.3'
222
>>> numToDottedQuad(16909060L)
223
'1.2.3.4'
224
>>> numToDottedQuad(4294967295L)
225
'255.255.255.255'
226
>>> numToDottedQuad(4294967296L)
227
Traceback (most recent call last):
228
ValueError: Not a good numeric IP: 4294967296
229
"""
230
231
# import here to avoid it when ip_addr values are not used
232
import socket, struct
233
234
# no need to intercept here, 4294967295L is fine
235
try:
236
return socket.inet_ntoa(
237
struct.pack('!L', long(num)))
238
except (socket.error, struct.error, OverflowError):
239
raise ValueError('Not a good numeric IP: %s' % num)
240
241
class ValidateError(Exception):
242
"""
243
This error indicates that the check failed.
244
It can be the base class for more specific errors.
245
246
Any check function that fails ought to raise this error.
247
(or a subclass)
248
249
>>> raise ValidateError
250
Traceback (most recent call last):
251
ValidateError
252
"""
253
254
class VdtMissingValue(ValidateError):
255
"""No value was supplied to a check that needed one."""
256
257
class VdtUnknownCheckError(ValidateError):
258
"""An unknown check function was requested"""
259
260
def __init__(self, value):
261
"""
262
>>> raise VdtUnknownCheckError('yoda')
263
Traceback (most recent call last):
264
VdtUnknownCheckError: the check "yoda" is unknown.
265
"""
266
ValidateError.__init__(
267
self,
268
'the check "%s" is unknown.' % value)
269
270
class VdtParamError(SyntaxError):
271
"""An incorrect parameter was passed"""
272
273
def __init__(self, name, value):
274
"""
275
>>> raise VdtParamError('yoda', 'jedi')
276
Traceback (most recent call last):
277
VdtParamError: passed an incorrect value "jedi" for parameter "yoda".
278
"""
279
SyntaxError.__init__(
280
self,
281
'passed an incorrect value "%s" for parameter "%s".' % (
282
value, name))
283
284
class VdtTypeError(ValidateError):
285
"""The value supplied was of the wrong type"""
286
287
def __init__(self, value):
288
"""
289
>>> raise VdtTypeError('jedi')
290
Traceback (most recent call last):
291
VdtTypeError: the value "jedi" is of the wrong type.
292
"""
293
ValidateError.__init__(
294
self,
295
'the value "%s" is of the wrong type.' % value)
296
297
class VdtValueError(ValidateError):
298
"""
299
The value supplied was of the correct type, but was not an allowed value.
300
"""
301
302
def __init__(self, value):
303
"""
304
>>> raise VdtValueError('jedi')
305
Traceback (most recent call last):
306
VdtValueError: the value "jedi" is unacceptable.
307
"""
308
ValidateError.__init__(
309
self,
310
'the value "%s" is unacceptable.' % value)
311
312
class VdtValueTooSmallError(VdtValueError):
313
"""The value supplied was of the correct type, but was too small."""
314
315
def __init__(self, value):
316
"""
317
>>> raise VdtValueTooSmallError('0')
318
Traceback (most recent call last):
319
VdtValueTooSmallError: the value "0" is too small.
320
"""
321
ValidateError.__init__(
322
self,
323
'the value "%s" is too small.' % value)
324
325
class VdtValueTooBigError(VdtValueError):
326
"""The value supplied was of the correct type, but was too big."""
327
328
def __init__(self, value):
329
"""
330
>>> raise VdtValueTooBigError('1')
331
Traceback (most recent call last):
332
VdtValueTooBigError: the value "1" is too big.
333
"""
334
ValidateError.__init__(
335
self,
336
'the value "%s" is too big.' % value)
337
338
class VdtValueTooShortError(VdtValueError):
339
"""The value supplied was of the correct type, but was too short."""
340
341
def __init__(self, value):
342
"""
343
>>> raise VdtValueTooShortError('jed')
344
Traceback (most recent call last):
345
VdtValueTooShortError: the value "jed" is too short.
346
"""
347
ValidateError.__init__(
348
self,
349
'the value "%s" is too short.' % (value,))
350
351
class VdtValueTooLongError(VdtValueError):
352
"""The value supplied was of the correct type, but was too long."""
353
354
def __init__(self, value):
355
"""
356
>>> raise VdtValueTooLongError('jedie')
357
Traceback (most recent call last):
358
VdtValueTooLongError: the value "jedie" is too long.
359
"""
360
ValidateError.__init__(
361
self,
362
'the value "%s" is too long.' % (value,))
363
364
class Validator(object):
365
"""
366
Validator is an object that allows you to register a set of 'checks'.
367
These checks take input and test that it conforms to the check.
368
369
This can also involve converting the value from a string into
370
the correct datatype.
371
372
The ``check`` method takes an input string which configures which
373
check is to be used and applies that check to a supplied value.
374
375
An example input string would be:
376
'int_range(param1, param2)'
377
378
You would then provide something like:
379
380
>>> def int_range_check(value, min, max):
381
... # turn min and max from strings to integers
382
... min = int(min)
383
... max = int(max)
384
... # check that value is of the correct type.
385
... # possible valid inputs are integers or strings
386
... # that represent integers
387
... if not isinstance(value, (int, long, StringTypes)):
388
... raise VdtTypeError(value)
389
... elif isinstance(value, StringTypes):
390
... # if we are given a string
391
... # attempt to convert to an integer
392
... try:
393
... value = int(value)
394
... except ValueError:
395
... raise VdtValueError(value)
396
... # check the value is between our constraints
397
... if not min <= value:
398
... raise VdtValueTooSmallError(value)
399
... if not value <= max:
400
... raise VdtValueTooBigError(value)
401
... return value
402
403
>>> fdict = {'int_range': int_range_check}
404
>>> vtr1 = Validator(fdict)
405
>>> vtr1.check('int_range(20, 40)', '30')
406
30
407
>>> vtr1.check('int_range(20, 40)', '60')
408
Traceback (most recent call last):
409
VdtValueTooBigError: the value "60" is too big.
410
411
New functions can be added with : ::
412
413
>>> vtr2 = Validator()
414
>>> vtr2.functions['int_range'] = int_range_check
415
416
Or by passing in a dictionary of functions when Validator
417
is instantiated.
418
419
Your functions *can* use keyword arguments,
420
but the first argument should always be 'value'.
421
422
If the function doesn't take additional arguments,
423
the parentheses are optional in the check.
424
It can be written with either of : ::
425
426
keyword = function_name
427
keyword = function_name()
428
429
The first program to utilise Validator() was Michael Foord's
430
ConfigObj, an alternative to ConfigParser which supports lists and
431
can validate a config file using a config schema.
432
For more details on using Validator with ConfigObj see:
433
http://www.voidspace.org.uk/python/configobj.html
434
"""
435
436
# this regex pulls values out of a comma separated line
437
_paramfinder = re.compile(r'''(?:'.*?')|(?:".*?")|(?:[^'",\s][^,]*)''')
438
# this regex is used for finding keyword arguments
439
_key_arg = re.compile(r'^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$')
440
# this regex does the initial parsing of the checks
441
_func_re = re.compile(r'(.+?)\((.*)\)')
442
443
def __init__(self, functions=None):
444
"""
445
>>> vtri = Validator()
446
"""
447
self.functions = {
448
'': self._pass,
449
'integer': is_integer,
450
'float': is_float,
451
'boolean': is_bool,
452
'ip_addr': is_ip_addr,
453
'string': is_string,
454
'list': is_list,
455
'int_list': is_int_list,
456
'float_list': is_float_list,
457
'bool_list': is_bool_list,
458
'ip_addr_list': is_ip_addr_list,
459
'string_list': is_string_list,
460
'mixed_list': is_mixed_list,
461
'pass': self._pass,
462
'option': is_option,
463
}
464
if functions is not None:
465
self.functions.update(functions)
466
# tekNico: for use by ConfigObj
467
self.baseErrorClass = ValidateError
468
469
def check(self, check, value, missing=False):
470
"""
471
Usage: check(check, value)
472
473
Arguments:
474
check: string representing check to apply (including arguments)
475
value: object to be checked
476
Returns value, converted to correct type if necessary
477
478
If the check fails, raises a ``ValidateError`` subclass.
479
480
>>> vtor.check('yoda', '')
481
Traceback (most recent call last):
482
VdtUnknownCheckError: the check "yoda" is unknown.
483
>>> vtor.check('yoda()', '')
484
Traceback (most recent call last):
485
VdtUnknownCheckError: the check "yoda" is unknown.
486
"""
487
fun_match = self._func_re.match(check)
488
if fun_match:
489
fun_name = fun_match.group(1)
490
fun_args = []
491
fun_kwargs = {}
492
# pull out args of group 2
493
for arg in self._paramfinder.findall(fun_match.group(2)):
494
# args may need whitespace removing (before removing quotes)
495
arg = arg.strip()
496
keymatch = self._key_arg.match(arg)
497
if keymatch:
498
val = keymatch.group(2)
499
if (val[0] in ("'", '"')) and (val[0] == val[-1]):
500
val = val[1:-1]
501
fun_kwargs[keymatch.group(1)] = val
502
continue
503
#
504
if (arg[0] in ("'", '"')) and (arg[0] == arg[-1]):
505
arg = arg[1:-1]
506
fun_args.append(arg)
507
else:
508
# allows for function names without (args)
509
(fun_name, fun_args, fun_kwargs) = (check, (), {})
510
#
511
if missing:
512
try:
513
value = fun_kwargs['default']
514
except KeyError:
515
raise VdtMissingValue
516
if value == 'None':
517
value = None
518
if value is None:
519
return None
520
# tekNico: default must be deleted if the value is specified too,
521
# otherwise the check function will get a spurious "default" keyword arg
522
try:
523
del fun_kwargs['default']
524
except KeyError:
525
pass
526
try:
527
return self.functions[fun_name](value, *fun_args, **fun_kwargs)
528
except KeyError:
529
raise VdtUnknownCheckError(fun_name)
530
531
def _pass(self, value):
532
"""
533
Dummy check that always passes
534
535
>>> vtor.check('', 0)
536
0
537
>>> vtor.check('', '0')
538
'0'
539
"""
540
return value
541
542
543
def _is_num_param(names, values, to_float=False):
544
"""
545
Return numbers from inputs or raise VdtParamError.
546
547
Lets ``None`` pass through.
548
Pass in keyword argument ``to_float=True`` to
549
use float for the conversion rather than int.
550
551
>>> _is_num_param(('', ''), (0, 1.0))
552
[0, 1]
553
>>> _is_num_param(('', ''), (0, 1.0), to_float=True)
554
[0.0, 1.0]
555
>>> _is_num_param(('a'), ('a'))
556
Traceback (most recent call last):
557
VdtParamError: passed an incorrect value "a" for parameter "a".
558
"""
559
fun = to_float and float or int
560
out_params = []
561
for (name, val) in zip(names, values):
562
if val is None:
563
out_params.append(val)
564
elif isinstance(val, (int, long, float, StringTypes)):
565
try:
566
out_params.append(fun(val))
567
except ValueError, e:
568
raise VdtParamError(name, val)
569
else:
570
raise VdtParamError(name, val)
571
return out_params
572
573
# built in checks
574
# you can override these by setting the appropriate name
575
# in Validator.functions
576
# note: if the params are specified wrongly in your input string,
577
# you will also raise errors.
578
579
def is_integer(value, min=None, max=None):
580
"""
581
A check that tests that a given value is an integer (int, or long)
582
and optionally, between bounds. A negative value is accepted, while
583
a float will fail.
584
585
If the value is a string, then the conversion is done - if possible.
586
Otherwise a VdtError is raised.
587
588
>>> vtor.check('integer', '-1')
589
-1
590
>>> vtor.check('integer', '0')
591
0
592
>>> vtor.check('integer', 9)
593
9
594
>>> vtor.check('integer', 'a')
595
Traceback (most recent call last):
596
VdtTypeError: the value "a" is of the wrong type.
597
>>> vtor.check('integer', '2.2')
598
Traceback (most recent call last):
599
VdtTypeError: the value "2.2" is of the wrong type.
600
>>> vtor.check('integer(10)', '20')
601
20
602
>>> vtor.check('integer(max=20)', '15')
603
15
604
>>> vtor.check('integer(10)', '9')
605
Traceback (most recent call last):
606
VdtValueTooSmallError: the value "9" is too small.
607
>>> vtor.check('integer(10)', 9)
608
Traceback (most recent call last):
609
VdtValueTooSmallError: the value "9" is too small.
610
>>> vtor.check('integer(max=20)', '35')
611
Traceback (most recent call last):
612
VdtValueTooBigError: the value "35" is too big.
613
>>> vtor.check('integer(max=20)', 35)
614
Traceback (most recent call last):
615
VdtValueTooBigError: the value "35" is too big.
616
>>> vtor.check('integer(0, 9)', False)
617
0
618
"""
619
# print value, type(value)
620
(min_val, max_val) = _is_num_param(('min', 'max'), (min, max))
621
if not isinstance(value, (int, long, StringTypes)):
622
raise VdtTypeError(value)
623
if isinstance(value, StringTypes):
624
# if it's a string - does it represent an integer ?
625
try:
626
value = int(value)
627
except ValueError:
628
raise VdtTypeError(value)
629
if (min_val is not None) and (value < min_val):
630
raise VdtValueTooSmallError(value)
631
if (max_val is not None) and (value > max_val):
632
raise VdtValueTooBigError(value)
633
return value
634
635
def is_float(value, min=None, max=None):
636
"""
637
A check that tests that a given value is a float
638
(an integer will be accepted), and optionally - that it is between bounds.
639
640
If the value is a string, then the conversion is done - if possible.
641
Otherwise a VdtError is raised.
642
643
This can accept negative values.
644
645
>>> vtor.check('float', '2')
646
2.0
647
648
From now on we multiply the value to avoid comparing decimals
649
650
>>> vtor.check('float', '-6.8') * 10
651
-68.0
652
>>> vtor.check('float', '12.2') * 10
653
122.0
654
>>> vtor.check('float', 8.4) * 10
655
84.0
656
>>> vtor.check('float', 'a')
657
Traceback (most recent call last):
658
VdtTypeError: the value "a" is of the wrong type.
659
>>> vtor.check('float(10.1)', '10.2') * 10
660
102.0
661
>>> vtor.check('float(max=20.2)', '15.1') * 10
662
151.0
663
>>> vtor.check('float(10.0)', '9.0')
664
Traceback (most recent call last):
665
VdtValueTooSmallError: the value "9.0" is too small.
666
>>> vtor.check('float(max=20.0)', '35.0')
667
Traceback (most recent call last):
668
VdtValueTooBigError: the value "35.0" is too big.
669
"""
670
(min_val, max_val) = _is_num_param(
671
('min', 'max'), (min, max), to_float=True)
672
if not isinstance(value, (int, long, float, StringTypes)):
673
raise VdtTypeError(value)
674
if not isinstance(value, float):
675
# if it's a string - does it represent a float ?
676
try:
677
value = float(value)
678
except ValueError:
679
raise VdtTypeError(value)
680
if (min_val is not None) and (value < min_val):
681
raise VdtValueTooSmallError(value)
682
if (max_val is not None) and (value > max_val):
683
raise VdtValueTooBigError(value)
684
return value
685
686
bool_dict = {
687
True: True, 'on': True, '1': True, 'true': True, 'yes': True,
688
False: False, 'off': False, '0': False, 'false': False, 'no': False,
689
}
690
691
def is_bool(value):
692
"""
693
Check if the value represents a boolean.
694
695
>>> vtor.check('boolean', 0)
696
0
697
>>> vtor.check('boolean', False)
698
0
699
>>> vtor.check('boolean', '0')
700
0
701
>>> vtor.check('boolean', 'off')
702
0
703
>>> vtor.check('boolean', 'false')
704
0
705
>>> vtor.check('boolean', 'no')
706
0
707
>>> vtor.check('boolean', 'nO')
708
0
709
>>> vtor.check('boolean', 'NO')
710
0
711
>>> vtor.check('boolean', 1)
712
1
713
>>> vtor.check('boolean', True)
714
1
715
>>> vtor.check('boolean', '1')
716
1
717
>>> vtor.check('boolean', 'on')
718
1
719
>>> vtor.check('boolean', 'true')
720
1
721
>>> vtor.check('boolean', 'yes')
722
1
723
>>> vtor.check('boolean', 'Yes')
724
1
725
>>> vtor.check('boolean', 'YES')
726
1
727
>>> vtor.check('boolean', '')
728
Traceback (most recent call last):
729
VdtTypeError: the value "" is of the wrong type.
730
>>> vtor.check('boolean', 'up')
731
Traceback (most recent call last):
732
VdtTypeError: the value "up" is of the wrong type.
733
734
"""
735
if isinstance(value, StringTypes):
736
try:
737
return bool_dict[value.lower()]
738
except KeyError:
739
raise VdtTypeError(value)
740
# we do an equality test rather than an identity test
741
# this ensures Python 2.2 compatibilty
742
# and allows 0 and 1 to represent True and False
743
if value == False:
744
return False
745
elif value == True:
746
return True
747
else:
748
raise VdtTypeError(value)
749
750
751
def is_ip_addr(value):
752
"""
753
Check that the supplied value is an Internet Protocol address, v.4,
754
represented by a dotted-quad string, i.e. '1.2.3.4'.
755
756
>>> vtor.check('ip_addr', '1 ')
757
'1'
758
>>> vtor.check('ip_addr', ' 1.2')
759
'1.2'
760
>>> vtor.check('ip_addr', ' 1.2.3 ')
761
'1.2.3'
762
>>> vtor.check('ip_addr', '1.2.3.4')
763
'1.2.3.4'
764
>>> vtor.check('ip_addr', '0.0.0.0')
765
'0.0.0.0'
766
>>> vtor.check('ip_addr', '255.255.255.255')
767
'255.255.255.255'
768
>>> vtor.check('ip_addr', '255.255.255.256')
769
Traceback (most recent call last):
770
VdtValueError: the value "255.255.255.256" is unacceptable.
771
>>> vtor.check('ip_addr', '1.2.3.4.5')
772
Traceback (most recent call last):
773
VdtValueError: the value "1.2.3.4.5" is unacceptable.
774
>>> vtor.check('ip_addr', '1.2.3. 4')
775
Traceback (most recent call last):
776
VdtValueError: the value "1.2.3. 4" is unacceptable.
777
>>> vtor.check('ip_addr', 0)
778
Traceback (most recent call last):
779
VdtTypeError: the value "0" is of the wrong type.
780
"""
781
if not isinstance(value, StringTypes):
782
raise VdtTypeError(value)
783
value = value.strip()
784
try:
785
dottedQuadToNum(value)
786
except ValueError:
787
raise VdtValueError(value)
788
return value
789
790
def is_list(value, min=None, max=None):
791
"""
792
Check that the value is a list of values.
793
794
You can optionally specify the minimum and maximum number of members.
795
796
It does no check on list members.
797
798
>>> vtor.check('list', ())
799
()
800
>>> vtor.check('list', [])
801
[]
802
>>> vtor.check('list', (1, 2))
803
(1, 2)
804
>>> vtor.check('list', [1, 2])
805
[1, 2]
806
>>> vtor.check('list', '12')
807
'12'
808
>>> vtor.check('list(3)', (1, 2))
809
Traceback (most recent call last):
810
VdtValueTooShortError: the value "(1, 2)" is too short.
811
>>> vtor.check('list(max=5)', (1, 2, 3, 4, 5, 6))
812
Traceback (most recent call last):
813
VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long.
814
>>> vtor.check('list(min=3, max=5)', (1, 2, 3, 4))
815
(1, 2, 3, 4)
816
>>> vtor.check('list', 0)
817
Traceback (most recent call last):
818
VdtTypeError: the value "0" is of the wrong type.
819
"""
820
(min_len, max_len) = _is_num_param(('min', 'max'), (min, max))
821
try:
822
num_members = len(value)
823
except TypeError:
824
raise VdtTypeError(value)
825
if min_len is not None and num_members < min_len:
826
raise VdtValueTooShortError(value)
827
if max_len is not None and num_members > max_len:
828
raise VdtValueTooLongError(value)
829
return value
830
831
def is_string(value, min=None, max=None):
832
"""
833
Check that the supplied value is a string.
834
835
You can optionally specify the minimum and maximum number of members.
836
837
>>> vtor.check('string', '0')
838
'0'
839
>>> vtor.check('string', 0)
840
Traceback (most recent call last):
841
VdtTypeError: the value "0" is of the wrong type.
842
>>> vtor.check('string(2)', '12')
843
'12'
844
>>> vtor.check('string(2)', '1')
845
Traceback (most recent call last):
846
VdtValueTooShortError: the value "1" is too short.
847
>>> vtor.check('string(min=2, max=3)', '123')
848
'123'
849
>>> vtor.check('string(min=2, max=3)', '1234')
850
Traceback (most recent call last):
851
VdtValueTooLongError: the value "1234" is too long.
852
"""
853
if not isinstance(value, StringTypes):
854
raise VdtTypeError(value)
855
return is_list(value, min, max)
856
857
def is_int_list(value, min=None, max=None):
858
"""
859
Check that the value is a list of integers.
860
861
You can optionally specify the minimum and maximum number of members.
862
863
Each list member is checked that it is an integer.
864
865
>>> vtor.check('int_list', ())
866
[]
867
>>> vtor.check('int_list', [])
868
[]
869
>>> vtor.check('int_list', (1, 2))
870
[1, 2]
871
>>> vtor.check('int_list', [1, 2])
872
[1, 2]
873
>>> vtor.check('int_list', [1, 'a'])
874
Traceback (most recent call last):
875
VdtTypeError: the value "a" is of the wrong type.
876
"""
877
return [is_integer(mem) for mem in is_list(value, min, max)]
878
879
def is_bool_list(value, min=None, max=None):
880
"""
881
Check that the value is a list of booleans.
882
883
You can optionally specify the minimum and maximum number of members.
884
885
Each list member is checked that it is a boolean.
886
887
>>> vtor.check('bool_list', ())
888
[]
889
>>> vtor.check('bool_list', [])
890
[]
891
>>> check_res = vtor.check('bool_list', (True, False))
892
>>> check_res == [True, False]
893
1
894
>>> check_res = vtor.check('bool_list', [True, False])
895
>>> check_res == [True, False]
896
1
897
>>> vtor.check('bool_list', [True, 'a'])
898
Traceback (most recent call last):
899
VdtTypeError: the value "a" is of the wrong type.
900
"""
901
return [is_bool(mem) for mem in is_list(value, min, max)]
902
903
def is_float_list(value, min=None, max=None):
904
"""
905
Check that the value is a list of floats.
906
907
You can optionally specify the minimum and maximum number of members.
908
909
Each list member is checked that it is a float.
910
911
>>> vtor.check('float_list', ())
912
[]
913
>>> vtor.check('float_list', [])
914
[]
915
>>> vtor.check('float_list', (1, 2.0))
916
[1.0, 2.0]
917
>>> vtor.check('float_list', [1, 2.0])
918
[1.0, 2.0]
919
>>> vtor.check('float_list', [1, 'a'])
920
Traceback (most recent call last):
921
VdtTypeError: the value "a" is of the wrong type.
922
"""
923
return [is_float(mem) for mem in is_list(value, min, max)]
924
925
def is_string_list(value, min=None, max=None):
926
"""
927
Check that the value is a list of strings.
928
929
You can optionally specify the minimum and maximum number of members.
930
931
Each list member is checked that it is a string.
932
933
>>> vtor.check('string_list', ())
934
[]
935
>>> vtor.check('string_list', [])
936
[]
937
>>> vtor.check('string_list', ('a', 'b'))
938
['a', 'b']
939
>>> vtor.check('string_list', ['a', 1])
940
Traceback (most recent call last):
941
VdtTypeError: the value "1" is of the wrong type.
942
"""
943
return [is_string(mem) for mem in is_list(value, min, max)]
944
945
def is_ip_addr_list(value, min=None, max=None):
946
"""
947
Check that the value is a list of IP addresses.
948
949
You can optionally specify the minimum and maximum number of members.
950
951
Each list member is checked that it is an IP address.
952
953
>>> vtor.check('ip_addr_list', ())
954
[]
955
>>> vtor.check('ip_addr_list', [])
956
[]
957
>>> vtor.check('ip_addr_list', ('1.2.3.4', '5.6.7.8'))
958
['1.2.3.4', '5.6.7.8']
959
>>> vtor.check('ip_addr_list', ['a'])
960
Traceback (most recent call last):
961
VdtValueError: the value "a" is unacceptable.
962
"""
963
return [is_ip_addr(mem) for mem in is_list(value, min, max)]
964
965
fun_dict = {
966
'integer': is_integer,
967
'float': is_float,
968
'ip_addr': is_ip_addr,
969
'string': is_string,
970
'boolean': is_bool,
971
}
972
973
def is_mixed_list(value, *args):
974
"""
975
Check that the value is a list.
976
Allow specifying the type of each member.
977
Work on lists of specific lengths.
978
979
You specify each member as a positional argument specifying type
980
981
Each type should be one of the following strings :
982
'integer', 'float', 'ip_addr', 'string', 'boolean'
983
984
So you can specify a list of two strings, followed by
985
two integers as :
986
987
mixed_list('string', 'string', 'integer', 'integer')
988
989
The length of the list must match the number of positional
990
arguments you supply.
991
992
>>> mix_str = "mixed_list('integer', 'float', 'ip_addr', 'string', 'boolean')"
993
>>> check_res = vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', True))
994
>>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
995
1
996
>>> check_res = vtor.check(mix_str, ('1', '2.0', '1.2.3.4', 'a', 'True'))
997
>>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
998
1
999
>>> vtor.check(mix_str, ('b', 2.0, '1.2.3.4', 'a', True))
1000
Traceback (most recent call last):
1001
VdtTypeError: the value "b" is of the wrong type.
1002
>>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a'))
1003
Traceback (most recent call last):
1004
VdtValueTooShortError: the value "(1, 2.0, '1.2.3.4', 'a')" is too short.
1005
>>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', 1, 'b'))
1006
Traceback (most recent call last):
1007
VdtValueTooLongError: the value "(1, 2.0, '1.2.3.4', 'a', 1, 'b')" is too long.
1008
>>> vtor.check(mix_str, 0)
1009
Traceback (most recent call last):
1010
VdtTypeError: the value "0" is of the wrong type.
1011
1012
This test requires an elaborate setup, because of a change in error string
1013
output from the interpreter between Python 2.2 and 2.3 .
1014
1015
>>> res_seq = (
1016
... 'passed an incorrect value "',
1017
... 'yoda',
1018
... '" for parameter "mixed_list".',
1019
... )
1020
>>> if INTP_VER == (2, 2):
1021
... res_str = "".join(res_seq)
1022
... else:
1023
... res_str = "'".join(res_seq)
1024
>>> try:
1025
... vtor.check('mixed_list("yoda")', ('a'))
1026
... except VdtParamError, err:
1027
... str(err) == res_str
1028
1
1029
"""
1030
try:
1031
length = len(value)
1032
except TypeError:
1033
raise VdtTypeError(value)
1034
if length < len(args):
1035
raise VdtValueTooShortError(value)
1036
elif length > len(args):
1037
raise VdtValueTooLongError(value)
1038
try:
1039
return [fun_dict[arg](val) for arg, val in zip(args, value)]
1040
except KeyError, e:
1041
raise VdtParamError('mixed_list', e)
1042
1043
def is_option(value, *options):
1044
"""
1045
This check matches the value to any of a set of options.
1046
1047
>>> vtor.check('option("yoda", "jedi")', 'yoda')
1048
'yoda'
1049
>>> vtor.check('option("yoda", "jedi")', 'jed')
1050
Traceback (most recent call last):
1051
VdtValueError: the value "jed" is unacceptable.
1052
>>> vtor.check('option("yoda", "jedi")', 0)
1053
Traceback (most recent call last):
1054
VdtTypeError: the value "0" is of the wrong type.
1055
"""
1056
if not isinstance(value, StringTypes):
1057
raise VdtTypeError(value)
1058
if not value in options:
1059
raise VdtValueError(value)
1060
return value
1061
1062
if __name__ == '__main__':
1063
# run the code tests in doctest format
1064
import doctest
1065
m = sys.modules.get('__main__')
1066
globs = m.__dict__.copy()
1067
globs.update({
1068
'INTP_VER': INTP_VER,
1069
'vtor': Validator(),
1070
})
1071
doctest.testmod(m, globs=globs)
1072
1073
"""
1074
TODO
1075
====
1076
1077
Consider which parts of the regex stuff to put back in
1078
1079
Can we implement a timestamp datatype ? (check DateUtil module)
1080
1081
ISSUES
1082
======
1083
1084
Lists passed as function arguments need additional quotes. Ugly, could do
1085
with fixing this.
1086
1087
If we could pull tuples out of arguments, it would be easier
1088
to specify arguments for 'mixed_lists'.
1089
1090
CHANGELOG
1091
=========
1092
1093
2005/08/25
1094
----------
1095
1096
Most errors now prefixed ``Vdt``
1097
1098
``VdtParamError`` no longer derives from ``VdtError``
1099
1100
Finalised as version 0.2.0
1101
1102
2005/08/21
1103
----------
1104
1105
By Nicola Larosa
1106
1107
Removed the "length" argument for lists and strings, and related tests
1108
1109
2005/08/16
1110
----------
1111
1112
By Nicola Larosa
1113
1114
Deleted the "none" and "multiple" types and checks
1115
1116
Added the None value for all types in Validation.check
1117
1118
2005/08/14
1119
----------
1120
1121
By Michael Foord
1122
1123
Removed timestamp.
1124
1125
By Nicola Larosa
1126
1127
Fixed bug in Validator.check: when a value that has a default is also
1128
specified in the config file, the default must be deleted from fun_kwargs
1129
anyway, otherwise the check function will get a spurious "default" keyword
1130
argument
1131
1132
Added "ip_addr_list" check
1133
1134
2005/08/13
1135
----------
1136
1137
By Nicola Larosa
1138
1139
Updated comments at top
1140
1141
2005/08/11
1142
----------
1143
1144
By Nicola Larosa
1145
1146
Added test for interpreter version: raises RuntimeError if earlier than
1147
2.2
1148
1149
Fixed last is_mixed_list test to work on Python 2.2 too
1150
1151
2005/08/10
1152
----------
1153
1154
By Nicola Larosa
1155
1156
Restored Python2.2 compatibility by avoiding usage of dict.pop
1157
1158
2005/08/07
1159
----------
1160
1161
By Nicola Larosa
1162
1163
Adjusted doctests for Python 2.2.3 compatibility, one test still fails
1164
for trivial reasons (string output delimiters)
1165
1166
2005/08/05
1167
----------
1168
1169
By Michael Foord
1170
1171
Added __version__, __all__, and __docformat__
1172
1173
Replaced ``basestring`` with ``types.StringTypes``
1174
1175
2005/07/28
1176
----------
1177
1178
By Nicola Larosa
1179
1180
Reformatted final docstring in ReST format, indented it for easier folding
1181
1182
2005/07/20
1183
----------
1184
1185
By Nicola Larosa
1186
1187
Added an 'ip_addr' IPv4 address value check, with tests
1188
1189
Updated the tests for mixed_list to include IP addresses
1190
1191
Changed all references to value "tests" into value "checks", including
1192
the main Validator method, and all code tests
1193
1194
2005/07/19
1195
----------
1196
1197
By Nicola Larosa
1198
1199
Added even more code tests
1200
1201
Refined the mixed_list check
1202
1203
2005/07/18
1204
----------
1205
1206
By Nicola Larosa
1207
1208
Introduced more VdtValueError subclasses
1209
1210
Collapsed the ``_function_test`` and ``_function_parse`` methods into the
1211
``check`` one
1212
1213
Refined the value checks, using the new VdtValueError subclasses
1214
1215
Changed "is_string" to use "is_list"
1216
1217
Added many more code tests
1218
1219
Changed the "bool" value type to "boolean"
1220
1221
Some more code cleanup
1222
1223
2005/07/17
1224
----------
1225
1226
By Nicola Larosa
1227
1228
Code tests converted to doctest format and placed in the respective
1229
docstrings, so they are automatically checked, and easier to update
1230
1231
Changed local vars "min" and "max" to "min_len", "max_len", "min_val" and
1232
"max_val", to avoid shadowing the builtin functions (but left function
1233
parameters alone)
1234
1235
Uniformed value check function names to is_* convention
1236
1237
``date`` type name changed to ``timestamp``
1238
1239
Avoided some code duplication in list check functions
1240
1241
Some more code cleanup
1242
1243
2005/07/09
1244
----------
1245
1246
Recoded the standard functions
1247
1248
2005/07/08
1249
----------
1250
1251
Improved paramfinder regex
1252
1253
Ripped out all the regex stuff, checks, and the example functions
1254
(to be replaced !)
1255
1256
2005/07/06
1257
----------
1258
1259
By Nicola Larosa
1260
1261
Code cleanup
1262
"""
1263
Loggerhead is a web-based interface for Breezy
Version: 2.0.1