refactor: move URN validation logic from base.py to scim_object.py

azmeuk · azmeuk · commit 1b57958163e1 · 2025-07-17T10:28:47.000+02:00
diff --git a/scim2_models/base.py b/scim2_models/base.py
@@ -1,4 +1,5 @@
 from inspect import isclass
+from typing import TYPE_CHECKING
 from typing import Any
 from typing import Optional
 from typing import get_args
@@ -28,82 +29,8 @@
 
 from .utils import UNION_TYPES
 
-
-def validate_model_attribute(model: type["BaseModel"], attribute_base: str) -> None:
-    """Validate that an attribute name or a sub-attribute path exist for a given model."""
-    from scim2_models.base import BaseModel
-
-    attribute_name, *sub_attribute_blocks = attribute_base.split(".")
-    sub_attribute_base = ".".join(sub_attribute_blocks)
-
-    aliases = {field.validation_alias for field in model.model_fields.values()}
-
-    if normalize_attribute_name(attribute_name) not in aliases:
-        raise ValueError(
-            f"Model '{model.__name__}' has no attribute named '{attribute_name}'"
-        )
-
-    if sub_attribute_base:
-        attribute_type = model.get_field_root_type(attribute_name)
-
-        if not attribute_type or not issubclass(attribute_type, BaseModel):
-            raise ValueError(
-                f"Attribute '{attribute_name}' is not a complex attribute, and cannot have a '{sub_attribute_base}' sub-attribute"
-            )
-
-        validate_model_attribute(attribute_type, sub_attribute_base)
-
-
-def extract_schema_and_attribute_base(attribute_urn: str) -> tuple[str, str]:
-    # Extract the schema urn part and the attribute name part from attribute
-    # name, as defined in :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
-
-    *urn_blocks, attribute_base = attribute_urn.split(":")
-    schema = ":".join(urn_blocks)
-    return schema, attribute_base
-
-
-def validate_attribute_urn(
-    attribute_name: str,
-    default_resource: Optional[type["BaseModel"]] = None,
-    resource_types: Optional[list[type["BaseModel"]]] = None,
-) -> str:
-    """Validate that an attribute urn is valid or not.
-
-    :param attribute_name: The attribute urn to check.
-    :default_resource: The default resource if `attribute_name` is not an absolute urn.
-    :resource_types: The available resources in which to look for the attribute.
-    :return: The normalized attribute URN.
-    """
-    from scim2_models.rfc7643.resource import Resource
-
-    if not resource_types:
-        resource_types = []
-
-    if default_resource and default_resource not in resource_types:
-        resource_types.append(default_resource)
-
-    default_schema = (
-        default_resource.model_fields["schemas"].default[0]
-        if default_resource
-        else None
-    )
-
-    schema: Optional[Any]
-    schema, attribute_base = extract_schema_and_attribute_base(attribute_name)
-    if not schema:
-        schema = default_schema
-
-    if not schema:
-        raise ValueError("No default schema and relative URN")
-
-    resource = Resource.get_by_schema(resource_types, schema)
-    if not resource:
-        raise ValueError(f"No resource matching schema '{schema}'")
-
-    validate_model_attribute(resource, attribute_base)
-
-    return f"{schema}:{attribute_base}"
+if TYPE_CHECKING:
+    pass
 
 
 def contains_attribute_or_subattributes(
diff --git a/scim2_models/rfc7643/resource.py b/scim2_models/rfc7643/resource.py
@@ -25,8 +25,10 @@
 from ..attributes import is_complex_attribute
 from ..base import BaseModel
 from ..base import BaseModelType
+from ..context import Context
 from ..reference import Reference
 from ..scim_object import ScimObject
+from ..scim_object import validate_attribute_urn
 from ..utils import UNION_TYPES
 from ..utils import normalize_attribute_name
 
@@ -208,15 +210,17 @@ def get_extension_model(
 
     @staticmethod
     def get_by_schema(
-        resource_types: list[type[BaseModel]], schema: str, with_extensions: bool = True
-    ) -> Optional[type]:
+        resource_types: list[type["Resource"]],
+        schema: str,
+        with_extensions: bool = True,
+    ) -> Optional[Union[type["Resource"], type["Extension"]]]:
         """Given a resource type list and a schema, find the matching resource type."""
-        by_schema = {
+        by_schema: dict[str, Union[type[Resource], type[Extension]]] = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
         }
         if with_extensions:
-            for resource_type in list(by_schema.values()):
+            for resource_type in resource_types:
                 by_schema.update(
                     {
                         schema.lower(): extension
@@ -228,7 +232,7 @@ def get_by_schema(
 
     @staticmethod
     def get_by_payload(
-        resource_types: list[type], payload: dict, **kwargs: Any
+        resource_types: list[type["Resource"]], payload: dict, **kwargs: Any
     ) -> Optional[type]:
         """Given a resource type list and a payload, find the matching resource type."""
         if not payload or not payload.get("schemas"):
@@ -260,6 +264,74 @@ def from_schema(cls, schema: "Schema") -> type["Resource"]:
 
         return make_python_model(schema, cls)
 
+    def _prepare_model_dump(
+        self,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        kwargs = super()._prepare_model_dump(scim_ctx, **kwargs)
+        kwargs["context"]["scim_attributes"] = [
+            validate_attribute_urn(attribute, self.__class__)
+            for attribute in (attributes or [])
+        ]
+        kwargs["context"]["scim_excluded_attributes"] = [
+            validate_attribute_urn(attribute, self.__class__)
+            for attribute in (excluded_attributes or [])
+        ]
+        return kwargs
+
+    def model_dump(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> dict:
+        """Create a model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        :param attributes: A multi-valued list of strings indicating the names of resource
+            attributes to return in the response, overriding the set of attributes that
+            would be returned by default.
+        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
+            attributes to be removed from the default set of attributes to return.
+        """
+        dump_kwargs = self._prepare_model_dump(
+            scim_ctx, attributes, excluded_attributes, **kwargs
+        )
+        if scim_ctx:
+            dump_kwargs.setdefault("mode", "json")
+        return super(ScimObject, self).model_dump(*args, **dump_kwargs)
+
+    def model_dump_json(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Create a JSON model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump_json`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        :param attributes: A multi-valued list of strings indicating the names of resource
+            attributes to return in the response, overriding the set of attributes that
+            would be returned by default.
+        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
+            attributes to be removed from the default set of attributes to return.
+        """
+        dump_kwargs = self._prepare_model_dump(
+            scim_ctx, attributes, excluded_attributes, **kwargs
+        )
+        return super(ScimObject, self).model_dump_json(*args, **dump_kwargs)
+
 
 AnyResource = TypeVar("AnyResource", bound="Resource")
 
diff --git a/scim2_models/scim_object.py b/scim2_models/scim_object.py
@@ -1,13 +1,93 @@
 """Base SCIM object classes with schema identification."""
 
+from typing import TYPE_CHECKING
 from typing import Annotated
 from typing import Any
 from typing import Optional
 
 from .annotations import Required
 from .base import BaseModel
-from .base import validate_attribute_urn
 from .context import Context
+from .utils import normalize_attribute_name
+
+if TYPE_CHECKING:
+    from .rfc7643.resource import Resource
+
+
+def validate_model_attribute(model: type["BaseModel"], attribute_base: str) -> None:
+    """Validate that an attribute name or a sub-attribute path exist for a given model."""
+    attribute_name, *sub_attribute_blocks = attribute_base.split(".")
+    sub_attribute_base = ".".join(sub_attribute_blocks)
+
+    aliases = {field.validation_alias for field in model.model_fields.values()}
+
+    if normalize_attribute_name(attribute_name) not in aliases:
+        raise ValueError(
+            f"Model '{model.__name__}' has no attribute named '{attribute_name}'"
+        )
+
+    if sub_attribute_base:
+        attribute_type = model.get_field_root_type(attribute_name)
+
+        if not attribute_type or not issubclass(attribute_type, BaseModel):
+            raise ValueError(
+                f"Attribute '{attribute_name}' is not a complex attribute, and cannot have a '{sub_attribute_base}' sub-attribute"
+            )
+
+        validate_model_attribute(attribute_type, sub_attribute_base)
+
+
+def extract_schema_and_attribute_base(attribute_urn: str) -> tuple[str, str]:
+    """Extract the schema urn part and the attribute name part from attribute name.
+
+    As defined in :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
+    """
+    *urn_blocks, attribute_base = attribute_urn.split(":")
+    schema = ":".join(urn_blocks)
+    return schema, attribute_base
+
+
+def validate_attribute_urn(
+    attribute_name: str,
+    default_resource: Optional[type["Resource"]] = None,
+    resource_types: Optional[list[type["Resource"]]] = None,
+) -> str:
+    """Validate that an attribute urn is valid or not.
+
+    :param attribute_name: The attribute urn to check.
+    :default_resource: The default resource if `attribute_name` is not an absolute urn.
+    :resource_types: The available resources in which to look for the attribute.
+    :return: The normalized attribute URN.
+    """
+    from .rfc7643.resource import Resource
+
+    if not resource_types:
+        resource_types = []
+
+    if default_resource and default_resource not in resource_types:
+        resource_types.append(default_resource)
+
+    default_schema = (
+        default_resource.model_fields["schemas"].default[0]
+        if default_resource
+        else None
+    )
+
+    schema: Optional[Any]
+    schema, attribute_base = extract_schema_and_attribute_base(attribute_name)
+    if not schema:
+        schema = default_schema
+
+    if not schema:
+        raise ValueError("No default schema and relative URN")
+
+    resource = Resource.get_by_schema(resource_types, schema)
+    if not resource:
+        raise ValueError(f"No resource matching schema '{schema}'")
+
+    validate_model_attribute(resource, attribute_base)
+
+    return f"{schema}:{attribute_base}"
 
 
 class ScimObject(BaseModel):
@@ -17,46 +97,19 @@ class ScimObject(BaseModel):
     SCIM schemas that define the attributes present in the current JSON
     structure."""
 
-    def _prepare_model_dump(
-        self,
-        scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> dict[str, Any]:
-        kwargs = super()._prepare_model_dump(scim_ctx, **kwargs)
-        kwargs["context"]["scim_attributes"] = [
-            validate_attribute_urn(attribute, self.__class__)
-            for attribute in (attributes or [])
-        ]
-        kwargs["context"]["scim_excluded_attributes"] = [
-            validate_attribute_urn(attribute, self.__class__)
-            for attribute in (excluded_attributes or [])
-        ]
-        return kwargs
-
     def model_dump(
         self,
         *args: Any,
         scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> dict:
         """Create a model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump`.
 
         :param scim_ctx: If a SCIM context is passed, some default values of
             Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
             messages. Pass :data:`None` to get the default Pydantic behavior.
-        :param attributes: A multi-valued list of strings indicating the names of resource
-            attributes to return in the response, overriding the set of attributes that
-            would be returned by default.
-        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
-            attributes to be removed from the default set of attributes to return.
         """
-        dump_kwargs = self._prepare_model_dump(
-            scim_ctx, attributes, excluded_attributes, **kwargs
-        )
+        dump_kwargs = self._prepare_model_dump(scim_ctx, **kwargs)
         if scim_ctx:
             dump_kwargs.setdefault("mode", "json")
         return super(BaseModel, self).model_dump(*args, **dump_kwargs)
@@ -65,22 +118,13 @@ def model_dump_json(
         self,
         *args: Any,
         scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> str:
         """Create a JSON model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump_json`.
 
         :param scim_ctx: If a SCIM context is passed, some default values of
             Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
             messages. Pass :data:`None` to get the default Pydantic behavior.
-        :param attributes: A multi-valued list of strings indicating the names of resource
-            attributes to return in the response, overriding the set of attributes that
-            would be returned by default.
-        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
-            attributes to be removed from the default set of attributes to return.
         """
-        dump_kwargs = self._prepare_model_dump(
-            scim_ctx, attributes, excluded_attributes, **kwargs
-        )
+        dump_kwargs = self._prepare_model_dump(scim_ctx, **kwargs)
         return super(BaseModel, self).model_dump_json(*args, **dump_kwargs)
diff --git a/tests/test_model_attributes.py b/tests/test_model_attributes.py
