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

scim2_models/attributes.py

@@ -1,7 +1,6 @@
 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
@@ -16,7 +15,7 @@ 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
+    _attribute_urn: str | None = None
 
     def get_attribute_urn(self, field_name: str) -> str:
         """Build the full URN of the attribute.
@@ -30,20 +29,20 @@ class ComplexAttribute(BaseModel):
 
 
 class MultiValuedComplexAttribute(ComplexAttribute):
-    type: Optional[str] = None
+    type: str | None = None
     """A label indicating the attribute's function."""
 
-    primary: Optional[bool] = None
+    primary: bool | None = None
     """A Boolean value indicating the 'primary' or preferred attribute value
     for this attribute."""
 
-    display: Annotated[Optional[str], Mutability.immutable] = None
+    display: Annotated[str | None, Mutability.immutable] = None
     """A human-readable name, primarily used for display purposes."""
 
-    value: Optional[Any] = None
+    value: Any | None = None
     """The value of an entitlement."""
 
-    ref: Optional[Reference[Any]] = Field(None, serialization_alias="$ref")
+    ref: Reference[Any] | None = Field(None, serialization_alias="$ref")
     """The reference URI of a target resource, if the attribute is a
     reference."""
 

scim2_models/base.py

@@ -29,12 +29,21 @@ from scim2_models.utils import _normalize_attribute_name
 from scim2_models.utils import _to_camel
 
 
-def _contains_attribute_or_subattributes(
-    attribute_urns: list[str], attribute_urn: str
-) -> bool:
-    return attribute_urn in attribute_urns or any(
-        item.startswith(f"{attribute_urn}.") or item.startswith(f"{attribute_urn}:")
-        for item in attribute_urns
+def _is_attribute_requested(requested_urns: list[str], current_urn: str) -> bool:
+    """Check if an attribute should be included based on the requested URNs.
+
+    Returns True if:
+    - The current attribute is explicitly requested
+    - A sub-attribute of the current attribute is requested
+    - The current attribute is a sub-attribute of a requested attribute
+    """
+    return (
+        current_urn in requested_urns
+        or any(
+            item.startswith(f"{current_urn}.") or item.startswith(f"{current_urn}:")
+            for item in requested_urns
+        )
+        or any(current_urn.startswith(f"{item}.") for item in requested_urns)
     )
 
 
@@ -96,7 +105,7 @@ class BaseModel(PydanticBaseModel):
         return field_annotation
 
     @classmethod
-    def get_field_root_type(cls, attribute_name: str) -> Optional[type]:
+    def get_field_root_type(cls, attribute_name: str) -> type | None:
         """Extract the root type from a model field.
 
         This method unwraps complex type annotations to find the underlying
@@ -244,7 +253,7 @@ class BaseModel(PydanticBaseModel):
             return result
 
         def normalize_value(
-            val: Any, model_class: Optional[type["BaseModel"]] = None
+            val: Any, model_class: type["BaseModel"] | None = None
         ) -> Any:
             """Normalize input value based on model class."""
             if not isinstance(val, dict):
@@ -478,9 +487,7 @@ class BaseModel(PydanticBaseModel):
         if returnability == Returned.default and (
             (
                 included_urns
-                and not _contains_attribute_or_subattributes(
-                    included_urns, attribute_urn
-                )
+                and not _is_attribute_requested(included_urns, attribute_urn)
             )
             or attribute_urn in excluded_urns
         ):
@@ -504,7 +511,7 @@ class BaseModel(PydanticBaseModel):
     def model_validate(
         cls,
         *args: Any,
-        scim_ctx: Optional[Context] = Context.DEFAULT,
+        scim_ctx: Context | None = Context.DEFAULT,
         original: Optional["BaseModel"] = None,
         **kwargs: Any,
     ) -> Self:

scim2_models/messages/bulk.py

@@ -1,7 +1,6 @@
 from enum import Enum
 from typing import Annotated
 from typing import Any
-from typing import Optional
 
 from pydantic import Field
 from pydantic import PlainSerializer
@@ -19,30 +18,30 @@ class BulkOperation(ComplexAttribute):
         patch = "PATCH"
         delete = "DELETE"
 
-    method: Optional[Method] = None
+    method: Method | None = None
     """The HTTP method of the current operation."""
 
-    bulk_id: Optional[str] = None
+    bulk_id: str | None = None
     """The transient identifier of a newly created resource, unique within a
     bulk request and created by the client."""
 
-    version: Optional[str] = None
+    version: str | None = None
     """The current resource version."""
 
-    path: Optional[str] = None
+    path: str | None = None
     """The resource's relative path to the SCIM service provider's root."""
 
-    data: Optional[Any] = None
+    data: Any | None = None
     """The resource data as it would appear for a single SCIM POST, PUT, or
     PATCH operation."""
 
-    location: Optional[str] = None
+    location: str | None = None
     """The resource endpoint URL."""
 
-    response: Optional[Any] = None
+    response: Any | None = None
     """The HTTP response body for the specified request operation."""
 
-    status: Annotated[Optional[int], PlainSerializer(_int_to_str)] = None
+    status: Annotated[int | None, PlainSerializer(_int_to_str)] = None
     """The HTTP response status code for the requested operation."""
 
 
@@ -58,12 +57,12 @@ class BulkRequest(Message):
         "urn:ietf:params:scim:api:messages:2.0:BulkRequest"
     ]
 
-    fail_on_errors: Optional[int] = None
+    fail_on_errors: int | None = None
     """An integer specifying the number of errors that the service provider
     will accept before the operation is terminated and an error response is
     returned."""
 
-    operations: Optional[list[BulkOperation]] = Field(
+    operations: list[BulkOperation] | None = Field(
         None, serialization_alias="Operations"
     )
     """Defines operations within a bulk job."""
@@ -81,7 +80,7 @@ class BulkResponse(Message):
         "urn:ietf:params:scim:api:messages:2.0:BulkResponse"
     ]
 
-    operations: Optional[list[BulkOperation]] = Field(
+    operations: list[BulkOperation] | None = Field(
         None, serialization_alias="Operations"
     )
     """Defines operations within a bulk job."""

scim2_models/messages/error.py

@@ -1,5 +1,4 @@
 from typing import Annotated
-from typing import Optional
 
 from pydantic import PlainSerializer
 
@@ -15,14 +14,14 @@ class Error(Message):
         "urn:ietf:params:scim:api:messages:2.0:Error"
     ]
 
-    status: Annotated[Optional[int], PlainSerializer(_int_to_str)] = None
+    status: Annotated[int | None, PlainSerializer(_int_to_str)] = None
     """The HTTP status code (see Section 6 of [RFC7231]) expressed as a JSON
     string."""
 
-    scim_type: Optional[str] = None
+    scim_type: str | None = None
     """A SCIM detail error keyword."""
 
-    detail: Optional[str] = None
+    detail: str | None = None
     """A detailed human-readable message."""
 
     @classmethod

scim2_models/messages/list_response.py

@@ -1,7 +1,6 @@
 from typing import Annotated
 from typing import Any
 from typing import Generic
-from typing import Optional
 
 from pydantic import Field
 from pydantic import ValidationInfo
@@ -22,19 +21,17 @@ class ListResponse(Message, Generic[AnyResource], metaclass=_GenericMessageMetac
         "urn:ietf:params:scim:api:messages:2.0:ListResponse"
     ]
 
-    total_results: Optional[int] = None
+    total_results: int | None = None
     """The total number of results returned by the list or query operation."""
 
-    start_index: Optional[int] = None
+    start_index: int | None = None
     """The 1-based index of the first result in the current set of list
     results."""
 
-    items_per_page: Optional[int] = None
+    items_per_page: int | None = None
     """The number of resources returned in a list response page."""
 
-    resources: Optional[list[AnyResource]] = Field(
-        None, serialization_alias="Resources"
-    )
+    resources: list[AnyResource] | None = Field(None, serialization_alias="Resources")
     """A multi-valued list of complex objects containing the requested
     resources."""
 

scim2_models/messages/message.py

@@ -1,7 +1,6 @@
+from collections.abc import Callable
 from typing import Annotated
 from typing import Any
-from typing import Callable
-from typing import Optional
 from typing import Union
 from typing import get_args
 from typing import get_origin
@@ -23,14 +22,14 @@ class Message(ScimObject):
 
 def _create_schema_discriminator(
     resource_types_schemas: list[str],
-) -> Callable[[Any], Optional[str]]:
+) -> Callable[[Any], str | None]:
     """Create a schema discriminator function for the given resource schemas.
 
     :param resource_types_schemas: List of valid resource schemas
     :return: Discriminator function for Pydantic
     """
 
-    def get_schema_from_payload(payload: Any) -> Optional[str]:
+    def get_schema_from_payload(payload: Any) -> str | None:
         """Extract schema from SCIM payload for discrimination.
 
         :param payload: SCIM payload dict or object
@@ -89,7 +88,7 @@ def _create_tagged_resource_union(resource_union: Any) -> Any:
         for resource_type in resource_types
     ]
     # Dynamic union construction from tuple - MyPy can't validate this at compile time
-    union = Union[tuple(tagged_resources)]  # type: ignore
+    union = Union[tuple(tagged_resources)]  # type: ignore  # noqa: UP007
     return Annotated[union, discriminator]
 
 

scim2_models/messages/patch_op.py

@@ -3,9 +3,7 @@ from inspect import isclass
 from typing import Annotated
 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
@@ -48,7 +46,7 @@ class PatchOperation(ComplexAttribute):
         despite :rfc:`RFC7644 §3.5.2 <7644#section-3.5.2>`, op is case-insensitive.
     """
 
-    path: Optional[str] = None
+    path: str | None = None
     """The "path" attribute value is a String containing an attribute path
     describing the target of the operation."""
 
@@ -113,7 +111,7 @@ class PatchOperation(ComplexAttribute):
 
         return self
 
-    value: Optional[Any] = None
+    value: Any | None = None
 
     @field_validator("op", mode="before")
     @classmethod
@@ -165,7 +163,7 @@ class PatchOp(Message, Generic[T]):
         return super().__new__(cls)
 
     def __class_getitem__(
-        cls, typevar_values: Union[type[Resource[Any]], tuple[type[Resource[Any]], ...]]
+        cls, typevar_values: type[Resource[Any]] | tuple[type[Resource[Any]], ...]
     ) -> Any:
         """Validate type parameter when creating parameterized type.
 
@@ -211,7 +209,7 @@ class PatchOp(Message, Generic[T]):
         "urn:ietf:params:scim:api:messages:2.0:PatchOp"
     ]
 
-    operations: Annotated[Optional[list[PatchOperation]], Required.true] = Field(
+    operations: Annotated[list[PatchOperation] | None, Required.true] = Field(
         None, serialization_alias="Operations", min_length=1
     )
     """The body of an HTTP PATCH request MUST contain the attribute

scim2_models/messages/search_request.py

@@ -1,6 +1,5 @@
 from enum import Enum
 from typing import Annotated
-from typing import Optional
 
 from pydantic import field_validator
 from pydantic import model_validator
@@ -21,14 +20,14 @@ class SearchRequest(Message):
         "urn:ietf:params:scim:api:messages:2.0:SearchRequest"
     ]
 
-    attributes: Optional[list[str]] = None
+    attributes: list[str] | None = None
     """A multi-valued list of strings indicating the names of resource
     attributes to return in the response, overriding the set of attributes that
     would be returned by default."""
 
     @field_validator("attributes")
     @classmethod
-    def validate_attributes_syntax(cls, v: Optional[list[str]]) -> Optional[list[str]]:
+    def validate_attributes_syntax(cls, v: list[str] | None) -> list[str] | None:
         """Validate syntax of attribute paths."""
         if v is None:
             return v
@@ -39,15 +38,15 @@ class SearchRequest(Message):
 
         return v
 
-    excluded_attributes: Optional[list[str]] = None
+    excluded_attributes: list[str] | None = None
     """A multi-valued list of strings indicating the names of resource
     attributes to be removed from the default set of attributes to return."""
 
     @field_validator("excluded_attributes")
     @classmethod
     def validate_excluded_attributes_syntax(
-        cls, v: Optional[list[str]]
-    ) -> Optional[list[str]]:
+        cls, v: list[str] | None
+    ) -> list[str] | None:
         """Validate syntax of excluded attribute paths."""
         if v is None:
             return v
@@ -58,16 +57,16 @@ class SearchRequest(Message):
 
         return v
 
-    filter: Optional[str] = None
+    filter: str | None = None
     """The filter string used to request a subset of resources."""
 
-    sort_by: Optional[str] = None
+    sort_by: str | None = None
     """A string indicating the attribute whose value SHALL be used to order the
     returned responses."""
 
     @field_validator("sort_by")
     @classmethod
-    def validate_sort_by_syntax(cls, v: Optional[str]) -> Optional[str]:
+    def validate_sort_by_syntax(cls, v: str | None) -> str | None:
         """Validate syntax of sort_by attribute path.
 
         :param v: The sort_by attribute path to validate
@@ -86,29 +85,29 @@ class SearchRequest(Message):
         ascending = "ascending"
         descending = "descending"
 
-    sort_order: Optional[SortOrder] = None
+    sort_order: SortOrder | None = None
     """A string indicating the order in which the "sortBy" parameter is
     applied."""
 
-    start_index: Optional[int] = None
+    start_index: int | None = None
     """An integer indicating the 1-based index of the first query result."""
 
     @field_validator("start_index")
     @classmethod
-    def start_index_floor(cls, value: Optional[int]) -> Optional[int]:
+    def start_index_floor(cls, value: int | None) -> int | None:
         """According to :rfc:`RFC7644 §3.4.2 <7644#section-3.4.2.4>, start_index values less than 1 are interpreted as 1.
 
         A value less than 1 SHALL be interpreted as 1.
         """
         return None if value is None else max(1, value)
 
-    count: Optional[int] = None
+    count: int | None = None
     """An integer indicating the desired maximum number of query results per
     page."""
 
     @field_validator("count")
     @classmethod
-    def count_floor(cls, value: Optional[int]) -> Optional[int]:
+    def count_floor(cls, value: int | None) -> int | None:
         """According to :rfc:`RFC7644 §3.4.2 <7644#section-3.4.2.4>, count values less than 0 are interpreted as 0.
 
         A negative value SHALL be interpreted as 0.
@@ -125,12 +124,12 @@ class SearchRequest(Message):
         return self
 
     @property
-    def start_index_0(self) -> Optional[int]:
+    def start_index_0(self) -> int | None:
         """The 0 indexed start index."""
         return self.start_index - 1 if self.start_index is not None else None
 
     @property
-    def stop_index_0(self) -> Optional[int]:
+    def stop_index_0(self) -> int | None:
         """The 0 indexed stop index."""
         return (
             self.start_index_0 + self.count

scim2_models/reference.py

@@ -1,13 +1,13 @@
 from collections import UserString
 from typing import Any
 from typing import Generic
+from typing import NewType
 from typing import TypeVar
 from typing import get_args
 from typing import get_origin
 
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
-from typing_extensions import NewType
 
 from .utils import UNION_TYPES
 

scim2_models/resources/enterprise_user.py

@@ -1,6 +1,5 @@
 from typing import Annotated
 from typing import Literal
-from typing import Optional
 
 from pydantic import Field
 
@@ -12,16 +11,16 @@ from .resource import Extension
 
 
 class Manager(ComplexAttribute):
-    value: Annotated[Optional[str], Required.true] = None
+    value: Annotated[str | None, Required.true] = None
     """The id of the SCIM resource representing the User's manager."""
 
-    ref: Annotated[Optional[Reference[Literal["User"]]], Required.true] = Field(
+    ref: Annotated[Reference[Literal["User"]] | None, Required.true] = Field(
         None,
         serialization_alias="$ref",
     )
     """The URI of the SCIM resource representing the User's manager."""
 
-    display_name: Annotated[Optional[str], Mutability.read_only] = None
+    display_name: Annotated[str | None, Mutability.read_only] = None
     """The displayName of the User's manager."""
 
 
@@ -30,24 +29,24 @@ class EnterpriseUser(Extension):
         "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User"
     ]
 
-    employee_number: Optional[str] = None
+    employee_number: str | None = None
     """Numeric or alphanumeric identifier assigned to a person, typically based
     on order of hire or association with an organization."""
 
-    cost_center: Optional[str] = None
+    cost_center: str | None = None
     """"Identifies the name of a cost center."""
 
-    organization: Optional[str] = None
+    organization: str | None = None
     """Identifies the name of an organization."""
 
-    division: Optional[str] = None
+    division: str | None = None
     """Identifies the name of a division."""
 
-    department: Optional[str] = None
+    department: str | None = None
     """Numeric or alphanumeric identifier assigned to a person, typically based
     on order of hire or association with an organization."""
 
-    manager: Optional[Manager] = None
+    manager: Manager | None = None
     """The User's manager.
 
     A complex type that optionally allows service providers to represent

scim2_models/resources/group.py

@@ -2,8 +2,6 @@ from typing import Annotated
 from typing import Any
 from typing import ClassVar
 from typing import Literal
-from typing import Optional
-from typing import Union
 
 from pydantic import Field
 
@@ -15,22 +13,22 @@ from .resource import Resource
 
 
 class GroupMember(ComplexAttribute):
-    value: Annotated[Optional[str], Mutability.immutable] = None
+    value: Annotated[str | None, Mutability.immutable] = None
     """Identifier of the member of this Group."""
 
     ref: Annotated[
-        Optional[Reference[Union[Literal["User"], Literal["Group"]]]],
+        Reference[Literal["User"] | Literal["Group"]] | None,
         Mutability.immutable,
     ] = Field(None, serialization_alias="$ref")
     """The reference URI of a target resource, if the attribute is a
     reference."""
 
-    type: Annotated[Optional[str], Mutability.immutable] = Field(
+    type: Annotated[str | None, Mutability.immutable] = Field(
         None, examples=["User", "Group"]
     )
     """A label indicating the attribute's function, e.g., "work" or "home"."""
 
-    display: Annotated[Optional[str], Mutability.read_only] = None
+    display: Annotated[str | None, Mutability.read_only] = None
 
 
 class Group(Resource[Any]):
@@ -38,10 +36,10 @@ class Group(Resource[Any]):
         "urn:ietf:params:scim:schemas:core:2.0:Group"
     ]
 
-    display_name: Optional[str] = None
+    display_name: str | None = None
     """A human-readable name for the Group."""
 
-    members: Optional[list[GroupMember]] = None
+    members: list[GroupMember] | None = None
     """A list of members of the Group."""
 
     Members: ClassVar[type[ComplexAttribute]] = GroupMember