scim2-models 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

scim2_models/resources/schema.py

@@ -4,12 +4,11 @@ from enum import Enum
 from typing import Annotated
 from typing import Any
 from typing import List  # noqa : UP005,UP035
-from typing import Literal
 from typing import Optional
 from typing import TypeVar
 from typing import Union
-from typing import get_origin
 
+from pydantic import Base64Bytes
 from pydantic import Field
 from pydantic import create_model
 from pydantic import field_validator
@@ -26,10 +25,10 @@ from ..attributes import ComplexAttribute
 from ..attributes import is_complex_attribute
 from ..base import BaseModel
 from ..constants import RESERVED_WORDS
-from ..reference import ExternalReference
+from ..path import URN
+from ..reference import URI
+from ..reference import External
 from ..reference import Reference
-from ..reference import URIReference
-from ..utils import Base64Bytes
 from ..utils import _normalize_attribute_name
 from .resource import Resource
 
@@ -65,10 +64,6 @@ def _make_python_model(
             for attr in (obj.attributes or [])
             if attr.name
         }
-        pydantic_attributes["schemas"] = (
-            Annotated[list[str], Required.true],
-            Field(default=[obj.id]),
-        )
 
     if not obj.name:
         raise ValueError("Schema or Attribute 'name' must be defined")
@@ -76,8 +71,9 @@ def _make_python_model(
     model_name = to_pascal(to_snake(obj.name))
     model: type[T] = create_model(model_name, __base__=base, **pydantic_attributes)  # type: ignore[call-overload]
 
-    # Set the ComplexType class as a member of the model
-    # e.g. make Member an attribute of Group
+    if isinstance(obj, Schema) and obj.id:
+        model.__schema__ = URN(obj.id)  # type: ignore[attr-defined]
+
     for attr_name in model.model_fields:
         attr_type = model.get_field_root_type(attr_name)
         if attr_type and is_complex_attribute(attr_type):
@@ -103,13 +99,14 @@ class Attribute(ComplexAttribute):
         ) -> type:
             if self.value == self.reference and reference_types is not None:
                 if reference_types == ["external"]:
-                    return Reference[ExternalReference]
+                    return Reference[External]
 
                 if reference_types == ["uri"]:
-                    return Reference[URIReference]
+                    return Reference[URI]
 
-                types = tuple(Literal[t] for t in reference_types)
-                return Reference[Union[types]]  # type: ignore  # noqa: UP007
+                if len(reference_types) == 1:
+                    return Reference[reference_types[0]]  # type: ignore[valid-type]
+                return Reference[Union[tuple(reference_types)]]  # type: ignore[misc,return-value] # noqa: UP007
 
             attr_types = {
                 self.string: str,
@@ -124,7 +121,7 @@ class Attribute(ComplexAttribute):
 
         @classmethod
         def from_python(cls, pytype: type) -> "Attribute.Type":
-            if get_origin(pytype) == Reference:
+            if isinstance(pytype, type) and issubclass(pytype, Reference):
                 return cls.reference
 
             if pytype and is_complex_attribute(pytype):
@@ -254,9 +251,7 @@ class Attribute(ComplexAttribute):
 
 
 class Schema(Resource[Any]):
-    schemas: Annotated[list[str], Required.true] = [
-        "urn:ietf:params:scim:schemas:core:2.0:Schema"
-    ]
+    __schema__ = URN("urn:ietf:params:scim:schemas:core:2.0:Schema")
 
     id: Annotated[str | None, Mutability.read_only, Required.true] = None
     """The unique URI of the schema."""
@@ -288,7 +283,7 @@ class Schema(Resource[Any]):
                 return attribute
         return None
 
-    def __getitem__(self, name: str) -> "Attribute":  # type: ignore[override]
+    def __getitem__(self, name: str) -> "Attribute":
         """Find an attribute by its name."""
         if attribute := self.get_attribute(name):
             return attribute

scim2_models/resources/service_provider_config.py

@@ -9,7 +9,8 @@ from ..annotations import Required
 from ..annotations import Returned
 from ..annotations import Uniqueness
 from ..attributes import ComplexAttribute
-from ..reference import ExternalReference
+from ..path import URN
+from ..reference import External
 from ..reference import Reference
 from .resource import Resource
 
@@ -73,15 +74,13 @@ class AuthenticationScheme(ComplexAttribute):
     description: Annotated[str | None, Mutability.read_only, Required.true] = None
     """A description of the authentication scheme."""
 
-    spec_uri: Annotated[Reference[ExternalReference] | None, Mutability.read_only] = (
-        None
-    )
+    spec_uri: Annotated[Reference[External] | None, Mutability.read_only] = None
     """An HTTP-addressable URL pointing to the authentication scheme's
     specification."""
 
-    documentation_uri: Annotated[
-        Reference[ExternalReference] | None, Mutability.read_only
-    ] = None
+    documentation_uri: Annotated[Reference[External] | None, Mutability.read_only] = (
+        None
+    )
     """An HTTP-addressable URL pointing to the authentication scheme's usage
     documentation."""
 
@@ -92,9 +91,7 @@ class AuthenticationScheme(ComplexAttribute):
 
 
 class ServiceProviderConfig(Resource[Any]):
-    schemas: Annotated[list[str], Required.true] = [
-        "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"
-    ]
+    __schema__ = URN("urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig")
 
     id: Annotated[
         str | None, Mutability.read_only, Returned.default, Uniqueness.global_
@@ -106,9 +103,9 @@ class ServiceProviderConfig(Resource[Any]):
     #     resources, the "id" attribute is not required for the service
     #     provider configuration resource
 
-    documentation_uri: Annotated[
-        Reference[ExternalReference] | None, Mutability.read_only
-    ] = None
+    documentation_uri: Annotated[Reference[External] | None, Mutability.read_only] = (
+        None
+    )
     """An HTTP-addressable URL pointing to the service provider's human-
     consumable help documentation."""
 

scim2_models/resources/user.py

@@ -1,8 +1,10 @@
 from enum import Enum
+from typing import TYPE_CHECKING
 from typing import Annotated
 from typing import ClassVar
-from typing import Literal
+from typing import Union
 
+from pydantic import Base64Bytes
 from pydantic import EmailStr
 from pydantic import Field
 
@@ -12,12 +14,15 @@ from ..annotations import Required
 from ..annotations import Returned
 from ..annotations import Uniqueness
 from ..attributes import ComplexAttribute
-from ..reference import ExternalReference
+from ..path import URN
+from ..reference import External
 from ..reference import Reference
-from ..utils import Base64Bytes
 from .resource import AnyExtension
 from .resource import Resource
 
+if TYPE_CHECKING:
+    from .group import Group
+
 
 class Name(ComplexAttribute):
     formatted: str | None = None
@@ -126,7 +131,7 @@ class Photo(ComplexAttribute):
         photo = "photo"
         thumbnail = "thumbnail"
 
-    value: Annotated[Reference[ExternalReference] | None, CaseExact.true] = None
+    value: Annotated[Reference[External] | None, CaseExact.true] = None
     """URL of a photo of the User."""
 
     display: str | None = None
@@ -197,8 +202,8 @@ class GroupMembership(ComplexAttribute):
     value: Annotated[str | None, Mutability.read_only] = None
     """The identifier of the User's group."""
 
-    ref: Annotated[
-        Reference[Literal["User"] | Literal["Group"]] | None,
+    ref: Annotated[  # type: ignore[type-arg]
+        Reference[Union["User", "Group"]] | None,
         Mutability.read_only,
     ] = Field(None, serialization_alias="$ref")
     """The reference URI of a target resource, if the attribute is a
@@ -245,9 +250,7 @@ class X509Certificate(ComplexAttribute):
 
 
 class User(Resource[AnyExtension]):
-    schemas: Annotated[list[str], Required.true] = [
-        "urn:ietf:params:scim:schemas:core:2.0:User"
-    ]
+    __schema__ = URN("urn:ietf:params:scim:schemas:core:2.0:User")
 
     user_name: Annotated[str | None, Uniqueness.server, Required.true] = None
     """Unique identifier for the User, typically used by the user to directly
@@ -265,7 +268,7 @@ class User(Resource[AnyExtension]):
     """The casual way to address the user in real life, e.g., 'Bob' or 'Bobby'
     instead of 'Robert'."""
 
-    profile_url: Reference[ExternalReference] | None = None
+    profile_url: Reference[External] | None = None
     """A fully qualified URL pointing to a page representing the User's online
     profile."""
 

scim2_models/scim_object.py

@@ -1,24 +1,107 @@
 """Base SCIM object classes with schema identification."""
 
+import warnings
 from typing import TYPE_CHECKING
 from typing import Annotated
 from typing import Any
+from typing import ClassVar
+
+from pydantic import ValidationInfo
+from pydantic import ValidatorFunctionWrapHandler
+from pydantic import model_validator
+from pydantic._internal._model_construction import ModelMetaclass
+from pydantic_core import PydanticCustomError
+from typing_extensions import Self
 
 from .annotations import Required
 from .base import BaseModel
 from .context import Context
+from .path import URN
 
 if TYPE_CHECKING:
     pass
 
 
-class ScimObject(BaseModel):
+class ScimMetaclass(ModelMetaclass):
+    """Metaclass for SCIM objects that handles __schema__ backward compatibility."""
+
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        **kwargs: Any,
+    ) -> type:
+        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+
+        if name in ("ScimObject", "Resource", "Extension"):
+            return cls
+
+        if getattr(cls, "__schema__", None) is None:
+            schemas_field = cls.model_fields.get("schemas")  # type: ignore[attr-defined]
+            if (
+                schemas_field
+                and schemas_field.default
+                and isinstance(schemas_field.default, list)
+                and schemas_field.default
+            ):
+                schema_value = schemas_field.default[0]
+                try:
+                    cls.__schema__ = URN(schema_value)  # type: ignore[attr-defined]
+                    warnings.warn(
+                        f"{name}: Defining schemas with a default value is deprecated "
+                        f"and will be removed in version 0.7. "
+                        f'Use __schema__ = URN("{schema_value}") instead.',
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                except ValueError:
+                    pass
+
+        return cls
+
+
+class ScimObject(BaseModel, metaclass=ScimMetaclass):
+    __schema__: ClassVar[URN | None] = None
+
     schemas: Annotated[list[str], Required.true]
     """The "schemas" attribute is a REQUIRED attribute and is an array of
     Strings containing URIs that are used to indicate the namespaces of the
     SCIM schemas that define the attributes present in the current JSON
     structure."""
 
+    @model_validator(mode="before")
+    @classmethod
+    def _populate_schemas_default(cls, data: Any) -> Any:
+        """Auto-generate schemas from __schema__ if not provided."""
+        if isinstance(data, dict) and "schemas" not in data:
+            schema = getattr(cls, "__schema__", None)
+            if schema:
+                data = {**data, "schemas": [schema]}
+        return data
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def _validate_schemas_attribute(
+        cls, value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
+    ) -> Self:
+        """Validate that the base schema is present in schemas attribute."""
+        obj: Self = handler(value)
+
+        scim_ctx = info.context.get("scim") if info.context else None
+        if scim_ctx is None or scim_ctx == Context.DEFAULT:
+            return obj
+
+        schema = getattr(cls, "__schema__", None)
+        if schema and schema not in obj.schemas:
+            raise PydanticCustomError(
+                "schema_error",
+                "schemas must contain the base schema '{schema}'",
+                {"schema": schema},
+            )
+
+        return obj
+
     def _prepare_model_dump(
         self,
         scim_ctx: Context | None = Context.DEFAULT,

scim2_models/utils.py

@@ -1,14 +1,8 @@
-import base64
 import re
 from typing import TYPE_CHECKING
-from typing import Annotated
-from typing import Literal
 from typing import Union
 
-from pydantic import EncodedBytes
-from pydantic import EncoderProtocol
 from pydantic.alias_generators import to_snake
-from pydantic_core import PydanticCustomError
 
 if TYPE_CHECKING:
     from .base import BaseModel
@@ -23,64 +17,12 @@ except ImportError:
 
 _UNDERSCORE_ALPHANUMERIC = re.compile(r"_+([0-9A-Za-z]+)")
 _NON_WORD_UNDERSCORE = re.compile(r"[\W_]+")
-_VALID_PATH_PATTERN = re.compile(r'^[a-zA-Z][a-zA-Z0-9._:\-\[\]"=\s]*$')
 
 
 def _int_to_str(status: int | None) -> str | None:
     return None if status is None else str(status)
 
 
-# Copied from Pydantic 2.10 repository
-class _Base64Encoder(EncoderProtocol):  # pragma: no cover
-    """Standard (non-URL-safe) Base64 encoder."""
-
-    @classmethod
-    def decode(cls, data: bytes) -> bytes:
-        """Decode the data from base64 encoded bytes to original bytes data.
-
-        Args:
-            data: The data to decode.
-
-        Returns:
-            The decoded data.
-
-        """
-        try:
-            return base64.b64decode(data)
-        except ValueError as e:
-            raise PydanticCustomError(
-                "base64_decode", "Base64 decoding error: '{error}'", {"error": str(e)}
-            ) from e
-
-    @classmethod
-    def encode(cls, value: bytes) -> bytes:
-        """Encode the data from bytes to a base64 encoded bytes.
-
-        Args:
-            value: The data to encode.
-
-        Returns:
-            The encoded data.
-
-        """
-        return base64.b64encode(value)
-
-    @classmethod
-    def get_json_format(cls) -> Literal["base64"]:
-        """Get the JSON format for the encoded data.
-
-        Returns:
-            The JSON format for the encoded data.
-
-        """
-        return "base64"
-
-
-# Compatibility with Pydantic <2.10
-# https://pydantic.dev/articles/pydantic-v2-10-release#use-b64decode-and-b64encode-for-base64bytes-and-base64str-types
-Base64Bytes = Annotated[bytes, EncodedBytes(encoder=_Base64Encoder)]
-
-
 def _to_camel(string: str) -> str:
     """Transform strings to camelCase.
 
@@ -106,84 +48,6 @@ def _normalize_attribute_name(attribute_name: str) -> str:
     return attribute_name.lower()
 
 
-def _validate_scim_path_syntax(path: str) -> bool:
-    """Check if path syntax is valid according to RFC 7644 simplified rules.
-
-    :param path: The path to validate
-    :return: True if path syntax is valid, False otherwise
-    """
-    if not path or not path.strip():
-        return False
-
-    # Cannot start with a digit
-    if path[0].isdigit():
-        return False
-
-    # Cannot contain double dots
-    if ".." in path:
-        return False
-
-    # Cannot contain invalid characters (basic check)
-    # Allow alphanumeric, dots, underscores, hyphens, colons (for URNs), brackets
-    if not _VALID_PATH_PATTERN.match(path):
-        return False
-
-    # If it contains a colon, validate it's a proper URN format
-    if ":" in path:
-        if not _validate_scim_urn_syntax(path):
-            return False
-
-    return True
-
-
-def _validate_scim_urn_syntax(path: str) -> bool:
-    """Validate URN-based path format.
-
-    :param path: The URN path to validate
-    :return: True if URN path format is valid, False otherwise
-    """
-    # Basic URN validation: should start with urn:
-    if not path.startswith("urn:"):
-        return False
-
-    # Split on the last colon to separate URN from attribute
-    urn_part, attr_part = path.rsplit(":", 1)
-
-    # URN part should have at least 4 parts (urn:namespace:specific:resource)
-    urn_segments = urn_part.split(":")
-    if len(urn_segments) < 4:
-        return False
-
-    # Attribute part should be valid
-    if not attr_part or attr_part[0].isdigit():
-        return False
-
-    return True
-
-
-def _extract_field_name(path: str) -> str | None:
-    """Extract the field name from a path.
-
-    For now, only handle simple paths (no filters, no complex expressions).
-    Returns None for complex paths that require filter parsing.
-
-    """
-    # Handle URN paths
-    if path.startswith("urn:"):
-        # First validate it's a proper URN
-        if not _validate_scim_urn_syntax(path):
-            return None
-        parts = path.rsplit(":", 1)
-        return parts[1]
-
-    # Simple attribute path (may have dots for sub-attributes)
-    # For now, just take the first part before any dot
-    if "." in path:
-        return path.split(".")[0]
-
-    return path
-
-
 def _find_field_name(model_class: type["BaseModel"], attr_name: str) -> str | None:
     """Find the actual field name in a resource class from an attribute name.
 
@@ -198,7 +62,3 @@ def _find_field_name(model_class: type["BaseModel"], attr_name: str) -> str | No
             return field_key
 
     return None
-
-
-def _get_path_parts(path: str) -> list[str]:
-    return path.split(".")

{scim2_models-0.5.2.dist-info → scim2_models-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scim2-models
-Version: 0.5.2
+Version: 0.6.1
 Summary: SCIM2 models serialization and validation with pydantic
 Keywords: scim,scim2,provisioning,pydantic,rfc7643,rfc7644
 Author: Yaal Coop
@@ -218,7 +218,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Environment :: Web Environment
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
-Requires-Dist: pydantic[email]>=2.7.0
+Requires-Dist: pydantic[email]>=2.12.0
 Requires-Python: >=3.10
 Project-URL: changelog, https://scim2-models.readthedocs.io/en/latest/changelog.html
 Project-URL: documentation, https://scim2-models.readthedocs.io

scim2_models-0.6.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+scim2_models/__init__.py,sha256=mEaFa7STotG40wV9cy9aw00Klcx7mqpwJXFhir1BKmI,4213
+scim2_models/annotations.py,sha256=oRjlKL1fqrYfa9UtaMdxF5fOT8CUUN3m-rdzvf7aiSA,3304
+scim2_models/attributes.py,sha256=v_bjJSdBmPlGh20W2Y57PIZnqvMTYHQyJuJLfQjGmwc,1874
+scim2_models/base.py,sha256=dB0idU8apEwPwJpax1EWYX-omxcIy9Z4DMjNhrwTJAg,22407
+scim2_models/constants.py,sha256=9egq8JW0dFAqPng85CiHoH5T6pRtYL87-gC0C-IMGsk,573
+scim2_models/context.py,sha256=RjgMIvWPr8f41qbVL1sjaDnm9GRKyrCrgfC4npwwcMg,9149
+scim2_models/exceptions.py,sha256=0rvJTRM3CbaB2-T_PAhii5W-YEvTY31scPdrauGJi0M,7655
+scim2_models/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/messages/bulk.py,sha256=fWm9s88FHa66Aa0XeLcN7HurHp98JhlqM1rkEnIKZ8A,2429
+scim2_models/messages/error.py,sha256=gbHxf47ZIamnZAgD7cNAwHXxEZsf36PTdtcejesYIy0,12138
+scim2_models/messages/list_response.py,sha256=ahAqdElGSNxt8LlOUeSsNbOykZdCLM4aJyirKcaOtoM,2260
+scim2_models/messages/message.py,sha256=7svNN_xi8BSyWmRoMdYFTjQGuV1F9HUpQYHb6TQtf8A,4081
+scim2_models/messages/patch_op.py,sha256=QwAkeHvzzUXFmS8Ut_ns99yhiSQehpuHAodI_eSc_hA,16236
+scim2_models/messages/search_request.py,sha256=OXw4-oehLC5NyD7yVFEq0QgPsxAaQwXE7hZMKiNkvzY,3017
+scim2_models/path.py,sha256=4u-Lqtq8lqSmJUi6thFDwhpzc-uzyVFulsTklIyIFL8,27053
+scim2_models/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/reference.py,sha256=-E6VD-lFPEIXpSpwu0G_3MKLbWKgZhwk8ER3-JhCHig,5636
+scim2_models/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/resources/enterprise_user.py,sha256=Wk8CzQrCXUE-roQYINpj4YhOlj2s_TD3Y3SnEXK6jKY,1798
+scim2_models/resources/group.py,sha256=nmmPlbP7gQluNJEtFIFYtjDYJ2AR4Uml5LuxMcY_NIk,1379
+scim2_models/resources/resource.py,sha256=0Y8xloQk6tWQ9L7gW__qlUkU55mpYAsxfpeuFuSX2Vk,20550
+scim2_models/resources/resource_type.py,sha256=IDzUcv9_XiAHOpaaG9j24sa-nNKY6i0wPDTTrxNqJgQ,3297
+scim2_models/resources/schema.py,sha256=wDh8G1oxCgyQcmChz30bVNPjyksYcgxD66k0mB1VIdI,10239
+scim2_models/resources/service_provider_config.py,sha256=cmfPtLPOuwNrZl9hGpbrMsQhoOwIytlf2Q_LAJegAcQ,5303
+scim2_models/resources/user.py,sha256=ZvyjxZiF52d_L_LUCEZpec6CXOe40_udZhOHpjzFpxs,11409
+scim2_models/scim_object.py,sha256=suYhQ0iFQs1aKTlSerWZsi_sAVhFX_9N24U_DmZxCbw,5321
+scim2_models/utils.py,sha256=Lb7mlP3I_IfAlqi_8_m4G-_1Rn7oKRqbNdpoDLjXXr0,1978
+scim2_models-0.6.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+scim2_models-0.6.1.dist-info/METADATA,sha256=4_foQD9Bpu-ghYMS923_giVn1VC-e5UUaIZsgNO1nTY,16486
+scim2_models-0.6.1.dist-info/RECORD,,

scim2_models/urn.py

@@ -1,126 +0,0 @@
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import Union
-
-from .base import BaseModel
-from .utils import _get_path_parts
-from .utils import _normalize_attribute_name
-
-if TYPE_CHECKING:
-    from .base import BaseModel
-    from .resources.resource import Extension
-    from .resources.resource import Resource
-
-
-def _get_or_create_extension_instance(
-    model: "Resource[Any]", extension_class: type
-) -> "Extension":
-    """Get existing extension instance or create a new one."""
-    extension_instance = model[extension_class]
-    if extension_instance is None:
-        extension_instance = extension_class()
-        model[extension_class] = extension_instance
-    return extension_instance
-
-
-def _normalize_path(model: type["BaseModel"] | None, path: str) -> tuple[str, str]:
-    """Resolve a path to (schema_urn, attribute_path)."""
-    from .resources.resource import Resource
-
-    # Absolute URN
-    if ":" in path:
-        if (
-            model
-            and issubclass(model, Resource)
-            and (
-                path in model.get_extension_models()
-                or path == model.model_fields["schemas"].default[0]
-            )
-        ):
-            return path, ""
-
-        parts = path.rsplit(":", 1)
-        return parts[0], parts[1]
-
-    # Relative URN with a schema
-    elif model and issubclass(model, Resource) and hasattr(model, "model_fields"):
-        schemas_field = model.model_fields.get("schemas")
-        return schemas_field.default[0], path  # type: ignore
-
-    return "", path
-
-
-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 = _get_path_parts(attribute_base)
-    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 _validate_attribute_urn(
-    attribute_name: str, resource: type["Resource[Any]"]
-) -> str | None:
-    """Validate that an attribute urn is valid or not.
-
-    :param attribute_name: The attribute urn to check.
-    :return: The normalized attribute URN.
-    """
-    from .resources.resource import Resource
-
-    schema: Any | None
-    schema, attribute_base = _normalize_path(resource, attribute_name)
-
-    validated_resource = Resource.get_by_schema([resource], schema)
-    if not validated_resource:
-        return None
-
-    try:
-        _validate_model_attribute(validated_resource, attribute_base)
-    except ValueError:
-        return None
-
-    return f"{schema}:{attribute_base}"
-
-
-def _resolve_path_to_target(
-    resource: "Resource[Any]", path: str
-) -> tuple[Union["Resource[Any]", "Extension"] | None, str]:
-    """Resolve a path to a target and an attribute_path.
-
-    The target can be the resource itself, or an extension object.
-    """
-    schema_urn, attr_path = _normalize_path(type(resource), path)
-
-    if not schema_urn:
-        return resource, attr_path
-
-    if extension_class := resource.get_extension_model(schema_urn):
-        # Points to the extension root
-        if not attr_path:
-            return resource, extension_class.__name__
-
-        extension_instance = _get_or_create_extension_instance(
-            resource, extension_class
-        )
-        return extension_instance, attr_path
-
-    if schema_urn in resource.schemas:
-        return resource, attr_path
-
-    return (None, "")