feat: fix all typing issues raised by mypy

Author: azmeuk

.pre-commit-config.yaml

@@ -19,6 +19,8 @@ repos:
     rev: v1.15.0
     hooks:
       - id: mypy
+        additional_dependencies:
+          - pydantic[email]>=2.7.0
   - repo: https://github.com/codespell-project/codespell
     rev: v2.4.1
     hooks:

pyproject.toml

@@ -105,10 +105,16 @@ docstring-code-format = true
 addopts = "--doctest-modules --doctest-glob='*.rst'"
 doctest_optionflags= "ALLOW_UNICODE IGNORE_EXCEPTION_DETAIL ELLIPSIS"
 
-# [tool.mypy]
-# plugins = [
-#   "pydantic.mypy"
-# ]
+[tool.mypy]
+plugins = [
+  "pydantic.mypy"
+]
+warn_unused_ignores = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
 
 [tool.tox]
 requires = ["tox>=4.19"]

scim2_models/rfc7643/resource.py

@@ -174,18 +174,12 @@ def __class_getitem__(cls, item: Any) -> type["Resource"]:
             f"{cls.__name__}[{', '.join(ext.__name__ for ext in valid_extensions)}]"
         )
 
-        class_attrs = {
-            "__scim_extension_metadata__": {
-                "args": (item,),
-                "origin": cls,
-                "extensions": valid_extensions,
-            }
-        }
+        class_attrs = {"__scim_extension_metadata__": valid_extensions}
 
         for extension in valid_extensions:
             schema = extension.model_fields["schemas"].default[0]
             class_attrs[extension.__name__] = Field(
-                None,
+                default=None,  # type: ignore[arg-type]
                 serialization_alias=schema,
                 validation_alias=normalize_attribute_name(schema),
             )
@@ -424,6 +418,10 @@ def model_attribute_to_scim_attribute(
 
     field_info = model.model_fields[attribute_name]
     root_type = model.get_field_root_type(attribute_name)
+    if root_type is None:
+        raise ValueError(
+            f"Could not determine root type for attribute {attribute_name}"
+        )
     attribute_type = Attribute.Type.from_python(root_type)
     sub_attributes = (
         [
@@ -443,7 +441,7 @@ def model_attribute_to_scim_attribute(
 
     return Attribute(
         name=field_info.serialization_alias or attribute_name,
-        type=attribute_type,
+        type=Attribute.Type(attribute_type),
         multi_valued=model.get_field_multiplicity(attribute_name),
         description=field_info.description,
         canonical_values=field_info.examples,

scim2_models/rfc7643/resource_type.py

@@ -84,16 +84,13 @@ def from_resource(cls, resource_model: type[Resource]) -> Self:
         name = schema.split(":")[-1]
 
         # Get extensions from the metadata system
-        if hasattr(resource_model, "__scim_extension_metadata__"):
-            extensions = resource_model.__scim_extension_metadata__["extensions"]
-        else:
-            extensions = []
+        extensions = getattr(resource_model, "__scim_extension_metadata__", [])
 
         return cls(
             id=name,
             name=name,
             description=name,
-            endpoint=f"/{name}s",
+            endpoint=f"/{name}s",  # type: ignore[arg-type]
             schema_=schema,
             schema_extensions=[
                 SchemaExtension(

scim2_models/rfc7643/schema.py

@@ -126,25 +126,25 @@ def to_python(
             return attr_types[self.value]
 
         @classmethod
-        def from_python(cls, pytype) -> str:
+        def from_python(cls, pytype: type) -> "Attribute.Type":
             if get_origin(pytype) == Reference:
-                return cls.reference.value
+                return cls.reference
 
-            if is_complex_attribute(pytype):
-                return cls.complex.value
+            if pytype and is_complex_attribute(pytype):
+                return cls.complex
 
             if pytype in (Required, CaseExact):
-                return cls.boolean.value
+                return cls.boolean
 
             attr_types = {
-                str: cls.string.value,
-                bool: cls.boolean.value,
-                float: cls.decimal.value,
-                int: cls.integer.value,
-                datetime: cls.date_time.value,
-                Base64Bytes: cls.binary.value,
+                str: cls.string,
+                bool: cls.boolean,
+                float: cls.decimal,
+                int: cls.integer,
+                datetime: cls.date_time,
+                Base64Bytes: cls.binary,
             }
-            return attr_types.get(pytype, cls.string.value)
+            return attr_types.get(pytype, cls.string)
 
     name: Annotated[
         Optional[str], Mutability.read_only, Required.true, CaseExact.true

tests/test_resource_extension.py

@@ -320,3 +320,31 @@ def test_class_getitem():
 
     with pytest.raises(TypeError, match="is not a valid Extension type"):
         User[int]
+
+
+def test_model_attribute_to_scim_attribute_error():
+    """Test error case where get_field_root_type returns None."""
+    from typing import Optional
+
+    from pydantic import Field
+
+    from scim2_models.base import BaseModel
+    from scim2_models.rfc7643.resource import model_attribute_to_scim_attribute
+
+    # Create a model with a field that has no clear root type
+    class TestModel(BaseModel):
+        problematic_field: Optional[str] = Field(default=None)
+
+    # Mock get_field_root_type to return None
+    original_method = TestModel.get_field_root_type
+    TestModel.get_field_root_type = classmethod(lambda cls, attr: None)
+
+    try:
+        with pytest.raises(
+            ValueError,
+            match="Could not determine root type for attribute problematic_field",
+        ):
+            model_attribute_to_scim_attribute(TestModel, "problematic_field")
+    finally:
+        # Restore the original method
+        TestModel.get_field_root_type = original_method