← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/util/configobj/validate.py

[merge] jam-integration

Show diffs side-by-side

added added

removed removed

Lines of Context:
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