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

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,83 +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 .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 not get_origin(resource_union) == Union:
-            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"
     ]
@@ -112,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

scim2_models/scim_object.py

@@ -0,0 +1,143 @@
+"""Base SCIM object classes with schema identification."""
+
+from typing import TYPE_CHECKING
+from typing import Annotated
+from typing import Any
+from typing import Optional
+
+from .annotations import Required
+from .base import BaseModel
+from .context import Context
+from .utils import normalize_attribute_name
+
+if TYPE_CHECKING:
+    from .rfc7643.resource import Resource
+
+
+def validate_model_attribute(model: type["BaseModel"], attribute_base: str) -> None:
+    """Validate that an attribute name or a sub-attribute path exist for a given model."""
+    attribute_name, *sub_attribute_blocks = attribute_base.split(".")
+    sub_attribute_base = ".".join(sub_attribute_blocks)
+
+    aliases = {field.validation_alias for field in model.model_fields.values()}
+
+    if normalize_attribute_name(attribute_name) not in aliases:
+        raise ValueError(
+            f"Model '{model.__name__}' has no attribute named '{attribute_name}'"
+        )
+
+    if sub_attribute_base:
+        attribute_type = model.get_field_root_type(attribute_name)
+
+        if not attribute_type or not issubclass(attribute_type, BaseModel):
+            raise ValueError(
+                f"Attribute '{attribute_name}' is not a complex attribute, and cannot have a '{sub_attribute_base}' sub-attribute"
+            )
+
+        validate_model_attribute(attribute_type, sub_attribute_base)
+
+
+def extract_schema_and_attribute_base(attribute_urn: str) -> tuple[str, str]:
+    """Extract the schema urn part and the attribute name part from attribute name.
+
+    As defined in :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
+    """
+    *urn_blocks, attribute_base = attribute_urn.split(":")
+    schema = ":".join(urn_blocks)
+    return schema, attribute_base
+
+
+def validate_attribute_urn(
+    attribute_name: str,
+    default_resource: Optional[type["Resource"]] = None,
+    resource_types: Optional[list[type["Resource"]]] = None,
+) -> str:
+    """Validate that an attribute urn is valid or not.
+
+    :param attribute_name: The attribute urn to check.
+    :default_resource: The default resource if `attribute_name` is not an absolute urn.
+    :resource_types: The available resources in which to look for the attribute.
+    :return: The normalized attribute URN.
+    """
+    from .rfc7643.resource import Resource
+
+    if not resource_types:
+        resource_types = []
+
+    if default_resource and default_resource not in resource_types:
+        resource_types.append(default_resource)
+
+    default_schema = (
+        default_resource.model_fields["schemas"].default[0]
+        if default_resource
+        else None
+    )
+
+    schema: Optional[Any]
+    schema, attribute_base = extract_schema_and_attribute_base(attribute_name)
+    if not schema:
+        schema = default_schema
+
+    if not schema:
+        raise ValueError("No default schema and relative URN")
+
+    resource = Resource.get_by_schema(resource_types, schema)
+    if not resource:
+        raise ValueError(f"No resource matching schema '{schema}'")
+
+    validate_model_attribute(resource, attribute_base)
+
+    return f"{schema}:{attribute_base}"
+
+
+class ScimObject(BaseModel):
+    schemas: Annotated[list[str], Required.true]
+    """The "schemas" attribute is a REQUIRED attribute and is an array of
+    Strings containing URIs that are used to indicate the namespaces of the
+    SCIM schemas that define the attributes present in the current JSON
+    structure."""
+
+    def _prepare_model_dump(
+        self,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        kwargs.setdefault("context", {}).setdefault("scim", scim_ctx)
+
+        if scim_ctx:
+            kwargs.setdefault("exclude_none", True)
+            kwargs.setdefault("by_alias", True)
+
+        return kwargs
+
+    def model_dump(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create a model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        """
+        dump_kwargs = self._prepare_model_dump(scim_ctx, **kwargs)
+        if scim_ctx:
+            dump_kwargs.setdefault("mode", "json")
+        return super(BaseModel, self).model_dump(*args, **dump_kwargs)
+
+    def model_dump_json(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        **kwargs: Any,
+    ) -> str:
+        """Create a JSON model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump_json`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        """
+        dump_kwargs = self._prepare_model_dump(scim_ctx, **kwargs)
+        return super(BaseModel, self).model_dump_json(*args, **dump_kwargs)

scim2_models/utils.py

@@ -11,7 +11,7 @@ from pydantic.alias_generators import to_snake
 from pydantic_core import PydanticCustomError
 
 try:
-    from types import UnionType  # type: ignore
+    from types import UnionType
 
     UNION_TYPES = [Union, UnionType]
 except ImportError:

{scim2_models-0.3.5.dist-info → scim2_models-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.3.5
+Version: 0.3.7
 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.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+scim2_models/__init__.py,sha256=yqYNm1B18OD-c8Y3QC3VWWv6Yoxw4PAvpC9eABhxef0,3128
+scim2_models/annotations.py,sha256=oRjlKL1fqrYfa9UtaMdxF5fOT8CUUN3m-rdzvf7aiSA,3304
+scim2_models/attributes.py,sha256=VloM7txtM2oexPrHO4phVY6nDzORMr3Vqf6EFAEZzyk,1804
+scim2_models/base.py,sha256=BcAjsbwaHhO8AnGJJF05MqfL636UBlM2njFuCvFL_SY,16795
+scim2_models/constants.py,sha256=9egq8JW0dFAqPng85CiHoH5T6pRtYL87-gC0C-IMGsk,573
+scim2_models/context.py,sha256=oV8BCBSl9NvXuue11q4EYnoSze1yqtja9U_HEdrR-88,9125
+scim2_models/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/reference.py,sha256=EQM8bbSr_kxbFMNlWYf_4sAJlSsOS5wUrn-9_eF0Ykc,2483
+scim2_models/scim_object.py,sha256=t1p6ha719w1YU2Gtcy_k2NY-X0kc8PJxwstKOGP0oPA,5183
+scim2_models/utils.py,sha256=1fmJoVCtrFURmvBegGti8UnXdj9EnzkNmg83jtpj70A,2755
+scim2_models/rfc7643/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/rfc7643/enterprise_user.py,sha256=TVa5aS-eLHcDkwyr58hZYsRKk0AwjUaUaSFhU51mn5E,1806
+scim2_models/rfc7643/group.py,sha256=lJXKopa__LoWhkaNqu0JFVyQaOMe-AF4vISaq0Gg7cE,1458
+scim2_models/rfc7643/resource.py,sha256=jPP6nGGEVOLIX7Zmka5xHLGk3jJBfpaMBPizU1mXFoo,17275
+scim2_models/rfc7643/resource_type.py,sha256=scLqbD3HX3fXT2JOXY9OUVnZz7i5ty2lx4VuiVxt6DE,3314
+scim2_models/rfc7643/schema.py,sha256=DJQvDx31jYYZyfS3noTu4-8C429u0ctUqRysmvUULyI,10647
+scim2_models/rfc7643/service_provider_config.py,sha256=6xJ182T-1szEQnN5Zb1cTdQCgTYIFi4XKygbvDlTKTM,5446
+scim2_models/rfc7643/user.py,sha256=ErOghhilUF7fipwDRqARyLwJhbntQx4GJG3u2sZNJXs,10664
+scim2_models/rfc7644/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/rfc7644/bulk.py,sha256=ZVGtitEDy--iDBzU2WR-LT7_rIizZFBD3sOo6rJ_WII,2590
+scim2_models/rfc7644/error.py,sha256=KZBJfI2z4TByAK6W3mN3e3m0ZrDguPLm66v9W971Awk,6302
+scim2_models/rfc7644/list_response.py,sha256=8o1_WR3AOZNv0hbCGcgq8lyeXaNjo1CiLxfteq8gctk,2396
+scim2_models/rfc7644/message.py,sha256=rX2KezTdM81Z9mw7JTJYjWF-VDnDeUm6-ZxsarmVdsE,3738
+scim2_models/rfc7644/patch_op.py,sha256=Yk2qr-vsuU6MMh6uFijo3Tw1vgo-clbgj1T0B8S1Tcs,2856
+scim2_models/rfc7644/search_request.py,sha256=kLhIfyjAjc7ar6wkT7t-A2ySB-_3XYP-gf_LspLU2RU,3063
+scim2_models-0.3.7.dist-info/METADATA,sha256=tqCuz5S5ESdKVlEQhpsOVxgXHUDfUyAC32rkIOH1w98,16288
+scim2_models-0.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scim2_models-0.3.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scim2_models-0.3.7.dist-info/RECORD,,