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

scim2_models/{rfc7643 → resources}/resource.py

@@ -28,9 +28,9 @@ from ..base import BaseModel
 from ..context import Context
 from ..reference import Reference
 from ..scim_object import ScimObject
-from ..scim_object import validate_attribute_urn
+from ..urn import _validate_attribute_urn
 from ..utils import UNION_TYPES
-from ..utils import normalize_attribute_name
+from ..utils import _normalize_attribute_name
 
 if TYPE_CHECKING:
     from .schema import Attribute
@@ -92,14 +92,14 @@ class Extension(ScimObject):
     @classmethod
     def to_schema(cls) -> "Schema":
         """Build a :class:`~scim2_models.Schema` from the current extension class."""
-        return model_to_schema(cls)
+        return _model_to_schema(cls)
 
     @classmethod
     def from_schema(cls, schema: "Schema") -> type["Extension"]:
         """Build a :class:`~scim2_models.Extension` subclass from the schema definition."""
-        from .schema import make_python_model
+        from .schema import _make_python_model
 
-        return make_python_model(schema, cls)
+        return _make_python_model(schema, cls)
 
 
 AnyExtension = TypeVar("AnyExtension", bound="Extension")
@@ -107,7 +107,7 @@ AnyExtension = TypeVar("AnyExtension", bound="Extension")
 _PARAMETERIZED_CLASSES: dict[tuple[type, tuple[Any, ...]], type] = {}
 
 
-def extension_serializer(
+def _extension_serializer(
     value: Any, handler: SerializerFunctionWrapHandler, info: SerializationInfo
 ) -> Optional[dict[str, Any]]:
     """Exclude the Resource attributes from the extension dump.
@@ -184,13 +184,13 @@ class Resource(ScimObject, Generic[AnyExtension]):
             class_attrs[extension.__name__] = Field(
                 default=None,  # type: ignore[arg-type]
                 serialization_alias=schema,
-                validation_alias=normalize_attribute_name(schema),
+                validation_alias=_normalize_attribute_name(schema),
             )
 
         new_annotations = {
             extension.__name__: Annotated[
                 Optional[extension],
-                WrapSerializer(extension_serializer),
+                WrapSerializer(_extension_serializer),
             ]
             for extension in valid_extensions
         }
@@ -288,14 +288,14 @@ class Resource(ScimObject, Generic[AnyExtension]):
     @classmethod
     def to_schema(cls) -> "Schema":
         """Build a :class:`~scim2_models.Schema` from the current resource class."""
-        return model_to_schema(cls)
+        return _model_to_schema(cls)
 
     @classmethod
     def from_schema(cls, schema: "Schema") -> type["Resource"]:
         """Build a :class:`scim2_models.Resource` subclass from the schema definition."""
-        from .schema import make_python_model
+        from .schema import _make_python_model
 
-        return make_python_model(schema, cls)
+        return _make_python_model(schema, cls)
 
     def _prepare_model_dump(
         self,
@@ -305,13 +305,19 @@ class Resource(ScimObject, Generic[AnyExtension]):
         **kwargs: Any,
     ) -> dict[str, Any]:
         kwargs = super()._prepare_model_dump(scim_ctx, **kwargs)
+
+        # RFC 7644: "SHOULD ignore any query parameters they do not recognize"
         kwargs["context"]["scim_attributes"] = [
-            validate_attribute_urn(attribute, self.__class__)
+            valid_attr
             for attribute in (attributes or [])
+            if (valid_attr := _validate_attribute_urn(attribute, self.__class__))
+            is not None
         ]
         kwargs["context"]["scim_excluded_attributes"] = [
-            validate_attribute_urn(attribute, self.__class__)
+            valid_attr
             for attribute in (excluded_attributes or [])
+            if (valid_attr := _validate_attribute_urn(attribute, self.__class__))
+            is not None
         ]
         return kwargs
 
@@ -330,9 +336,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
             messages. Pass :data:`None` to get the default Pydantic behavior.
         :param attributes: 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.
+            would be returned by default. Invalid values are ignored.
         :param excluded_attributes: A multi-valued list of strings indicating the names of resource
-            attributes to be removed from the default set of attributes to return.
+            attributes to be removed from the default set of attributes to return. Invalid values are ignored.
         """
         dump_kwargs = self._prepare_model_dump(
             scim_ctx, attributes, excluded_attributes, **kwargs
@@ -356,9 +362,9 @@ class Resource(ScimObject, Generic[AnyExtension]):
             messages. Pass :data:`None` to get the default Pydantic behavior.
         :param attributes: 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.
+            would be returned by default. Invalid values are ignored.
         :param excluded_attributes: A multi-valued list of strings indicating the names of resource
-            attributes to be removed from the default set of attributes to return.
+            attributes to be removed from the default set of attributes to return. Invalid values are ignored.
         """
         dump_kwargs = self._prepare_model_dump(
             scim_ctx, attributes, excluded_attributes, **kwargs
@@ -369,7 +375,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
 AnyResource = TypeVar("AnyResource", bound="Resource")
 
 
-def dedicated_attributes(
+def _dedicated_attributes(
     model: type[BaseModel], excluded_models: list[type[BaseModel]]
 ) -> dict[str, Any]:
     """Return attributes that are not members the parent 'excluded_models'."""
@@ -397,13 +403,13 @@ def dedicated_attributes(
     return field_infos
 
 
-def model_to_schema(model: type[BaseModel]) -> "Schema":
-    from scim2_models.rfc7643.schema import Schema
+def _model_to_schema(model: type[BaseModel]) -> "Schema":
+    from scim2_models.resources.schema import Schema
 
     schema_urn = model.model_fields["schemas"].default[0]
-    field_infos = dedicated_attributes(model, [Resource])
+    field_infos = _dedicated_attributes(model, [Resource])
     attributes = [
-        model_attribute_to_scim_attribute(model, attribute_name)
+        _model_attribute_to_scim_attribute(model, attribute_name)
         for attribute_name in field_infos
         if attribute_name != "schemas"
     ]
@@ -416,10 +422,10 @@ def model_to_schema(model: type[BaseModel]) -> "Schema":
     return schema
 
 
-def model_attribute_to_scim_attribute(
+def _model_attribute_to_scim_attribute(
     model: type[BaseModel], attribute_name: str
 ) -> "Attribute":
-    from scim2_models.rfc7643.schema import Attribute
+    from scim2_models.resources.schema import Attribute
 
     field_info = model.model_fields[attribute_name]
     root_type = model.get_field_root_type(attribute_name)
@@ -430,8 +436,8 @@ def model_attribute_to_scim_attribute(
     attribute_type = Attribute.Type.from_python(root_type)
     sub_attributes = (
         [
-            model_attribute_to_scim_attribute(root_type, sub_attribute_name)
-            for sub_attribute_name in dedicated_attributes(
+            _model_attribute_to_scim_attribute(root_type, sub_attribute_name)
+            for sub_attribute_name in _dedicated_attributes(
                 root_type,
                 [MultiValuedComplexAttribute],
             )

scim2_models/{rfc7643 → resources}/schema.py

@@ -31,13 +31,13 @@ from ..reference import ExternalReference
 from ..reference import Reference
 from ..reference import URIReference
 from ..utils import Base64Bytes
-from ..utils import normalize_attribute_name
+from ..utils import _normalize_attribute_name
 from .resource import Resource
 
 T = TypeVar("T", bound=BaseModel)
 
 
-def make_python_identifier(identifier: str) -> str:
+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)
     if sanitized in RESERVED_WORDS:
@@ -46,7 +46,7 @@ def make_python_identifier(identifier: str) -> str:
     return sanitized
 
 
-def make_python_model(
+def _make_python_model(
     obj: Union["Schema", "Attribute"],
     base: type[T],
     multiple: bool = False,
@@ -54,14 +54,14 @@ def make_python_model(
     """Build a Python model from a Schema or an Attribute object."""
     if isinstance(obj, Attribute):
         pydantic_attributes = {
-            to_snake(make_python_identifier(attr.name)): attr.to_python()
+            to_snake(_make_python_identifier(attr.name)): attr._to_python()
             for attr in (obj.sub_attributes or [])
             if attr.name
         }
 
     else:
         pydantic_attributes = {
-            to_snake(make_python_identifier(attr.name)): attr.to_python()
+            to_snake(_make_python_identifier(attr.name)): attr._to_python()
             for attr in (obj.attributes or [])
             if attr.name
         }
@@ -97,7 +97,7 @@ class Attribute(ComplexAttribute):
         reference = "reference"
         binary = "binary"
 
-        def to_python(
+        def _to_python(
             self,
             multiple: bool = False,
             reference_types: Optional[list[str]] = None,
@@ -210,15 +210,15 @@ class Attribute(ComplexAttribute):
     """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) -> Optional[tuple[Any, Any]]:
         """Build tuple suited to be passed to pydantic 'create_model'."""
         if not self.name or not self.type:
             return None
 
-        attr_type = self.type.to_python(bool(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(
+            attr_type = _make_python_model(
                 obj=self, base=attr_type, multiple=bool(self.multi_valued)
             )
 
@@ -238,7 +238,7 @@ class Attribute(ComplexAttribute):
             description=self.description,
             examples=self.canonical_values,
             serialization_alias=self.name,
-            validation_alias=normalize_attribute_name(self.name),
+            validation_alias=_normalize_attribute_name(self.name),
             default=None,
         )
 

scim2_models/scim_object.py

@@ -8,86 +8,9 @@ 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}"
+    pass
 
 
 class ScimObject(BaseModel):

scim2_models/urn.py

@@ -0,0 +1,109 @@
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Optional
+
+from .base import BaseModel
+from .utils import _normalize_attribute_name
+
+if TYPE_CHECKING:
+    from .base import BaseModel
+    from .resources.resource import Resource
+
+
+def _get_or_create_extension_instance(
+    model: "Resource", extension_class: type
+) -> "BaseModel":
+    """Get existing extension instance or create a new one."""
+    extension_instance = model[extension_class]
+    if extension_instance is None:
+        extension_instance = extension_class()
+        model[extension_class] = extension_instance
+    return extension_instance
+
+
+def _normalize_path(model: Optional[type["BaseModel"]], path: str) -> tuple[str, str]:
+    """Resolve a path to (schema_urn, attribute_path)."""
+    from .resources.resource import Resource
+
+    # Absolute URN
+    if ":" in path:
+        parts = path.rsplit(":", 1)
+        return parts[0], parts[1]
+
+    # Relative URN with a schema
+    elif model and issubclass(model, Resource) and hasattr(model, "model_fields"):
+        schemas_field = model.model_fields.get("schemas")
+        return schemas_field.default[0], path  # type: ignore
+
+    return "", path
+
+
+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 _validate_attribute_urn(
+    attribute_name: str, resource: type["Resource"]
+) -> Optional[str]:
+    """Validate that an attribute urn is valid or not.
+
+    :param attribute_name: The attribute urn to check.
+    :return: The normalized attribute URN.
+    """
+    from .resources.resource import Resource
+
+    schema: Optional[Any]
+    schema, attribute_base = _normalize_path(resource, attribute_name)
+
+    validated_resource = Resource.get_by_schema([resource], schema)
+    if not validated_resource:
+        return None
+
+    try:
+        _validate_model_attribute(validated_resource, attribute_base)
+    except ValueError:
+        return None
+
+    return f"{schema}:{attribute_base}"
+
+
+def _resolve_path_to_target(
+    resource: "Resource", path: str
+) -> tuple[Optional["BaseModel"], str]:
+    """Resolve a path to a target and an attribute_path.
+
+    The target can be the resource itself, or an extension object.
+    """
+    schema_urn, attr_path = _normalize_path(type(resource), path)
+
+    if not schema_urn:
+        return resource, attr_path
+
+    if schema_urn in resource.schemas:
+        return resource, attr_path
+
+    extension_class = resource.get_extension_model(schema_urn)
+    if not extension_class:
+        return (None, "")
+
+    extension_instance = _get_or_create_extension_instance(resource, extension_class)
+    return extension_instance, attr_path

scim2_models/utils.py

@@ -19,12 +19,12 @@ except ImportError:
     UNION_TYPES = [Union]
 
 
-def int_to_str(status: Optional[int]) -> Optional[str]:
+def _int_to_str(status: Optional[int]) -> Optional[str]:
     return None if status is None else str(status)
 
 
 # Copied from Pydantic 2.10 repository
-class Base64Encoder(EncoderProtocol):  # pragma: no cover
+class _Base64Encoder(EncoderProtocol):  # pragma: no cover
     """Standard (non-URL-safe) Base64 encoder."""
 
     @classmethod
@@ -71,10 +71,10 @@ class Base64Encoder(EncoderProtocol):  # pragma: no cover
 
 # Compatibility with Pydantic <2.10
 # https://pydantic.dev/articles/pydantic-v2-10-release#use-b64decode-and-b64encode-for-base64bytes-and-base64str-types
-Base64Bytes = Annotated[bytes, EncodedBytes(encoder=Base64Encoder)]
+Base64Bytes = Annotated[bytes, EncodedBytes(encoder=_Base64Encoder)]
 
 
-def to_camel(string: str) -> str:
+def _to_camel(string: str) -> str:
     """Transform strings to camelCase.
 
     This method is used for attribute name serialization. This is more
@@ -87,7 +87,7 @@ def to_camel(string: str) -> str:
     return camel
 
 
-def normalize_attribute_name(attribute_name: str) -> str:
+def _normalize_attribute_name(attribute_name: str) -> str:
     """Remove all non-alphabetical characters and lowerise a string.
 
     This method is used for attribute name validation.
@@ -97,3 +97,105 @@ def normalize_attribute_name(attribute_name: str) -> str:
         attribute_name = re.sub(r"[\W_]+", "", attribute_name)
 
     return attribute_name.lower()
+
+
+def _validate_scim_path_syntax(path: str) -> bool:
+    """Check if path syntax is valid according to RFC 7644 simplified rules.
+
+    :param path: The path to validate
+    :type path: str
+    :return: True if path syntax is valid, False otherwise
+    :rtype: bool
+    """
+    if not path or not path.strip():
+        return False
+
+    # Cannot start with a digit
+    if path[0].isdigit():
+        return False
+
+    # Cannot contain double dots
+    if ".." in path:
+        return False
+
+    # Cannot contain invalid characters (basic check)
+    # Allow alphanumeric, dots, underscores, hyphens, colons (for URNs), brackets
+    if not re.match(r'^[a-zA-Z][a-zA-Z0-9._:\-\[\]"=\s]*$', path):
+        return False
+
+    # If it contains a colon, validate it's a proper URN format
+    if ":" in path:
+        if not _validate_scim_urn_syntax(path):
+            return False
+
+    return True
+
+
+def _validate_scim_urn_syntax(path: str) -> bool:
+    """Validate URN-based path format.
+
+    :param path: The URN path to validate
+    :type path: str
+    :return: True if URN path format is valid, False otherwise
+    :rtype: bool
+    """
+    # Basic URN validation: should start with urn:
+    if not path.startswith("urn:"):
+        return False
+
+    # Split on the last colon to separate URN from attribute
+    urn_part, attr_part = path.rsplit(":", 1)
+
+    # URN part should have at least 4 parts (urn:namespace:specific:resource)
+    urn_segments = urn_part.split(":")
+    if len(urn_segments) < 4:
+        return False
+
+    # Attribute part should be valid
+    if not attr_part or attr_part[0].isdigit():
+        return False
+
+    return True
+
+
+def _extract_field_name(path: str) -> Optional[str]:
+    """Extract the field name from a path.
+
+    For now, only handle simple paths (no filters, no complex expressions).
+    Returns None for complex paths that require filter parsing.
+
+    """
+    # Handle URN paths
+    if path.startswith("urn:"):
+        # First validate it's a proper URN
+        if not _validate_scim_urn_syntax(path):
+            return None
+        parts = path.rsplit(":", 1)
+        return parts[1]
+
+    # Simple attribute path (may have dots for sub-attributes)
+    # For now, just take the first part before any dot
+    if "." in path:
+        return path.split(".")[0]
+
+    return path
+
+
+def _find_field_name(resource_class, attr_name: str) -> Optional[str]:
+    """Find the actual field name in a resource class from an attribute name.
+
+    Args:
+        resource_class: The resource class to search in
+        attr_name: The attribute name to find (e.g., "nickName")
+
+    Returns:
+        The actual field name if found (e.g., "nick_name"), None otherwise
+
+    """
+    normalized_attr_name = _normalize_attribute_name(attr_name)
+
+    for field_key in resource_class.model_fields:
+        if _normalize_attribute_name(field_key) == normalized_attr_name:
+            return field_key
+
+    return None

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

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

@@ -0,0 +1,30 @@
+scim2_models/__init__.py,sha256=IACL_c94UhKq0ZEXOb3LMZgeEQMfQhdOVpWGDnHSpXo,3201
+scim2_models/annotations.py,sha256=oRjlKL1fqrYfa9UtaMdxF5fOT8CUUN3m-rdzvf7aiSA,3304
+scim2_models/attributes.py,sha256=REp_WMTxs02NDcJJrSCbplCqnhVtExvfzozp_JJ_BdY,1785
+scim2_models/base.py,sha256=8Nh-R8vN_Gd9_NU9Oq-heD5h2MzjT_X9djidG3OeO0g,20389
+scim2_models/constants.py,sha256=9egq8JW0dFAqPng85CiHoH5T6pRtYL87-gC0C-IMGsk,573
+scim2_models/context.py,sha256=RjgMIvWPr8f41qbVL1sjaDnm9GRKyrCrgfC4npwwcMg,9149
+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=6a-lf8iIQhlMY7lCM7RcSde4f1kECncE0Ae8uJ4RaaA,2404
+scim2_models/urn.py,sha256=n94gnOBMJguXfyczcFvkn8ipvZuRXoxYPC7QeXe9HoY,3559
+scim2_models/utils.py,sha256=3yvU261wl5IR-zPcNhcNcQFwCd0h--k07mfTSgUY1nE,5681
+scim2_models/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/messages/bulk.py,sha256=snPB722V_Msg1JBFcaTeEW_sa-jt-KHv6fh071NoKCg,2592
+scim2_models/messages/error.py,sha256=_IHUoFwl-QJiICIcRkhaXf_9C7RXgiX7TL_26QXDo2c,6304
+scim2_models/messages/list_response.py,sha256=B-XELBTks6I45pKheAS5Go9x5IDKhrLJWsqC8y3G00s,2400
+scim2_models/messages/message.py,sha256=sjo_iFMJelZkssvA4O5xTqIt-urDxUbSP6N_WsnZ63Y,4081
+scim2_models/messages/patch_op.py,sha256=yT_5gDcXWeSOdxvpYrdHh5nD2uD-B9kdfQ5qjC-JUkY,19726
+scim2_models/messages/search_request.py,sha256=BDTDzvtfCuFZDFsZBHl8ys8Te02jLuvGaTNipBQByrM,4632
+scim2_models/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scim2_models/resources/enterprise_user.py,sha256=TVa5aS-eLHcDkwyr58hZYsRKk0AwjUaUaSFhU51mn5E,1806
+scim2_models/resources/group.py,sha256=lJXKopa__LoWhkaNqu0JFVyQaOMe-AF4vISaq0Gg7cE,1458
+scim2_models/resources/resource.py,sha256=GZaV_bi6r2A_UfPSQgEb3jGEeEqMhw2YGImRIhfKOY0,17615
+scim2_models/resources/resource_type.py,sha256=scLqbD3HX3fXT2JOXY9OUVnZz7i5ty2lx4VuiVxt6DE,3314
+scim2_models/resources/schema.py,sha256=KBqDRr2sgLrqL8UYWon-uxBzIA0118srJ8tXobs950E,10659
+scim2_models/resources/service_provider_config.py,sha256=6xJ182T-1szEQnN5Zb1cTdQCgTYIFi4XKygbvDlTKTM,5446
+scim2_models/resources/user.py,sha256=ErOghhilUF7fipwDRqARyLwJhbntQx4GJG3u2sZNJXs,10664
+scim2_models-0.4.1.dist-info/METADATA,sha256=zu1Txl8FZcnVF6WYYkBl5g7O1rvfcnaG1Dk987DtIRM,16288
+scim2_models-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scim2_models-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scim2_models-0.4.1.dist-info/RECORD,,