#389

Committed 24 May 2025 01:01PM UTC coverage: 93.409% (-0.2%) from 93.644%

Build # #389

Build Type

Pull #56

coveralls-python

Committed by

LeanderCS

Commit Message

48 | Remove typing_extensions dep

Pull Request Pull Request #56: 48 | Update ArrayElementValidator and IsDataclassValidator

Run Details

64 of 73 new or added lines in 4 files covered. (87.67%)

87 existing lines in 18 files now uncovered.

1885 of 2018 relevant lines covered (93.41%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.0

/flask_inputfilter/validators/is_dataclass_validator.py

from __future__ import annotations

import dataclasses
from typing import Any, Optional, Type, TypeVar, Union, _GenericAlias

from flask_inputfilter.exceptions import ValidationError
from flask_inputfilter.validators import BaseValidator

T = TypeVar("T")


# TODO: Replace with typing.get_origin when Python 3.7 support is dropped.
def get_origin(tp: Any) -> Optional[Type[Any]]:
    """Get the unsubscripted version of a type.

    This supports typing types like List, Dict, etc. and their
    typing_extensions equivalents.
    """
    if isinstance(tp, _GenericAlias):
        return tp.__origin__
    return None


# TODO: Replace with typing.get_args when Python 3.7 support is dropped.
def get_args(tp: Any) -> tuple[Any, ...]:
    """Get type arguments with all substitutions performed.

    For unions, basic types, and special typing forms, returns
    the type arguments. For example, for List[int] returns (int,).
    """
    if isinstance(tp, _GenericAlias):
        return tp.__args__
    return ()


class IsDataclassValidator(BaseValidator):
    """
    Validates that the provided value conforms to a specific
    dataclass type.

    **Parameters:**

    - **dataclass_type** (*Type[dict]*): The expected dataclass type.
    - **error_message** (*Optional[str]*): Custom error message if validation fails.

    **Expected Behavior:**

    Ensures the input is a dictionary and, that all expected keys are present. Raises a ``ValidationError`` if the structure does not match.
    All fields in the dataclass are validated against their types, including nested dataclasses, lists, and dictionaries.

    **Example Usage:**

    .. code-block:: python

        from dataclasses import dataclass

        @dataclass
        class User:
            id: int
            name: str

        class UserInputFilter(InputFilter):
            def __init__(self):
                super().__init__()

                self.add('user', validators=[
                    IsDataclassValidator(dataclass_type=User)
                ])
    """

    __slots__ = ("dataclass_type", "error_message")

    def __init__(
        self,
        dataclass_type: Type[T],
        error_message: Optional[str] = None,
    ) -> None:
        self.dataclass_type = dataclass_type
        self.error_message = error_message

    def validate(self, value: Any) -> None:
        if not isinstance(value, dict):
            raise ValidationError(
                self.error_message
                or "The provided value is not a dict instance."
            )

        if not dataclasses.is_dataclass(self.dataclass_type):
            raise ValidationError(
                self.error_message
                or f"'{self.dataclass_type}' is not a valid dataclass."
            )

        for field in dataclasses.fields(self.dataclass_type):
            field_name = field.name
            field_type = field.type
            has_default = (
                field.default is not dataclasses.MISSING
                or field.default_factory is not dataclasses.MISSING
            )

            if field_name not in value:
                if not has_default:
                    raise ValidationError(
                        self.error_message
                        or f"Missing required field '{field_name}' in value '{value}'."
                    )
                continue

            field_value = value[field_name]

            origin = get_origin(field_type)
            args = get_args(field_type)

            if origin is not None:
                if origin is list:
                    if not isinstance(field_value, list) or not all(
                        isinstance(item, args[0]) for item in field_value
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not a valid list of '{args[0]}'."
                        )
                elif origin is dict:
                    if not isinstance(field_value, dict) or not all(
                        isinstance(k, args[0]) and isinstance(v, args[1])
                        for k, v in field_value.items()
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not a valid dict with keys of type '{args[0]}' and values of type '{args[1]}'."
                        )
                elif origin is Union and type(None) in args:
                    if field_value is not None and not isinstance(
                        field_value, args[0]
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not of type '{args[0]}'."
                        )
                else:
                    raise ValidationError(
                        self.error_message
                        or f"Unsupported type '{field_type}' for field '{field_name}'."
                    )
            elif dataclasses.is_dataclass(field_type):
                IsDataclassValidator(field_type).validate(field_value)
            else:
                if not isinstance(field_value, field_type):
                    raise ValidationError(
                        self.error_message
                        or f"Field '{field_name}' in value '{value}' is not of type '{field_type}'."
                    )

1	from __future__ import annotations	1✔
2
3	import dataclasses	1✔
4	from typing import Any, Optional, Type, TypeVar, Union, _GenericAlias	1✔
5
6	from flask_inputfilter.exceptions import ValidationError	1✔
7	from flask_inputfilter.validators import BaseValidator	1✔
8
9	T = TypeVar("T")	1✔
10
11
12	# TODO: Replace with typing.get_origin when Python 3.7 support is dropped.
13	def get_origin(tp: Any) -> Optional[Type[Any]]:	1✔
14	"""Get the unsubscripted version of a type.
15
16	This supports typing types like List, Dict, etc. and their
17	typing_extensions equivalents.
18	"""
19	if isinstance(tp, _GenericAlias):	1✔
20	return tp.__origin__	1✔
21	return None	1✔
22
23
24	# TODO: Replace with typing.get_args when Python 3.7 support is dropped.
25	def get_args(tp: Any) -> tuple[Any, ...]:	1✔
26	"""Get type arguments with all substitutions performed.
27
28	For unions, basic types, and special typing forms, returns
29	the type arguments. For example, for List[int] returns (int,).
30	"""
31	if isinstance(tp, _GenericAlias):	1✔
32	return tp.__args__	1✔
33	return ()	1✔
34
35
36	class IsDataclassValidator(BaseValidator):	1✔
37	"""
38	Validates that the provided value conforms to a specific
39	dataclass type.
40
41	Parameters:
42
43	- dataclass_type (Type[dict]): The expected dataclass type.
44	- error_message (Optional[str]): Custom error message if validation fails.
45
46	Expected Behavior:
47
48	Ensures the input is a dictionary and, that all expected keys are present. Raises a ``ValidationError`` if the structure does not match.
49	All fields in the dataclass are validated against their types, including nested dataclasses, lists, and dictionaries.
50
51	Example Usage:
52
53	.. code-block:: python
54
55	from dataclasses import dataclass
56
57	@dataclass
58	class User:
59	id: int
60	name: str
61
62	class UserInputFilter(InputFilter):
63	def __init__(self):
64	super().__init__()
65
66	self.add('user', validators=[
67	IsDataclassValidator(dataclass_type=User)
68	])
69	"""
70
71	__slots__ = ("dataclass_type", "error_message")	1✔
72
73	def __init__(	1✔
74	self,
75	dataclass_type: Type[T],
76	error_message: Optional[str] = None,
77	) -> None:
78	self.dataclass_type = dataclass_type	1✔
79	self.error_message = error_message	1✔
80
81	def validate(self, value: Any) -> None:	1✔
82	if not isinstance(value, dict):	1✔
83	raise ValidationError(	1✔
84	self.error_message
85	or "The provided value is not a dict instance."
86	)
87
88	if not dataclasses.is_dataclass(self.dataclass_type):	1✔
UNCOV 89	raise ValidationError(	×
90	self.error_message
91	or f"'{self.dataclass_type}' is not a valid dataclass."
92	)
93
94	for field in dataclasses.fields(self.dataclass_type):	1✔
95	field_name = field.name	1✔
96	field_type = field.type	1✔
97	has_default = (	1✔
98	field.default is not dataclasses.MISSING
99	or field.default_factory is not dataclasses.MISSING
100	)
101
102	if field_name not in value:	1✔
103	if not has_default:	1✔
NEW 104	raise ValidationError(	×
105	self.error_message
106	or f"Missing required field '{field_name}' in value '{value}'."
107	)
NEW 108	continue	×
109
110	field_value = value[field_name]	1✔
111
112	origin = get_origin(field_type)	1✔
113	args = get_args(field_type)	1✔
114
115	if origin is not None:	1✔
116	if origin is list:	1✔
NEW 117	if not isinstance(field_value, list) or not all(	×
118	isinstance(item, args[0]) for item in field_value
119	):
NEW 120	raise ValidationError(	×
121	self.error_message
122	or f"Field '{field_name}' in value '{value}' is not a valid list of '{args[0]}'."
123	)
124	elif origin is dict:	1✔
NEW 125	if not isinstance(field_value, dict) or not all(	×
126	isinstance(k, args[0]) and isinstance(v, args[1])
127	for k, v in field_value.items()
128	):
NEW 129	raise ValidationError(	×
130	self.error_message
131	or f"Field '{field_name}' in value '{value}' is not a valid dict with keys of type '{args[0]}' and values of type '{args[1]}'."
132	)
133	elif origin is Union and type(None) in args:	1✔
134	if field_value is not None and not isinstance(	1✔
135	field_value, args[0]
136	):
NEW 137	raise ValidationError(	×
138	self.error_message
139	or f"Field '{field_name}' in value '{value}' is not of type '{args[0]}'."
140	)
141	else:
NEW 142	raise ValidationError(	×
143	self.error_message
144	or f"Unsupported type '{field_type}' for field '{field_name}'."
145	)
146	elif dataclasses.is_dataclass(field_type):	1✔
147	IsDataclassValidator(field_type).validate(field_value)	1✔
148	else:
149	if not isinstance(field_value, field_type):	1✔
150	raise ValidationError(	1✔
151	self.error_message
152	or f"Field '{field_name}' in value '{value}' is not of type '{field_type}'."
153	)

LeanderCS / flask-inputfilter / #389

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous