scim2-models 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

scim2_models/rfc7643/schema.py

@@ -6,6 +6,7 @@ from typing import Any
 from typing import List  # noqa : UP005,UP035
 from typing import Literal
 from typing import Optional
+from typing import TypeVar
 from typing import Union
 from typing import get_origin
 
@@ -16,24 +17,25 @@ from pydantic.alias_generators import to_pascal
 from pydantic.alias_generators import to_snake
 from pydantic_core import Url
 
+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 ..attributes import is_complex_attribute
 from ..base import BaseModel
-from ..base import CaseExact
-from ..base import ComplexAttribute
-from ..base import ExternalReference
-from ..base import MultiValuedComplexAttribute
-from ..base import Mutability
-from ..base import Reference
-from ..base import Required
-from ..base import Returned
-from ..base import Uniqueness
-from ..base import URIReference
-from ..base import is_complex_attribute
 from ..constants import RESERVED_WORDS
+from ..reference import ExternalReference
+from ..reference import Reference
+from ..reference import URIReference
 from ..utils import Base64Bytes
 from ..utils import normalize_attribute_name
-from .resource import Extension
 from .resource import Resource
 
+T = TypeVar("T", bound=BaseModel)
+
 
 def make_python_identifier(identifier: str) -> str:
     """Sanitize string to be a suitable Python/Pydantic class attribute name."""
@@ -46,9 +48,9 @@ def make_python_identifier(identifier: str) -> str:
 
 def make_python_model(
     obj: Union["Schema", "Attribute"],
-    base: Optional[type[BaseModel]] = None,
-    multiple=False,
-) -> Union[Resource, Extension]:
+    base: type[T],
+    multiple: bool = False,
+) -> type[T]:
     """Build a Python model from a Schema or an Attribute object."""
     if isinstance(obj, Attribute):
         pydantic_attributes = {
@@ -56,7 +58,6 @@ def make_python_model(
             for attr in (obj.sub_attributes or [])
             if attr.name
         }
-        base = MultiValuedComplexAttribute if multiple else ComplexAttribute
 
     else:
         pydantic_attributes = {
@@ -69,14 +70,17 @@ def make_python_model(
             Field(default=[obj.id]),
         )
 
+    if not obj.name:
+        raise ValueError("Schema or Attribute 'name' must be defined")
+
     model_name = to_pascal(to_snake(obj.name))
-    model = create_model(model_name, __base__=base, **pydantic_attributes)
+    model: type[T] = create_model(model_name, __base__=base, **pydantic_attributes)  # type: ignore[call-overload]
 
     # Set the ComplexType class as a member of the model
     # e.g. make Member an attribute of Group
     for attr_name in model.model_fields:
         attr_type = model.get_field_root_type(attr_name)
-        if is_complex_attribute(attr_type):
+        if attr_type and is_complex_attribute(attr_type):
             setattr(model, attr_type.__name__, attr_type)
 
     return model
@@ -95,7 +99,7 @@ class Attribute(ComplexAttribute):
 
         def to_python(
             self,
-            multiple=False,
+            multiple: bool = False,
             reference_types: Optional[list[str]] = None,
         ) -> type:
             if self.value == self.reference and reference_types is not None:
@@ -122,32 +126,32 @@ class Attribute(ComplexAttribute):
             return attr_types[self.value]
 
         @classmethod
-        def from_python(cls, pytype) -> str:
+        def from_python(cls, pytype: type) -> "Attribute.Type":
             if get_origin(pytype) == Reference:
-                return cls.reference.value
+                return cls.reference
 
-            if is_complex_attribute(pytype):
-                return cls.complex.value
+            if pytype and is_complex_attribute(pytype):
+                return cls.complex
 
             if pytype in (Required, CaseExact):
-                return cls.boolean.value
+                return cls.boolean
 
             attr_types = {
-                str: cls.string.value,
-                bool: cls.boolean.value,
-                float: cls.decimal.value,
-                int: cls.integer.value,
-                datetime: cls.date_time.value,
-                Base64Bytes: cls.binary.value,
+                str: cls.string,
+                bool: cls.boolean,
+                float: cls.decimal,
+                int: cls.integer,
+                datetime: cls.date_time,
+                Base64Bytes: cls.binary,
             }
-            return attr_types.get(pytype, cls.string.value)
+            return attr_types.get(pytype, cls.string)
 
     name: Annotated[
         Optional[str], Mutability.read_only, Required.true, CaseExact.true
     ] = None
     """The attribute's name."""
 
-    type: Annotated[Type, Mutability.read_only, Required.true] = Field(
+    type: Annotated[Optional[Type], Mutability.read_only, Required.true] = Field(
         None, examples=[item.value for item in Type]
     )
     """The attribute's data type."""
@@ -206,15 +210,17 @@ class Attribute(ComplexAttribute):
     """When an attribute is of type "complex", "subAttributes" defines a set of
     sub-attributes."""
 
-    def to_python(self) -> Optional[tuple[Any, Field]]:
+    def to_python(self) -> Optional[tuple[Any, Any]]:
         """Build tuple suited to be passed to pydantic 'create_model'."""
-        if not self.name:
+        if not self.name or not self.type:
             return None
 
-        attr_type = self.type.to_python(self.multi_valued, self.reference_types)
+        attr_type = self.type.to_python(bool(self.multi_valued), self.reference_types)
 
         if attr_type in (ComplexAttribute, MultiValuedComplexAttribute):
-            attr_type = make_python_model(obj=self, multiple=self.multi_valued)
+            attr_type = make_python_model(
+                obj=self, base=attr_type, multiple=bool(self.multi_valued)
+            )
 
         if self.multi_valued:
             attr_type = list[attr_type]  # type: ignore
@@ -245,7 +251,7 @@ class Attribute(ComplexAttribute):
                 return sub_attribute
         return None
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> "Attribute":
         """Find an attribute by its name."""
         if attribute := self.get_attribute(name):
             return attribute
@@ -287,7 +293,7 @@ class Schema(Resource):
                 return attribute
         return None
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> "Attribute":  # type: ignore[override]
         """Find an attribute by its name."""
         if attribute := self.get_attribute(name):
             return attribute

scim2_models/rfc7643/service_provider_config.py

@@ -4,13 +4,13 @@ from typing import Optional
 
 from pydantic import Field
 
-from ..base import ComplexAttribute
-from ..base import ExternalReference
-from ..base import Mutability
-from ..base import Reference
-from ..base import Required
-from ..base import Returned
-from ..base import Uniqueness
+from ..annotations import Mutability
+from ..annotations import Required
+from ..annotations import Returned
+from ..annotations import Uniqueness
+from ..attributes import ComplexAttribute
+from ..reference import ExternalReference
+from ..reference import Reference
 from .resource import Resource
 
 

scim2_models/rfc7643/user.py

@@ -8,15 +8,15 @@ from typing import Union
 from pydantic import EmailStr
 from pydantic import Field
 
-from ..base import CaseExact
-from ..base import ComplexAttribute
-from ..base import ExternalReference
-from ..base import MultiValuedComplexAttribute
-from ..base import Mutability
-from ..base import Reference
-from ..base import Required
-from ..base import Returned
-from ..base import Uniqueness
+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 ..reference import ExternalReference
+from ..reference import Reference
 from ..utils import Base64Bytes
 from .resource import AnyExtension
 from .resource import Resource

scim2_models/rfc7644/bulk.py

@@ -6,8 +6,8 @@ from typing import Optional
 from pydantic import Field
 from pydantic import PlainSerializer
 
-from ..base import ComplexAttribute
-from ..base import Required
+from ..annotations import Required
+from ..attributes import ComplexAttribute
 from ..utils import int_to_str
 from .message import Message
 

scim2_models/rfc7644/error.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import PlainSerializer
 
-from ..base import Required
+from ..annotations import Required
 from ..utils import int_to_str
 from .message import Message
 
@@ -26,7 +26,7 @@ class Error(Message):
     """A detailed human-readable message."""
 
     @classmethod
-    def make_invalid_filter_error(cls):
+    def make_invalid_filter_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the specified filter syntax was invalid (does not comply with :rfc:`Figure 1 of RFC7644 <7644#section-3.4.2.2>`), or the specified attribute and filter comparison combination is not supported."""
         return Error(
             status=400,
@@ -35,7 +35,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_too_many_error(cls):
+    def make_too_many_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the specified filter yields many more results than the server is willing to calculate or process.  For example, a filter such as ``(userName pr)`` by itself would return all entries with a ``userName`` and MAY not be acceptable to the service provider."""
         return Error(
             status=400,
@@ -44,7 +44,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_uniqueness_error(cls):
+    def make_uniqueness_error(cls) -> "Error":
         """Pre-defined error intended to be raised when One or more of the attribute values are already in use or are reserved."""
         return Error(
             status=409,
@@ -53,7 +53,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_mutability_error(cls):
+    def make_mutability_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the attempted modification is not compatible with the target attribute's mutability or current state (e.g., modification of an "immutable" attribute with an existing value)."""
         return Error(
             status=400,
@@ -62,7 +62,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_invalid_syntax_error(cls):
+    def make_invalid_syntax_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the request body message structure was invalid or did not conform to the request schema."""
         return Error(
             status=400,
@@ -71,7 +71,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_invalid_path_error(cls):
+    def make_invalid_path_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the "path" attribute was invalid or malformed (see :rfc:`Figure 7 of RFC7644 <7644#section-3.5.2>`)."""
         return Error(
             status=400,
@@ -80,7 +80,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_no_target_error(cls):
+    def make_no_target_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the specified "path" did not yield an attribute or attribute value that could be operated on.  This occurs when the specified "path" value contains a filter that yields no match."""
         return Error(
             status=400,
@@ -89,7 +89,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_invalid_value_error(cls):
+    def make_invalid_value_error(cls) -> "Error":
         """Pre-defined error intended to be raised when a required value was missing, or the value specified was not compatible with the operation or attribute type (see :rfc:`Section 2.2 of RFC7643 <7643#section-2.2>`), or resource schema (see :rfc:`Section 4 of RFC7643 <7643#section-4>`)."""
         return Error(
             status=400,
@@ -98,7 +98,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_invalid_version_error(cls):
+    def make_invalid_version_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the specified SCIM protocol version is not supported (see :rfc:`Section 3.13 of RFC7644 <7644#section-3.13>`)."""
         return Error(
             status=400,
@@ -107,7 +107,7 @@ class Error(Message):
         )
 
     @classmethod
-    def make_sensitive_error(cls):
+    def make_sensitive_error(cls) -> "Error":
         """Pre-defined error intended to be raised when the specified request cannot be completed, due to the passing of sensitive (e.g., personal) information in a request URI.  For example, personal information SHALL NOT be transmitted over request URIs.  See :rfc:`Section 7.5.2 of RFC7644 <7644#section-7.5.2>`."""
         return Error(
             status=400,

scim2_models/rfc7644/list_response.py

@@ -2,84 +2,22 @@ from typing import Annotated
 from typing import Any
 from typing import Generic
 from typing import Optional
-from typing import Union
-from typing import get_args
-from typing import get_origin
 
-from pydantic import Discriminator
 from pydantic import Field
-from pydantic import Tag
 from pydantic import ValidationInfo
 from pydantic import ValidatorFunctionWrapHandler
 from pydantic import model_validator
 from pydantic_core import PydanticCustomError
 from typing_extensions import Self
 
-from ..base import BaseModel
-from ..base import BaseModelType
-from ..base import Context
-from ..base import Required
+from ..annotations import Required
+from ..context import Context
 from ..rfc7643.resource import AnyResource
-from ..utils import UNION_TYPES
+from .message import GenericMessageMetaclass
 from .message import Message
 
 
-class ListResponseMetaclass(BaseModelType):
-    def tagged_resource_union(resource_union):
-        """Build Discriminated Unions, so pydantic can guess which class are needed to instantiate by inspecting a payload.
-
-        https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions
-        """
-        if get_origin(resource_union) not in UNION_TYPES:
-            return resource_union
-
-        resource_types = get_args(resource_union)
-
-        def get_schema_from_payload(payload: Any) -> Optional[str]:
-            if not payload:
-                return None
-
-            payload_schemas = (
-                payload.get("schemas", [])
-                if isinstance(payload, dict)
-                else payload.schemas
-            )
-
-            resource_types_schemas = [
-                resource_type.model_fields["schemas"].default[0]
-                for resource_type in resource_types
-            ]
-            common_schemas = [
-                schema for schema in payload_schemas if schema in resource_types_schemas
-            ]
-            return common_schemas[0] if common_schemas else None
-
-        discriminator = Discriminator(get_schema_from_payload)
-
-        def get_tag(resource_type: type[BaseModel]) -> Tag:
-            return Tag(resource_type.model_fields["schemas"].default[0])
-
-        tagged_resources = [
-            Annotated[resource_type, get_tag(resource_type)]
-            for resource_type in resource_types
-        ]
-        union = Union[tuple(tagged_resources)]
-        return Annotated[union, discriminator]
-
-    def __new__(cls, name, bases, attrs, **kwargs):
-        if kwargs.get("__pydantic_generic_metadata__") and kwargs[
-            "__pydantic_generic_metadata__"
-        ].get("args"):
-            tagged_union = cls.tagged_resource_union(
-                kwargs["__pydantic_generic_metadata__"]["args"][0]
-            )
-            kwargs["__pydantic_generic_metadata__"]["args"] = (tagged_union,)
-
-        klass = super().__new__(cls, name, bases, attrs, **kwargs)
-        return klass
-
-
-class ListResponse(Message, Generic[AnyResource], metaclass=ListResponseMetaclass):
+class ListResponse(Message, Generic[AnyResource], metaclass=GenericMessageMetaclass):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:api:messages:2.0:ListResponse"
     ]
@@ -113,6 +51,7 @@ class ListResponse(Message, Generic[AnyResource], metaclass=ListResponseMetaclas
         - 'resources' must be set if 'totalResults' is non-zero.
         """
         obj = handler(value)
+        assert isinstance(obj, cls)
 
         if (
             not info.context

scim2_models/rfc7644/message.py

@@ -1,10 +1,110 @@
 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
+
+from pydantic import Discriminator
+from pydantic import Tag
+from pydantic._internal._model_construction import ModelMetaclass
 
 from ..base import BaseModel
-from ..base import Required
+from ..scim_object import ScimObject
+from ..utils import UNION_TYPES
 
 
-class Message(BaseModel):
+class Message(ScimObject):
     """SCIM protocol messages as defined by :rfc:`RFC7644 §3.1 <7644#section-3.1>`."""
 
-    schemas: Annotated[list[str], Required.true]
+
+def create_schema_discriminator(
+    resource_types_schemas: list[str],
+) -> Callable[[Any], Optional[str]]:
+    """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]:
+        """Extract schema from SCIM payload for discrimination.
+
+        :param payload: SCIM payload dict or object
+        :return: First matching schema or None
+        """
+        if not payload:
+            return None
+
+        payload_schemas = (
+            payload.get("schemas", []) if isinstance(payload, dict) else payload.schemas
+        )
+
+        common_schemas = [
+            schema for schema in payload_schemas if schema in resource_types_schemas
+        ]
+        return common_schemas[0] if common_schemas else None
+
+    return get_schema_from_payload
+
+
+def get_tag(resource_type: type[BaseModel]) -> Tag:
+    """Create Pydantic tag from resource type schema.
+
+    :param resource_type: SCIM resource type
+    :return: Pydantic Tag for discrimination
+    """
+    return Tag(resource_type.model_fields["schemas"].default[0])
+
+
+def create_tagged_resource_union(resource_union: Any) -> Any:
+    """Build Discriminated Unions for SCIM resources.
+
+    Creates discriminated unions so Pydantic can determine which class to instantiate
+    by inspecting the payload's schemas field.
+
+    :param resource_union: Union type of SCIM resources
+    :return: Annotated discriminated union or original type
+    """
+    if get_origin(resource_union) not in UNION_TYPES:
+        return resource_union
+
+    resource_types = get_args(resource_union)
+
+    # Set up schemas for the discriminator function
+    resource_types_schemas = [
+        resource_type.model_fields["schemas"].default[0]
+        for resource_type in resource_types
+    ]
+
+    # Create discriminator function with schemas captured in closure
+    schema_discriminator = create_schema_discriminator(resource_types_schemas)
+    discriminator = Discriminator(schema_discriminator)
+
+    tagged_resources = [
+        Annotated[resource_type, get_tag(resource_type)]
+        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
+    return Annotated[union, discriminator]
+
+
+class GenericMessageMetaclass(ModelMetaclass):
+    """Metaclass for SCIM generic types with discriminated unions."""
+
+    def __new__(
+        cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any], **kwargs: Any
+    ) -> type:
+        """Create class with tagged resource unions for generic parameters."""
+        if kwargs.get("__pydantic_generic_metadata__") and kwargs[
+            "__pydantic_generic_metadata__"
+        ].get("args"):
+            tagged_union = create_tagged_resource_union(
+                kwargs["__pydantic_generic_metadata__"]["args"][0]
+            )
+            kwargs["__pydantic_generic_metadata__"]["args"] = (tagged_union,)
+
+        klass = super().__new__(cls, name, bases, attrs, **kwargs)
+        return klass

scim2_models/rfc7644/patch_op.py

@@ -5,9 +5,11 @@ from typing import Optional
 
 from pydantic import Field
 from pydantic import field_validator
+from pydantic import model_validator
+from typing_extensions import Self
 
-from ..base import ComplexAttribute
-from ..base import Required
+from ..annotations import Required
+from ..attributes import ComplexAttribute
 from .message import Message
 
 
@@ -17,7 +19,7 @@ class PatchOperation(ComplexAttribute):
         remove = "remove"
         add = "add"
 
-    op: Optional[Optional[Op]] = None
+    op: Op
     """Each PATCH operation object MUST have exactly one "op" member, whose
     value indicates the operation to perform and MAY be one of "add", "remove",
     or "replace".
@@ -32,11 +34,23 @@ class PatchOperation(ComplexAttribute):
     """The "path" attribute value is a String containing an attribute path
     describing the target of the operation."""
 
+    @model_validator(mode="after")
+    def validate_path(self) -> Self:
+        # The "path" attribute value is a String containing an attribute path
+        # describing the target of the operation. The "path" attribute is
+        # OPTIONAL for "add" and "replace" and is REQUIRED for "remove"
+        # operations. See relevant operation sections below for details.
+
+        if self.path is None and self.op == PatchOperation.Op.remove:
+            raise ValueError("Op.path is required for remove operations")
+
+        return self
+
     value: Optional[Any] = None
 
     @field_validator("op", mode="before")
     @classmethod
-    def normalize_op(cls, v):
+    def normalize_op(cls, v: Any) -> Any:
         """Ignorecase for op.
 
         This brings
@@ -63,8 +77,8 @@ class PatchOp(Message):
         "urn:ietf:params:scim:api:messages:2.0:PatchOp"
     ]
 
-    operations: Optional[list[PatchOperation]] = Field(
-        None, serialization_alias="Operations"
+    operations: Annotated[Optional[list[PatchOperation]], Required.true] = Field(
+        None, serialization_alias="Operations", min_length=1
     )
     """The body of an HTTP PATCH request MUST contain the attribute
     "Operations", whose value is an array of one or more PATCH operations."""

scim2_models/rfc7644/search_request.py

@@ -5,7 +5,7 @@ from typing import Optional
 from pydantic import field_validator
 from pydantic import model_validator
 
-from ..base import Required
+from ..annotations import Required
 from .message import Message
 
 
@@ -69,7 +69,7 @@ class SearchRequest(Message):
         return None if value is None else max(0, value)
 
     @model_validator(mode="after")
-    def attributes_validator(self):
+    def attributes_validator(self) -> "SearchRequest":
         if self.attributes and self.excluded_attributes:
             raise ValueError(
                 "'attributes' and 'excluded_attributes' are mutually exclusive"
@@ -78,12 +78,12 @@ class SearchRequest(Message):
         return self
 
     @property
-    def start_index_0(self):
+    def start_index_0(self) -> Optional[int]:
         """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):
+    def stop_index_0(self) -> Optional[int]:
         """The 0 indexed stop index."""
         return (
             self.start_index_0 + self.count