maleo-identity 0.0.85__py3-none-any.whl → 0.1.24__py3-none-any.whl

maleo/identity/mixins/user_profile.py

@@ -1,88 +1,119 @@
 from pydantic import BaseModel, Field
-from typing import Optional
-from maleo.soma.mixins.parameter import Expand as BaseExpand
-from maleo.soma.types.base import OptionalDate, OptionalString
-from maleo.identity.enums.user_profile import ExpandableField
+from typing import Annotated, Generic, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.string import OptStrT
+from ..enums.user_profile import IdentifierType
+from ..types.user_profile import IdentifierValueType
 
 
-class Expand(BaseExpand[ExpandableField]):
-    pass
+class LeadingTitle(BaseModel, Generic[OptStrT]):
+    leading_title: Annotated[
+        OptStrT, Field(..., description="User's Leading Title", max_length=25)
+    ]
 
 
-class IdCard(BaseModel):
-    id_card: str = Field(..., max_length=16, description="User's ID Card")
+class FirstName(BaseModel, Generic[OptStrT]):
+    first_name: Annotated[
+        OptStrT, Field(..., description="User's First Name", max_length=50)
+    ]
 
 
-class OptionalIdCard(BaseModel):
-    id_card: OptionalString = Field(
-        None, max_length=16, description="Optional User's ID Card"
-    )
+class MiddleName(BaseModel, Generic[OptStrT]):
+    middle_name: Annotated[
+        OptStrT, Field(..., description="User's Middle Name", max_length=50)
+    ]
 
 
-class LeadingTitle(BaseModel):
-    leading_title: OptionalString = Field(
-        None, max_length=25, description="User's leading title"
-    )
+class LastName(BaseModel, Generic[OptStrT]):
+    last_name: Annotated[
+        OptStrT, Field(..., description="User's Last Name", max_length=50)
+    ]
 
 
-class FirstName(BaseModel):
-    first_name: str = Field(..., max_length=50, description="User's first name")
+class EndingTitle(BaseModel, Generic[OptStrT]):
+    ending_title: Annotated[
+        OptStrT, Field(..., description="User's Ending Title", max_length=25)
+    ]
 
 
-class MiddleName(BaseModel):
-    middle_name: OptionalString = Field(
-        None, max_length=50, description="User's middle name"
-    )
+class AvatarName(BaseModel, Generic[OptStrT]):
+    avatar_name: Annotated[OptStrT, Field(..., description="User's Avatar Name")]
 
 
-class LastName(BaseModel):
-    last_name: str = Field(..., max_length=50, description="User's last name")
+class AvatarUrl(BaseModel, Generic[OptStrT]):
+    avatar_url: Annotated[OptStrT, Field(..., description="User's Avatar URL")]
 
 
-class EndingTitle(BaseModel):
-    ending_title: OptionalString = Field(
-        None, max_length=25, description="User's ending title"
-    )
+class UserProfileIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def column_and_value(self) -> tuple[str, IdentifierValueType]:
+        return self.type.column, self.value
 
 
-class FullName(BaseModel):
-    full_name: str = Field(..., max_length=200, description="User's full name")
+class IdUserProfileIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
 
 
-class BirthPlace(BaseModel):
-    birth_place: OptionalString = Field(
-        None, max_length=50, description="User's birth place"
-    )
+class UserIdUserProfileIdentifier(Identifier[Literal[IdentifierType.USER_ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.USER_ID],
+        Field(IdentifierType.USER_ID, description="Identifier's type"),
+    ] = IdentifierType.USER_ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
 
 
-class BirthDate(BaseModel):
-    birth_date: OptionalDate = Field(None, description="User's birth date")
+class UUIDUserProfileIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
 
 
-class AvatarName(BaseModel):
-    avatar_name: str = Field(..., description="User's avatar's name")
+class IdCardUserProfileIdentifier(Identifier[Literal[IdentifierType.ID_CARD], str]):
+    type: Annotated[
+        Literal[IdentifierType.ID_CARD],
+        Field(IdentifierType.ID_CARD, description="Identifier's type"),
+    ] = IdentifierType.ID_CARD
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=16)]
 
 
-class OptionalAvatarUrl(BaseModel):
-    avatar_url: OptionalString = Field(None, description="Avatar's URL")
+AnyUserProfileIdentifier = (
+    UserProfileIdentifier
+    | IdUserProfileIdentifier
+    | UserIdUserProfileIdentifier
+    | UUIDUserProfileIdentifier
+    | IdCardUserProfileIdentifier
+)
 
 
-class OptionalAvatar(BaseModel):
-    avatar: Optional[bytes] = Field(None, description="Optional Avatar")
+def is_id_identifier(
+    identifier: AnyUserProfileIdentifier,
+) -> TypeGuard[IdUserProfileIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
 
 
-class OptionalAvatarName(BaseModel):
-    avatar_name: OptionalString = Field(None, description="Optional avatar's name")
+def is_user_id_identifier(
+    identifier: AnyUserProfileIdentifier,
+) -> TypeGuard[UserIdUserProfileIdentifier]:
+    return identifier.type is IdentifierType.USER_ID and isinstance(
+        identifier.value, int
+    )
 
 
-class OptionalAvatarContentType(BaseModel):
-    content_type: OptionalString = Field(
-        None, description="Optional avatar's content type"
-    )
+def is_uuid_identifier(
+    identifier: AnyUserProfileIdentifier,
+) -> TypeGuard[UUIDUserProfileIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
 
 
-class AvatarData(
-    OptionalAvatarContentType,
-    OptionalAvatar,
-):
-    pass
+def is_id_card_identifier(
+    identifier: AnyUserProfileIdentifier,
+) -> TypeGuard[IdCardUserProfileIdentifier]:
+    return identifier.type is IdentifierType.ID_CARD and isinstance(
+        identifier.value, str
+    )

maleo/identity/mixins/user_system_role.py

@@ -1,6 +1,74 @@
-from maleo.soma.mixins.parameter import Expand as BaseExpand
-from maleo.identity.enums.user_system_role import ExpandableField
+from pydantic import BaseModel, Field
+from typing import Annotated, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.any import ManyAny
+from maleo.types.string import ManyStrs
+from ..enums.user_system_role import IdentifierType, OptListOfExpandableFields
+from ..types.user_system_role import CompositeIdentifierType, IdentifierValueType
 
 
-class Expand(BaseExpand[ExpandableField]):
-    pass
+class Expand(BaseModel):
+    expand: Annotated[
+        OptListOfExpandableFields, Field(None, description="Expanded field(s)")
+    ] = None
+
+
+class UserSystemRoleIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def columns_and_values(self) -> tuple[ManyStrs, ManyAny]:
+        values = self.value if isinstance(self.value, tuple) else (self.value,)
+        return self.type.columns, values
+
+
+class IdUserSystemRoleIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDUserSystemRoleIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeUserSystemRoleIdentifier(
+    Identifier[Literal[IdentifierType.COMPOSITE], CompositeIdentifierType]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifierType, Field(..., description="Identifier's value")]
+
+
+AnyUserSystemRoleIdentifier = (
+    UserSystemRoleIdentifier
+    | IdUserSystemRoleIdentifier
+    | UUIDUserSystemRoleIdentifier
+    | CompositeUserSystemRoleIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyUserSystemRoleIdentifier,
+) -> TypeGuard[IdUserSystemRoleIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyUserSystemRoleIdentifier,
+) -> TypeGuard[UUIDUserSystemRoleIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyUserSystemRoleIdentifier,
+) -> TypeGuard[CompositeUserSystemRoleIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )

maleo/identity/schemas/api_key.py

@@ -0,0 +1,171 @@
+from pydantic import Field
+from typing import Annotated, Literal, overload
+from uuid import UUID
+from maleo.enums.status import (
+    ListOfDataStatuses,
+    FULL_DATA_STATUSES,
+)
+from maleo.schemas.mixins.filter import convert as convert_filter
+from maleo.schemas.mixins.identity import (
+    Ids,
+    UUIDs,
+    IntUserId,
+    IntUserIds,
+    IntOrganizationId,
+    IntOrganizationIds,
+)
+from maleo.schemas.mixins.sort import convert as convert_sort
+from maleo.schemas.parameter import (
+    ReadSingleParameter as BaseReadSingleParameter,
+    ReadPaginatedMultipleParameter,
+    DeleteSingleParameter as BaseDeleteSingleParameter,
+)
+from maleo.types.dict import StrToAnyDict
+from maleo.types.integer import OptInt, OptListOfInts
+from maleo.types.uuid import OptListOfUUIDs
+from ..enums.api_key import IdentifierType
+from ..mixins.api_key import APIKeyIdentifier
+from ..types.api_key import CompositeIdentifierType, IdentifierValueType
+
+
+class CreateParameter(
+    IntOrganizationId[OptInt],
+    IntUserId[int],
+):
+    pass
+
+
+class ReadMultipleParameter(
+    ReadPaginatedMultipleParameter,
+    IntOrganizationIds[OptListOfInts],
+    IntUserIds[OptListOfInts],
+    UUIDs[OptListOfUUIDs],
+    Ids[OptListOfInts],
+):
+    ids: Annotated[OptListOfInts, Field(None, description="Ids")] = None
+    uuids: Annotated[OptListOfUUIDs, Field(None, description="UUIDs")] = None
+    user_ids: Annotated[OptListOfInts, Field(None, description="User's IDs")] = None
+    organization_ids: Annotated[
+        OptListOfInts, Field(None, description="Organization's IDs")
+    ] = None
+
+    @property
+    def _query_param_fields(self) -> set[str]:
+        return {
+            "ids",
+            "uuids",
+            "statuses",
+            "user_ids",
+            "organization_ids",
+            "search",
+            "page",
+            "limit",
+            "use_cache",
+        }
+
+    def to_query_params(self) -> StrToAnyDict:
+        params = self.model_dump(
+            mode="json", include=self._query_param_fields, exclude_none=True
+        )
+        params["filters"] = convert_filter(self.date_filters)
+        params["sorts"] = convert_sort(self.sort_columns)
+        params = {k: v for k, v in params.items()}
+        return params
+
+
+class ReadSingleParameter(BaseReadSingleParameter[APIKeyIdentifier]):
+    @classmethod
+    def from_identifier(
+        cls,
+        identifier: APIKeyIdentifier,
+        statuses: ListOfDataStatuses = FULL_DATA_STATUSES,
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter":
+        return cls(identifier=identifier, statuses=statuses, use_cache=use_cache)
+
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.ID],
+        identifier_value: int,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.UUID],
+        identifier_value: UUID,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.COMPOSITE],
+        identifier_value: CompositeIdentifierType,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter":
+        return cls(
+            identifier=APIKeyIdentifier(type=identifier_type, value=identifier_value),
+            statuses=statuses,
+            use_cache=use_cache,
+        )
+
+    def to_query_params(self) -> StrToAnyDict:
+        return self.model_dump(
+            mode="json", include={"statuses", "use_cache"}, exclude_none=True
+        )
+
+
+class DeleteSingleParameter(BaseDeleteSingleParameter[APIKeyIdentifier]):
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: Literal[IdentifierType.ID], identifier_value: int
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: Literal[IdentifierType.UUID], identifier_value: UUID
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.COMPOSITE],
+        identifier_value: CompositeIdentifierType,
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: IdentifierType, identifier_value: IdentifierValueType
+    ) -> "DeleteSingleParameter": ...
+    @classmethod
+    def new(
+        cls, identifier_type: IdentifierType, identifier_value: IdentifierValueType
+    ) -> "DeleteSingleParameter":
+        return cls(
+            identifier=APIKeyIdentifier(type=identifier_type, value=identifier_value)
+        )