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

scim2_models/attributes.py

@@ -43,7 +43,7 @@ class MultiValuedComplexAttribute(ComplexAttribute):
     value: Optional[Any] = None
     """The value of an entitlement."""
 
-    ref: Optional[Reference] = Field(None, serialization_alias="$ref")
+    ref: Optional[Reference[Any]] = Field(None, serialization_alias="$ref")
     """The reference URI of a target resource, if the attribute is a
     reference."""
 

scim2_models/base.py

@@ -220,8 +220,8 @@ class BaseModel(PydanticBaseModel):
         """
 
         def normalize_dict_keys(
-            input_dict: dict, model_class: type["BaseModel"]
-        ) -> dict:
+            input_dict: dict[str, Any], model_class: type["BaseModel"]
+        ) -> dict[str, Any]:
             """Normalize dictionary keys, preserving case for Any fields."""
             result = {}
 

scim2_models/messages/message.py

@@ -112,8 +112,8 @@ class _GenericMessageMetaclass(ModelMetaclass):
         return klass
 
 
-def _get_resource_class(obj) -> Optional[type[Resource]]:
+def _get_resource_class(obj: BaseModel) -> type[Resource[Any]]:
     """Extract the resource class from generic type parameter."""
     metadata = getattr(obj.__class__, "__pydantic_generic_metadata__", {"args": [None]})
     resource_class = metadata["args"][0]
-    return resource_class
+    return resource_class  # type: ignore[no-any-return]

scim2_models/messages/patch_op.py

@@ -5,6 +5,7 @@ from typing import Any
 from typing import Generic
 from typing import Optional
 from typing import TypeVar
+from typing import Union
 
 from pydantic import Field
 from pydantic import ValidationInfo
@@ -26,7 +27,7 @@ from .error import Error
 from .message import Message
 from .message import _get_resource_class
 
-T = TypeVar("T", bound=Resource)
+T = TypeVar("T", bound=Resource[Any])
 
 
 class PatchOperation(ComplexAttribute):
@@ -51,7 +52,7 @@ class PatchOperation(ComplexAttribute):
     describing the target of the operation."""
 
     def _validate_mutability(
-        self, resource_class: type[BaseModel], field_name: str
+        self, resource_class: type[Resource[Any]], field_name: str
     ) -> None:
         """Validate mutability constraints."""
         # RFC 7644 Section 3.5.2: "Servers should be tolerant of schema extensions"
@@ -72,7 +73,7 @@ class PatchOperation(ComplexAttribute):
             raise ValueError(Error.make_mutability_error().detail)
 
     def _validate_required_attribute(
-        self, resource_class: type[BaseModel], field_name: str
+        self, resource_class: type[Resource[Any]], field_name: str
     ) -> None:
         """Validate required attribute constraints for remove operations."""
         # RFC 7644 Section 3.5.2.3: Only validate for remove operations
@@ -143,7 +144,7 @@ class PatchOp(Message, Generic[T]):
         - Using PatchOp without a type parameter raises TypeError
     """
 
-    def __new__(cls, *args: Any, **kwargs: Any):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
         """Create new PatchOp instance with type parameter validation.
 
         Only handles the case of direct instantiation without type parameter (PatchOp()).
@@ -162,39 +163,48 @@ class PatchOp(Message, Generic[T]):
 
         return super().__new__(cls)
 
-    def __class_getitem__(cls, item):
+    def __class_getitem__(
+        cls, typevar_values: Union[type[Resource[Any]], tuple[type[Resource[Any]], ...]]
+    ) -> Any:
         """Validate type parameter when creating parameterized type.
 
         Ensures the type parameter is a concrete Resource subclass (not Resource itself)
         or a TypeVar bound to Resource. Rejects invalid types (str, int, etc.) and Union types.
         """
-        # Allow TypeVar as type parameter
-        if isinstance(item, TypeVar):
+        if isinstance(typevar_values, TypeVar):
             # Check if TypeVar is bound to Resource or its subclass
-            if item.__bound__ is not None and (
-                item.__bound__ is Resource
-                or (isclass(item.__bound__) and issubclass(item.__bound__, Resource))
+            if typevar_values.__bound__ is not None and (
+                typevar_values.__bound__ is Resource
+                or (
+                    isclass(typevar_values.__bound__)
+                    and issubclass(typevar_values.__bound__, Resource)
+                )
             ):
-                return super().__class_getitem__(item)
+                return super().__class_getitem__(typevar_values)
             else:
                 raise TypeError(
-                    f"PatchOp TypeVar must be bound to Resource or its subclass, got {item}. "
+                    f"PatchOp TypeVar must be bound to Resource or its subclass, got {typevar_values}. "
                     "Example: T = TypeVar('T', bound=Resource)"
                 )
 
         # Check if type parameter is a concrete Resource subclass (not Resource itself)
-        if item is Resource:
+        if typevar_values is Resource:
             raise TypeError(
                 "PatchOp requires a concrete Resource subclass, not Resource itself. "
                 "Use PatchOp[User], PatchOp[Group], etc. instead of PatchOp[Resource]."
             )
-        if not (isclass(item) and issubclass(item, Resource) and item is not Resource):
+
+        if not (
+            isclass(typevar_values)
+            and issubclass(typevar_values, Resource)
+            and typevar_values is not Resource
+        ):
             raise TypeError(
-                f"PatchOp type parameter must be a concrete Resource subclass or TypeVar, got {item}. "
+                f"PatchOp type parameter must be a concrete Resource subclass or TypeVar, got {typevar_values}. "
                 "Use PatchOp[User], PatchOp[Group], etc."
             )
 
-        return super().__class_getitem__(item)
+        return super().__class_getitem__(typevar_values)
 
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:api:messages:2.0:PatchOp"
@@ -254,7 +264,9 @@ class PatchOp(Message, Generic[T]):
 
         return modified
 
-    def _apply_operation(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_operation(
+        self, resource: Resource[Any], operation: PatchOperation
+    ) -> bool:
         """Apply a single patch operation to a resource.
 
         :return: :data:`True` if the resource was modified, else :data:`False`.
@@ -266,7 +278,9 @@ class PatchOp(Message, Generic[T]):
 
         raise ValueError(Error.make_invalid_value_error().detail)
 
-    def _apply_add_replace(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_add_replace(
+        self, resource: Resource[Any], operation: PatchOperation
+    ) -> bool:
         """Apply an add or replace operation."""
         # RFC 7644 Section 3.5.2.1: "If path is specified, add/replace at that path"
         if operation.path is not None:
@@ -280,7 +294,7 @@ class PatchOp(Message, Generic[T]):
         # RFC 7644 Section 3.5.2.1: "If no path specified, add/replace at root level"
         return self._apply_root_attributes(resource, operation.value)
 
-    def _apply_remove(self, resource: Resource, operation: PatchOperation) -> bool:
+    def _apply_remove(self, resource: Resource[Any], operation: PatchOperation) -> bool:
         """Apply a remove operation."""
         # RFC 7644 Section 3.5.2.3: "Path is required for remove operations"
         if operation.path is None:
@@ -294,7 +308,8 @@ class PatchOp(Message, Generic[T]):
 
         return self._remove_value_at_path(resource, operation.path)
 
-    def _apply_root_attributes(self, resource: BaseModel, value: Any) -> bool:
+    @classmethod
+    def _apply_root_attributes(cls, resource: BaseModel, value: Any) -> bool:
         """Apply attributes to the resource root."""
         if not isinstance(value, dict):
             return False
@@ -312,8 +327,9 @@ class PatchOp(Message, Generic[T]):
 
         return modified
 
+    @classmethod
     def _set_value_at_path(
-        self, resource: Resource, path: str, value: Any, is_add: bool
+        cls, resource: Resource[Any], path: str, value: Any, is_add: bool
     ) -> bool:
         """Set a value at a specific path."""
         target, attr_path = _resolve_path_to_target(resource, path)
@@ -323,12 +339,13 @@ class PatchOp(Message, Generic[T]):
 
         path_parts = attr_path.split(".")
         if len(path_parts) == 1:
-            return self._set_simple_attribute(target, path_parts[0], value, is_add)
+            return cls._set_simple_attribute(target, path_parts[0], value, is_add)
 
-        return self._set_complex_attribute(target, path_parts, value, is_add)
+        return cls._set_complex_attribute(target, path_parts, value, is_add)
 
+    @classmethod
     def _set_simple_attribute(
-        self, resource: BaseModel, attr_name: str, value: Any, is_add: bool
+        cls, resource: BaseModel, attr_name: str, value: Any, is_add: bool
     ) -> bool:
         """Set a value on a simple (non-nested) attribute."""
         field_name = _find_field_name(type(resource), attr_name)
@@ -336,8 +353,8 @@ class PatchOp(Message, Generic[T]):
             raise ValueError(Error.make_no_target_error().detail)
 
         # RFC 7644 Section 3.5.2.1: "For multi-valued attributes, add operation appends values"
-        if is_add and self._is_multivalued_field(resource, field_name):
-            return self._handle_multivalued_add(resource, field_name, value)
+        if is_add and cls._is_multivalued_field(resource, field_name):
+            return cls._handle_multivalued_add(resource, field_name, value)
 
         old_value = getattr(resource, field_name)
         if old_value == value:
@@ -346,8 +363,9 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, field_name, value)
         return True
 
+    @classmethod
     def _set_complex_attribute(
-        self, resource: BaseModel, path_parts: list[str], value: Any, is_add: bool
+        cls, resource: BaseModel, path_parts: list[str], value: Any, is_add: bool
     ) -> bool:
         """Set a value on a complex (nested) attribute."""
         parent_attr = path_parts[0]
@@ -359,38 +377,45 @@ class PatchOp(Message, Generic[T]):
 
         parent_obj = getattr(resource, parent_field_name)
         if parent_obj is None:
-            parent_obj = self._create_parent_object(resource, parent_field_name)
+            parent_obj = cls._create_parent_object(resource, parent_field_name)
             if parent_obj is None:
                 return False
 
-        return self._set_value_at_path(parent_obj, sub_path, value, is_add)
+        return cls._set_value_at_path(parent_obj, sub_path, value, is_add)
 
-    def _is_multivalued_field(self, resource: BaseModel, field_name: str) -> bool:
+    @classmethod
+    def _is_multivalued_field(cls, resource: BaseModel, field_name: str) -> bool:
         """Check if a field is multi-valued."""
         return hasattr(resource, field_name) and type(resource).get_field_multiplicity(
             field_name
         )
 
+    @classmethod
     def _handle_multivalued_add(
-        self, resource: BaseModel, field_name: str, value: Any
+        cls, resource: BaseModel, field_name: str, value: Any
     ) -> bool:
         """Handle adding values to a multi-valued attribute."""
         current_list = getattr(resource, field_name) or []
 
         # RFC 7644 Section 3.5.2.1: "Add operation appends values to multi-valued attributes"
         if isinstance(value, list):
-            return self._add_multiple_values(resource, field_name, current_list, value)
+            return cls._add_multiple_values(resource, field_name, current_list, value)
 
-        return self._add_single_value(resource, field_name, current_list, value)
+        return cls._add_single_value(resource, field_name, current_list, value)
 
+    @classmethod
     def _add_multiple_values(
-        self, resource: BaseModel, field_name: str, current_list: list, values: list
+        cls,
+        resource: BaseModel,
+        field_name: str,
+        current_list: list[Any],
+        values: list[Any],
     ) -> bool:
         """Add multiple values to a multi-valued attribute."""
         new_values = []
         # RFC 7644 Section 3.5.2.1: "Do not add duplicate values"
         for new_val in values:
-            if not self._value_exists_in_list(current_list, new_val):
+            if not cls._value_exists_in_list(current_list, new_val):
                 new_values.append(new_val)
 
         if not new_values:
@@ -399,23 +424,26 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, field_name, current_list + new_values)
         return True
 
+    @classmethod
     def _add_single_value(
-        self, resource: BaseModel, field_name: str, current_list: list, value: Any
+        cls, resource: BaseModel, field_name: str, current_list: list[Any], value: Any
     ) -> bool:
         """Add a single value to a multi-valued attribute."""
         # RFC 7644 Section 3.5.2.1: "Do not add duplicate values"
-        if self._value_exists_in_list(current_list, value):
+        if cls._value_exists_in_list(current_list, value):
             return False
 
         current_list.append(value)
         setattr(resource, field_name, current_list)
         return True
 
-    def _value_exists_in_list(self, current_list: list, new_value: Any) -> bool:
+    @classmethod
+    def _value_exists_in_list(cls, current_list: list[Any], new_value: Any) -> bool:
         """Check if a value already exists in a list."""
-        return any(self._values_match(item, new_value) for item in current_list)
+        return any(cls._values_match(item, new_value) for item in current_list)
 
-    def _create_parent_object(self, resource: BaseModel, parent_field_name: str) -> Any:
+    @classmethod
+    def _create_parent_object(cls, resource: BaseModel, parent_field_name: str) -> Any:
         """Create a parent object if it doesn't exist."""
         parent_class = type(resource).get_field_root_type(parent_field_name)
         if not parent_class or not isclass(parent_class):
@@ -425,7 +453,8 @@ class PatchOp(Message, Generic[T]):
         setattr(resource, parent_field_name, parent_obj)
         return parent_obj
 
-    def _remove_value_at_path(self, resource: Resource, path: str) -> bool:
+    @classmethod
+    def _remove_value_at_path(cls, resource: Resource[Any], path: str) -> bool:
         """Remove a value at a specific path."""
         target, attr_path = _resolve_path_to_target(resource, path)
 
@@ -448,10 +477,11 @@ class PatchOp(Message, Generic[T]):
             return True
 
         sub_path = ".".join(path_parts)
-        return self._remove_value_at_path(parent_obj, sub_path)
+        return cls._remove_value_at_path(parent_obj, sub_path)
 
+    @classmethod
     def _remove_specific_value(
-        self, resource: Resource, path: str, value_to_remove: Any
+        cls, resource: Resource[Any], path: str, value_to_remove: Any
     ) -> bool:
         """Remove a specific value from a multi-valued attribute."""
         target, attr_path = _resolve_path_to_target(resource, path)
@@ -472,7 +502,7 @@ class PatchOp(Message, Generic[T]):
         modified = False
         # RFC 7644 Section 3.5.2.3: "Remove matching values from multi-valued attributes"
         for item in current_list:
-            if not self._values_match(item, value_to_remove):
+            if not cls._values_match(item, value_to_remove):
                 new_list.append(item)
             else:
                 modified = True
@@ -483,10 +513,11 @@ class PatchOp(Message, Generic[T]):
 
         return False
 
-    def _values_match(self, value1: Any, value2: Any) -> bool:
+    @classmethod
+    def _values_match(cls, value1: Any, value2: Any) -> bool:
         """Check if two values match, converting BaseModel to dict for comparison."""
 
-        def to_dict(value):
+        def to_dict(value: Any) -> dict[str, Any]:
             return value.model_dump() if isinstance(value, BaseModel) else value
 
         return to_dict(value1) == to_dict(value2)

scim2_models/messages/search_request.py

@@ -71,9 +71,7 @@ class SearchRequest(Message):
         """Validate syntax of sort_by attribute path.
 
         :param v: The sort_by attribute path to validate
-        :type v: Optional[str]
         :return: The validated sort_by attribute path
-        :rtype: Optional[str]
         :raises ValueError: If sort_by attribute path has invalid syntax
         """
         if v is None:

scim2_models/reference.py

@@ -61,9 +61,7 @@ class Reference(UserString, Generic[ReferenceTypes]):
         """Get reference types from a type annotation.
 
         :param type_annotation: Type annotation to extract reference types from
-        :type type_annotation: Any
         :return: List of reference type strings
-        :rtype: list[str]
         """
         first_arg = get_args(type_annotation)[0]
         types = (

scim2_models/resources/group.py

@@ -1,4 +1,5 @@
 from typing import Annotated
+from typing import Any
 from typing import ClassVar
 from typing import Literal
 from typing import Optional
@@ -33,7 +34,7 @@ class GroupMember(MultiValuedComplexAttribute):
     display: Annotated[Optional[str], Mutability.read_only] = None
 
 
-class Group(Resource):
+class Group(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:Group"
     ]

scim2_models/resources/resource.py

@@ -148,7 +148,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
     """A complex attribute containing resource metadata."""
 
     @classmethod
-    def __class_getitem__(cls, item: Any) -> type["Resource"]:
+    def __class_getitem__(cls, item: Any) -> type["Resource[Any]"]:
         """Create a Resource class with extension fields dynamically added."""
         if hasattr(cls, "__scim_extension_metadata__"):
             return cls
@@ -241,12 +241,12 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
     @staticmethod
     def get_by_schema(
-        resource_types: list[type["Resource"]],
+        resource_types: list[type["Resource[Any]"]],
         schema: str,
         with_extensions: bool = True,
-    ) -> Optional[Union[type["Resource"], type["Extension"]]]:
+    ) -> Optional[Union[type["Resource[Any]"], type["Extension"]]]:
         """Given a resource type list and a schema, find the matching resource type."""
-        by_schema: dict[str, Union[type[Resource], type[Extension]]] = {
+        by_schema: dict[str, Union[type[Resource[Any]], type[Extension]]] = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
         }
@@ -263,7 +263,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
 
     @staticmethod
     def get_by_payload(
-        resource_types: list[type["Resource"]],
+        resource_types: list[type["Resource[Any]"]],
         payload: dict[str, Any],
         **kwargs: Any,
     ) -> Optional[type]:
@@ -291,7 +291,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
         return _model_to_schema(cls)
 
     @classmethod
-    def from_schema(cls, schema: "Schema") -> type["Resource"]:
+    def from_schema(cls, schema: "Schema") -> type["Resource[Any]"]:
         """Build a :class:`scim2_models.Resource` subclass from the schema definition."""
         from .schema import _make_python_model
 
@@ -372,7 +372,7 @@ class Resource(ScimObject, Generic[AnyExtension]):
         return super(ScimObject, self).model_dump_json(*args, **dump_kwargs)
 
 
-AnyResource = TypeVar("AnyResource", bound="Resource")
+AnyResource = TypeVar("AnyResource", bound="Resource[Any]")
 
 
 def _dedicated_attributes(

scim2_models/resources/resource_type.py

@@ -1,4 +1,5 @@
 from typing import Annotated
+from typing import Any
 from typing import Optional
 
 from pydantic import Field
@@ -34,7 +35,7 @@ class SchemaExtension(ComplexAttribute):
     """
 
 
-class ResourceType(Resource):
+class ResourceType(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:ResourceType"
     ]
@@ -78,7 +79,7 @@ class ResourceType(Resource):
     """A list of URIs of the resource type's schema extensions."""
 
     @classmethod
-    def from_resource(cls, resource_model: type[Resource]) -> Self:
+    def from_resource(cls, resource_model: type[Resource[Any]]) -> Self:
         """Build a naive ResourceType from a resource model."""
         schema = resource_model.model_fields["schemas"].default[0]
         name = schema.split(":")[-1]

scim2_models/resources/schema.py

@@ -258,7 +258,7 @@ class Attribute(ComplexAttribute):
         raise KeyError(f"This attribute has no '{name}' sub-attribute")
 
 
-class Schema(Resource):
+class Schema(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:Schema"
     ]

scim2_models/resources/service_provider_config.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import Annotated
+from typing import Any
 from typing import Optional
 
 from pydantic import Field
@@ -93,7 +94,7 @@ class AuthenticationScheme(ComplexAttribute):
     address."""
 
 
-class ServiceProviderConfig(Resource):
+class ServiceProviderConfig(Resource[Any]):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"
     ]

scim2_models/urn.py

@@ -1,18 +1,20 @@
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Optional
+from typing import Union
 
 from .base import BaseModel
 from .utils import _normalize_attribute_name
 
 if TYPE_CHECKING:
     from .base import BaseModel
+    from .resources.resource import Extension
     from .resources.resource import Resource
 
 
 def _get_or_create_extension_instance(
-    model: "Resource", extension_class: type
-) -> "BaseModel":
+    model: "Resource[Any]", extension_class: type
+) -> "Extension":
     """Get existing extension instance or create a new one."""
     extension_instance = model[extension_class]
     if extension_instance is None:
@@ -62,7 +64,7 @@ def _validate_model_attribute(model: type["BaseModel"], attribute_base: str) ->
 
 
 def _validate_attribute_urn(
-    attribute_name: str, resource: type["Resource"]
+    attribute_name: str, resource: type["Resource[Any]"]
 ) -> Optional[str]:
     """Validate that an attribute urn is valid or not.
 
@@ -87,8 +89,8 @@ def _validate_attribute_urn(
 
 
 def _resolve_path_to_target(
-    resource: "Resource", path: str
-) -> tuple[Optional["BaseModel"], str]:
+    resource: "Resource[Any]", path: str
+) -> tuple[Optional[Union["Resource[Any]", "Extension"]], str]:
     """Resolve a path to a target and an attribute_path.
 
     The target can be the resource itself, or an extension object.

scim2_models/utils.py

@@ -1,5 +1,6 @@
 import base64
 import re
+from typing import TYPE_CHECKING
 from typing import Annotated
 from typing import Literal
 from typing import Optional
@@ -10,6 +11,9 @@ from pydantic import EncoderProtocol
 from pydantic.alias_generators import to_snake
 from pydantic_core import PydanticCustomError
 
+if TYPE_CHECKING:
+    from .base import BaseModel
+
 try:
     from types import UnionType
 
@@ -103,9 +107,7 @@ 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
@@ -135,9 +137,7 @@ 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:"):
@@ -181,20 +181,16 @@ def _extract_field_name(path: str) -> Optional[str]:
     return path
 
 
-def _find_field_name(resource_class, attr_name: str) -> Optional[str]:
+def _find_field_name(model_class: type["BaseModel"], 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
-
+    :param resource_class: The resource class to search in
+    :param 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:
+    for field_key in model_class.model_fields:
         if _normalize_attribute_name(field_key) == normalized_attr_name:
             return field_key
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.4.1
+Version: 0.4.2
 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.2.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=ISPpiCLPlDXq_NTudSs2186fvy2SRxmFXJNeVHEvbsY,1790
+scim2_models/base.py,sha256=TGEUVvaXZv5uuR-J_tR6MKeaPjZeGK3cLN6TPotwJnY,20409
+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=HwbY0PLF16Bu_1zaxXbspjBP_CtTrQkaK2KLmD1ycD0,2422
+scim2_models/scim_object.py,sha256=6a-lf8iIQhlMY7lCM7RcSde4f1kECncE0Ae8uJ4RaaA,2404
+scim2_models/urn.py,sha256=c5jJXZCsik4-QBV1-z3vXTB__DKY7xYZqDPMmOsIbEo,3669
+scim2_models/utils.py,sha256=sGnoY9KJS0elxfgPTp9S0CqzXXoxt5hIVUSjkPCaAh0,5691
+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=rs4Zcr5gXl8KDMscLOYKp4spg9lvH_o3w-Rn2R76eN0,4118
+scim2_models/messages/patch_op.py,sha256=uvLq8-kfQgit_sIE2jzQ7FFWE-o7J5aPDjpCPsEPV_g,20386
+scim2_models/messages/search_request.py,sha256=7v_ALuJV6qgJ_VD5hcdq9KoxIFiwCgGj9QqrlC695Co,4571
+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=_7zkfVsdVXmPXoexL0xDXLfuKV7gR71RiBzR-RCPC4I,1486
+scim2_models/resources/resource.py,sha256=pVciWEM8yW13iOOheetXkJ573uZ4kJbexgxBJU4x8_4,17650
+scim2_models/resources/resource_type.py,sha256=DgGefRQ9bXDFl1AsMPbfuznJqMshfKyUWbpo0vzsyes,3347
+scim2_models/resources/schema.py,sha256=zVq_D_JLDl3w1JjgEtfAQaqrLup8APtQCmz9RBrviUw,10664
+scim2_models/resources/service_provider_config.py,sha256=yHzpLZIQ7r0nooWOcK2Sq6Q53sdcy443Pq4LverRlGI,5474
+scim2_models/resources/user.py,sha256=ErOghhilUF7fipwDRqARyLwJhbntQx4GJG3u2sZNJXs,10664
+scim2_models-0.4.2.dist-info/METADATA,sha256=Y77SSW3WFIIlJQG_WjWzX_pXhFEBMP9WhGdYUvTHJFA,16288
+scim2_models-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scim2_models-0.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scim2_models-0.4.2.dist-info/RECORD,,

scim2_models-0.4.1.dist-info/RECORD

@@ -1,30 +0,0 @@
-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,,