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

scim2_models/{rfc7643 → resources}/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,26 +17,27 @@ 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 ..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:
@@ -44,23 +46,22 @@ def make_python_identifier(identifier: str) -> str:
     return sanitized
 
 
-def make_python_model(
+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 = {
-            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
         }
-        base = MultiValuedComplexAttribute if multiple else ComplexAttribute
 
     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
         }
@@ -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
@@ -93,9 +97,9 @@ class Attribute(ComplexAttribute):
         reference = "reference"
         binary = "binary"
 
-        def to_python(
+        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
@@ -232,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,
         )
 
@@ -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 → resources}/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 → resources}/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/scim_object.py

@@ -0,0 +1,66 @@
+"""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
+
+if TYPE_CHECKING:
+    pass
+
+
+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/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

@@ -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:
@@ -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.6.dist-info → scim2_models-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.3.6
+Version: 0.4.0
 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.0.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=yM13Jtk9c1dJJ3ci9dE5kwXqruFb1Lm0rrIs6nct3YE,19050
+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.0.dist-info/METADATA,sha256=PNXZC9wPGqbZqpDMQUh6WcRhyLy1EFmchdVorOH1dgc,16288
+scim2_models-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scim2_models-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scim2_models-0.4.0.dist-info/RECORD,,