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

scim2_models/resources/resource.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING
 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 typing import cast
@@ -42,20 +41,20 @@ class Meta(ComplexAttribute):
     This attribute SHALL be ignored when provided by clients.  "meta" contains the following sub-attributes:
     """
 
-    resource_type: Optional[str] = None
+    resource_type: str | None = None
     """The name of the resource type of the resource.
 
     This attribute has a mutability of "readOnly" and "caseExact" as
     "true".
     """
 
-    created: Optional[datetime] = None
+    created: datetime | None = None
     """The "DateTime" that the resource was added to the service provider.
 
     This attribute MUST be a DateTime.
     """
 
-    last_modified: Optional[datetime] = None
+    last_modified: datetime | None = None
     """The most recent DateTime that the details of this resource were updated
     at the service provider.
 
@@ -63,14 +62,14 @@ class Meta(ComplexAttribute):
     the value MUST be the same as the value of "created".
     """
 
-    location: Optional[str] = None
+    location: str | None = None
     """The URI of the resource being returned.
 
     This value MUST be the same as the "Content-Location" HTTP response
     header (see Section 3.1.4.2 of [RFC7231]).
     """
 
-    version: Optional[str] = None
+    version: str | None = None
     """The version of the resource being returned.
 
     This value must be the same as the entity-tag (ETag) HTTP response
@@ -108,7 +107,7 @@ _PARAMETERIZED_CLASSES: dict[tuple[type, tuple[Any, ...]], type] = {}
 
 def _extension_serializer(
     value: Any, handler: SerializerFunctionWrapHandler, info: SerializationInfo
-) -> Optional[dict[str, Any]]:
+) -> dict[str, Any] | None:
     """Exclude the Resource attributes from the extension dump.
 
     For instance, attributes 'meta', 'id' or 'schemas' should not be
@@ -128,7 +127,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
     # https://www.rfc-editor.org/rfc/rfc7643#section-3.1
 
     id: Annotated[
-        Optional[str], Mutability.read_only, Returned.always, Uniqueness.global_
+        str | None, Mutability.read_only, Returned.always, Uniqueness.global_
     ] = None
     """A unique identifier for a SCIM resource as defined by the service
     provider.
@@ -138,12 +137,12 @@ class Resource(ScimObject, Generic[AnyExtension]):
     """
 
     external_id: Annotated[
-        Optional[str], Mutability.read_write, Returned.default, CaseExact.true
+        str | None, Mutability.read_write, Returned.default, CaseExact.true
     ] = None
     """A String that is an identifier for the resource as defined by the
     provisioning client."""
 
-    meta: Annotated[Optional[Meta], Mutability.read_only, Returned.default] = None
+    meta: Annotated[Meta | None, Mutability.read_only, Returned.default] = None
     """A complex attribute containing resource metadata."""
 
     @classmethod
@@ -188,7 +187,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
         new_annotations = {
             extension.__name__: Annotated[
-                Optional[extension],
+                extension | None,
                 WrapSerializer(_extension_serializer),
             ]
             for extension in valid_extensions
@@ -207,11 +206,11 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
         return new_class
 
-    def __getitem__(self, item: Any) -> Optional[Extension]:
+    def __getitem__(self, item: Any) -> Extension | None:
         if not isinstance(item, type) or not issubclass(item, Extension):
             raise KeyError(f"{item} is not a valid extension type")
 
-        return cast(Optional[Extension], getattr(self, item.__name__))
+        return cast(Extension | None, getattr(self, item.__name__))
 
     def __setitem__(self, item: Any, value: "Extension") -> None:
         if not isinstance(item, type) or not issubclass(item, Extension):
@@ -231,7 +230,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
     @classmethod
     def get_extension_model(
         cls, name_or_schema: Union[str, "Schema"]
-    ) -> Optional[type[Extension]]:
+    ) -> type[Extension] | None:
         """Return an extension by its name or schema."""
         for schema, extension in cls.get_extension_models().items():
             if schema == name_or_schema or extension.__name__ == name_or_schema:
@@ -243,9 +242,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
         resource_types: list[type["Resource[Any]"]],
         schema: str,
         with_extensions: bool = True,
-    ) -> Optional[Union[type["Resource[Any]"], type["Extension"]]]:
+    ) -> type["Resource[Any]"] | type["Extension"] | None:
         """Given a resource type list and a schema, find the matching resource type."""
-        by_schema: dict[str, Union[type[Resource[Any]], type[Extension]]] = {
+        by_schema: dict[str, type[Resource[Any]] | type[Extension]] = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
         }
@@ -265,7 +264,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
         resource_types: list[type["Resource[Any]"]],
         payload: dict[str, Any],
         **kwargs: Any,
-    ) -> Optional[type]:
+    ) -> type | None:
         """Given a resource type list and a payload, find the matching resource type."""
         if not payload or not payload.get("schemas"):
             return None
@@ -298,9 +297,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
     def _prepare_model_dump(
         self,
-        scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
+        scim_ctx: Context | None = Context.DEFAULT,
+        attributes: list[str] | None = None,
+        excluded_attributes: list[str] | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         kwargs = super()._prepare_model_dump(scim_ctx, **kwargs)
@@ -323,9 +322,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
     def model_dump(
         self,
         *args: Any,
-        scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
+        scim_ctx: Context | None = Context.DEFAULT,
+        attributes: list[str] | None = None,
+        excluded_attributes: list[str] | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """Create a model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump`.
@@ -349,9 +348,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
     def model_dump_json(
         self,
         *args: Any,
-        scim_ctx: Optional[Context] = Context.DEFAULT,
-        attributes: Optional[list[str]] = None,
-        excluded_attributes: Optional[list[str]] = None,
+        scim_ctx: Context | None = Context.DEFAULT,
+        attributes: list[str] | None = None,
+        excluded_attributes: list[str] | None = None,
         **kwargs: Any,
     ) -> str:
         """Create a JSON model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump_json`.

scim2_models/resources/resource_type.py

@@ -1,6 +1,5 @@
 from typing import Annotated
 from typing import Any
-from typing import Optional
 
 from pydantic import Field
 from typing_extensions import Self
@@ -17,14 +16,14 @@ from .resource import Resource
 
 class SchemaExtension(ComplexAttribute):
     schema_: Annotated[
-        Optional[Reference[URIReference]],
+        Reference[URIReference] | None,
         Mutability.read_only,
         Required.true,
         CaseExact.true,
     ] = Field(None, alias="schema")
     """The URI of a schema extension."""
 
-    required: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    required: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value that specifies whether or not the schema extension is
     required for the resource type.
 
@@ -40,33 +39,33 @@ class ResourceType(Resource[Any]):
         "urn:ietf:params:scim:schemas:core:2.0:ResourceType"
     ]
 
-    name: Annotated[Optional[str], Mutability.read_only, Required.true] = None
+    name: Annotated[str | None, Mutability.read_only, Required.true] = None
     """The resource type name.
 
     When applicable, service providers MUST specify the name, e.g.,
     'User'.
     """
 
-    description: Annotated[Optional[str], Mutability.read_only] = None
+    description: Annotated[str | None, Mutability.read_only] = None
     """The resource type's human-readable description.
 
     When applicable, service providers MUST specify the description.
     """
 
-    id: Annotated[Optional[str], Mutability.read_only, Returned.default] = None
+    id: Annotated[str | None, Mutability.read_only, Returned.default] = None
     """The resource type's server unique id.
 
     This is often the same value as the "name" attribute.
     """
 
     endpoint: Annotated[
-        Optional[Reference[URIReference]], Mutability.read_only, Required.true
+        Reference[URIReference] | None, Mutability.read_only, Required.true
     ] = None
     """The resource type's HTTP-addressable endpoint relative to the Base URL,
     e.g., '/Users'."""
 
     schema_: Annotated[
-        Optional[Reference[URIReference]],
+        Reference[URIReference] | None,
         Mutability.read_only,
         Required.true,
         CaseExact.true,
@@ -74,7 +73,7 @@ class ResourceType(Resource[Any]):
     """The resource type's primary/base schema URI."""
 
     schema_extensions: Annotated[
-        Optional[list[SchemaExtension]], Mutability.read_only, Required.true
+        list[SchemaExtension] | None, Mutability.read_only, Required.true
     ] = None
     """A list of URIs of the resource type's schema extensions."""
 

scim2_models/resources/schema.py

@@ -35,10 +35,12 @@ from .resource import Resource
 
 T = TypeVar("T", bound=BaseModel)
 
+_NON_WORD_OR_LEADING_DIGIT = re.compile(r"\W|^(?=\d)")
+
 
 def _make_python_identifier(identifier: str) -> str:
     """Sanitize string to be a suitable Python/Pydantic class attribute name."""
-    sanitized = re.sub(r"\W|^(?=\d)", "", identifier)
+    sanitized = _NON_WORD_OR_LEADING_DIGIT.sub("", identifier)
     if sanitized in RESERVED_WORDS:
         sanitized = f"{sanitized}_"
 
@@ -97,7 +99,7 @@ class Attribute(ComplexAttribute):
 
         def _to_python(
             self,
-            reference_types: Optional[list[str]] = None,
+            reference_types: list[str] | None = None,
         ) -> type:
             if self.value == self.reference and reference_types is not None:
                 if reference_types == ["external"]:
@@ -107,7 +109,7 @@ class Attribute(ComplexAttribute):
                     return Reference[URIReference]
 
                 types = tuple(Literal[t] for t in reference_types)
-                return Reference[Union[types]]  # type: ignore
+                return Reference[Union[types]]  # type: ignore  # noqa: UP007
 
             attr_types = {
                 self.string: str,
@@ -118,7 +120,7 @@ class Attribute(ComplexAttribute):
                 self.binary: Base64Bytes,
                 self.complex: ComplexAttribute,
             }
-            return attr_types[self.value]
+            return attr_types[self]
 
         @classmethod
         def from_python(cls, pytype: type) -> "Attribute.Type":
@@ -141,21 +143,21 @@ class Attribute(ComplexAttribute):
             }
             return attr_types.get(pytype, cls.string)
 
-    name: Annotated[
-        Optional[str], Mutability.read_only, Required.true, CaseExact.true
-    ] = None
+    name: Annotated[str | None, Mutability.read_only, Required.true, CaseExact.true] = (
+        None
+    )
     """The attribute's name."""
 
-    type: Annotated[Optional[Type], Mutability.read_only, Required.true] = Field(
+    type: Annotated[Type | None, Mutability.read_only, Required.true] = Field(
         None, examples=[item.value for item in Type]
     )
     """The attribute's data type."""
 
-    multi_valued: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    multi_valued: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value indicating the attribute's plurality."""
 
     description: Annotated[
-        Optional[str], Mutability.read_only, Required.false, CaseExact.true
+        str | None, Mutability.read_only, Required.false, CaseExact.true
     ] = None
     """The attribute's human-readable description."""
 
@@ -164,7 +166,7 @@ class Attribute(ComplexAttribute):
     required."""
 
     canonical_values: Annotated[
-        Optional[list[str]], Mutability.read_only, CaseExact.true
+        list[str] | None, Mutability.read_only, CaseExact.true
     ] = None
     """A collection of suggested canonical values that MAY be used (e.g.,
     "work" and "home")."""
@@ -195,17 +197,17 @@ class Attribute(ComplexAttribute):
     uniqueness of attribute values."""
 
     reference_types: Annotated[
-        Optional[list[str]], Mutability.read_only, Required.false, CaseExact.true
+        list[str] | None, Mutability.read_only, Required.false, CaseExact.true
     ] = None
     """A multi-valued array of JSON strings that indicate the SCIM resource
     types that may be referenced."""
 
     # for python 3.9 and 3.10 compatibility, this should be 'list' and not 'List'
-    sub_attributes: Annotated[Optional[List["Attribute"]], Mutability.read_only] = None  # noqa: UP006
+    sub_attributes: Annotated[List["Attribute"] | None, Mutability.read_only] = None  # noqa: UP006
     """When an attribute is of type "complex", "subAttributes" defines a set of
     sub-attributes."""
 
-    def _to_python(self) -> Optional[tuple[Any, Any]]:
+    def _to_python(self) -> tuple[Any, Any] | None:
         """Build tuple suited to be passed to pydantic 'create_model'."""
         if not self.name or not self.type:
             return None
@@ -219,7 +221,7 @@ class Attribute(ComplexAttribute):
             attr_type = list[attr_type]  # type: ignore
 
         annotation = Annotated[
-            Optional[attr_type],  # type: ignore
+            attr_type | None,  # type: ignore
             self.required,
             self.case_exact,
             self.mutability,
@@ -256,19 +258,19 @@ class Schema(Resource[Any]):
         "urn:ietf:params:scim:schemas:core:2.0:Schema"
     ]
 
-    id: Annotated[Optional[str], Mutability.read_only, Required.true] = None
+    id: Annotated[str | None, Mutability.read_only, Required.true] = None
     """The unique URI of the schema."""
 
     name: Annotated[
-        Optional[str], Mutability.read_only, Returned.default, Required.true
+        str | None, Mutability.read_only, Returned.default, Required.true
     ] = None
     """The schema's human-readable name."""
 
-    description: Annotated[Optional[str], Mutability.read_only, Returned.default] = None
+    description: Annotated[str | None, Mutability.read_only, Returned.default] = None
     """The schema's human-readable description."""
 
     attributes: Annotated[
-        Optional[list[Attribute]], Mutability.read_only, Required.true
+        list[Attribute] | None, Mutability.read_only, Required.true
     ] = None
     """A complex type that defines service provider attributes and their
     qualities via the following set of sub-attributes."""
@@ -279,7 +281,7 @@ class Schema(Resource[Any]):
         """Ensure that schema ids are URI, as defined in RFC7643 §7."""
         return str(Url(value))
 
-    def get_attribute(self, attribute_name: str) -> Optional[Attribute]:
+    def get_attribute(self, attribute_name: str) -> Attribute | None:
         """Find an attribute by its name."""
         for attribute in self.attributes or []:
             if attribute.name == attribute_name:

scim2_models/resources/service_provider_config.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
 
@@ -16,43 +15,41 @@ from .resource import Resource
 
 
 class Patch(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
 
 class Bulk(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
-    max_operations: Annotated[Optional[int], Mutability.read_only, Required.true] = None
+    max_operations: Annotated[int | None, Mutability.read_only, Required.true] = None
     """An integer value specifying the maximum number of operations."""
 
-    max_payload_size: Annotated[Optional[int], Mutability.read_only, Required.true] = (
-        None
-    )
+    max_payload_size: Annotated[int | None, Mutability.read_only, Required.true] = None
     """An integer value specifying the maximum payload size in bytes."""
 
 
 class Filter(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
-    max_results: Annotated[Optional[int], Mutability.read_only, Required.true] = None
+    max_results: Annotated[int | None, Mutability.read_only, Required.true] = None
     """An integer value specifying the maximum number of resources returned in a response."""
 
 
 class ChangePassword(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
 
 class Sort(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
 
 class ETag(ComplexAttribute):
-    supported: Annotated[Optional[bool], Mutability.read_only, Required.true] = None
+    supported: Annotated[bool | None, Mutability.read_only, Required.true] = None
     """A Boolean value specifying whether or not the operation is supported."""
 
 
@@ -64,31 +61,31 @@ class AuthenticationScheme(ComplexAttribute):
         httpbasic = "httpbasic"
         httpdigest = "httpdigest"
 
-    type: Annotated[Optional[Type], Mutability.read_only, Required.true] = Field(
+    type: Annotated[Type | None, Mutability.read_only, Required.true] = Field(
         None,
         examples=["oauth", "oauth2", "oauthbearertoken", "httpbasic", "httpdigest"],
     )
     """The authentication scheme."""
 
-    name: Annotated[Optional[str], Mutability.read_only, Required.true] = None
+    name: Annotated[str | None, Mutability.read_only, Required.true] = None
     """The common authentication scheme name, e.g., HTTP Basic."""
 
-    description: Annotated[Optional[str], Mutability.read_only, Required.true] = None
+    description: Annotated[str | None, Mutability.read_only, Required.true] = None
     """A description of the authentication scheme."""
 
-    spec_uri: Annotated[
-        Optional[Reference[ExternalReference]], Mutability.read_only
-    ] = None
+    spec_uri: Annotated[Reference[ExternalReference] | None, Mutability.read_only] = (
+        None
+    )
     """An HTTP-addressable URL pointing to the authentication scheme's
     specification."""
 
     documentation_uri: Annotated[
-        Optional[Reference[ExternalReference]], Mutability.read_only
+        Reference[ExternalReference] | None, Mutability.read_only
     ] = None
     """An HTTP-addressable URL pointing to the authentication scheme's usage
     documentation."""
 
-    primary: Annotated[Optional[bool], Mutability.read_only] = None
+    primary: Annotated[bool | None, Mutability.read_only] = None
     """A Boolean value indicating the 'primary' or preferred attribute value
     for this attribute, e.g., the preferred mailing address or primary email
     address."""
@@ -100,7 +97,7 @@ class ServiceProviderConfig(Resource[Any]):
     ]
 
     id: Annotated[
-        Optional[str], Mutability.read_only, Returned.default, Uniqueness.global_
+        str | None, Mutability.read_only, Returned.default, Uniqueness.global_
     ] = None
     """A unique identifier for a SCIM resource as defined by the service
     provider."""
@@ -110,34 +107,34 @@ class ServiceProviderConfig(Resource[Any]):
     #     provider configuration resource
 
     documentation_uri: Annotated[
-        Optional[Reference[ExternalReference]], Mutability.read_only
+        Reference[ExternalReference] | None, Mutability.read_only
     ] = None
     """An HTTP-addressable URL pointing to the service provider's human-
     consumable help documentation."""
 
-    patch: Annotated[Optional[Patch], Mutability.read_only, Required.true] = None
+    patch: Annotated[Patch | None, Mutability.read_only, Required.true] = None
     """A complex type that specifies PATCH configuration options."""
 
-    bulk: Annotated[Optional[Bulk], Mutability.read_only, Required.true] = None
+    bulk: Annotated[Bulk | None, Mutability.read_only, Required.true] = None
     """A complex type that specifies bulk configuration options."""
 
-    filter: Annotated[Optional[Filter], Mutability.read_only, Required.true] = None
+    filter: Annotated[Filter | None, Mutability.read_only, Required.true] = None
     """A complex type that specifies FILTER options."""
 
     change_password: Annotated[
-        Optional[ChangePassword], Mutability.read_only, Required.true
+        ChangePassword | None, Mutability.read_only, Required.true
     ] = None
     """A complex type that specifies configuration options related to changing
     a password."""
 
-    sort: Annotated[Optional[Sort], Mutability.read_only, Required.true] = None
+    sort: Annotated[Sort | None, Mutability.read_only, Required.true] = None
     """A complex type that specifies sort result options."""
 
-    etag: Annotated[Optional[ETag], Mutability.read_only, Required.true] = None
+    etag: Annotated[ETag | None, Mutability.read_only, Required.true] = None
     """A complex type that specifies ETag configuration options."""
 
     authentication_schemes: Annotated[
-        Optional[list[AuthenticationScheme]], Mutability.read_only, Required.true
+        list[AuthenticationScheme] | None, Mutability.read_only, Required.true
     ] = None
     """A complex type that specifies supported authentication scheme
     properties."""