Skip to content

Field Errors

field_errors

Base class for errors associated with a specific field.

Defines FieldErrors which represents validation or constraint errors
associated with a single field.

FieldErrors

Bases: Error[object]

Base class for errors associated with a specific field.

Example 
class SomeError(Error[object]):
    pass


class FieldErrorAggregate(FieldErrors[SomeError]):
    pass


field_errors = FieldErrorAggregate(
    field=FieldReference("email"),
    errors=[
        SomeError.from_string("Format is invalid"),
        SomeError.from_string("Domain not allowed"),
    ],
)
assert field_errors.field.value == "email"
assert len(field_errors) == 2
for err in field_errors:
    assert "invalid" in str(err) or "not allowed" in str(err)
Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
class FieldErrors[ContainedErrorType: Error[object]](Error[object]):
    """Base class for errors associated with a specific field.

    Example:
        ```python
        class SomeError(Error[object]):
            pass


        class FieldErrorAggregate(FieldErrors[SomeError]):
            pass


        field_errors = FieldErrorAggregate(
            field=FieldReference("email"),
            errors=[
                SomeError.from_string("Format is invalid"),
                SomeError.from_string("Domain not allowed"),
            ],
        )
        assert field_errors.field.value == "email"
        assert len(field_errors) == 2
        for err in field_errors:
            assert "invalid" in str(err) or "not allowed" in str(err)
        ```

    """

    def __init__(self, field: FieldReference, errors: Iterable[ContainedErrorType]) -> None:
        """Initialise with a field reference and the errors associated with it.

        Args:
            field: Reference to the field these errors belong to.
            errors: The errors associated with *field*. Must be non-empty.

        Raises:
            RuleViolatedError: If *errors* is empty or *field* is falsy.
        """
        self._field = field
        self._errors: Sequence[ContainedErrorType] = tuple(errors)

        if not self._errors or not field or not field.value:
            raise RuleViolatedError(
                ErrorMessage("FieldErrors must contain at least one error and field defined.")
            )

        message = ErrorMessage(f"{len(self._errors)} error(s) for field '{field.value}'.")

        super().__init__(message=message)

    def __repr__(self) -> str:
        """Return a concise string representation of the field errors."""
        return (
            f"<{self._get_title_prefix()} field={self._field.value!r} errors={len(self._errors)}>"
        )

    def __str__(self) -> str:
        """Return a human-readable string representation of the field errors."""
        error_messages = "\n".join(f" - {str(error)}" for error in self._errors)
        return f"{self._get_title_prefix()} for field '{self._field.value}':\n{error_messages}"

    def __iter__(self) -> Iterator[ContainedErrorType]:
        """Iterate over the errors associated with the field."""
        return iter(self._errors)

    def __len__(self) -> int:
        """Return the number of errors associated with the field."""
        return len(self._errors)

    @property
    def field(self) -> FieldReference:
        """The field associated with these errors."""
        return self._field

    @property
    def errors(self) -> Sequence[ContainedErrorType]:
        """The collection of errors associated with the field."""
        return self._errors

    def as_debug_string(self) -> str:
        """Return detailed, multi-line string of this field error collection for debugging."""
        error_strings = [f"    {err.as_debug_string()}" for err in self._errors]
        return (
            f"{self._get_title_prefix()}(\n"
            f"  field={repr(self._field)},\n"
            f"  errors=[\n"
            + ("" if not error_strings else "\n".join(error_strings) + "\n")
            + "  ]\n"
            ")"
        )

    def _get_title_prefix(self) -> str:
        """Get the title prefix for this field error type."""
        return self.__class__.__name__

field: FieldReference property

The field associated with these errors.

errors: Sequence[ContainedErrorType] property

The collection of errors associated with the field.

__init__(field: FieldReference, errors: Iterable[ContainedErrorType]) -> None

Initialise with a field reference and the errors associated with it.

Parameters:

Name Type Description Default
field FieldReference

Reference to the field these errors belong to.

 required
errors Iterable[ContainedErrorType]

The errors associated with field. Must be non-empty.

 required

Raises:

Type Description
RuleViolatedError

If errors is empty or field is falsy.
Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def __init__(self, field: FieldReference, errors: Iterable[ContainedErrorType]) -> None:
    """Initialise with a field reference and the errors associated with it.

    Args:
        field: Reference to the field these errors belong to.
        errors: The errors associated with *field*. Must be non-empty.

    Raises:
        RuleViolatedError: If *errors* is empty or *field* is falsy.
    """
    self._field = field
    self._errors: Sequence[ContainedErrorType] = tuple(errors)

    if not self._errors or not field or not field.value:
        raise RuleViolatedError(
            ErrorMessage("FieldErrors must contain at least one error and field defined.")
        )

    message = ErrorMessage(f"{len(self._errors)} error(s) for field '{field.value}'.")

    super().__init__(message=message)

__repr__() -> str

Return a concise string representation of the field errors.

Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
64
65
66
67
68
def __repr__(self) -> str:
    """Return a concise string representation of the field errors."""
    return (
        f"<{self._get_title_prefix()} field={self._field.value!r} errors={len(self._errors)}>"
    )

__str__() -> str

Return a human-readable string representation of the field errors.

Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
70
71
72
73
def __str__(self) -> str:
    """Return a human-readable string representation of the field errors."""
    error_messages = "\n".join(f" - {str(error)}" for error in self._errors)
    return f"{self._get_title_prefix()} for field '{self._field.value}':\n{error_messages}"

__iter__() -> Iterator[ContainedErrorType]

Iterate over the errors associated with the field.

Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
75
76
77
def __iter__(self) -> Iterator[ContainedErrorType]:
    """Iterate over the errors associated with the field."""
    return iter(self._errors)

__len__() -> int

Return the number of errors associated with the field.

Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
79
80
81
def __len__(self) -> int:
    """Return the number of errors associated with the field."""
    return len(self._errors)

as_debug_string() -> str

Return detailed, multi-line string of this field error collection for debugging.

Source code in src/forging_blocks/foundation/errors/combined/field_errors.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def as_debug_string(self) -> str:
    """Return detailed, multi-line string of this field error collection for debugging."""
    error_strings = [f"    {err.as_debug_string()}" for err in self._errors]
    return (
        f"{self._get_title_prefix()}(\n"
        f"  field={repr(self._field)},\n"
        f"  errors=[\n"
        + ("" if not error_strings else "\n".join(error_strings) + "\n")
        + "  ]\n"
        ")"
    )