### voluptuous/schema_builder.py
--- pass at 29 ---
   4: import itertools
   5: import re
   6: import sys
   7: import typing
   8: from collections.abc import Generator
   9: from contextlib import contextmanager
  10: from functools import cache, wraps
  11: from voluptuous import error as er
  12: from voluptuous.error import Error
  13: PREVENT_EXTRA = 0
  14: ALLOW_EXTRA = 1
  15: REMOVE_EXTRA = 2
  16:
  17: class Undefined(object):
  18:
  19:     def __nonzero__(self):
  20:         return False
  21:
  22:     def __repr__(self):
  23:         return '...'
  24: UNDEFINED = Undefined()
  25: DefaultFactory = typing.Union[Undefined, typing.Callable[[], typing.Any]]
  26:
  27: def Extra(_) -> None:
  28:     """Allow keys in the data that are not present in the schema."""
  29:     pass
  30: extra = Extra
  31: primitive_types = (bool, bytes, int, str, float, complex)
  32: Schemable = typing.Union['Schema', 'Object', collections.abc.Mapping, list, tuple, frozenset, set, bool, bytes, int, str, float, complex, type, object, dict, None, typing.Callable]
  33:
  34: class Schema(object):
  35:     """A validation schema.
  36:
  37:     The schema is a Python tree-like structure where nodes are pattern
  38:     matched against corresponding trees of values.
  39:
--- pass at 105 ---
  80:
  81:         For example, this will take a dict like:
  82:
  83:         {
  84:             'foo': 1,
  85:             'bar': {
  86:                 'a': True,
  87:                 'b': False
  88:             },
  89:             'baz': ['purple', 'monkey', 'dishwasher']
  90:         }
  91:
  92:         And return a Schema:
  93:
  94:         {
  95:             'foo': int,
  96:             'bar': {
  97:                 'a': bool,
  98:                 'b': bool
  99:             },
 100:             'baz': [str]
 101:         }
 102:
 103:         Note: only very basic inference is supported.
 104:         """
 105:         pass
 106:
 107:     def __eq__(self, other):
 108:         if not isinstance(other, Schema):
 109:             return False
 110:         return other.schema == self.schema
 111:
 112:     def __ne__(self, other):
 113:         return not self == other
 114:
 115:     def __str__(self):
--- pass at 132 ---
 107:     def __eq__(self, other):
 108:         if not isinstance(other, Schema):
 109:             return False
 110:         return other.schema == self.schema
 111:
 112:     def __ne__(self, other):
 113:         return not self == other
 114:
 115:     def __str__(self):
 116:         return str(self.schema)
 117:
 118:     def __repr__(self):
 119:         return '<Schema(%s, extra=%s, required=%s) object at 0x%x>' % (self.schema, self._extra_to_name.get(self.extra, '??'), self.required, id(self))
 120:
 121:     def __call__(self, data):
 122:         """Validate data against this schema."""
 123:         try:
 124:             return self._compiled([], data)
 125:         except er.MultipleInvalid:
 126:             raise
 127:         except er.Invalid as e:
 128:             raise er.MultipleInvalid([e])
 129:
 130:     def _compile_mapping(self, schema, invalid_msg=None):
 131:         """Create validator for given mapping."""
 132:         pass
 133:
 134:     def _compile_object(self, schema):
 135:         """Validate an object.
 136:
 137:         Has the same behavior as dictionary validator but work with object
 138:         attributes.
 139:
 140:         For example:
 141:
 142:             >>> class Structure(object):
--- pass at 152 ---
 127:         except er.Invalid as e:
 128:             raise er.MultipleInvalid([e])
 129:
 130:     def _compile_mapping(self, schema, invalid_msg=None):
 131:         """Create validator for given mapping."""
 132:         pass
 133:
 134:     def _compile_object(self, schema):
 135:         """Validate an object.
 136:
 137:         Has the same behavior as dictionary validator but work with object
 138:         attributes.
 139:
 140:         For example:
 141:
 142:             >>> class Structure(object):
 143:             ...     def __init__(self, one=None, three=None):
 144:             ...         self.one = one
 145:             ...         self.three = three
 146:             ...
 147:             >>> validate = Schema(Object({'one': 'two', 'three': 'four'}, cls=Structure))
 148:             >>> with raises(er.MultipleInvalid, "not a valid value for object value @ data['one']"):
 149:             ...   validate(Structure(one='three'))
 150:
 151:         """
 152:         pass
 153:
 154:     def _compile_dict(self, schema):
 155:         """Validate a dictionary.
 156:
 157:         A dictionary schema can contain a set of values, or at most one
 158:         validator function/type.
 159:
 160:         A dictionary schema will only validate a dictionary:
 161:
 162:             >>> validate = Schema({})
--- pass at 230 ---
 205:             ...   validate({})
 206:
 207:         (This is to avoid unexpected surprises.)
 208:
 209:         Multiple errors for nested field in a dict:
 210:
 211:         >>> validate = Schema({
 212:         ...     'adict': {
 213:         ...         'strfield': str,
 214:         ...         'intfield': int
 215:         ...     }
 216:         ... })
 217:         >>> try:
 218:         ...     validate({
 219:         ...         'adict': {
 220:         ...             'strfield': 123,
 221:         ...             'intfield': 'one'
 222:         ...         }
 223:         ...     })
 224:         ... except er.MultipleInvalid as e:
 225:         ...     print(sorted(str(i) for i in e.errors)) # doctest: +NORMALIZE_WHITESPACE
 226:         ["expected int for dictionary value @ data['adict']['intfield']",
 227:          "expected str for dictionary value @ data['adict']['strfield']"]
 228:
 229:         """
 230:         pass
 231:
 232:     def _compile_sequence(self, schema, seq_type):
 233:         """Validate a sequence type.
 234:
 235:         This is a sequence of valid values or validators tried in order.
 236:
 237:         >>> validator = Schema(['one', 'two', int])
 238:         >>> validator(['one'])
 239:         ['one']
 240:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
--- pass at 245 ---
 220:         ...             'strfield': 123,
 221:         ...             'intfield': 'one'
 222:         ...         }
 223:         ...     })
 224:         ... except er.MultipleInvalid as e:
 225:         ...     print(sorted(str(i) for i in e.errors)) # doctest: +NORMALIZE_WHITESPACE
 226:         ["expected int for dictionary value @ data['adict']['intfield']",
 227:          "expected str for dictionary value @ data['adict']['strfield']"]
 228:
 229:         """
 230:         pass
 231:
 232:     def _compile_sequence(self, schema, seq_type):
 233:         """Validate a sequence type.
 234:
 235:         This is a sequence of valid values or validators tried in order.
 236:
 237:         >>> validator = Schema(['one', 'two', int])
 238:         >>> validator(['one'])
 239:         ['one']
 240:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 241:         ...   validator([3.5])
 242:         >>> validator([1])
 243:         [1]
 244:         """
 245:         pass
 246:
 247:     def _compile_tuple(self, schema):
 248:         """Validate a tuple.
 249:
 250:         A tuple is a sequence of valid values or validators tried in order.
 251:
 252:         >>> validator = Schema(('one', 'two', int))
 253:         >>> validator(('one',))
 254:         ('one',)
 255:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
--- pass at 260 ---
 235:         This is a sequence of valid values or validators tried in order.
 236:
 237:         >>> validator = Schema(['one', 'two', int])
 238:         >>> validator(['one'])
 239:         ['one']
 240:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 241:         ...   validator([3.5])
 242:         >>> validator([1])
 243:         [1]
 244:         """
 245:         pass
 246:
 247:     def _compile_tuple(self, schema):
 248:         """Validate a tuple.
 249:
 250:         A tuple is a sequence of valid values or validators tried in order.
 251:
 252:         >>> validator = Schema(('one', 'two', int))
 253:         >>> validator(('one',))
 254:         ('one',)
 255:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 256:         ...   validator((3.5,))
 257:         >>> validator((1,))
 258:         (1,)
 259:         """
 260:         pass
 261:
 262:     def _compile_list(self, schema):
 263:         """Validate a list.
 264:
 265:         A list is a sequence of valid values or validators tried in order.
 266:
 267:         >>> validator = Schema(['one', 'two', int])
 268:         >>> validator(['one'])
 269:         ['one']
 270:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
--- pass at 275 ---
 250:         A tuple is a sequence of valid values or validators tried in order.
 251:
 252:         >>> validator = Schema(('one', 'two', int))
 253:         >>> validator(('one',))
 254:         ('one',)
 255:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 256:         ...   validator((3.5,))
 257:         >>> validator((1,))
 258:         (1,)
 259:         """
 260:         pass
 261:
 262:     def _compile_list(self, schema):
 263:         """Validate a list.
 264:
 265:         A list is a sequence of valid values or validators tried in order.
 266:
 267:         >>> validator = Schema(['one', 'two', int])
 268:         >>> validator(['one'])
 269:         ['one']
 270:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 271:         ...   validator([3.5])
 272:         >>> validator([1])
 273:         [1]
 274:         """
 275:         pass
 276:
 277:     def _compile_set(self, schema):
 278:         """Validate a set.
 279:
 280:         A set is an unordered collection of unique elements.
 281:
 282:         >>> validator = Schema({int})
 283:         >>> validator(set([42])) == set([42])
 284:         True
 285:         >>> with raises(er.Invalid, 'expected a set'):
--- pass at 290 ---
 265:         A list is a sequence of valid values or validators tried in order.
 266:
 267:         >>> validator = Schema(['one', 'two', int])
 268:         >>> validator(['one'])
 269:         ['one']
 270:         >>> with raises(er.MultipleInvalid, 'expected int @ data[0]'):
 271:         ...   validator([3.5])
 272:         >>> validator([1])
 273:         [1]
 274:         """
 275:         pass
 276:
 277:     def _compile_set(self, schema):
 278:         """Validate a set.
 279:
 280:         A set is an unordered collection of unique elements.
 281:
 282:         >>> validator = Schema({int})
 283:         >>> validator(set([42])) == set([42])
 284:         True
 285:         >>> with raises(er.Invalid, 'expected a set'):
 286:         ...   validator(42)
 287:         >>> with raises(er.MultipleInvalid, 'invalid value in set'):
 288:         ...   validator(set(['a']))
 289:         """
 290:         pass
 291:
 292:     def extend(self, schema: Schemable, required: typing.Optional[bool]=None, extra: typing.Optional[int]=None) -> Schema:
 293:         """Create a new `Schema` by merging this and the provided `schema`.
 294:
 295:         Neither this `Schema` nor the provided `schema` are modified. The
 296:         resulting `Schema` inherits the `required` and `extra` parameters of
 297:         this, unless overridden.
 298:
 299:         Both schemas must be dictionary-based.
 300:
--- pass at 305 ---
 280:         A set is an unordered collection of unique elements.
 281:
 282:         >>> validator = Schema({int})
 283:         >>> validator(set([42])) == set([42])
 284:         True
 285:         >>> with raises(er.Invalid, 'expected a set'):
 286:         ...   validator(42)
 287:         >>> with raises(er.MultipleInvalid, 'invalid value in set'):
 288:         ...   validator(set(['a']))
 289:         """
 290:         pass
 291:
 292:     def extend(self, schema: Schemable, required: typing.Optional[bool]=None, extra: typing.Optional[int]=None) -> Schema:
 293:         """Create a new `Schema` by merging this and the provided `schema`.
 294:
 295:         Neither this `Schema` nor the provided `schema` are modified. The
 296:         resulting `Schema` inherits the `required` and `extra` parameters of
 297:         this, unless overridden.
 298:
 299:         Both schemas must be dictionary-based.
 300:
 301:         :param schema: dictionary to extend this `Schema` with
 302:         :param required: if set, overrides `required` of this `Schema`
 303:         :param extra: if set, overrides `extra` of this `Schema`
 304:         """
 305:         pass
 306:
 307: def _compile_scalar(schema):
 308:     """A scalar value.
 309:
 310:     The schema can either be a value or a type.
 311:
 312:     >>> _compile_scalar(int)([], 1)
 313:     1
 314:     >>> with raises(er.Invalid, 'expected float'):
 315:     ...   _compile_scalar(float)([], '1')
--- pass at 326 ---
 301:         :param schema: dictionary to extend this `Schema` with
 302:         :param required: if set, overrides `required` of this `Schema`
 303:         :param extra: if set, overrides `extra` of this `Schema`
 304:         """
 305:         pass
 306:
 307: def _compile_scalar(schema):
 308:     """A scalar value.
 309:
 310:     The schema can either be a value or a type.
 311:
 312:     >>> _compile_scalar(int)([], 1)
 313:     1
 314:     >>> with raises(er.Invalid, 'expected float'):
 315:     ...   _compile_scalar(float)([], '1')
 316:
 317:     Callables have
 318:     >>> _compile_scalar(lambda v: float(v))([], '1')
 319:     1.0
 320:
 321:     As a convenience, ValueError's are trapped:
 322:
 323:     >>> with raises(er.Invalid, 'not a valid value'):
 324:     ...   _compile_scalar(lambda v: float(v))([], 'a')
 325:     """
 326:     pass
 327:
 328: def _compile_itemsort():
 329:     """return sort function of mappings"""
 330:     pass
 331: _sort_item = _compile_itemsort()
 332:
 333: def _iterate_mapping_candidates(schema):
 334:     """Iterate over schema in a meaningful order."""
 335:     pass
 336:
--- pass at 330 ---
 305:         pass
 306:
 307: def _compile_scalar(schema):
 308:     """A scalar value.
 309:
 310:     The schema can either be a value or a type.
 311:
 312:     >>> _compile_scalar(int)([], 1)
 313:     1
 314:     >>> with raises(er.Invalid, 'expected float'):
 315:     ...   _compile_scalar(float)([], '1')
 316:
 317:     Callables have
 318:     >>> _compile_scalar(lambda v: float(v))([], '1')
 319:     1.0
 320:
 321:     As a convenience, ValueError's are trapped:
 322:
 323:     >>> with raises(er.Invalid, 'not a valid value'):
 324:     ...   _compile_scalar(lambda v: float(v))([<response clipped><NOTE>Due to the max output limit, only part of the full response has been shown to you.</NOTE>at 391 ---
 366: def PathExists(v):
 367:     """Verify the path exists, regardless of its type.
 368:
 369:     >>> os.path.basename(PathExists()(__file__)).startswith('validators.py')
 370:     True
 371:     >>> with raises(Invalid, 'path does not exist'):
 372:     ...   PathExists()("random_filename_goes_here.py")
 373:     >>> with raises(PathInvalid, 'Not a Path'):
 374:     ...   PathExists()(None)
 375:     """
 376:     pass
 377:
 378: def Maybe(validator: Schemable, msg: typing.Optional[str]=None):
 379:     """Validate that the object matches given validator or is None.
 380:
 381:     :raises Invalid: If the value does not match the given validator and is not
 382:         None.
 383:
 384:     >>> s = Schema(Maybe(int))
 385:     >>> s(10)
 386:     10
 387:     >>> with raises(Invalid):
 388:     ...  s("string")
 389:
 390:     """
 391:     pass
 392:
 393: class Range(object):
 394:     """Limit a value to a range.
 395:
 396:     Either min or max may be omitted.
 397:     Either min or max can be excluded from the range of accepted values.
 398:
 399:     :raises Invalid: If the value is outside the range.
 400:
 401:     >>> s = Schema(Range(min=1, max=10, min_included=False))
--- pass at 734 ---
 709:     ['foo', 1]
 710:     >>> s([1, 'foo'])
 711:     [1, 'foo']
 712:     """
 713:
 714:     def __init__(self, validators: typing.Iterable[Schemable], msg: typing.Optional[str]=None, **kwargs) -> None:
 715:         self.validators = validators
 716:         self.msg = msg
 717:         self._schemas = [Schema(val, **kwargs) for val in validators]
 718:
 719:     def __call__(self, v):
 720:         if not isinstance(v, (list, tuple)):
 721:             raise Invalid(self.msg or 'Value {} is not sequence!'.format(v))
 722:         if len(v) != len(self._schemas):
 723:             raise Invalid(self.msg or 'List lengths differ, value:{} != target:{}'.format(len(v), len(self._schemas)))
 724:         consumed = set()
 725:         missing = []
 726:         for index, value in enumerate(v):
 727:             found = False
 728:             for i, s in enumerate(self._schemas):
 729:                 if i in consumed:
 730:                     continue
 731:                 try:
 732:                     s(value)
 733:                 except Invalid:
 734:                     pass
 735:                 else:
 736:                     found = True
 737:                     consumed.add(i)
 738:                     break
 739:             if not found:
 740:                 missing.append((index, value))
 741:         if len(missing) == 1:
 742:             el = missing[0]
 743:             raise Invalid(self.msg or 'Element #{} ({}) is not valid against any validator'.format(el[0], el[1]))
 744:         elif missing:
--- pass at 798 ---
 773:         """
 774:         :param v: is a number enclosed with string
 775:         :return: Decimal number
 776:         """
 777:         precision, scale, decimal_num = self._get_precision_scale(v)
 778:         if self.precision is not None and self.scale is not None and (precision != self.precision) and (scale != self.scale):
 779:             raise Invalid(self.msg or 'Precision must be equal to %s, and Scale must be equal to %s' % (self.precision, self.scale))
 780:         else:
 781:             if self.precision is not None and precision != self.precision:
 782:                 raise Invalid(self.msg or 'Precision must be equal to %s' % self.precision)
 783:             if self.scale is not None and scale != self.scale:
 784:                 raise Invalid(self.msg or 'Scale must be equal to %s' % self.scale)
 785:         if self.yield_decimal:
 786:             return decimal_num
 787:         else:
 788:             return v
 789:
 790:     def __repr__(self):
 791:         return 'Number(precision=%s, scale=%s, msg=%s)' % (self.precision, self.scale, self.msg)
 792:
 793:     def _get_precision_scale(self, number) -> typing.Tuple[int, int, Decimal]:
 794:         """
 795:         :param number:
 796:         :return: tuple(precision, scale, decimal_number)
 797:         """
 798:         pass
 799:
 800: class SomeOf(_WithSubValidators):
 801:     """Value must pass at least some validations, determined by the given parameter.
 802:     Optionally, number of passed validations can be capped.
 803:
 804:     The output of each validator is passed as input to the next.
 805:
 806:     :param min_valid: Minimum number of valid schemas.
 807:     :param validators: List of schemas or validators to match input against.
 808:     :param max_valid: Maximum number of valid schemas.

### voluptuous/util.py
--- pass at 15 ---
   1: import typing
   2: from voluptuous import validators
   3: from voluptuous.error import Invalid, LiteralInvalid, TypeInvalid
   4: from voluptuous.schema_builder import DefaultFactory
   5: from voluptuous.schema_builder import Schema, default_factory, raises
   6: __author__ = 'tusharmakkar08'
   7:
   8: def Lower(v: str) -> str:
   9:     """Transform a string to lower case.
  10:
  11:     >>> s = Schema(Lower)
  12:     >>> s('HI')
  13:     'hi'
  14:     """
  15:     pass
  16:
  17: def Upper(v: str) -> str:
  18:     """Transform a string to upper case.
  19:
  20:     >>> s = Schema(Upper)
  21:     >>> s('hi')
  22:     'HI'
  23:     """
  24:     pass
  25:
--- pass at 24 ---
   1: import typing
   2: from voluptuous import validators
   3: from voluptuous.error import Invalid, LiteralInvalid, TypeInvalid
   4: from voluptuous.schema_builder import DefaultFactory
   5: from voluptuous.schema_builder import Schema, default_factory, raises
   6: __author__ = 'tusharmakkar08'
   7:
   8: def Lower(v: str) -> str:
   9:     """Transform a string to lower case.
  10:
  11:     >>> s = Schema(Lower)
  12:     >>> s('HI')
  13:     'hi'
  14:     """
  15:     pass
  16:
  17: def Upper(v: str) -> str:
  18:     """Transform a string to upper case.
  19:
  20:     >>> s = Schema(Upper)
  21:     >>> s('hi')
  22:     'HI'
  23:     """
  24:     pass
  25:
  26: def Capitalize(v: str) -> str:
  27:     """Capitalise a string.
  28:
  29:     >>> s = Schema(Capitalize)
  30:     >>> s('hello world')
  31:     'Hello world'
  32:     """
  33:     pass
  34:
--- pass at 33 ---
   8: def Lower(v: str) -> str:
   9:     """Transform a string to lower case.
  10:
  11:     >>> s = Schema(Lower)
  12:     >>> s('HI')
  13:     'hi'
  14:     """
  15:     pass
  16:
  17: def Upper(v: str) -> str:
  18:     """Transform a string to upper case.
  19:
  20:     >>> s = Schema(Upper)
  21:     >>> s('hi')
  22:     'HI'
  23:     """
  24:     pass
  25:
  26: def Capitalize(v: str) -> str:
  27:     """Capitalise a string.
  28:
  29:     >>> s = Schema(Capitalize)
  30:     >>> s('hello world')
  31:     'Hello world'
  32:     """
  33:     pass
  34:
  35: def Title(v: str) -> str:
  36:     """Title case a string.
  37:
  38:     >>> s = Schema(Title)
  39:     >>> s('hello world')
  40:     'Hello World'
  41:     """
  42:     pass
  43:
--- pass at 42 ---
  17: def Upper(v: str) -> str:
  18:     """Transform a string to upper case.
  19:
  20:     >>> s = Schema(Upper)
  21:     >>> s('hi')
  22:     'HI'
  23:     """
  24:     pass
  25:
  26: def Capitalize(v: str) -> str:
  27:     """Capitalise a string.
  28:
  29:     >>> s = Schema(Capitalize)
  30:     >>> s('hello world')
  31:     'Hello world'
  32:     """
  33:     pass
  34:
  35: def Title(v: str) -> str:
  36:     """Title case a string.
  37:
  38:     >>> s = Schema(Title)
  39:     >>> s('hello world')
  40:     'Hello World'
  41:     """
  42:     pass
  43:
  44: def Strip(v: str) -> str:
  45:     """Strip whitespace from a string.
  46:
  47:     >>> s = Schema(Strip)
  48:     >>> s('  hello world  ')
  49:     'hello world'
  50:     """
  51:     pass
  52:
--- pass at 51 ---
  26: def Capitalize(v: str) -> str:
  27:     """Capitalise a string.
  28:
  29:     >>> s = Schema(Capitalize)
  30:     >>> s('hello world')
  31:     'Hello world'
  32:     """
  33:     pass
  34:
  35: def Title(v: str) -> str:
  36:     """Title case a string.
  37:
  38:     >>> s = Schema(Title)
  39:     >>> s('hello world')
  40:     'Hello World'
  41:     """
  42:     pass
  43:
  44: def Strip(v: str) -> str:
  45:     """Strip whitespace from a string.
  46:
  47:     >>> s = Schema(Strip)
  48:     >>> s('  hello world  ')
  49:     'hello world'
  50:     """
  51:     pass
  52:
  53: class DefaultTo(object):
  54:     """Sets a value to default_value if none provided.
  55:
  56:     >>> s = Schema(DefaultTo(42))
  57:     >>> s(None)
  58:     42
  59:     >>> s = Schema(DefaultTo(list))
  60:     >>> s(None)
  61:     []

### voluptuous/humanize.py
--- pass at 12 ---
   1: import typing
   2: from voluptuous import Invalid, MultipleInvalid
   3: from voluptuous.error import Error
   4: from voluptuous.schema_builder import Schema
   5: MAX_VALIDATION_ERROR_ITEM_LENGTH = 500
   6:
   7: def humanize_error(data, validation_error: Invalid, max_sub_error_length: int=MAX_VALIDATION_ERROR_ITEM_LENGTH) -> str:
   8:     """Provide a more helpful + complete validation error message than that provided automatically
   9:     Invalid and MultipleInvalid do not include the offending value in error messages,
  10:     and MultipleInvalid.__str__ only provides the first error.
  11:     """
  12:     pass

### voluptuous/error.py
--- pass at 116 ---
  91: class FalseInvalid(Invalid):
  92:     """The value is not False."""
  93:
  94: class BooleanInvalid(Invalid):
  95:     """The value is not a boolean."""
  96:
  97: class UrlInvalid(Invalid):
  98:     """The value is not a URL."""
  99:
 100: class EmailInvalid(Invalid):
 101:     """The value is not an email address."""
 102:
 103: class FileInvalid(Invalid):
 104:     """The value is not a file."""
 105:
 106: class DirInvalid(Invalid):
 107:     """The value is not a directory."""
 108:
 109: class PathInvalid(Invalid):
 110:     """The value is not a path."""
 111:
 112: class LiteralInvalid(Invalid):
 113:     """The literal values do not match."""
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
--- pass at 125 ---
 100: class EmailInvalid(Invalid):
 101:     """The value is not an email address."""
 102:
 103: class FileInvalid(Invalid):
 104:     """The value is not a file."""
 105:
 106: class DirInvalid(Invalid):
 107:     """The value is not a directory."""
 108:
 109: class PathInvalid(Invalid):
 110:     """The value is not a path."""
 111:
 112: class LiteralInvalid(Invalid):
 113:     """The literal values do not match."""
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
 127: class NotInInvalid(Invalid):
 128:     pass
 129:
 130: class ExactSequenceInvalid(Invalid):
 131:     pass
 132:
 133: class NotEnoughValid(Invalid):
 134:     """The value did not pass enough validations."""
 135:     pass
--- pass at 128 ---
 103: class FileInvalid(Invalid):
 104:     """The value is not a file."""
 105:
 106: class DirInvalid(Invalid):
 107:     """The value is not a directory."""
 108:
 109: class PathInvalid(Invalid):
 110:     """The value is not a path."""
 111:
 112: class LiteralInvalid(Invalid):
 113:     """The literal values do not match."""
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
 127: class NotInInvalid(Invalid):
 128:     pass
 129:
 130: class ExactSequenceInvalid(Invalid):
 131:     pass
 132:
 133: class NotEnoughValid(Invalid):
 134:     """The value did not pass enough validations."""
 135:     pass
 136:
 137: class TooManyValid(Invalid):
 138:     """The value passed more than expected validations."""
--- pass at 131 ---
 106: class DirInvalid(Invalid):
 107:     """The value is not a directory."""
 108:
 109: class PathInvalid(Invalid):
 110:     """The value is not a path."""
 111:
 112: class LiteralInvalid(Invalid):
 113:     """The literal values do not match."""
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
 127: class NotInInvalid(Invalid):
 128:     pass
 129:
 130: class ExactSequenceInvalid(Invalid):
 131:     pass
 132:
 133: class NotEnoughValid(Invalid):
 134:     """The value did not pass enough validations."""
 135:     pass
 136:
 137: class TooManyValid(Invalid):
 138:     """The value passed more than expected validations."""
 139:     pass
--- pass at 135 ---
 110:     """The value is not a path."""
 111:
 112: class LiteralInvalid(Invalid):
 113:     """The literal values do not match."""
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
 127: class NotInInvalid(Invalid):
 128:     pass
 129:
 130: class ExactSequenceInvalid(Invalid):
 131:     pass
 132:
 133: class NotEnoughValid(Invalid):
 134:     """The value did not pass enough validations."""
 135:     pass
 136:
 137: class TooManyValid(Invalid):
 138:     """The value passed more than expected validations."""
 139:     pass
--- pass at 139 ---
 114:
 115: class LengthInvalid(Invalid):
 116:     pass
 117:
 118: class DatetimeInvalid(Invalid):
 119:     """The value is not a formatted datetime string."""
 120:
 121: class DateInvalid(Invalid):
 122:     """The value is not a formatted date string."""
 123:
 124: class InInvalid(Invalid):
 125:     pass
 126:
 127: class NotInInvalid(Invalid):
 128:     pass
 129:
 130: class ExactSequenceInvalid(Invalid):
 131:     pass
 132:
 133: class NotEnoughValid(Invalid):
 134:     """The value did not pass enough validations."""
 135:     pass
 136:
 137: class TooManyValid(Invalid):
 138:     """The value passed more than expected validations."""
 139:     pass
[The command completed with exit code 0.]
[Current working directory: /workspace/voluptuous]
[Python interpreter: /usr/bin/python]
[Command finished with exit code 0]