wip

Author: keithasaurus

docs/how_to/dictionaries/is_dict.rst

@@ -18,5 +18,10 @@ don't need to initialize it, you can just load :data:`is_dict_validator`.
     Valid(val={'a': 1, 'b': None})
 
     >>> is_dict_validator(None)
-    Invalid(err_type=TypeErr(expected_type=<class 'dict'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'dict'>),
+        value=None,
+        validator=IsDictValidator()
+    )
+
 

docs/how_to/extension.rst

@@ -44,7 +44,11 @@ Here's how our :class:`Validator` can be used:
     >>> float_validator(5.5)
     Valid(val=5.5)
     >>> float_validator(5)
-    Invalid(err_type=TypeErr(expected_type=<class 'float'>), value=5, ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'float'>),
+        value=5,
+        validator=<SimpleFloatValidator object at ...>
+    )
 
 Predicates
 ----------
@@ -108,7 +112,13 @@ In the code above, if :class:`Predicate<koda_validate.Predicate>` is specified,
     >>> validator(3.14)
     Valid(val=3.14)
     >>> validator(1.1)
-    Invalid(err_type=PredicateErrs(predicates=[FloatMin(min=2.5)]), value=1.1, ...)
+    Invalid(
+        err_type=PredicateErrs(predicates=[
+            FloatMin(min=2.5),
+        ]),
+        value=1.1,
+        validator=<SimpleFloatValidator object at ...>
+    )
 
 We limited the Validator to one :class:`Predicate` for simplicity. In Koda Validate, :class:`Validator`\s
 that accept predicates typically allow of a ``list`` of :class:`Predicate`\s. Because :class:`Predicate`\s

docs/how_to/performance.rst

@@ -118,9 +118,17 @@ The validator should behave as the wrapped :class:`Validator` normally would:
     >>> cached_int_validator(5)  # cache hit
     Valid(val=5)
     >>> cached_int_validator("a string")  # cache miss
-    Invalid(err_type=TypeErr(expected_type=<class 'int'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'int'>),
+        value='a string',
+        validator=IntValidator()
+    )
     >>> cached_int_validator("a string")  # cache hit
-    Invalid(err_type=TypeErr(expected_type=<class 'int'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'int'>),
+        value='a string',
+        validator=IntValidator()
+    )
 
 .. note::
 

docs/how_to/results.rst

@@ -25,7 +25,7 @@ generic parameter for the same purpose. So, a ``Validator[int]`` will always ret
 .. note::
 
     ``ValidationResult[int]`` is a more concise way to express ``Union[Valid[int], Invalid]``,
-to which it is exactly equivalent.
+    to which it is exactly equivalent.
 
 Branching on Validity
 ---------------------
@@ -101,10 +101,14 @@ ValidationResult.map()
 Sometimes you might want to convert the data contained by :class:`Valid` into another
 type. ``.map`` allows you to do that without a lot of boilerplate:
 
+.. testsetup:: valid-map
+
+    from koda_validate import IntValidator
+
 .. doctest:: valid-map
-    >>> validator = IntValidator()
-    >>> validator(5).map(str)
-    Valid(val="5")
+
+    >>> IntValidator()(5).map(str)
+    Valid(val='5')
 
 
 Working with ``Invalid``

docs/index.rst

@@ -35,7 +35,11 @@ Easy enough. Let's see how it works:
    Valid(val='a string')
 
    >>> my_first_validator(0)
-   Invalid(err_type=TypeErr(expected_type=<class 'str'>), ...)
+   Invalid(
+       err_type=TypeErr(expected_type=<class 'str'>),
+       value=0,
+       validator=StringValidator()
+   )
 
 For both valid and invalid cases, a value is returned -- no exceptions
 are raised.

docs/philosophy/predicates.rst

@@ -30,10 +30,20 @@ Usage:
     Valid(val=6)
 
     >>> int_validator("a string")
-    Invalid(err_type=TypeErr(expected_type=<class 'int'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'int'>),
+        value='a string',
+        validator=IntValidator(Min(minimum=5, exclusive_minimum=False))
+    )
 
     >>> int_validator(4)
-    Invalid(err_type=PredicateErrs(predicates=[Min(minimum=5, exclusive_minimum=False)]), ...)
+    Invalid(
+        err_type=PredicateErrs(predicates=[
+            Min(minimum=5, exclusive_minimum=False),
+        ]),
+        value=4,
+        validator=IntValidator(Min(minimum=5, exclusive_minimum=False))
+    )
 
 As you can see the value ``4`` passes the ``int`` type check but fails to pass the ``Min(5)`` predicate.
 

docs/philosophy/validators.rst

@@ -54,8 +54,11 @@ Usage:
     Valid(val=5)
 
     >>> int_validator("not an integer")
-    Invalid(err_type=TypeErr(expected_type=<class 'int'>), ...)
-
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'int'>),
+        value='not an integer',
+        validator=IntValidator()
+    )
 
 Having this simple function signature-based definition for validation is useful, because it means we can *compose*
 validators. Perhaps the simplest example of this is how ``ListValidator`` accepts a validator for the items of the ``list``:

koda_validate/bytes.py

@@ -13,9 +13,19 @@ class BytesValidator(_ToTupleStandardValidator[bytes]):
     >>> from koda_validate import *
     >>> validator = BytesValidator(not_blank, MaxLength(100), preprocessors=[strip])
     >>> validator(b"")
-    Invalid(err_type=PredicateErrs(predicates=[NotBlank()]), ...)
+    Invalid(
+        err_type=PredicateErrs(predicates=[
+            NotBlank(),
+        ]),
+        value=b'',
+        validator=BytesValidator(NotBlank(), MaxLength(length=100), preprocessors=[Strip()])
+    )
     >>> validator("")
-    Invalid(err_type=TypeErr(expected_type=<class 'bytes'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'bytes'>),
+        value='',
+        validator=BytesValidator(NotBlank(), MaxLength(length=100), preprocessors=[Strip()])
+    )
     >>> validator(b' ok ')
     Valid(val=b'ok')
 

koda_validate/string.py

@@ -18,9 +18,19 @@ class StringValidator(_ToTupleStandardValidator[str]):
     >>> from koda_validate import *
     >>> validator = StringValidator(not_blank, MaxLength(100), preprocessors=[strip])
     >>> validator("")
-    Invalid(err_type=PredicateErrs(predicates=[NotBlank()]), ...)
+    Invalid(
+        err_type=PredicateErrs(predicates=[
+            NotBlank(),
+        ]),
+        value='',
+        validator=StringValidator(NotBlank(), MaxLength(length=100), preprocessors=[Strip()])
+    )
     >>> validator(None)
-    Invalid(err_type=TypeErr(expected_type=<class 'str'>), ...)
+    Invalid(
+        err_type=TypeErr(expected_type=<class 'str'>),
+        value=None,
+        validator=StringValidator(NotBlank(), MaxLength(length=100), preprocessors=[Strip()])
+    )
     >>> validator(" ok ")
     Valid(val='ok')