scim2-models 0.4.0__tar.gz → 0.4.2__tar.gz

{scim2_models-0.4.0 → scim2_models-0.4.2}/.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 ---
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.4'
+    rev: 'v0.12.7'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
@@ -16,9 +16,10 @@ repos:
         exclude: "\\.svg$|\\.map$|\\.min\\.css$|\\.min\\.js$|\\.po$|\\.pot$"
       - id: check-toml
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.17.0
+    rev: v1.17.1
     hooks:
       - id: mypy
+        exclude: ^(tests/|conftest.py)
         additional_dependencies:
           - pydantic[email]>=2.7.0
   - repo: https://github.com/codespell-project/codespell

{scim2_models-0.4.0 → scim2_models-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.4.0
+Version: 0.4.2
 Summary: SCIM2 models serialization and validation with pydantic
 Project-URL: documentation, https://scim2-models.readthedocs.io
 Project-URL: repository, https://github.com/python-scim/scim2-models

{scim2_models-0.4.0 → scim2_models-0.4.2}/doc/changelog.rst

@@ -1,6 +1,20 @@
 Changelog
 =========
 
+[0.4.2] - 2025-08-05
+--------------------
+
+Fixed
+^^^^^
+- The library is 100% typed with mypy strict.
+
+[0.4.1] - 2025-07-23
+--------------------
+
+Fixed
+^^^^^
+- Allow ``TypeVar`` as type parameters for :class:`~scim2_models.PatchOp`.
+
 [0.4.0] - 2025-07-23
 --------------------
 

{scim2_models-0.4.0 → scim2_models-0.4.2}/doc/conf.py

@@ -62,6 +62,14 @@ html_theme_options = {
             "title": "scim2-cli",
             "url": "https://scim2-cli.readthedocs.io",
         },
+        {
+            "title": "scim2-server",
+            "url": "https://github.com/python-scim/scim2-server",
+        },
+        {
+            "title": "pytest-scim2-server",
+            "url": "https://github.com/pytest-dev/pytest-scim2-server",
+        },
     ],
 }
 html_context = {

{scim2_models-0.4.0 → scim2_models-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "scim2-models"
-version = "0.4.0"
+version = "0.4.2"
 description = "SCIM2 models serialization and validation with pydantic"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE"}
@@ -114,6 +114,7 @@ exclude = [
   "tests/",
   "conftest.py",
 ]
+strict=true
 
 [tool.pydantic-mypy]
 init_forbid_extra = true

{scim2_models-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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
@@ -26,7 +27,7 @@ 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 +52,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 +73,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 +144,7 @@ class PatchOp(Message, Generic[T]):
         - Using PatchOp without a type parameter raises TypeError
     """
 
-    def __new__(cls, *args, **kwargs):
+    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,25 +163,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).
-        Rejects invalid types (str, int, etc.) and Union types.
+        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.
         """
+        if isinstance(typevar_values, TypeVar):
+            # Check if TypeVar is bound to Resource or its subclass
+            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__(typevar_values)
+            else:
+                raise TypeError(
+                    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, 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"
@@ -240,7 +264,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`.
@@ -252,7 +278,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:
@@ -266,7 +294,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:
@@ -280,7 +308,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
@@ -298,8 +327,9 @@ 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)
@@ -309,12 +339,13 @@ class PatchOp(Message, Generic[T]):
 
         path_parts = attr_path.split(".")
         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)
@@ -322,8 +353,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:
@@ -332,8 +363,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]
@@ -345,38 +377,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:
@@ -385,23 +424,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):
@@ -411,7 +453,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)
 
@@ -434,10 +477,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)
@@ -458,7 +502,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
@@ -469,10 +513,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-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/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 @@ 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 +263,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 +291,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 +372,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(

{scim2_models-0.4.0 → scim2_models-0.4.2}/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-0.4.0 → scim2_models-0.4.2}/scim2_models/resources/schema.py

@@ -258,7 +258,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-0.4.0 → scim2_models-0.4.2}/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
@@ -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"
     ]

{scim2_models-0.4.0 → scim2_models-0.4.2}/scim2_models/urn.py

@@ -1,18 +1,20 @@
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Optional
+from typing import Union
 
 from .base import BaseModel
 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", extension_class: type
-) -> "BaseModel":
+    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:
@@ -62,7 +64,7 @@ def _validate_model_attribute(model: type["BaseModel"], attribute_base: str) ->
 
 
 def _validate_attribute_urn(
-    attribute_name: str, resource: type["Resource"]
+    attribute_name: str, resource: type["Resource[Any]"]
 ) -> Optional[str]:
     """Validate that an attribute urn is valid or not.
 
@@ -87,8 +89,8 @@ def _validate_attribute_urn(
 
 
 def _resolve_path_to_target(
-    resource: "Resource", path: str
-) -> tuple[Optional["BaseModel"], str]:
+    resource: "Resource[Any]", path: str
+) -> tuple[Optional[Union["Resource[Any]", "Extension"]], str]:
     """Resolve a path to a target and an attribute_path.
 
     The target can be the resource itself, or an extension object.