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

maleo/identity/constants/api_key.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+API_KEY_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="api_key",
+            name="API Key",
+            slug="api-keys",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/organization.py

@@ -1,17 +1,10 @@
-from typing import Callable, Dict
-from uuid import UUID
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.organization import IdentifierType
-from maleo.identity.types.base.organization import IdentifierValueType
+from maleo.schemas.resource import Resource, ResourceIdentifier
 
-IDENTIFIER_TYPE_VALUE_TYPE_MAP: Dict[
-    IdentifierType, Callable[..., IdentifierValueType]
-] = {IdentifierType.ID: int, IdentifierType.UUID: UUID, IdentifierType.KEY: str}
 
-RESOURCE = Resource(
+ORGANIZATION_RESOURCE = Resource(
     identifiers=[
         ResourceIdentifier(
-            key="organizations", name="Organizations", url_slug="organizations"
+            key="organization", name="Organization", slug="organizations"
         )
     ],
     details=None,

maleo/identity/constants/organization_registration_code.py

@@ -1,24 +1,12 @@
-from typing import Callable, Dict
-from uuid import UUID
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.organization_registration_code import IdentifierType
-from maleo.identity.types.base.organization_registration_code import IdentifierValueType
+from maleo.schemas.resource import Resource, ResourceIdentifier
 
-IDENTIFIER_TYPE_VALUE_TYPE_MAP: Dict[
-    IdentifierType, Callable[..., IdentifierValueType]
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.ORGANIZATION_ID: int,
-    IdentifierType.CODE: UUID,
-}
 
-RESOURCE = Resource(
+ORGANIZATION_REGISTRATION_CODE_RESOURCE = Resource(
     identifiers=[
         ResourceIdentifier(
-            key="organization_registration_codes",
-            name="Organization Registration Codes",
-            url_slug="organization-registration-codes",
+            key="organization_registration_code",
+            name="Organization Registration Code",
+            slug="organization-registration-codes",
         )
     ],
     details=None,

maleo/identity/constants/organization_relation.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+ORGANIZATION_RELATION_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="organization_relation",
+            name="Organization Relation",
+            slug="organization-relations",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/patient.py

@@ -0,0 +1,7 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+PATIENT_RESOURCE = Resource(
+    identifiers=[ResourceIdentifier(key="patient", name="Patient", slug="patients")],
+    details=None,
+)

maleo/identity/constants/user.py

@@ -1,24 +1,7 @@
-from typing import Callable, Dict, List
-from uuid import UUID
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.user import IdentifierType, ExpandableField
-from maleo.identity.types.base.user import IdentifierValueType
+from maleo.schemas.resource import Resource, ResourceIdentifier
 
-IDENTIFIER_TYPE_VALUE_TYPE_MAP: Dict[
-    IdentifierType, Callable[..., IdentifierValueType]
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.USERNAME: str,
-    IdentifierType.EMAIL: str,
-}
 
-EXPANDABLE_FIELDS_DEPENDENCIES_MAP: Dict[ExpandableField, List[ExpandableField]] = {
-    ExpandableField.PROFILE: [ExpandableField.GENDER, ExpandableField.BLOOD_TYPE],
-    ExpandableField.SYSTEM_ROLES: [ExpandableField.SYSTEM_ROLE_DETAILS],
-}
-
-RESOURCE = Resource(
-    identifiers=[ResourceIdentifier(key="users", name="Users", url_slug="users")],
+USER_RESOURCE = Resource(
+    identifiers=[ResourceIdentifier(key="user", name="User", slug="users")],
     details=None,
 )

maleo/identity/constants/user_medical_role.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+USER_MEDICAL_ROLE_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="user_medical_role",
+            name="User Medical Role",
+            slug="user-medical-roles",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/user_organization_role.py

@@ -1,46 +1,12 @@
-from typing import Dict, List
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.user import ExpandableField as UserExpandableField
-from maleo.identity.enums.organization import (
-    ExpandableField as OrganizationExpandableField,
-)
-from maleo.identity.enums.user_organization_role import (
-    ExpandableField as UserOrganizationRoleExpandableField,
-)
-
-EXPANDABLE_FIELDS_DEPENDENCIES_MAP: Dict[
-    UserOrganizationRoleExpandableField, List[UserOrganizationRoleExpandableField]
-] = {
-    UserOrganizationRoleExpandableField.USER: [
-        UserOrganizationRoleExpandableField.USER_TYPE,
-        UserOrganizationRoleExpandableField.PROFILE,
-    ],
-    UserOrganizationRoleExpandableField.ORGANIZATION: [
-        UserOrganizationRoleExpandableField.ORGANIZATION_TYPE,
-        UserOrganizationRoleExpandableField.REGISTRATION_CODE,
-    ],
-}
-
-USER_EXPANDABLE_FIELDS_MAP: Dict[
-    UserOrganizationRoleExpandableField, UserExpandableField
-] = {
-    UserOrganizationRoleExpandableField.USER_TYPE: UserExpandableField.USER_TYPE,
-    UserOrganizationRoleExpandableField.PROFILE: UserExpandableField.PROFILE,
-}
+from maleo.schemas.resource import Resource, ResourceIdentifier
 
-ORGANIZATION_EXPANDABLE_FIELDS_MAP: Dict[
-    UserOrganizationRoleExpandableField, OrganizationExpandableField
-] = {
-    UserOrganizationRoleExpandableField.ORGANIZATION_TYPE: OrganizationExpandableField.ORGANIZATION_TYPE,
-    UserOrganizationRoleExpandableField.REGISTRATION_CODE: OrganizationExpandableField.REGISTRATION_CODE,
-}
 
-RESOURCE = Resource(
+USER_ORGANIZATION_ROLE_RESOURCE = Resource(
     identifiers=[
         ResourceIdentifier(
-            key="user_organization_roles",
-            name="UserOrganization Roles",
-            url_slug="user-organization-roles",
+            key="user_organization_role",
+            name="User Organization Role",
+            slug="user-organization-roles",
         )
     ],
     details=None,

maleo/identity/constants/user_profile.py

@@ -1,28 +1,10 @@
-from typing import Callable, Dict
-from uuid import UUID
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.user_profile import IdentifierType, ValidImageMimeType
-from maleo.identity.types.base.user_profile import IdentifierValueType
+from maleo.schemas.resource import Resource, ResourceIdentifier
 
-IDENTIFIER_TYPE_VALUE_TYPE_MAP: Dict[
-    IdentifierType, Callable[..., IdentifierValueType]
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.USER_ID: int,
-    IdentifierType.ID_CARD: str,
-}
 
-MIME_TYPE_EXTENSION_MAP: Dict[ValidImageMimeType, str] = {
-    ValidImageMimeType.JPEG: ".jpeg",
-    ValidImageMimeType.JPG: ".jpg",
-    ValidImageMimeType.PNG: ".png",
-}
-
-RESOURCE = Resource(
+USER_PROFILE_RESOURCE = Resource(
     identifiers=[
         ResourceIdentifier(
-            key="user_profiles", name="User Profiles", url_slug="user-profiles"
+            key="user_profile", name="User Profile", slug="user-profiles"
         )
     ],
     details=None,

maleo/identity/constants/user_system_role.py

@@ -1,16 +1,17 @@
-from typing import Dict, List
-from maleo.soma.schemas.resource import Resource, ResourceIdentifier
-from maleo.identity.enums.user_system_role import ExpandableField
+from maleo.schemas.resource import Resource, ResourceIdentifier
+from maleo.types.string import DoubleStrs
 
-EXPANDABLE_FIELDS_DEPENDENCIES_MAP: Dict[ExpandableField, List[ExpandableField]] = {}
 
-RESOURCE = Resource(
+USER_SYSTEM_ROLE_RESOURCE = Resource(
     identifiers=[
         ResourceIdentifier(
-            key="user_system_roles",
-            name="User System Roles",
-            url_slug="user-system-roles",
+            key="user_system_role",
+            name="User System Role",
+            slug="user-system-roles",
         )
     ],
     details=None,
 )
+
+
+COMPOSITE_COLUMS: DoubleStrs = ("user_id", "system_role")

maleo/identity/enums/api_key.py

@@ -0,0 +1,25 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs, ManyStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    API_KEY = "api_key"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def columns(self) -> ManyStrs:
+        if self is IdentifierType.ID:
+            return ("id",)
+        elif self is IdentifierType.UUID:
+            return ("uuid",)
+        elif self is IdentifierType.API_KEY:
+            return ("api_key",)
+        elif self is IdentifierType.COMPOSITE:
+            return ("user_id", "organization_id")
+        raise ValueError(f"Unknown column(s) for identifier type: {self}")

maleo/identity/enums/organization.py

@@ -1,4 +1,14 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class Granularity(StrEnum):
+    STANDARD = "standard"
+    FULL = "full"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
 
 
 class IdentifierType(StrEnum):
@@ -6,7 +16,10 @@ class IdentifierType(StrEnum):
     UUID = "uuid"
     KEY = "key"
 
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
 
-class ExpandableField(StrEnum):
-    ORGANIZATION_TYPE = "organization_type"
-    REGISTRATION_CODE = "registration_code"
+    @property
+    def column(self) -> str:
+        return self.value

maleo/identity/enums/organization_registration_code.py

@@ -1,4 +1,5 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs
 
 
 class IdentifierType(StrEnum):
@@ -6,3 +7,11 @@ class IdentifierType(StrEnum):
     UUID = "uuid"
     ORGANIZATION_ID = "organization_id"
     CODE = "code"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def column(self) -> str:
+        return self.value

maleo/identity/enums/organization_relation.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs, ManyStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def columns(self) -> ManyStrs:
+        if self is IdentifierType.ID:
+            return ("id",)
+        elif self is IdentifierType.UUID:
+            return ("uuid",)
+        elif self is IdentifierType.COMPOSITE:
+            return ("source_id", "target_id", "relation")
+        raise ValueError(f"Unknown column(s) for identifier type: {self}")

maleo/identity/enums/patient.py

@@ -0,0 +1,29 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def column(self) -> str:
+        return self.value
+
+
+class ExpandableField(StrEnum):
+    GENDER = "gender"
+    BLOOD_TYPE = "blood_type"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+OptExpandableField = ExpandableField | None
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/enums/user.py

@@ -1,4 +1,14 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class Granularity(StrEnum):
+    STANDARD = "standard"
+    FULL = "full"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
 
 
 class IdentifierType(StrEnum):
@@ -7,11 +17,10 @@ class IdentifierType(StrEnum):
     USERNAME = "username"
     EMAIL = "email"
 
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
 
-class ExpandableField(StrEnum):
-    USER_TYPE = "user_type"
-    SYSTEM_ROLES = "system_roles"
-    SYSTEM_ROLE_DETAILS = "system_roles.system_role_details"
-    PROFILE = "profile"
-    GENDER = "profile.gender"
-    BLOOD_TYPE = "profile.blood_type"
+    @property
+    def column(self) -> str:
+        return self.value

maleo/identity/enums/user_medical_role.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs, ManyStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def columns(self) -> ManyStrs:
+        if self is IdentifierType.ID:
+            return ("id",)
+        elif self is IdentifierType.UUID:
+            return ("uuid",)
+        elif self is IdentifierType.COMPOSITE:
+            return ("user_id", "organization_id", "medical_role")
+        raise ValueError(f"Unknown column(s) for identifier type: {self}")

maleo/identity/enums/user_organization_role.py

@@ -1,15 +1,22 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs, ManyStrs
 
 
-class ExpandableField(StrEnum):
-    USER = "user"
-    USER_TYPE = "user.user_type"
-    SYSTEM_ROLES = "system_roles"
-    SYSTEM_ROLE_DETAILS = "system_roles.system_role_details"
-    PROFILE = "user.profile"
-    GENDER = "profile.gender"
-    BLOOD_TYPE = "profile.blood_type"
-    ORGANIZATION = "organization"
-    ORGANIZATION_TYPE = "organization.organization_type"
-    REGISTRATION_CODE = "organization.registration_code"
-    USER_ORGANIZATION = "user_organization"
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def columns(self) -> ManyStrs:
+        if self is IdentifierType.ID:
+            return ("id",)
+        elif self is IdentifierType.UUID:
+            return ("uuid",)
+        elif self is IdentifierType.COMPOSITE:
+            return ("user_id", "organization_id", "organization_role")
+        raise ValueError(f"Unknown column(s) for identifier type: {self}")

maleo/identity/enums/user_profile.py

@@ -1,4 +1,5 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs
 
 
 class IdentifierType(StrEnum):
@@ -7,13 +8,10 @@ class IdentifierType(StrEnum):
     USER_ID = "user_id"
     ID_CARD = "id_card"
 
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
 
-class ValidImageMimeType(StrEnum):
-    JPEG = "image/jpeg"
-    JPG = "image/jpg"
-    PNG = "image/png"
-
-
-class ExpandableField(StrEnum):
-    GENDER = "gender"
-    BLOOD_TYPE = "blood_type"
+    @property
+    def column(self) -> str:
+        return self.value

maleo/identity/enums/user_system_role.py

@@ -1,5 +1,35 @@
 from enum import StrEnum
+from maleo.types.string import ListOfStrs, ManyStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+    @property
+    def columns(self) -> ManyStrs:
+        if self is IdentifierType.ID:
+            return ("id",)
+        elif self is IdentifierType.UUID:
+            return ("uuid",)
+        elif self is IdentifierType.COMPOSITE:
+            return ("user_id", "system_role")
+        raise ValueError(f"Unknown column(s) for identifier type: {self}")
 
 
 class ExpandableField(StrEnum):
     SYSTEM_ROLE = "system_role"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+OptExpandableField = ExpandableField | None
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/mixins/api_key.py

@@ -0,0 +1,72 @@
+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.api_key import IdentifierType
+from ..types.api_key import CompositeIdentifierType, IdentifierValueType
+
+
+class APIKey(BaseModel):
+    api_key: Annotated[str, Field(..., description="API Key", max_length=255)]
+
+
+class APIKeyIdentifier(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 IdAPIKeyIdentifier(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 UUIDAPIKeyIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeAPIKeyIdentifier(
+    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")]
+
+
+AnyAPIKeyIdentifier = (
+    APIKeyIdentifier
+    | IdAPIKeyIdentifier
+    | UUIDAPIKeyIdentifier
+    | CompositeAPIKeyIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[IdAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[UUIDAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[CompositeAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )

maleo/identity/mixins/common.py

@@ -0,0 +1,29 @@
+from pydantic import Field
+from typing import Annotated, Generic
+from maleo.schemas.mixins.identity import (
+    IdCard as BaseIdCard,
+    FullName as BaseFullName,
+    BirthPlace as BaseBirthPlace,
+    PlaceOfBirth as BasePlaceOfBirth,
+)
+from maleo.types.string import OptStrT
+
+
+class IdCard(BaseIdCard[OptStrT], Generic[OptStrT]):
+    id_card: Annotated[OptStrT, Field(..., description="Id Card", max_length=16)]
+
+
+class FullName(BaseFullName[OptStrT], Generic[OptStrT]):
+    full_name: Annotated[OptStrT, Field(..., description="Full Name", max_length=200)]
+
+
+class BirthPlace(BaseBirthPlace[OptStrT], Generic[OptStrT]):
+    birth_place: Annotated[
+        OptStrT, Field(..., description="Birth Place", max_length=50)
+    ]
+
+
+class PlaceOfBirth(BasePlaceOfBirth[OptStrT], Generic[OptStrT]):
+    place_of_birth: Annotated[
+        OptStrT, Field(..., description="Place of Birth", max_length=50)
+    ]