scim2-models 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

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."""
 
@@ -53,5 +53,5 @@ def is_complex_attribute(type_: type) -> bool:
     return (
         get_origin(type_) != Reference
         and isclass(type_)
-        and issubclass(type_, (ComplexAttribute, MultiValuedComplexAttribute))
+        and issubclass(type_, ComplexAttribute)
     )

scim2_models/base.py

@@ -220,8 +220,8 @@ class BaseModel(PydanticBaseModel):
         """
 
         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 @@ class _GenericMessageMetaclass(ModelMetaclass):
         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 Any
 from typing import Generic
 from typing import Optional
 from typing import TypeVar
+from typing import Union
 
 from pydantic import Field
 from pydantic import ValidationInfo
@@ -21,12 +22,13 @@ from ..resources.resource import Resource
 from ..urn import _resolve_path_to_target
 from ..utils import _extract_field_name
 from ..utils import _find_field_name
+from ..utils import _get_path_parts
 from ..utils import _validate_scim_path_syntax
 from .error import Error
 from .message import Message
 from .message import _get_resource_class
 
-T = TypeVar("T", bound=Resource)
+T = TypeVar("T", bound=Resource[Any])
 
 
 class PatchOperation(ComplexAttribute):
@@ -51,7 +53,7 @@ class PatchOperation(ComplexAttribute):
     describing the target of the operation."""
 
     def _validate_mutability(
-        self, resource_class: type[BaseModel], field_name: str
+        self, resource_class: type[Resource[Any]], field_name: str
     ) -> None:
         """Validate mutability constraints."""
         # RFC 7644 Section 3.5.2: "Servers should be tolerant of schema extensions"
@@ -72,7 +74,7 @@ class PatchOperation(ComplexAttribute):
             raise ValueError(Error.make_mutability_error().detail)
 
     def _validate_required_attribute(
-        self, resource_class: type[BaseModel], field_name: str
+        self, resource_class: type[Resource[Any]], field_name: str
     ) -> None:
         """Validate required attribute constraints for remove operations."""
         # RFC 7644 Section 3.5.2.3: Only validate for remove operations
@@ -143,7 +145,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 +164,48 @@ class PatchOp(Message, Generic[T]):
 
         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"
@@ -207,12 +218,17 @@ class PatchOp(Message, Generic[T]):
     "Operations", whose value is an array of one or more PATCH operations."""
 
     @model_validator(mode="after")
-    def validate_operations(self) -> Self:
+    def validate_operations(self, info: ValidationInfo) -> Self:
         """Validate operations against resource type metadata if available.
 
         When PatchOp is used with a specific resource type (e.g., PatchOp[User]),
         this validator will automatically check mutability and required constraints.
         """
+        # RFC 7644: The body of an HTTP PATCH request MUST contain the attribute "Operations"
+        scim_ctx = info.context.get("scim") if info.context else None
+        if scim_ctx == Context.RESOURCE_PATCH_REQUEST and self.operations is None:
+            raise ValueError(Error.make_invalid_value_error().detail)
+
         resource_class = _get_resource_class(self)
         if resource_class is None or not self.operations:
             return self
@@ -254,7 +270,9 @@ class PatchOp(Message, Generic[T]):
 
         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 +284,9 @@ class PatchOp(Message, Generic[T]):
 
         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 +300,7 @@ class PatchOp(Message, Generic[T]):
         # 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:
@@ -294,7 +314,8 @@ class PatchOp(Message, Generic[T]):
 
         return self._remove_value_at_path(resource, operation.path)
 
-    def _apply_root_attributes(self, resource: BaseModel, value: Any) -> bool:
+    @classmethod
+    def _apply_root_attributes(cls, resource: BaseModel, value: Any) -> bool:
         """Apply attributes to the resource root."""
         if not isinstance(value, dict):
             return False
@@ -312,23 +333,34 @@ class PatchOp(Message, Generic[T]):
 
         return modified
 
+    @classmethod
     def _set_value_at_path(
-        self, resource: Resource, path: str, value: Any, is_add: bool
+        cls, 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)
 
-        if not attr_path or not target:
+        if not target:
             raise ValueError(Error.make_invalid_path_error().detail)
 
-        path_parts = attr_path.split(".")
+        if not attr_path:
+            if not isinstance(value, dict):
+                raise ValueError(Error.make_invalid_path_error().detail)
+
+            updated_data = {**target.model_dump(), **value}
+            updated_target = type(target).model_validate(updated_data)
+            target.__dict__.update(updated_target.__dict__)
+            return True
+
+        path_parts = _get_path_parts(attr_path)
         if len(path_parts) == 1:
-            return self._set_simple_attribute(target, path_parts[0], value, is_add)
+            return cls._set_simple_attribute(target, path_parts[0], value, is_add)
 
-        return self._set_complex_attribute(target, path_parts, value, is_add)
+        return cls._set_complex_attribute(target, path_parts, value, is_add)
 
+    @classmethod
     def _set_simple_attribute(
-        self, resource: BaseModel, attr_name: str, value: Any, is_add: bool
+        cls, resource: BaseModel, attr_name: str, value: Any, is_add: bool
     ) -> bool:
         """Set a value on a simple (non-nested) attribute."""
         field_name = _find_field_name(type(resource), attr_name)
@@ -336,8 +368,8 @@ class PatchOp(Message, Generic[T]):
             raise ValueError(Error.make_no_target_error().detail)
 
         # RFC 7644 Section 3.5.2.1: "For multi-valued attributes, add operation appends values"
-        if is_add and self._is_multivalued_field(resource, field_name):
-            return self._handle_multivalued_add(resource, field_name, value)
+        if is_add and cls._is_multivalued_field(resource, field_name):
+            return cls._handle_multivalued_add(resource, field_name, value)
 
         old_value = getattr(resource, field_name)
         if old_value == value:
@@ -346,8 +378,9 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, field_name, value)
         return True
 
+    @classmethod
     def _set_complex_attribute(
-        self, resource: BaseModel, path_parts: list[str], value: Any, is_add: bool
+        cls, resource: BaseModel, path_parts: list[str], value: Any, is_add: bool
     ) -> bool:
         """Set a value on a complex (nested) attribute."""
         parent_attr = path_parts[0]
@@ -359,38 +392,45 @@ class PatchOp(Message, Generic[T]):
 
         parent_obj = getattr(resource, parent_field_name)
         if parent_obj is None:
-            parent_obj = self._create_parent_object(resource, parent_field_name)
+            parent_obj = cls._create_parent_object(resource, parent_field_name)
             if parent_obj is None:
                 return False
 
-        return self._set_value_at_path(parent_obj, sub_path, value, is_add)
+        return cls._set_value_at_path(parent_obj, sub_path, value, is_add)
 
-    def _is_multivalued_field(self, resource: BaseModel, field_name: str) -> bool:
+    @classmethod
+    def _is_multivalued_field(cls, resource: BaseModel, field_name: str) -> bool:
         """Check if a field is multi-valued."""
         return hasattr(resource, field_name) and type(resource).get_field_multiplicity(
             field_name
         )
 
+    @classmethod
     def _handle_multivalued_add(
-        self, resource: BaseModel, field_name: str, value: Any
+        cls, resource: BaseModel, field_name: str, value: Any
     ) -> bool:
         """Handle adding values to a multi-valued attribute."""
         current_list = getattr(resource, field_name) or []
 
         # RFC 7644 Section 3.5.2.1: "Add operation appends values to multi-valued attributes"
         if isinstance(value, list):
-            return self._add_multiple_values(resource, field_name, current_list, value)
+            return cls._add_multiple_values(resource, field_name, current_list, value)
 
-        return self._add_single_value(resource, field_name, current_list, value)
+        return cls._add_single_value(resource, field_name, current_list, value)
 
+    @classmethod
     def _add_multiple_values(
-        self, resource: BaseModel, field_name: str, current_list: list, values: list
+        cls,
+        resource: BaseModel,
+        field_name: str,
+        current_list: list[Any],
+        values: list[Any],
     ) -> bool:
         """Add multiple values to a multi-valued attribute."""
         new_values = []
         # RFC 7644 Section 3.5.2.1: "Do not add duplicate values"
         for new_val in values:
-            if not self._value_exists_in_list(current_list, new_val):
+            if not cls._value_exists_in_list(current_list, new_val):
                 new_values.append(new_val)
 
         if not new_values:
@@ -399,23 +439,26 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, field_name, current_list + new_values)
         return True
 
+    @classmethod
     def _add_single_value(
-        self, resource: BaseModel, field_name: str, current_list: list, value: Any
+        cls, 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"
-        if self._value_exists_in_list(current_list, value):
+        if cls._value_exists_in_list(current_list, value):
             return False
 
         current_list.append(value)
         setattr(resource, field_name, current_list)
         return True
 
-    def _value_exists_in_list(self, current_list: list, new_value: Any) -> bool:
+    @classmethod
+    def _value_exists_in_list(cls, 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)
+        return any(cls._values_match(item, new_value) for item in current_list)
 
-    def _create_parent_object(self, resource: BaseModel, parent_field_name: str) -> Any:
+    @classmethod
+    def _create_parent_object(cls, resource: BaseModel, parent_field_name: str) -> Any:
         """Create a parent object if it doesn't exist."""
         parent_class = type(resource).get_field_root_type(parent_field_name)
         if not parent_class or not isclass(parent_class):
@@ -425,7 +468,8 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, parent_field_name, parent_obj)
         return parent_obj
 
-    def _remove_value_at_path(self, resource: Resource, path: str) -> bool:
+    @classmethod
+    def _remove_value_at_path(cls, resource: Resource[Any], path: str) -> bool:
         """Remove a value at a specific path."""
         target, attr_path = _resolve_path_to_target(resource, path)
 
@@ -433,7 +477,7 @@ class PatchOp(Message, Generic[T]):
         if not attr_path or not target:
             raise ValueError(Error.make_invalid_path_error().detail)
 
-        parent_attr, *path_parts = attr_path.split(".")
+        parent_attr, *path_parts = _get_path_parts(attr_path)
         field_name = _find_field_name(type(target), parent_attr)
         if not field_name:
             raise ValueError(Error.make_no_target_error().detail)
@@ -448,10 +492,11 @@ class PatchOp(Message, Generic[T]):
             return True
 
         sub_path = ".".join(path_parts)
-        return self._remove_value_at_path(parent_obj, sub_path)
+        return cls._remove_value_at_path(parent_obj, sub_path)
 
+    @classmethod
     def _remove_specific_value(
-        self, resource: Resource, path: str, value_to_remove: Any
+        cls, 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)
@@ -472,7 +517,7 @@ class PatchOp(Message, Generic[T]):
         modified = False
         # RFC 7644 Section 3.5.2.3: "Remove matching values from multi-valued attributes"
         for item in current_list:
-            if not self._values_match(item, value_to_remove):
+            if not cls._values_match(item, value_to_remove):
                 new_list.append(item)
             else:
                 modified = True
@@ -483,10 +528,11 @@ class PatchOp(Message, Generic[T]):
 
         return False
 
-    def _values_match(self, value1: Any, value2: Any) -> bool:
+    @classmethod
+    def _values_match(cls, 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/messages/search_request.py

@@ -71,9 +71,7 @@ class SearchRequest(Message):
         """Validate syntax of sort_by attribute path.
 
         :param v: The sort_by attribute path to validate
-        :type v: Optional[str]
         :return: The validated sort_by attribute path
-        :rtype: Optional[str]
         :raises ValueError: If sort_by attribute path has invalid syntax
         """
         if v is None:

scim2_models/reference.py

@@ -61,9 +61,7 @@ class Reference(UserString, Generic[ReferenceTypes]):
         """Get reference types from a type annotation.
 
         :param type_annotation: Type annotation to extract reference types from
-        :type type_annotation: Any
         :return: List of reference type strings
-        :rtype: list[str]
         """
         first_arg = get_args(type_annotation)[0]
         types = (

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
@@ -9,12 +10,11 @@ from pydantic import Field
 from ..annotations import Mutability
 from ..annotations import Required
 from ..attributes import ComplexAttribute
-from ..attributes import MultiValuedComplexAttribute
 from ..reference import Reference
 from .resource import Resource
 
 
-class GroupMember(MultiValuedComplexAttribute):
+class GroupMember(ComplexAttribute):
     value: Annotated[Optional[str], Mutability.immutable] = None
     """Identifier of the member of this Group."""
 
@@ -33,7 +33,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

@@ -22,7 +22,6 @@ from ..annotations import Required
 from ..annotations import Returned
 from ..annotations import Uniqueness
 from ..attributes import ComplexAttribute
-from ..attributes import MultiValuedComplexAttribute
 from ..attributes import is_complex_attribute
 from ..base import BaseModel
 from ..context import Context
@@ -148,7 +147,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 +240,12 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
     @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 +262,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
     @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 +290,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
         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 +371,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
         return super(ScimObject, self).model_dump_json(*args, **dump_kwargs)
 
 
-AnyResource = TypeVar("AnyResource", bound="Resource")
+AnyResource = TypeVar("AnyResource", bound="Resource[Any]")
 
 
 def _dedicated_attributes(
@@ -437,10 +436,7 @@ def _model_attribute_to_scim_attribute(
     sub_attributes = (
         [
             _model_attribute_to_scim_attribute(root_type, sub_attribute_name)
-            for sub_attribute_name in _dedicated_attributes(
-                root_type,
-                [MultiValuedComplexAttribute],
-            )
+            for sub_attribute_name in root_type.model_fields  # type: ignore
             if (
                 attribute_name != "sub_attributes"
                 or sub_attribute_name != "sub_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

@@ -23,7 +23,6 @@ from ..annotations import Required
 from ..annotations import Returned
 from ..annotations import Uniqueness
 from ..attributes import ComplexAttribute
-from ..attributes import MultiValuedComplexAttribute
 from ..attributes import is_complex_attribute
 from ..base import BaseModel
 from ..constants import RESERVED_WORDS
@@ -49,7 +48,6 @@ def _make_python_identifier(identifier: str) -> str:
 def _make_python_model(
     obj: Union["Schema", "Attribute"],
     base: type[T],
-    multiple: bool = False,
 ) -> type[T]:
     """Build a Python model from a Schema or an Attribute object."""
     if isinstance(obj, Attribute):
@@ -99,7 +97,6 @@ class Attribute(ComplexAttribute):
 
         def _to_python(
             self,
-            multiple: bool = False,
             reference_types: Optional[list[str]] = None,
         ) -> type:
             if self.value == self.reference and reference_types is not None:
@@ -119,9 +116,7 @@ class Attribute(ComplexAttribute):
                 self.integer: int,
                 self.date_time: datetime,
                 self.binary: Base64Bytes,
-                self.complex: MultiValuedComplexAttribute
-                if multiple
-                else ComplexAttribute,
+                self.complex: ComplexAttribute,
             }
             return attr_types[self.value]
 
@@ -215,12 +210,10 @@ class Attribute(ComplexAttribute):
         if not self.name or not self.type:
             return None
 
-        attr_type = self.type._to_python(bool(self.multi_valued), self.reference_types)
+        attr_type = self.type._to_python(self.reference_types)
 
-        if attr_type in (ComplexAttribute, MultiValuedComplexAttribute):
-            attr_type = _make_python_model(
-                obj=self, base=attr_type, multiple=bool(self.multi_valued)
-            )
+        if attr_type == ComplexAttribute:
+            attr_type = _make_python_model(obj=self, base=attr_type)
 
         if self.multi_valued:
             attr_type = list[attr_type]  # type: ignore
@@ -258,7 +251,7 @@ class Attribute(ComplexAttribute):
         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"
     ]

scim2_models/resources/service_provider_config.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import Annotated
+from typing import Any
 from typing import Optional
 
 from pydantic import Field
@@ -37,7 +38,7 @@ class Filter(ComplexAttribute):
     """A Boolean value specifying whether or not the operation is supported."""
 
     max_results: Annotated[Optional[int], Mutability.read_only, Required.true] = None
-    """A Boolean value specifying whether or not the operation is supported."""
+    """An integer value specifying the maximum number of resources returned in a response."""
 
 
 class ChangePassword(ComplexAttribute):
@@ -65,7 +66,7 @@ class AuthenticationScheme(ComplexAttribute):
 
     type: Annotated[Optional[Type], Mutability.read_only, Required.true] = Field(
         None,
-        examples=["oauth", "oauth2", "oauthbreakertoken", "httpbasic", "httpdigest"],
+        examples=["oauth", "oauth2", "oauthbearertoken", "httpbasic", "httpdigest"],
     )
     """The authentication scheme."""
 
@@ -93,7 +94,7 @@ class AuthenticationScheme(ComplexAttribute):
     address."""
 
 
-class ServiceProviderConfig(Resource):
+class ServiceProviderConfig(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"
     ]