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

scim2_client/client.py

@@ -3,6 +3,7 @@ import sys
 from collections.abc import Collection
 from dataclasses import dataclass
 from typing import Optional
+from typing import TypeVar
 from typing import Union
 
 from pydantic import ValidationError
@@ -27,6 +28,8 @@ from scim2_client.errors import SCIMResponseErrorObject
 from scim2_client.errors import UnexpectedContentType
 from scim2_client.errors import UnexpectedStatusCode
 
+ResourceT = TypeVar("ResourceT", bound=Resource)
+
 BASE_HEADERS = {
     "Accept": "application/scim+json",
     "Content-Type": "application/scim+json",
@@ -151,6 +154,26 @@ class SCIMClient:
     :rfc:`RFC7644 §3.12 <7644#section-3.12>`.
     """
 
+    PATCH_RESPONSE_STATUS_CODES: list[int] = [
+        200,
+        204,
+        307,
+        308,
+        400,
+        401,
+        403,
+        404,
+        409,
+        412,
+        500,
+        501,
+    ]
+    """Resource patching HTTP codes.
+
+    As defined at :rfc:`RFC7644 §3.5.2 <7644#section-3.5.2>` and
+    :rfc:`RFC7644 §3.12 <7644#section-3.12>`.
+    """
+
     def __init__(
         self,
         resource_models: Optional[Collection[type[Resource]]] = None,
@@ -179,13 +202,16 @@ class SCIMClient:
                 return resource_model
         return None
 
-    def check_resource_model(
+    def _check_resource_model(
         self, resource_model: type[Resource], payload=None
     ) -> None:
-        if (
-            resource_model not in self.resource_models
-            and resource_model not in CONFIG_RESOURCES
-        ):
+        schema_to_check = resource_model.model_fields["schemas"].default[0]
+        for element in self.resource_models:
+            schema = element.model_fields["schemas"].default[0]
+            if schema_to_check == schema:
+                return
+
+        if resource_model not in CONFIG_RESOURCES:
             raise SCIMRequestError(
                 f"Unknown resource type: '{resource_model}'", source=payload
             )
@@ -299,11 +325,15 @@ class SCIMClient:
         if not expected_types:
             return response_payload
 
+        # For no-content responses, return None directly
+        if response_payload is None:
+            return None
+
         actual_type = Resource.get_by_payload(
             expected_types, response_payload, with_extensions=False
         )
 
-        if response_payload and not actual_type:
+        if not actual_type:
             expected = ", ".join([type_.__name__ for type_ in expected_types])
             try:
                 schema = ", ".join(response_payload["schemas"])
@@ -323,12 +353,11 @@ class SCIMClient:
                 scim_exc.add_note(str(exc))
             raise scim_exc from exc
 
-    def prepare_create_request(
+    def _prepare_create_request(
         self,
         resource: Union[AnyResource, dict],
         check_request_payload: Optional[bool] = None,
         expected_status_codes: Optional[list[int]] = None,
-        raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> RequestPayload:
         req = RequestPayload(
@@ -361,7 +390,7 @@ class SCIMClient:
                         scim_validation_exc.add_note(str(exc))
                     raise scim_validation_exc from exc
 
-            self.check_resource_model(resource_model, resource)
+            self._check_resource_model(resource_model, resource)
             req.expected_types = [resource.__class__]
             req.url = req.request_kwargs.pop(
                 "url", self.resource_endpoint(resource_model)
@@ -372,14 +401,13 @@ class SCIMClient:
 
         return req
 
-    def prepare_query_request(
+    def _prepare_query_request(
         self,
         resource_model: Optional[type[Resource]] = None,
         id: Optional[str] = None,
         search_request: Optional[Union[SearchRequest, dict]] = None,
         check_request_payload: Optional[bool] = None,
         expected_status_codes: Optional[list[int]] = None,
-        raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> RequestPayload:
         req = RequestPayload(
@@ -391,7 +419,7 @@ class SCIMClient:
             check_request_payload = self.check_request_payload
 
         if resource_model and check_request_payload:
-            self.check_resource_model(resource_model)
+            self._check_resource_model(resource_model)
 
         payload: Optional[SearchRequest]
         if not check_request_payload:
@@ -429,12 +457,11 @@ class SCIMClient:
 
         return req
 
-    def prepare_search_request(
+    def _prepare_search_request(
         self,
         search_request: Optional[SearchRequest] = None,
         check_request_payload: Optional[bool] = None,
         expected_status_codes: Optional[list[int]] = None,
-        raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> RequestPayload:
         req = RequestPayload(
@@ -461,12 +488,11 @@ class SCIMClient:
         req.expected_types = [ListResponse[Union[self.resource_models]]]
         return req
 
-    def prepare_delete_request(
+    def _prepare_delete_request(
         self,
         resource_model: type,
         id: str,
         expected_status_codes: Optional[list[int]] = None,
-        raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> RequestPayload:
         req = RequestPayload(
@@ -474,17 +500,16 @@ class SCIMClient:
             request_kwargs=kwargs,
         )
 
-        self.check_resource_model(resource_model)
+        self._check_resource_model(resource_model)
         delete_url = self.resource_endpoint(resource_model) + f"/{id}"
         req.url = req.request_kwargs.pop("url", delete_url)
         return req
 
-    def prepare_replace_request(
+    def _prepare_replace_request(
         self,
         resource: Union[AnyResource, dict],
         check_request_payload: Optional[bool] = None,
         expected_status_codes: Optional[list[int]] = None,
-        raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> RequestPayload:
         req = RequestPayload(
@@ -519,7 +544,7 @@ class SCIMClient:
                         scim_validation_exc.add_note(str(exc))
                     raise scim_validation_exc from exc
 
-            self.check_resource_model(resource_model, resource)
+            self._check_resource_model(resource_model, resource)
 
             if not resource.id:
                 raise SCIMRequestError("Resource must have an id", source=resource)
@@ -534,9 +559,75 @@ class SCIMClient:
 
         return req
 
+    def _prepare_patch_request(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        expected_status_codes: Optional[list[int]] = None,
+        **kwargs,
+    ) -> RequestPayload:
+        """Prepare a PATCH request payload.
+
+        :param resource_model: The resource type to modify (e.g., User, Group).
+        :param id: The resource ID.
+        :param patch_op: A PatchOp instance parameterized with the same resource type as resource_model
+                        (e.g., PatchOp[User] when resource_model is User), or a dict representation.
+        :param check_request_payload: If :data:`False`, :code:`patch_op` is expected to be a dict
+                                     that will be passed as-is in the request. This value can be
+                                     overwritten in methods.
+        :param expected_status_codes: List of HTTP status codes expected for this request.
+        :param raise_scim_errors: If :data:`True` and the server returned an
+                                 :class:`~scim2_models.Error` object during a request, a
+                                 :class:`~scim2_client.SCIMResponseErrorObject` exception will be raised.
+        :param kwargs: Additional request parameters.
+        :return: The prepared request payload.
+        """
+        req = RequestPayload(
+            expected_status_codes=expected_status_codes,
+            request_kwargs=kwargs,
+        )
+
+        if check_request_payload is None:
+            check_request_payload = self.check_request_payload
+
+        self._check_resource_model(resource_model)
+
+        if not check_request_payload:
+            req.payload = patch_op
+            req.url = req.request_kwargs.pop(
+                "url", f"{self.resource_endpoint(resource_model)}/{id}"
+            )
+
+        else:
+            if isinstance(patch_op, dict):
+                req.payload = patch_op
+            else:
+                try:
+                    req.payload = patch_op.model_dump(
+                        scim_ctx=Context.RESOURCE_PATCH_REQUEST
+                    )
+                except ValidationError as exc:
+                    scim_validation_exc = RequestPayloadValidationError(source=patch_op)
+                    if sys.version_info >= (3, 11):  # pragma: no cover
+                        scim_validation_exc.add_note(str(exc))
+                    raise scim_validation_exc from exc
+
+            req.url = req.request_kwargs.pop(
+                "url", f"{self.resource_endpoint(resource_model)}/{id}"
+            )
+
+        req.expected_types = [resource_model]
+        return req
+
     def modify(
-        self, resource: Union[AnyResource, dict], op: PatchOp, **kwargs
-    ) -> Optional[Union[AnyResource, dict]]:
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
         raise NotImplementedError()
 
     def build_resource_models(
@@ -552,13 +643,13 @@ class SCIMClient:
         for schema, resource_type in resource_types_by_schema.items():
             schema_obj = schema_objs_by_schema[schema]
             model = Resource.from_schema(schema_obj)
-            extensions = []
+            extensions: tuple[type[Extension], ...] = ()
             for ext_schema in resource_type.schema_extensions or []:
                 schema_obj = schema_objs_by_schema[ext_schema.schema_]
                 extension = Extension.from_schema(schema_obj)
-                extensions.append(extension)
+                extensions = extensions + (extension,)
             if extensions:
-                model = model[Union[tuple(extensions)]]
+                model = model[Union[extensions]]
             resource_models.append(model)
 
         return tuple(resource_models)
@@ -615,7 +706,7 @@ class BaseSyncSCIMClient(SCIMClient):
 
     def query(
         self,
-        resource_model: Optional[type[Resource]] = None,
+        resource_model: Optional[type[AnyResource]] = None,
         id: Optional[str] = None,
         search_request: Optional[Union[SearchRequest, dict]] = None,
         check_request_payload: Optional[bool] = None,
@@ -820,6 +911,62 @@ class BaseSyncSCIMClient(SCIMClient):
         """
         raise NotImplementedError()
 
+    def modify(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        check_response_payload: Optional[bool] = None,
+        expected_status_codes: Optional[
+            list[int]
+        ] = SCIMClient.PATCH_RESPONSE_STATUS_CODES,
+        raise_scim_errors: Optional[bool] = None,
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
+        """Perform a PATCH request to modify a resource, as defined in :rfc:`RFC7644 §3.5.2 <7644#section-3.5.2>`.
+
+        :param resource_model: The type of the resource to modify.
+        :param id: The id of the resource to modify.
+        :param patch_op: The :class:`~scim2_models.PatchOp` object describing the modifications.
+            Must be parameterized with the same resource type as ``resource_model``
+            (e.g., :code:`PatchOp[User]` when ``resource_model`` is :code:`User`).
+        :param check_request_payload: If set, overwrites :paramref:`scim2_client.SCIMClient.check_request_payload`.
+        :param check_response_payload: If set, overwrites :paramref:`scim2_client.SCIMClient.check_response_payload`.
+        :param expected_status_codes: The list of expected status codes form the response.
+            If :data:`None` any status code is accepted.
+        :param raise_scim_errors: If set, overwrites :paramref:`scim2_client.SCIMClient.raise_scim_errors`.
+        :param kwargs: Additional parameters passed to the underlying
+            HTTP request library.
+
+        :return:
+            - An :class:`~scim2_models.Error` object in case of error.
+            - The updated object as returned by the server in case of success if status code is 200.
+            - :data:`None` in case of success if status code is 204.
+
+        :usage:
+
+        .. code-block:: python
+            :caption: Modification of a `User` resource
+
+            from scim2_models import User, PatchOp, PatchOperation
+
+            operation = PatchOperation(
+                op="replace", path="displayName", value="New Display Name"
+            )
+            patch_op = PatchOp[User](operations=[operation])
+            response = scim.modify(User, "my-user-id", patch_op)
+            # 'response' may be a User, None, or an Error object
+
+        .. tip::
+
+            Check the :attr:`~scim2_models.Context.RESOURCE_PATCH_REQUEST`
+            and :attr:`~scim2_models.Context.RESOURCE_PATCH_RESPONSE` contexts to understand
+            which value will excluded from the request payload, and which values are expected in
+            the response payload.
+        """
+        raise NotImplementedError()
+
     def discover(self, schemas=True, resource_types=True, service_provider_config=True):
         """Dynamically discover the server configuration objects.
 
@@ -1097,6 +1244,62 @@ class BaseAsyncSCIMClient(SCIMClient):
         """
         raise NotImplementedError()
 
+    async def modify(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        check_response_payload: Optional[bool] = None,
+        expected_status_codes: Optional[
+            list[int]
+        ] = SCIMClient.PATCH_RESPONSE_STATUS_CODES,
+        raise_scim_errors: Optional[bool] = None,
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
+        """Perform a PATCH request to modify a resource, as defined in :rfc:`RFC7644 §3.5.2 <7644#section-3.5.2>`.
+
+        :param resource_model: The type of the resource to modify.
+        :param id: The id of the resource to modify.
+        :param patch_op: The :class:`~scim2_models.PatchOp` object describing the modifications.
+            Must be parameterized with the same resource type as ``resource_model``
+            (e.g., :code:`PatchOp[User]` when ``resource_model`` is :code:`User`).
+        :param check_request_payload: If set, overwrites :paramref:`scim2_client.SCIMClient.check_request_payload`.
+        :param check_response_payload: If set, overwrites :paramref:`scim2_client.SCIMClient.check_response_payload`.
+        :param expected_status_codes: The list of expected status codes form the response.
+            If :data:`None` any status code is accepted.
+        :param raise_scim_errors: If set, overwrites :paramref:`scim2_client.SCIMClient.raise_scim_errors`.
+        :param kwargs: Additional parameters passed to the underlying
+            HTTP request library.
+
+        :return:
+            - An :class:`~scim2_models.Error` object in case of error.
+            - The updated object as returned by the server in case of success if status code is 200.
+            - :data:`None` in case of success if status code is 204.
+
+        :usage:
+
+        .. code-block:: python
+            :caption: Modification of a `User` resource
+
+            from scim2_models import User, PatchOp, PatchOperation
+
+            operation = PatchOperation(
+                op="replace", path="displayName", value="New Display Name"
+            )
+            patch_op = PatchOp[User](operations=[operation])
+            response = await scim.modify(User, "my-user-id", patch_op)
+            # 'response' may be a User, None, or an Error object
+
+        .. tip::
+
+            Check the :attr:`~scim2_models.Context.RESOURCE_PATCH_REQUEST`
+            and :attr:`~scim2_models.Context.RESOURCE_PATCH_RESPONSE` contexts to understand
+            which value will excluded from the request payload, and which values are expected in
+            the response payload.
+        """
+        raise NotImplementedError()
+
     async def discover(
         self, schemas=True, resource_types=True, service_provider_config=True
     ):

scim2_client/engines/httpx.py

@@ -2,6 +2,7 @@ import json
 import sys
 from contextlib import contextmanager
 from typing import Optional
+from typing import TypeVar
 from typing import Union
 
 from httpx import Client
@@ -11,6 +12,7 @@ from scim2_models import AnyResource
 from scim2_models import Context
 from scim2_models import Error
 from scim2_models import ListResponse
+from scim2_models import PatchOp
 from scim2_models import Resource
 from scim2_models import SearchRequest
 
@@ -20,6 +22,8 @@ from scim2_client.errors import RequestNetworkError
 from scim2_client.errors import SCIMClientError
 from scim2_client.errors import UnexpectedContentFormat
 
+ResourceT = TypeVar("ResourceT", bound=Resource)
+
 
 @contextmanager
 def handle_request_error(payload=None):
@@ -77,11 +81,10 @@ class SyncSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_create_request(
+        req = self._prepare_create_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -102,7 +105,7 @@ class SyncSCIMClient(BaseSyncSCIMClient):
 
     def query(
         self,
-        resource_model: Optional[type[Resource]] = None,
+        resource_model: Optional[type[AnyResource]] = None,
         id: Optional[str] = None,
         search_request: Optional[Union[SearchRequest, dict]] = None,
         check_request_payload: Optional[bool] = None,
@@ -112,14 +115,13 @@ class SyncSCIMClient(BaseSyncSCIMClient):
         ] = BaseSyncSCIMClient.QUERY_RESPONSE_STATUS_CODES,
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
-    ):
-        req = self.prepare_query_request(
+    ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
+        req = self._prepare_query_request(
             resource_model=resource_model,
             id=id,
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -151,11 +153,10 @@ class SyncSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
-        req = self.prepare_search_request(
+        req = self._prepare_search_request(
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -185,11 +186,10 @@ class SyncSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Optional[Union[Error, dict]]:
-        req = self.prepare_delete_request(
+        req = self._prepare_delete_request(
             resource_model=resource_model,
             id=id,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -217,11 +217,10 @@ class SyncSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_replace_request(
+        req = self._prepare_replace_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -240,6 +239,45 @@ class SyncSCIMClient(BaseSyncSCIMClient):
                 scim_ctx=Context.RESOURCE_REPLACEMENT_RESPONSE,
             )
 
+    def modify(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        check_response_payload: Optional[bool] = None,
+        expected_status_codes: Optional[
+            list[int]
+        ] = BaseSyncSCIMClient.PATCH_RESPONSE_STATUS_CODES,
+        raise_scim_errors: Optional[bool] = None,
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
+        req = self._prepare_patch_request(
+            resource_model=resource_model,
+            id=id,
+            patch_op=patch_op,
+            check_request_payload=check_request_payload,
+            expected_status_codes=expected_status_codes,
+            **kwargs,
+        )
+
+        with handle_request_error(req.payload):
+            response = self.client.patch(
+                req.url, json=req.payload, **req.request_kwargs
+            )
+
+        with handle_response_error(response):
+            return self.check_response(
+                payload=response.json() if response.text else None,
+                status_code=response.status_code,
+                headers=response.headers,
+                expected_status_codes=req.expected_status_codes,
+                expected_types=req.expected_types,
+                check_response_payload=check_response_payload,
+                raise_scim_errors=raise_scim_errors,
+                scim_ctx=Context.RESOURCE_PATCH_RESPONSE,
+            )
+
 
 class AsyncSCIMClient(BaseAsyncSCIMClient):
     """Perform SCIM requests over the network and validate responses.
@@ -273,11 +311,10 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_create_request(
+        req = self._prepare_create_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -310,14 +347,13 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
         ] = BaseAsyncSCIMClient.QUERY_RESPONSE_STATUS_CODES,
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
-    ):
-        req = self.prepare_query_request(
+    ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
+        req = self._prepare_query_request(
             resource_model=resource_model,
             id=id,
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -349,11 +385,10 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
-        req = self.prepare_search_request(
+        req = self._prepare_search_request(
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -385,11 +420,10 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Optional[Union[Error, dict]]:
-        req = self.prepare_delete_request(
+        req = self._prepare_delete_request(
             resource_model=resource_model,
             id=id,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -417,11 +451,10 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_replace_request(
+        req = self._prepare_replace_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
@@ -441,3 +474,42 @@ class AsyncSCIMClient(BaseAsyncSCIMClient):
                 raise_scim_errors=raise_scim_errors,
                 scim_ctx=Context.RESOURCE_REPLACEMENT_RESPONSE,
             )
+
+    async def modify(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        check_response_payload: Optional[bool] = None,
+        expected_status_codes: Optional[
+            list[int]
+        ] = BaseAsyncSCIMClient.PATCH_RESPONSE_STATUS_CODES,
+        raise_scim_errors: Optional[bool] = None,
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
+        req = self._prepare_patch_request(
+            resource_model=resource_model,
+            id=id,
+            patch_op=patch_op,
+            check_request_payload=check_request_payload,
+            expected_status_codes=expected_status_codes,
+            **kwargs,
+        )
+
+        with handle_request_error(req.payload):
+            response = await self.client.patch(
+                req.url, json=req.payload, **req.request_kwargs
+            )
+
+        with handle_response_error(response):
+            return self.check_response(
+                payload=response.json() if response.text else None,
+                status_code=response.status_code,
+                headers=response.headers,
+                expected_status_codes=req.expected_status_codes,
+                expected_types=req.expected_types,
+                check_response_payload=check_response_payload,
+                raise_scim_errors=raise_scim_errors,
+                scim_ctx=Context.RESOURCE_PATCH_RESPONSE,
+            )

scim2_client/engines/werkzeug.py

@@ -1,6 +1,7 @@
 import json
 from contextlib import contextmanager
 from typing import Optional
+from typing import TypeVar
 from typing import Union
 from urllib.parse import urlencode
 
@@ -8,6 +9,7 @@ from scim2_models import AnyResource
 from scim2_models import Context
 from scim2_models import Error
 from scim2_models import ListResponse
+from scim2_models import PatchOp
 from scim2_models import Resource
 from scim2_models import SearchRequest
 from werkzeug.test import Client
@@ -16,6 +18,8 @@ from scim2_client.client import BaseSyncSCIMClient
 from scim2_client.errors import SCIMClientError
 from scim2_client.errors import UnexpectedContentFormat
 
+ResourceT = TypeVar("ResourceT", bound=Resource)
+
 
 @contextmanager
 def handle_response_error(response):
@@ -86,7 +90,7 @@ class TestSCIMClient(BaseSyncSCIMClient):
         self.scim_prefix = scim_prefix
         self.environ = environ or {}
 
-    def make_url(self, url: Optional[str]) -> str:
+    def _make_url(self, url: Optional[str]) -> str:
         url = url or ""
         prefix = (
             self.scim_prefix[:-1]
@@ -110,16 +114,17 @@ class TestSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_create_request(
+        req = self._prepare_create_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
         environ = {**self.environ, **req.request_kwargs}
-        response = self.client.post(self.make_url(req.url), json=req.payload, **environ)
+        response = self.client.post(
+            self._make_url(req.url), json=req.payload, **environ
+        )
 
         with handle_response_error(req.payload):
             return self.check_response(
@@ -135,7 +140,7 @@ class TestSCIMClient(BaseSyncSCIMClient):
 
     def query(
         self,
-        resource_model: Optional[type[Resource]] = None,
+        resource_model: Optional[type[AnyResource]] = None,
         id: Optional[str] = None,
         search_request: Optional[Union[SearchRequest, dict]] = None,
         check_request_payload: Optional[bool] = None,
@@ -145,21 +150,20 @@ class TestSCIMClient(BaseSyncSCIMClient):
         ] = BaseSyncSCIMClient.QUERY_RESPONSE_STATUS_CODES,
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
-    ):
-        req = self.prepare_query_request(
+    ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
+        req = self._prepare_query_request(
             resource_model=resource_model,
             id=id,
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
         query_string = urlencode(req.payload, doseq=False) if req.payload else None
         environ = {**self.environ, **req.request_kwargs}
         response = self.client.get(
-            self.make_url(req.url), query_string=query_string, **environ
+            self._make_url(req.url), query_string=query_string, **environ
         )
 
         with handle_response_error(req.payload):
@@ -185,16 +189,17 @@ class TestSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, ListResponse[AnyResource], Error, dict]:
-        req = self.prepare_search_request(
+        req = self._prepare_search_request(
             search_request=search_request,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
         environ = {**self.environ, **req.request_kwargs}
-        response = self.client.post(self.make_url(req.url), json=req.payload, **environ)
+        response = self.client.post(
+            self._make_url(req.url), json=req.payload, **environ
+        )
 
         with handle_response_error(response):
             return self.check_response(
@@ -219,16 +224,15 @@ class TestSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Optional[Union[Error, dict]]:
-        req = self.prepare_delete_request(
+        req = self._prepare_delete_request(
             resource_model=resource_model,
             id=id,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
         environ = {**self.environ, **req.request_kwargs}
-        response = self.client.delete(self.make_url(req.url), **environ)
+        response = self.client.delete(self._make_url(req.url), **environ)
 
         with handle_response_error(response):
             return self.check_response(
@@ -251,16 +255,15 @@ class TestSCIMClient(BaseSyncSCIMClient):
         raise_scim_errors: Optional[bool] = None,
         **kwargs,
     ) -> Union[AnyResource, Error, dict]:
-        req = self.prepare_replace_request(
+        req = self._prepare_replace_request(
             resource=resource,
             check_request_payload=check_request_payload,
             expected_status_codes=expected_status_codes,
-            raise_scim_errors=raise_scim_errors,
             **kwargs,
         )
 
         environ = {**self.environ, **req.request_kwargs}
-        response = self.client.put(self.make_url(req.url), json=req.payload, **environ)
+        response = self.client.put(self._make_url(req.url), json=req.payload, **environ)
 
         with handle_response_error(response):
             return self.check_response(
@@ -273,3 +276,42 @@ class TestSCIMClient(BaseSyncSCIMClient):
                 raise_scim_errors=raise_scim_errors,
                 scim_ctx=Context.RESOURCE_REPLACEMENT_RESPONSE,
             )
+
+    def modify(
+        self,
+        resource_model: type[ResourceT],
+        id: str,
+        patch_op: Union[PatchOp[ResourceT], dict],
+        check_request_payload: Optional[bool] = None,
+        check_response_payload: Optional[bool] = None,
+        expected_status_codes: Optional[
+            list[int]
+        ] = BaseSyncSCIMClient.PATCH_RESPONSE_STATUS_CODES,
+        raise_scim_errors: Optional[bool] = None,
+        **kwargs,
+    ) -> Optional[Union[ResourceT, Error, dict]]:
+        req = self._prepare_patch_request(
+            resource_model=resource_model,
+            id=id,
+            patch_op=patch_op,
+            check_request_payload=check_request_payload,
+            expected_status_codes=expected_status_codes,
+            **kwargs,
+        )
+
+        environ = {**self.environ, **req.request_kwargs}
+        response = self.client.patch(
+            self._make_url(req.url), json=req.payload, **environ
+        )
+
+        with handle_response_error(response):
+            return self.check_response(
+                payload=response.json if response.text else None,
+                status_code=response.status_code,
+                headers=response.headers,
+                expected_status_codes=req.expected_status_codes,
+                expected_types=req.expected_types,
+                check_response_payload=check_response_payload,
+                raise_scim_errors=raise_scim_errors,
+                scim_ctx=Context.RESOURCE_PATCH_RESPONSE,
+            )

scim2_client/errors.py

@@ -9,12 +9,14 @@ class SCIMClientError(Exception):
         caused the exception.
     """
 
-    def __init__(self, message: str, source: Any = None, *args, **kwargs):
+    def __init__(
+        self, message: str, source: Any = None, *args: Any, **kwargs: Any
+    ) -> None:
         self.message = message
         self.source = source
         super().__init__(*args, **kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.message or "UNKNOWN"
 
 
@@ -29,7 +31,7 @@ class RequestNetworkError(SCIMRequestError):
     The original :class:`~httpx.RequestError` is available with :attr:`~BaseException.__cause__`.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop("message", "Network error happened during request")
         super().__init__(message, *args, **kwargs)
 
@@ -54,7 +56,7 @@ class RequestPayloadValidationError(SCIMRequestError):
             print("Original validation error cause", exc.__cause__)
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop("message", "Server request payload validation error")
         super().__init__(message, *args, **kwargs)
 
@@ -69,7 +71,7 @@ class SCIMResponseErrorObject(SCIMResponseError):
     Those errors are only raised when the :code:`raise_scim_errors` parameter is :data:`True`.
     """
 
-    def __init__(self, obj, *args, **kwargs):
+    def __init__(self, obj: Any, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop(
             "message", f"The server returned a SCIM Error object: {obj}"
         )
@@ -79,7 +81,7 @@ class SCIMResponseErrorObject(SCIMResponseError):
 class UnexpectedStatusCode(SCIMResponseError):
     """Error raised when a server returned an unexpected status code for a given :class:`~scim2_models.Context`."""
 
-    def __init__(self, status_code: int, *args, **kwargs):
+    def __init__(self, status_code: int, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop(
             "message", f"Unexpected response status code: {status_code}"
         )
@@ -89,7 +91,7 @@ class UnexpectedStatusCode(SCIMResponseError):
 class UnexpectedContentType(SCIMResponseError):
     """Error raised when a server returned an unexpected `Content-Type` header in a response."""
 
-    def __init__(self, content_type, *args, **kwargs):
+    def __init__(self, content_type: str, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop("message", f"Unexpected content type: {content_type}")
         super().__init__(message, *args, **kwargs)
 
@@ -97,7 +99,7 @@ class UnexpectedContentType(SCIMResponseError):
 class UnexpectedContentFormat(SCIMResponseError):
     """Error raised when a server returned a response in a non-JSON format."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop("message", "Unexpected response content format")
         super().__init__(message, *args, **kwargs)
 
@@ -117,6 +119,6 @@ class ResponsePayloadValidationError(SCIMResponseError):
             print("Original validation error cause", exc.__cause__)
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         message = kwargs.pop("message", "Server response payload validation error")
         super().__init__(message, *args, **kwargs)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-client
-Version: 0.5.2
+Version: 0.6.1
 Summary: Pythonically build SCIM requests and parse SCIM responses
 Project-URL: documentation, https://scim2-client.readthedocs.io
 Project-URL: repository, https://github.com/python-scim/scim2-client
@@ -223,7 +223,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.9
-Requires-Dist: scim2-models>=0.2.0
+Requires-Dist: scim2-models>=0.4.1
 Provides-Extra: httpx
 Requires-Dist: httpx>=0.28.0; extra == 'httpx'
 Provides-Extra: werkzeug

scim2_client-0.6.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+scim2_client/__init__.py,sha256=l0pyBLiTpFA68ao98PqQLT_Xx0mw8BHumwrIHYCWa_M,845
+scim2_client/client.py,sha256=jtL0Lhy8USPECiAwVbD5grIVePFIIdfibVu0_5EQISQ,55067
+scim2_client/errors.py,sha256=LTTrjwTImKcPmeEcd_WqSphaGNf_2tlRA4V7UhndAE8,4572
+scim2_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_client/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_client/engines/httpx.py,sha256=vpMa6_1q8RsyZo1hCm8FOt5htbgiEW58LZ5EwkMu82s,20535
+scim2_client/engines/werkzeug.py,sha256=mszoQSneEH2SsewcG7Pq6hW-zFIeyreObFuO2K89ssc,12277
+scim2_client-0.6.1.dist-info/METADATA,sha256=SVVX7EcdbqP_9jF9yS1CB2dsNrGidGKNctJAQ0U81Ws,16986
+scim2_client-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scim2_client-0.6.1.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scim2_client-0.6.1.dist-info/RECORD,,

scim2_client-0.5.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-scim2_client/__init__.py,sha256=l0pyBLiTpFA68ao98PqQLT_Xx0mw8BHumwrIHYCWa_M,845
-scim2_client/client.py,sha256=jSj_g8qjpCFF1sKd-STJNPjfdHN_zjGAkYBes9CveOY,46374
-scim2_client/errors.py,sha256=FVmRXsaZLn1VZhJ3dSDs4IqycuU92AEun9JWWMseVO8,4397
-scim2_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scim2_client/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scim2_client/engines/httpx.py,sha256=L39ZZHjqe43uIQpgh_r_maqM2gkf3_Rk6d8MeNe57gk,17781
-scim2_client/engines/werkzeug.py,sha256=DmUBWytoWPehcrgBpGzlRJLCT7mrAW_VWSQ6BHylwCo,10800
-scim2_client-0.5.2.dist-info/METADATA,sha256=hmKozbJhq6eZxe_rFfspw-hHsD9H1pQmfsHMm_CTTdk,16986
-scim2_client-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scim2_client-0.5.2.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scim2_client-0.5.2.dist-info/RECORD,,