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

{scim2_models-0.3.6 → scim2_models-0.4.0}/.github/workflows/tests.yaml

@@ -34,6 +34,20 @@ jobs:
       - name: Run tests
         run: uv run pytest --showlocals
 
+  coverage:
+    name: py${{ matrix.python }} unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+      - name: Install Python ${{ matrix.python }}
+        run: uv python install ${{ matrix.python }}
+      - name: Run tests
+        run: uv run pytest --cov --cov-fail-under=100
+
   downstream-tests:
     name: py${{ matrix.python }} ${{ matrix.downstream }} downstream unit tests
     runs-on: ubuntu-latest

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.3.6
+Version: 0.4.0
 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.3.6 → scim2_models-0.4.0}/conftest.py

@@ -5,7 +5,7 @@ import scim2_models
 
 
 @pytest.fixture(autouse=True)
-def add_doctest_namespace(doctest_namespace):
+def add_doctest_namespace(doctest_namespace: dict) -> dict:
     doctest_namespace["pydantic"] = pydantic
     imports = {item: getattr(scim2_models, item) for item in scim2_models.__all__}
     doctest_namespace.update(imports)

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

@@ -1,6 +1,27 @@
 Changelog
 =========
 
+[0.4.0] - 2025-07-23
+--------------------
+
+Added
+^^^^^
+- Proper path validation for :attr:`~scim2_models.SearchRequest.attributes`, :attr:`~scim2_models.SearchRequest.excluded_attributes` and :attr:`~scim2_models.SearchRequest.sort_by`.
+- Implement :meth:`~scim2_models.PatchOp.patch`
+
+Fixed
+^^^^^
+- When using ``model_dump``, ignore invalid ``attributes`` and ``excluded_attributes``
+  as suggested by RFC7644.
+- Don't normalize attributes typed with :data:`Any`. :issue:`20`
+
+[0.3.7] - 2025-07-17
+--------------------
+
+Fixed
+^^^^^
+- All non strict mypy type annotations are fixed.
+
 [0.3.6] - 2025-07-02
 --------------------
 

{scim2_models-0.3.6 → scim2_models-0.4.0}/doc/tutorial.rst

@@ -204,9 +204,9 @@ If a response resource type cannot be found, a ``pydantic.ValidationError`` will
     >>> response = ListResponse[Union[User, Group]].model_validate(payload)
     >>> user, group = response.resources
     >>> type(user)
-    <class 'scim2_models.rfc7643.user.User'>
+    <class 'scim2_models.resources.user.User'>
     >>> type(group)
-    <class 'scim2_models.rfc7643.group.Group'>
+    <class 'scim2_models.resources.group.Group'>
 
 
 Schema extensions
@@ -403,9 +403,49 @@ This can be used by client applications that intends to dynamically discover ser
           :language: json
           :caption: schema-group.json
 
-Bulk and Patch operations
-=========================
+Patch operations
+================
+
+:class:`~scim2_models.PatchOp` allows you to apply patch operations to modify SCIM resources.
+The :meth:`~scim2_models.PatchOp.patch` method applies operations in sequence and returns whether the resource was modified. The return code is a boolean indicating whether the object have been modified by the operations.
+
+.. note::
+   :class:`~scim2_models.PatchOp` takes a type parameter that should be the class of the resource
+   that is expected to be patched.
+
+.. code-block:: python
+
+    >>> from scim2_models import User, PatchOp, PatchOperation
+    >>> user = User(user_name="john.doe", nick_name="Johnny")
+
+    >>> payload = {
+    ...   "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+    ...   "Operations": [
+    ...     {"op": "replace", "path": "nickName", "value": "John" },
+    ...     {"op": "add", "path": "emails", "value": [{"value": "john@example.com"}]},
+    ...   ]
+    ... }
+    >>> patch = PatchOp[User].model_validate(
+    ...     payload, scim_ctx=Context.RESOURCE_PATCH_REQUEST
+    ... )
+
+    >>> modified = patch.patch(user)
+    >>> print(modified)
+    True
+    >>> print(user.nick_name)
+    John
+    >>> print(user.emails[0].value)
+    john@example.com
+
+.. warning::
+
+   Patch operations are validated in the :attr:`~scim2_models.Context.RESOURCE_PATCH_REQUEST`
+   context. Make sure to validate patch operations with the correct context to
+   ensure proper validation of mutability and required constraints.
+
+Bulk operations
+===============
 
 .. todo::
 
-   Bulk and Patch operations are not implemented yet, but any help is welcome!
+   Bulk operations are not implemented yet, but any help is welcome!

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "scim2-models"
-version = "0.3.6"
+version = "0.4.0"
 description = "SCIM2 models serialization and validation with pydantic"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE"}
@@ -68,6 +68,7 @@ exclude_lines = [
     "pragma: no cover",
     "raise NotImplementedError",
     "except ImportError",
+    "if TYPE_CHECKING:",
 ]
 
 [tool.ruff.lint]
@@ -104,10 +105,20 @@ docstring-code-format = true
 addopts = "--doctest-modules --doctest-glob='*.rst'"
 doctest_optionflags= "ALLOW_UNICODE IGNORE_EXCEPTION_DETAIL ELLIPSIS"
 
-# [tool.mypy]
-# plugins = [
-#   "pydantic.mypy"
-# ]
+[tool.mypy]
+plugins = [
+  "pydantic.mypy"
+]
+warn_unused_ignores = true
+exclude = [
+  "tests/",
+  "conftest.py",
+]
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
 
 [tool.tox]
 requires = ["tox>=4.19"]

scim2_models-0.4.0/scim2_models/__init__.py

@@ -0,0 +1,109 @@
+from .annotations import CaseExact
+from .annotations import Mutability
+from .annotations import Required
+from .annotations import Returned
+from .annotations import Uniqueness
+from .attributes import ComplexAttribute
+from .attributes import MultiValuedComplexAttribute
+from .base import BaseModel
+from .context import Context
+from .messages.bulk import BulkOperation
+from .messages.bulk import BulkRequest
+from .messages.bulk import BulkResponse
+from .messages.error import Error
+from .messages.list_response import ListResponse
+from .messages.message import Message
+from .messages.patch_op import PatchOp
+from .messages.patch_op import PatchOperation
+from .messages.search_request import SearchRequest
+from .reference import ExternalReference
+from .reference import Reference
+from .reference import URIReference
+from .resources.enterprise_user import EnterpriseUser
+from .resources.enterprise_user import Manager
+from .resources.group import Group
+from .resources.group import GroupMember
+from .resources.resource import AnyExtension
+from .resources.resource import AnyResource
+from .resources.resource import Extension
+from .resources.resource import Meta
+from .resources.resource import Resource
+from .resources.resource_type import ResourceType
+from .resources.resource_type import SchemaExtension
+from .resources.schema import Attribute
+from .resources.schema import Schema
+from .resources.service_provider_config import AuthenticationScheme
+from .resources.service_provider_config import Bulk
+from .resources.service_provider_config import ChangePassword
+from .resources.service_provider_config import ETag
+from .resources.service_provider_config import Filter
+from .resources.service_provider_config import Patch
+from .resources.service_provider_config import ServiceProviderConfig
+from .resources.service_provider_config import Sort
+from .resources.user import Address
+from .resources.user import Email
+from .resources.user import Entitlement
+from .resources.user import GroupMembership
+from .resources.user import Im
+from .resources.user import Name
+from .resources.user import PhoneNumber
+from .resources.user import Photo
+from .resources.user import Role
+from .resources.user import User
+from .resources.user import X509Certificate
+
+__all__ = [
+    "Address",
+    "AnyResource",
+    "AnyExtension",
+    "Attribute",
+    "AuthenticationScheme",
+    "BaseModel",
+    "Bulk",
+    "BulkOperation",
+    "BulkRequest",
+    "BulkResponse",
+    "CaseExact",
+    "ChangePassword",
+    "ComplexAttribute",
+    "Context",
+    "ETag",
+    "Email",
+    "EnterpriseUser",
+    "Entitlement",
+    "Error",
+    "ExternalReference",
+    "Extension",
+    "Filter",
+    "Group",
+    "GroupMember",
+    "GroupMembership",
+    "Im",
+    "ListResponse",
+    "Manager",
+    "Message",
+    "Meta",
+    "Mutability",
+    "MultiValuedComplexAttribute",
+    "Name",
+    "Patch",
+    "PatchOp",
+    "PatchOperation",
+    "PhoneNumber",
+    "Photo",
+    "Reference",
+    "Required",
+    "Resource",
+    "ResourceType",
+    "Returned",
+    "Role",
+    "Schema",
+    "SchemaExtension",
+    "SearchRequest",
+    "ServiceProviderConfig",
+    "Sort",
+    "Uniqueness",
+    "URIReference",
+    "User",
+    "X509Certificate",
+]

scim2_models-0.4.0/scim2_models/annotations.py

@@ -0,0 +1,104 @@
+from enum import Enum
+
+
+class Mutability(str, Enum):
+    """A single keyword indicating the circumstances under which the value of the attribute can be (re)defined."""
+
+    read_only = "readOnly"
+    """The attribute SHALL NOT be modified."""
+
+    read_write = "readWrite"
+    """The attribute MAY be updated and read at any time."""
+
+    immutable = "immutable"
+    """The attribute MAY be defined at resource creation (e.g., POST) or at
+    record replacement via a request (e.g., a PUT).
+
+    The attribute SHALL NOT be updated.
+    """
+
+    write_only = "writeOnly"
+    """The attribute MAY be updated at any time.
+
+    Attribute values SHALL NOT be returned (e.g., because the value is a
+    stored hash).  Note: An attribute with a mutability of "writeOnly"
+    usually also has a returned setting of "never".
+    """
+
+    _default = read_write
+
+
+class Returned(str, Enum):
+    """A single keyword that indicates when an attribute and associated values are returned in response to a GET request or in response to a PUT, POST, or PATCH request."""
+
+    always = "always"  # cannot be excluded
+    """The attribute is always returned, regardless of the contents of the
+    "attributes" parameter.
+
+    For example, "id" is always returned to identify a SCIM resource.
+    """
+
+    never = "never"  # always excluded
+    """The attribute is never returned, regardless of the contents of the
+    "attributes" parameter."""
+
+    default = "default"  # included by default but can be excluded
+    """The attribute is returned by default in all SCIM operation responses
+    where attribute values are returned, unless it is explicitly excluded."""
+
+    request = "request"  # excluded by default but can be included
+    """The attribute is returned in response to any PUT, POST, or PATCH
+    operations if specified in the "attributes" parameter."""
+
+    _default = default
+
+
+class Uniqueness(str, Enum):
+    """A single keyword value that specifies how the service provider enforces uniqueness of attribute values."""
+
+    none = "none"
+    """The values are not intended to be unique in any way."""
+
+    server = "server"
+    """The value SHOULD be unique within the context of the current SCIM
+    endpoint (or tenancy) and MAY be globally unique (e.g., a "username", email
+    address, or other server-generated key or counter).
+
+    No two resources on the same server SHOULD possess the same value.
+    """
+
+    global_ = "global"
+    """The value SHOULD be globally unique (e.g., an email address, a GUID, or
+    other value).
+
+    No two resources on any server SHOULD possess the same value.
+    """
+
+    _default = none
+
+
+class Required(Enum):
+    """A Boolean value that specifies whether the attribute is required or not.
+
+    Missing required attributes raise a :class:`~pydantic.ValidationError` on :attr:`~scim2_models.Context.RESOURCE_CREATION_REQUEST` and :attr:`~scim2_models.Context.RESOURCE_REPLACEMENT_REQUEST` validations.
+    """
+
+    true = True
+    false = False
+
+    _default = false
+
+    def __bool__(self) -> bool:
+        return self.value
+
+
+class CaseExact(Enum):
+    """A Boolean value that specifies whether a string attribute is case- sensitive or not."""
+
+    true = True
+    false = False
+
+    _default = false
+
+    def __bool__(self) -> bool:
+        return self.value

scim2_models-0.4.0/scim2_models/attributes.py

@@ -0,0 +1,57 @@
+from inspect import isclass
+from typing import Annotated
+from typing import Any
+from typing import Optional
+from typing import get_origin
+
+from pydantic import Field
+
+from .annotations import Mutability
+
+# This import will work because we'll import this module after BaseModel is defined
+from .base import BaseModel
+from .reference import Reference
+
+
+class ComplexAttribute(BaseModel):
+    """A complex attribute as defined in :rfc:`RFC7643 §2.3.8 <7643#section-2.3.8>`."""
+
+    _attribute_urn: Optional[str] = None
+
+    def get_attribute_urn(self, field_name: str) -> str:
+        """Build the full URN of the attribute.
+
+        See :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
+        """
+        alias = (
+            self.__class__.model_fields[field_name].serialization_alias or field_name
+        )
+        return f"{self._attribute_urn}.{alias}"
+
+
+class MultiValuedComplexAttribute(ComplexAttribute):
+    type: Optional[str] = None
+    """A label indicating the attribute's function."""
+
+    primary: Optional[bool] = None
+    """A Boolean value indicating the 'primary' or preferred attribute value
+    for this attribute."""
+
+    display: Annotated[Optional[str], Mutability.immutable] = None
+    """A human-readable name, primarily used for display purposes."""
+
+    value: Optional[Any] = None
+    """The value of an entitlement."""
+
+    ref: Optional[Reference] = Field(None, serialization_alias="$ref")
+    """The reference URI of a target resource, if the attribute is a
+    reference."""
+
+
+def is_complex_attribute(type_: type) -> bool:
+    # issubclass raise a TypeError with 'Reference' on python < 3.11
+    return (
+        get_origin(type_) != Reference
+        and isclass(type_)
+        and issubclass(type_, (ComplexAttribute, MultiValuedComplexAttribute))
+    )