chore: remove code planed for 0.8 removal

Author: azmeuk

doc/changelog.rst

@@ -60,6 +60,15 @@ Changed
 
 Removed
 ^^^^^^^
+- ``Resource.get_by_schema`` and ``Resource.get_by_payload``, deprecated in 0.6.13. Use
+  :func:`~scim2_models.get_model_by_schema` and :func:`~scim2_models.get_model_by_payload`, whose
+  ``resource_types`` parameter is named ``models``.
+- The ``original`` parameter of :meth:`~scim2_models.BaseModel.model_validate`, deprecated in
+  0.6.7. Validate the payload, then call :meth:`~scim2_models.Resource.replace` on the result to
+  compare it against the stored resource. A replacement request is no longer checked against an
+  original at validation time, so an immutable attribute that changed raises
+  :exc:`~scim2_models.MutabilityException` from ``replace`` instead of a
+  :exc:`~pydantic.ValidationError` from ``model_validate``.
 - ``Path.field_name``, ``Path.field_type``, ``Path.is_multivalued``, ``Path.get_annotation`` and
   ``Path.urn``. Use :meth:`~scim2_models.Path.resolve`, whose
   :class:`~scim2_models.AttributeBinding` carries them.

scim2_models/base.py

@@ -1,4 +1,3 @@
-import warnings
 from collections.abc import Mapping
 from inspect import isclass
 from types import MappingProxyType
@@ -7,7 +6,6 @@
 from typing import ClassVar
 from typing import NamedTuple
 from typing import NoReturn
-from typing import Optional
 from typing import cast
 from typing import get_args
 from typing import get_origin
@@ -432,13 +430,10 @@ def enforce_scim_context(self, info: ValidationInfo) -> Self:
         if not scim_context or scim_context == Context.DEFAULT:
             return self
 
-        from scim2_models.resources.resource import Resource
-
         is_create_or_replace = scim_context in (
             Context.RESOURCE_CREATION_REQUEST,
             Context.RESOURCE_REPLACEMENT_REQUEST,
         )
-        original = info.context.get("original") if info.context else None
         fields_set = self.model_fields_set
 
         for field_name in self.__class__.model_fields:
@@ -456,14 +451,6 @@ def enforce_scim_context(self, info: ValidationInfo) -> Self:
             if self.get_field_multiplicity(field_name) and value is not None:
                 self._check_primary_uniqueness(field_name, value)
 
-        # DEPRECATED: Remove when original is not used in validation
-        if (
-            scim_context == Context.RESOURCE_REPLACEMENT_REQUEST
-            and original is not None
-            and issubclass(type(self), Resource)
-        ):
-            self._check_replacement_mutability(original)
-
         return self
 
     def _raise_field_error(
@@ -550,13 +537,6 @@ def _check_returnability(self, field_name: str, value: Any) -> None:
                 },
             )
 
-    def _check_replacement_mutability(self, original: "BaseModel") -> None:
-        """Check if 'immutable' attributes have been mutated in replacement requests."""
-        try:
-            self._apply_replace_constraints(original)
-        except MutabilityException as exc:
-            raise exc.as_pydantic_error() from exc
-
     def _check_primary_uniqueness(self, field_name: str, value: Any) -> None:
         """Validate that only one attribute can be marked as primary in multi-valued lists, per :rfc:`RFC7643 §2.4 <7643#section-2.4>`."""
         element_type = self.get_field_root_type(field_name)
@@ -794,13 +774,11 @@ def _scim_response_serializer(
     def _prepare_model_validate(
         cls,
         scim_ctx: Context | None = Context.DEFAULT,
-        original: Optional["BaseModel"] = None,
         scim_policy: ScimPolicy | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         context = kwargs.setdefault("context", {})
         context.setdefault("scim", scim_ctx)
-        context.setdefault("original", original)
         context.setdefault("scim_policy", scim_policy)
         return kwargs
 
@@ -809,7 +787,6 @@ def model_validate(
         cls,
         *args: Any,
         scim_ctx: Context | None = Context.DEFAULT,
-        original: Optional["BaseModel"] = None,
         scim_policy: ScimPolicy | None = None,
         **kwargs: Any,
     ) -> Self:
@@ -818,26 +795,8 @@ def model_validate(
         :param scim_ctx: The SCIM :class:`~scim2_models.Context` in which the validation happens.
         :param scim_policy: The :class:`~scim2_models.ScimPolicy` the validation
             runs under. Defaults to the strict reading of the specification.
-        :param original: If this parameter is set during :attr:`~Context.RESOURCE_REPLACEMENT_REQUEST`,
-            :attr:`~scim2_models.Mutability.immutable` parameters will be compared against the *original* model value.
-            An exception is raised if values are different.
-
-            .. deprecated:: 0.6.7
-                Use :meth:`~scim2_models.Resource.replace` on the validated instance instead.
-                Will be removed in 0.8.0.
         """
-        if original is not None:
-            warnings.warn(
-                "The 'original' parameter is deprecated, "
-                "use the 'replace' method on the validated instance instead. "
-                "Will be removed in 0.8.0.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-        validate_kwargs = cls._prepare_model_validate(
-            scim_ctx, original, scim_policy, **kwargs
-        )
+        validate_kwargs = cls._prepare_model_validate(scim_ctx, scim_policy, **kwargs)
         return super().model_validate(*args, **validate_kwargs)
 
     @classmethod

scim2_models/context.py

@@ -83,9 +83,7 @@ class Context(Enum):
     and servers validating resource replacement request payloads.
 
     - When used for serialization, it will not dump attributes annotated with :attr:`~scim2_models.Mutability.read_only`.
-    - When used for validation, it will ignore attributes annotated with :attr:`scim2_models.Mutability.read_only` and raise a :class:`~pydantic_core.ValidationError`:
-        - when finding attributes annotated with :attr:`~scim2_models.Mutability.immutable` different than the ``original`` parameter passed to :meth:`~scim2_models.BaseModel.model_validate`;
-        - when attributes annotated with :attr:`Required.true <scim2_models.Required.true>` are missing on null.
+    - When used for validation, it will ignore attributes annotated with :attr:`scim2_models.Mutability.read_only` and raise a :class:`~pydantic_core.ValidationError` when attributes annotated with :attr:`Required.true <scim2_models.Required.true>` are missing or null. Comparing the payload against the stored resource is :meth:`~scim2_models.Resource.replace`'s business.
     """
 
     RESOURCE_REPLACEMENT_RESPONSE = auto()

scim2_models/resources/resource.py

@@ -1,7 +1,5 @@
 import copyreg
-import warnings
 from collections.abc import MutableMapping
-from collections.abc import Sequence
 from datetime import datetime
 from enum import Enum
 from typing import TYPE_CHECKING
@@ -34,12 +32,9 @@
 from ..base import BaseModel
 from ..context import Context
 from ..exceptions import InvalidPathException
-from ..lookup import get_model_by_payload
-from ..lookup import get_model_by_schema
 from ..path import Path
 from ..policy import ScimPolicy
 from ..policy import _policy
-from ..scim_object import AnyScimObject
 from ..scim_object import ScimObject
 from ..utils import UNION_TYPES
 from ..utils import _normalize_attribute_name
@@ -366,44 +361,6 @@ def get_extension_model(
                 return extension
         return None
 
-    @staticmethod
-    def get_by_schema(
-        resource_types: Sequence[type[AnyScimObject]],
-        schema: str,
-        with_extensions: bool = True,
-    ) -> type[AnyScimObject] | type["Extension"] | None:
-        """Given a resource type list and a schema, find the matching resource type.
-
-        .. deprecated:: 0.6.13
-            Use :func:`~scim2_models.get_model_by_schema` instead.
-        """
-        warnings.warn(
-            "Resource.get_by_schema is deprecated, use "
-            "scim2_models.get_model_by_schema instead. Will be removed in 0.8.0.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return get_model_by_schema(resource_types, schema, with_extensions)
-
-    @staticmethod
-    def get_by_payload(
-        resource_types: Sequence[type[AnyScimObject]],
-        payload: dict[str, Any],
-        **kwargs: Any,
-    ) -> type[AnyScimObject] | type["Extension"] | None:
-        """Given a resource type list and a payload, find the matching resource type.
-
-        .. deprecated:: 0.6.13
-            Use :func:`~scim2_models.get_model_by_payload` instead.
-        """
-        warnings.warn(
-            "Resource.get_by_payload is deprecated, use "
-            "scim2_models.get_model_by_payload instead. Will be removed in 0.8.0.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return get_model_by_payload(resource_types, payload, **kwargs)
-
     def _model_schemas(self) -> list[str]:
         """List the base schema and the schemas of the declared extensions."""
         return super()._model_schemas() + list(self.get_extension_models())

tests/test_model_validation.py

@@ -184,120 +184,6 @@ class SubResource(Resource):
     ]
 
 
-def test_validate_replacement_request_mutability():
-    """Test query validation for resource model replacement requests.
-
-    Attributes marked as:
-    - Mutability.immutable raise a ValidationError if different than the 'original' item.
-    - Mutability.read_only are copied from the original
-    """
-    original = MutResource(read_only="y", read_write="y", write_only="y", immutable="y")
-    with pytest.warns(DeprecationWarning, match="original"):
-        assert MutResource.model_validate(
-            {
-                "schemas": ["urn:example:MutResource"],
-                "readOnly": "x",
-                "readWrite": "x",
-                "writeOnly": "x",
-                "immutable": "y",
-            },
-            scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-            original=original,
-        ) == MutResource(
-            schemas=["urn:example:MutResource"],
-            read_only="y",
-            readWrite="x",
-            writeOnly="x",
-            immutable="y",
-        )
-
-    with pytest.warns(DeprecationWarning, match="original"):
-        MutResource.model_validate(
-            {
-                "schemas": ["urn:example:MutResource"],
-                "immutable": "y",
-            },
-            scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-            original=original,
-        )
-
-    with pytest.warns(DeprecationWarning, match="original"):
-        with pytest.raises(
-            ValidationError,
-            match="mutability",
-        ):
-            MutResource.model_validate(
-                {
-                    "schemas": ["urn:example:MutResource"],
-                    "immutable": "x",
-                },
-                scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-                original=original,
-            )
-
-
-def test_validate_replacement_request_mutability_sub_attributes():
-    """Test query validation for resource model replacement requests.
-
-    Sub-attributes marked as:
-    - Mutability.immutable raise a ValidationError if different than the 'original' item.
-    - Mutability.read_only are ignored
-    """
-
-    class Sub(ComplexAttribute):
-        immutable: Annotated[str | None, Mutability.immutable] = None
-
-    class Super(Resource):
-        __schema__ = URN("urn:example:Super")
-        sub: Sub | None = None
-
-    original = Super(sub=Sub(immutable="y"))
-    with pytest.warns(DeprecationWarning, match="original"):
-        assert Super.model_validate(
-            {
-                "schemas": ["urn:example:Super"],
-                "sub": {
-                    "immutable": "y",
-                },
-            },
-            scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-            original=original,
-        ) == Super(
-            schemas=["urn:example:Super"],
-            sub=Sub(
-                immutable="y",
-            ),
-        )
-
-    with pytest.warns(DeprecationWarning, match="original"):
-        Super.model_validate(
-            {
-                "schemas": ["urn:example:Super"],
-                "sub": {
-                    "immutable": "y",
-                },
-            },
-            scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-            original=original,
-        )
-
-    with pytest.warns(DeprecationWarning, match="original"):
-        with pytest.raises(
-            ValidationError,
-            match="mutability",
-        ):
-            Super.model_validate(
-                {
-                    "schemas": ["urn:example:Super"],
-                    "sub": {
-                        "immutable": "x",
-                    },
-                },
-                scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-                original=original,
-            )
-
-
 def test_replace_detects_changed_field():
     """Replace raises MutabilityException when an immutable field differs."""
     from scim2_models.exceptions import MutabilityException
@@ -597,19 +483,8 @@ class MyResource(Resource):
     assert replacement[MyExt].read_write == "new"
 
 
-def test_original_parameter_emits_deprecation_warning():
-    """Passing 'original' to model_validate emits a DeprecationWarning."""
-    original = MutResource(immutable="y")
-    with pytest.warns(DeprecationWarning, match="original"):
-        MutResource.model_validate(
-            {"schemas": ["urn:example:MutResource"], "immutable": "y"},
-            scim_ctx=Context.RESOURCE_REPLACEMENT_REQUEST,
-            original=original,
-        )
-
-
-def test_replacement_request_without_original_parameter():
-    """Replacement requests work without 'original' when using replace manually."""
+def test_replace_after_validating_a_replacement_request():
+    """A replacement request is validated on its own, then compared to the stored resource."""
     from scim2_models.exceptions import MutabilityException
 
     original = MutResource(immutable="y")
@@ -621,8 +496,8 @@ def test_replacement_request_without_original_parameter():
         replacement.replace(original)
 
 
-def test_replacement_request_without_original_allows_matching_values():
-    """Replacement requests validate and replace succeeds with identical immutable values."""
+def test_replace_after_validating_a_replacement_request_that_changes_nothing():
+    """A replacement request repeating the immutable values it was given is accepted."""
     original = MutResource(immutable="y")
     replacement = MutResource.model_validate(
         {"schemas": ["urn:example:MutResource"], "immutable": "y"},

tests/test_models.py

@@ -12,7 +12,6 @@
 from scim2_models import Group
 from scim2_models import ListResponse
 from scim2_models import PatchOp
-from scim2_models import Resource
 from scim2_models import ResourceType
 from scim2_models import Schema
 from scim2_models import SearchRequest
@@ -175,24 +174,6 @@ def test_get_model_by_schema():
     )
 
 
-def test_get_by_schema_deprecation():
-    """Resource.get_by_schema is kept as a deprecated alias."""
-    with pytest.warns(DeprecationWarning, match="get_model_by_schema"):
-        assert (
-            Resource.get_by_schema(
-                [Group], "urn:ietf:params:scim:schemas:core:2.0:Group"
-            )
-            == Group
-        )
-
-
-def test_get_by_payload_deprecation():
-    """Resource.get_by_payload is kept as a deprecated alias."""
-    payload = {"schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"]}
-    with pytest.warns(DeprecationWarning, match="get_model_by_payload"):
-        assert Resource.get_by_payload([Group], payload) == Group
-
-
 def test_get_message_by_schema_along_resources():
     """Messages such as ListResponse can be looked up next to resources carrying extensions."""
     resource_types = [ListResponse[User], User[EnterpriseUser]]