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

scim2_models/__init__.py

@@ -1,15 +1,15 @@
+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 .base import BaseModel
-from .base import CaseExact
-from .base import ComplexAttribute
-from .base import Context
-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 .context import Context
+from .reference import ExternalReference
+from .reference import Reference
+from .reference import URIReference
 from .rfc7643.enterprise_user import EnterpriseUser
 from .rfc7643.enterprise_user import Manager
 from .rfc7643.group import Group

scim2_models/annotations.py

@@ -0,0 +1,104 @@
+from enum import Enum
+
+
+class Mutability(str, Enum):
+    """A single keyword indicating the circumstances under which the value of the attribute can be (re)defined."""
+
+    read_only = "readOnly"
+    """The attribute SHALL NOT be modified."""
+
+    read_write = "readWrite"
+    """The attribute MAY be updated and read at any time."""
+
+    immutable = "immutable"
+    """The attribute MAY be defined at resource creation (e.g., POST) or at
+    record replacement via a request (e.g., a PUT).
+
+    The attribute SHALL NOT be updated.
+    """
+
+    write_only = "writeOnly"
+    """The attribute MAY be updated at any time.
+
+    Attribute values SHALL NOT be returned (e.g., because the value is a
+    stored hash).  Note: An attribute with a mutability of "writeOnly"
+    usually also has a returned setting of "never".
+    """
+
+    _default = read_write
+
+
+class Returned(str, Enum):
+    """A single keyword that indicates when an attribute and associated values are returned in response to a GET request or in response to a PUT, POST, or PATCH request."""
+
+    always = "always"  # cannot be excluded
+    """The attribute is always returned, regardless of the contents of the
+    "attributes" parameter.
+
+    For example, "id" is always returned to identify a SCIM resource.
+    """
+
+    never = "never"  # always excluded
+    """The attribute is never returned, regardless of the contents of the
+    "attributes" parameter."""
+
+    default = "default"  # included by default but can be excluded
+    """The attribute is returned by default in all SCIM operation responses
+    where attribute values are returned, unless it is explicitly excluded."""
+
+    request = "request"  # excluded by default but can be included
+    """The attribute is returned in response to any PUT, POST, or PATCH
+    operations if specified in the "attributes" parameter."""
+
+    _default = default
+
+
+class Uniqueness(str, Enum):
+    """A single keyword value that specifies how the service provider enforces uniqueness of attribute values."""
+
+    none = "none"
+    """The values are not intended to be unique in any way."""
+
+    server = "server"
+    """The value SHOULD be unique within the context of the current SCIM
+    endpoint (or tenancy) and MAY be globally unique (e.g., a "username", email
+    address, or other server-generated key or counter).
+
+    No two resources on the same server SHOULD possess the same value.
+    """
+
+    global_ = "global"
+    """The value SHOULD be globally unique (e.g., an email address, a GUID, or
+    other value).
+
+    No two resources on any server SHOULD possess the same value.
+    """
+
+    _default = none
+
+
+class Required(Enum):
+    """A Boolean value that specifies whether the attribute is required or not.
+
+    Missing required attributes raise a :class:`~pydantic.ValidationError` on :attr:`~scim2_models.Context.RESOURCE_CREATION_REQUEST` and :attr:`~scim2_models.Context.RESOURCE_REPLACEMENT_REQUEST` validations.
+    """
+
+    true = True
+    false = False
+
+    _default = false
+
+    def __bool__(self) -> bool:
+        return self.value
+
+
+class CaseExact(Enum):
+    """A Boolean value that specifies whether a string attribute is case- sensitive or not."""
+
+    true = True
+    false = False
+
+    _default = false
+
+    def __bool__(self) -> bool:
+        return self.value

scim2_models/attributes.py

@@ -0,0 +1,57 @@
+from inspect import isclass
+from typing import Annotated
+from typing import Any
+from typing import Optional
+from typing import get_origin
+
+from pydantic import Field
+
+from .annotations import Mutability
+
+# This import will work because we'll import this module after BaseModel is defined
+from .base import BaseModel
+from .reference import Reference
+
+
+class ComplexAttribute(BaseModel):
+    """A complex attribute as defined in :rfc:`RFC7643 §2.3.8 <7643#section-2.3.8>`."""
+
+    attribute_urn: Optional[str] = Field(None, exclude=True)
+
+    def get_attribute_urn(self, field_name: str) -> str:
+        """Build the full URN of the attribute.
+
+        See :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
+        """
+        alias = (
+            self.__class__.model_fields[field_name].serialization_alias or field_name
+        )
+        return f"{self.attribute_urn}.{alias}"
+
+
+class MultiValuedComplexAttribute(ComplexAttribute):
+    type: Optional[str] = None
+    """A label indicating the attribute's function."""
+
+    primary: Optional[bool] = None
+    """A Boolean value indicating the 'primary' or preferred attribute value
+    for this attribute."""
+
+    display: Annotated[Optional[str], Mutability.immutable] = None
+    """A human-readable name, primarily used for display purposes."""
+
+    value: Optional[Any] = None
+    """The value of an entitlement."""
+
+    ref: Optional[Reference] = Field(None, serialization_alias="$ref")
+    """The reference URI of a target resource, if the attribute is a
+    reference."""
+
+
+def is_complex_attribute(type_: type) -> bool:
+    # issubclass raise a TypeError with 'Reference' on python < 3.11
+    return (
+        get_origin(type_) != Reference
+        and isclass(type_)
+        and issubclass(type_, (ComplexAttribute, MultiValuedComplexAttribute))
+    )