chore: enable mypy strict

Author: azmeuk

.pre-commit-config.yaml

@@ -19,6 +19,7 @@ repos:
     rev: v1.17.0
     hooks:
       - id: mypy
+        exclude: ^(tests/|conftest.py)
         additional_dependencies:
           - pydantic[email]>=2.7.0
   - repo: https://github.com/codespell-project/codespell

pyproject.toml

@@ -114,6 +114,7 @@ exclude = [
   "tests/",
   "conftest.py",
 ]
+strict=true
 
 [tool.pydantic-mypy]
 init_forbid_extra = true

scim2_models/attributes.py

@@ -43,7 +43,7 @@ class MultiValuedComplexAttribute(ComplexAttribute):
     value: Optional[Any] = None
     """The value of an entitlement."""
 
-    ref: Optional[Reference] = Field(None, serialization_alias="$ref")
+    ref: Optional[Reference[Any]] = Field(None, serialization_alias="$ref")
     """The reference URI of a target resource, if the attribute is a
     reference."""
 

scim2_models/base.py

@@ -220,8 +220,8 @@ def normalize_attribute_names(
         """
 
         def normalize_dict_keys(
-            input_dict: dict, model_class: type["BaseModel"]
-        ) -> dict:
+            input_dict: dict[str, Any], model_class: type["BaseModel"]
+        ) -> dict[str, Any]:
             """Normalize dictionary keys, preserving case for Any fields."""
             result = {}
 

scim2_models/messages/message.py

@@ -112,8 +112,8 @@ def __new__(
         return klass
 
 
-def _get_resource_class(obj) -> Optional[type[Resource]]:
+def _get_resource_class(obj: BaseModel) -> type[Resource[Any]]:
     """Extract the resource class from generic type parameter."""
     metadata = getattr(obj.__class__, "__pydantic_generic_metadata__", {"args": [None]})
     resource_class = metadata["args"][0]
-    return resource_class
+    return resource_class  # type: ignore[no-any-return]

scim2_models/messages/patch_op.py

@@ -5,6 +5,7 @@
 from typing import Generic
 from typing import Optional
 from typing import TypeVar
+from typing import Union
 
 from pydantic import Field
 from pydantic import ValidationInfo
@@ -26,7 +27,7 @@
 from .message import Message
 from .message import _get_resource_class
 
-T = TypeVar("T", bound=Resource)
+T = TypeVar("T", bound=Resource[Any])
 
 
 class PatchOperation(ComplexAttribute):
@@ -143,7 +144,7 @@ class PatchOp(Message, Generic[T]):
         - Using PatchOp without a type parameter raises TypeError
     """
 
-    def __new__(cls, *args: Any, **kwargs: Any):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
         """Create new PatchOp instance with type parameter validation.
 
         Only handles the case of direct instantiation without type parameter (PatchOp()).
@@ -162,39 +163,48 @@ def __new__(cls, *args: Any, **kwargs: Any):
 
         return super().__new__(cls)
 
-    def __class_getitem__(cls, item):
+    def __class_getitem__(
+        cls, typevar_values: Union[type[Resource[Any]], tuple[type[Resource[Any]], ...]]
+    ) -> Any:
         """Validate type parameter when creating parameterized type.
 
         Ensures the type parameter is a concrete Resource subclass (not Resource itself)
         or a TypeVar bound to Resource. Rejects invalid types (str, int, etc.) and Union types.
         """
-        # Allow TypeVar as type parameter
-        if isinstance(item, TypeVar):
+        if isinstance(typevar_values, TypeVar):
             # Check if TypeVar is bound to Resource or its subclass
-            if item.__bound__ is not None and (
-                item.__bound__ is Resource
-                or (isclass(item.__bound__) and issubclass(item.__bound__, Resource))
+            if typevar_values.__bound__ is not None and (
+                typevar_values.__bound__ is Resource
+                or (
+                    isclass(typevar_values.__bound__)
+                    and issubclass(typevar_values.__bound__, Resource)
+                )
             ):
-                return super().__class_getitem__(item)
+                return super().__class_getitem__(typevar_values)
             else:
                 raise TypeError(
-                    f"PatchOp TypeVar must be bound to Resource or its subclass, got {item}. "
+                    f"PatchOp TypeVar must be bound to Resource or its subclass, got {typevar_values}. "
                     "Example: T = TypeVar('T', bound=Resource)"
                 )
 
         # Check if type parameter is a concrete Resource subclass (not Resource itself)
-        if item is Resource:
+        if typevar_values is Resource:
             raise TypeError(
                 "PatchOp requires a concrete Resource subclass, not Resource itself. "
                 "Use PatchOp[User], PatchOp[Group], etc. instead of PatchOp[Resource]."
             )
-        if not (isclass(item) and issubclass(item, Resource) and item is not Resource):
+
+        if not (
+            isclass(typevar_values)
+            and issubclass(typevar_values, Resource)
+            and typevar_values is not Resource
+        ):
             raise TypeError(
-                f"PatchOp type parameter must be a concrete Resource subclass or TypeVar, got {item}. "
+                f"PatchOp type parameter must be a concrete Resource subclass or TypeVar, got {typevar_values}. "
                 "Use PatchOp[User], PatchOp[Group], etc."
             )
 
-        return super().__class_getitem__(item)
+        return super().__class_getitem__(typevar_values)
 
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:api:messages:2.0:PatchOp"
@@ -254,7 +264,9 @@ def patch(self, resource: T) -> bool:
 
         return modified
 
-    def _apply_operation(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_operation(
+        self, resource: Resource[Any], operation: PatchOperation
+    ) -> bool:
         """Apply a single patch operation to a resource.
 
         :return: :data:`True` if the resource was modified, else :data:`False`.
@@ -266,7 +278,9 @@ def _apply_operation(self, resource: Resource, operation: PatchOperation) -> boo
 
         raise ValueError(Error.make_invalid_value_error().detail)
 
-    def _apply_add_replace(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_add_replace(
+        self, resource: Resource[Any], operation: PatchOperation
+    ) -> bool:
         """Apply an add or replace operation."""
         # RFC 7644 Section 3.5.2.1: "If path is specified, add/replace at that path"
         if operation.path is not None:
@@ -280,7 +294,7 @@ def _apply_add_replace(self, resource: Resource, operation: PatchOperation) -> b
         # RFC 7644 Section 3.5.2.1: "If no path specified, add/replace at root level"
         return self._apply_root_attributes(resource, operation.value)
 
-    def _apply_remove(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_remove(self, resource: Resource[Any], operation: PatchOperation) -> bool:
         """Apply a remove operation."""
         # RFC 7644 Section 3.5.2.3: "Path is required for remove operations"
         if operation.path is None:
@@ -313,7 +327,7 @@ def _apply_root_attributes(self, resource: BaseModel, value: Any) -> bool:
         return modified
 
     def _set_value_at_path(
-        self, resource: Resource, path: str, value: Any, is_add: bool
+        self, resource: Resource[Any], path: str, value: Any, is_add: bool
     ) -> bool:
         """Set a value at a specific path."""
         target, attr_path = _resolve_path_to_target(resource, path)
@@ -384,7 +398,11 @@ def _handle_multivalued_add(
         return self._add_single_value(resource, field_name, current_list, value)
 
     def _add_multiple_values(
-        self, resource: BaseModel, field_name: str, current_list: list, values: list
+        self,
+        resource: BaseModel,
+        field_name: str,
+        current_list: list[Any],
+        values: list[Any],
     ) -> bool:
         """Add multiple values to a multi-valued attribute."""
         new_values = []
@@ -400,7 +418,7 @@ def _add_multiple_values(
         return True
 
     def _add_single_value(
-        self, resource: BaseModel, field_name: str, current_list: list, value: Any
+        self, resource: BaseModel, field_name: str, current_list: list[Any], value: Any
     ) -> bool:
         """Add a single value to a multi-valued attribute."""
         # RFC 7644 Section 3.5.2.1: "Do not add duplicate values"
@@ -411,7 +429,7 @@ def _add_single_value(
         setattr(resource, field_name, current_list)
         return True
 
-    def _value_exists_in_list(self, current_list: list, new_value: Any) -> bool:
+    def _value_exists_in_list(self, current_list: list[Any], new_value: Any) -> bool:
         """Check if a value already exists in a list."""
         return any(self._values_match(item, new_value) for item in current_list)
 
@@ -425,7 +443,7 @@ def _create_parent_object(self, resource: BaseModel, parent_field_name: str) ->
         setattr(resource, parent_field_name, parent_obj)
         return parent_obj
 
-    def _remove_value_at_path(self, resource: Resource, path: str) -> bool:
+    def _remove_value_at_path(self, resource: Resource[Any], path: str) -> bool:
         """Remove a value at a specific path."""
         target, attr_path = _resolve_path_to_target(resource, path)
 
@@ -451,7 +469,7 @@ def _remove_value_at_path(self, resource: Resource, path: str) -> bool:
         return self._remove_value_at_path(parent_obj, sub_path)
 
     def _remove_specific_value(
-        self, resource: Resource, path: str, value_to_remove: Any
+        self, resource: Resource[Any], path: str, value_to_remove: Any
     ) -> bool:
         """Remove a specific value from a multi-valued attribute."""
         target, attr_path = _resolve_path_to_target(resource, path)
@@ -486,7 +504,7 @@ def _remove_specific_value(
     def _values_match(self, value1: Any, value2: Any) -> bool:
         """Check if two values match, converting BaseModel to dict for comparison."""
 
-        def to_dict(value):
+        def to_dict(value: Any) -> dict[str, Any]:
             return value.model_dump() if isinstance(value, BaseModel) else value
 
         return to_dict(value1) == to_dict(value2)

scim2_models/resources/group.py

@@ -1,4 +1,5 @@
 from typing import Annotated
+from typing import Any
 from typing import ClassVar
 from typing import Literal
 from typing import Optional
@@ -33,7 +34,7 @@ class GroupMember(MultiValuedComplexAttribute):
     display: Annotated[Optional[str], Mutability.read_only] = None
 
 
-class Group(Resource):
+class Group(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:Group"
     ]

scim2_models/resources/resource.py

@@ -148,7 +148,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
     """A complex attribute containing resource metadata."""
 
     @classmethod
-    def __class_getitem__(cls, item: Any) -> type["Resource"]:
+    def __class_getitem__(cls, item: Any) -> type["Resource[Any]"]:
         """Create a Resource class with extension fields dynamically added."""
         if hasattr(cls, "__scim_extension_metadata__"):
             return cls
@@ -241,12 +241,12 @@ def get_extension_model(
 
     @staticmethod
     def get_by_schema(
-        resource_types: list[type["Resource"]],
+        resource_types: list[type["Resource[Any]"]],
         schema: str,
         with_extensions: bool = True,
-    ) -> Optional[Union[type["Resource"], type["Extension"]]]:
+    ) -> Optional[Union[type["Resource[Any]"], type["Extension"]]]:
         """Given a resource type list and a schema, find the matching resource type."""
-        by_schema: dict[str, Union[type[Resource], type[Extension]]] = {
+        by_schema: dict[str, Union[type[Resource[Any]], type[Extension]]] = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
         }
@@ -263,7 +263,7 @@ def get_by_schema(
 
     @staticmethod
     def get_by_payload(
-        resource_types: list[type["Resource"]],
+        resource_types: list[type["Resource[Any]"]],
         payload: dict[str, Any],
         **kwargs: Any,
     ) -> Optional[type]:
@@ -291,7 +291,7 @@ def to_schema(cls) -> "Schema":
         return _model_to_schema(cls)
 
     @classmethod
-    def from_schema(cls, schema: "Schema") -> type["Resource"]:
+    def from_schema(cls, schema: "Schema") -> type["Resource[Any]"]:
         """Build a :class:`scim2_models.Resource` subclass from the schema definition."""
         from .schema import _make_python_model
 
@@ -372,7 +372,7 @@ def model_dump_json(
         return super(ScimObject, self).model_dump_json(*args, **dump_kwargs)
 
 
-AnyResource = TypeVar("AnyResource", bound="Resource")
+AnyResource = TypeVar("AnyResource", bound="Resource[Any]")
 
 
 def _dedicated_attributes(

scim2_models/resources/resource_type.py

@@ -1,4 +1,5 @@
 from typing import Annotated
+from typing import Any
 from typing import Optional
 
 from pydantic import Field
@@ -34,7 +35,7 @@ class SchemaExtension(ComplexAttribute):
     """
 
 
-class ResourceType(Resource):
+class ResourceType(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:ResourceType"
     ]
@@ -78,7 +79,7 @@ class ResourceType(Resource):
     """A list of URIs of the resource type's schema extensions."""
 
     @classmethod
-    def from_resource(cls, resource_model: type[Resource]) -> Self:
+    def from_resource(cls, resource_model: type[Resource[Any]]) -> Self:
         """Build a naive ResourceType from a resource model."""
         schema = resource_model.model_fields["schemas"].default[0]
         name = schema.split(":")[-1]

scim2_models/resources/schema.py

@@ -258,7 +258,7 @@ def __getitem__(self, name: str) -> "Attribute":
         raise KeyError(f"This attribute has no '{name}' sub-attribute")
 
 
-class Schema(Resource):
+class Schema(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:Schema"
     ]