added support for types and subclass of types

Author: phenobarbital

datamodel/abstract.py

@@ -209,6 +209,8 @@ def _initialize_fields(attrs, annotations, strict):
                     # check type of field:
                     if _is_prim:
                         _type_category = 'primitive'
+                    elif origin == type:
+                        _type_category = 'typing'
                     elif _is_dc:
                         _type_category = 'dataclass'
                     elif _is_typing:  # noqa

datamodel/converters.pyx

@@ -586,12 +586,6 @@ cdef object _parse_typing_type(
     """
     cdef tuple type_args = getattr(T, '__args__', ())
 
-    print('FIELD > ', field, field.origin)
-    print('T > ', T)
-    print('NAME > ', name)
-    print('DATA > ', data)
-    print('Type Args > ', type_args)
-
     if field.origin in {dict, Mapping} or name in {'Dict', 'Mapping'}:
         if isinstance(data, dict):
             if type_args:

datamodel/validation.pyx

@@ -50,9 +50,6 @@ cpdef list _validation(object F, str name, object value, object annotated_type,
         annotated_type = annotated_type.type
     errors = []
 
-    print(' ::: F ', F, name, value)
-    print(' BASE ', F.origin, F.args, field_type)
-    print('THIS > ', F.origin is Callable)
     # first: calling (if exists) custom validator:
     fn = F.metadata.get('validator', None)
     if fn is not None and callable(fn):
@@ -108,6 +105,15 @@ cpdef list _validation(object F, str name, object value, object annotated_type,
                     f"Field '{name}': expected an awaitable, but got {type(value)}."
                 )
         elif field_type == 'typing' or hasattr(annotated_type, '__module__') and annotated_type.__module__ == 'typing':
+            if F.origin is type:
+                for allowed in F.args:
+                    if isinstance(value, allowed):
+                        break
+                else:
+                    expected = ', '.join([str(t) for t in F.args])
+                    errors.append(
+                        _create_error(name, value, f'Invalid type for {annotated_type}.{name}, expected a subclass of {expected}', val_type, annotated_type)
+                    )
             if F.origin is tuple:
                 # Check if we are in the homogeneous case: Tuple[T, ...]
                 if len(F.args) == 2 and F.args[1] is Ellipsis:

datamodel/version.py

@@ -6,7 +6,7 @@
     'simple library based on python +3.8 to use Dataclass-syntax'
     'for interacting with Data'
 )
-__version__ = '0.8.12'
+__version__ = '0.8.13'
 __copyright__ = 'Copyright (c) 2020-2024 Jesus Lara'
 __author__ = 'Jesus Lara'
 __author_email__ = '[email protected]'

examples/test_type_user.py

@@ -0,0 +1,41 @@
+from typing import Type, Union
+from datamodel import BaseModel, Field
+from datamodel.exceptions import ValidationError
+
+# Define a basic user hierarchy.
+class User(BaseModel):
+    username: str = Field(required=True)
+    email: str = Field(required=True)
+
+class BasicUser(User):
+    level: str = Field(default="basic")
+
+class ProUser(User):
+    level: str = Field(default="pro")
+    perks: list = Field(default_factory=list)
+
+# Employee model whose user_class field must be a type (class)
+# that is either BasicUser or ProUser.
+class Employee(BaseModel):
+    # The type hint below means: user_class must be a type (class)
+    # that is a subclass of either BasicUser or ProUser.
+    user_class: type[BasicUser | ProUser] = Field(required=True)
+
+
+try:
+    # This should raise a ValidationError because the type hint
+    # specifies that user_class must be a type (class), not an instance.
+    user = BasicUser(username="user", email="email")
+    employee = Employee(user_class=user)
+    print(employee)
+except ValidationError as e:
+    print(e.payload)
+
+try:
+    # This should raise a ValidationError because the type hint
+    # specifies that user_class must be a type (class), not an instance.
+    user = User(username="user", email="email")
+    employee = Employee(user_class=user)
+    print(employee)
+except ValidationError as e:
+    print(e.payload)

tests/test_type_user.py

@@ -0,0 +1,65 @@
+# test_employee.py
+from typing import Type, Union
+import pytest
+from datamodel import BaseModel, Field
+from datamodel.exceptions import ValidationError
+
+
+# Define a basic user hierarchy.
+class User(BaseModel):
+    username: str = Field(required=True)
+    email: str = Field(required=True)
+
+class BasicUser(User):
+    level: str = Field(default="basic")
+
+class ProUser(User):
+    level: str = Field(default="pro")
+    perks: list = Field(default_factory=list)
+
+# Employee model whose user_class field must be a type (class)
+# that is either BasicUser or ProUser.
+class Employee(BaseModel):
+    # The type hint below means: user_class must be a type (class)
+    # that is a subclass of either BasicUser or ProUser.
+    user_class: type[BasicUser | ProUser] = Field(required=True)
+
+# NOTE: In your converters/validation modules you must support such fields by:
+# - Checking that get_origin(annotated_type) is type.
+# - Extracting get_args(annotated_type) and verifying that
+#   the supplied value is a type and a subclass of one of the allowed types.
+
+# Example test functions below:
+
+def test_valid_employee_basic():
+    """Test that an Employee can be created with BasicUser as its user_class."""
+    user = BasicUser(username="user", email="email")
+    emp = Employee(user_class=user)
+    # Verify that the field user_class was correctly set to BasicUser
+    assert isinstance(emp.user_class, BasicUser)
+
+def test_valid_employee_pro():
+    """Test that an Employee can be created with ProUser as its user_class."""
+    user = ProUser(username="user", email="email")
+    emp = Employee(user_class=user)
+    assert isinstance(emp.user_class, ProUser)
+
+def test_invalid_employee_team():
+    """Test that assigning a type not allowed (TeamUser) raises a validation error."""
+    with pytest.raises(ValidationError) as excinfo:
+        user = User(username="user", email="email")
+        Employee(user_class=user)
+    errors = excinfo.value.payload
+    # Check that the error mentions the 'user_class' field and the allowed types.
+    assert "user_class" in errors
+    error_message = errors["user_class"][0]["error"]
+    assert "subclass" in error_message
+
+# For manual testing when running this file directly:
+if __name__ == "__main__":
+    test_valid_employee_basic()
+    test_valid_employee_pro()
+    try:
+        test_invalid_employee_team()
+    except Exception as e:
+        print("Expected error:", e)