maleo-enums 0.0.28__py3-none-any.whl → 0.0.32__py3-none-any.whl

maleo/enums/medical.py

@@ -1,9 +1,10 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-from maleo.types.string import ListOfStrings
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
 
 
-class Role(StrEnum):
+class MedicalRole(StrEnum):
     # Level 1: Director category
     DIRECTOR = "director"
     PRESIDENT = "president"
@@ -72,48 +73,94 @@ class Role(StrEnum):
     NUTRITIONIST = "nutritionist"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-RoleT = TypeVar("RoleT", bound=Role)
-OptionalRole = Optional[Role]
-OptionalRoleT = TypeVar("OptionalRoleT", bound=OptionalRole)
-ListOfRoles = List[Role]
-ListOfRolesT = TypeVar("ListOfRolesT", bound=ListOfRoles)
-OptionalListOfRoles = Optional[ListOfRoles]
-OptionalListOfRolesT = TypeVar("OptionalListOfRolesT", bound=OptionalListOfRoles)
-SequenceOfRoles = Sequence[Role]
-SequenceOfRolesT = TypeVar("SequenceOfRolesT", bound=SequenceOfRoles)
-OptionalSequenceOfRoles = Optional[SequenceOfRoles]
-OptionalSequenceOfRolesT = TypeVar(
-    "OptionalSequenceOfRolesT", bound=OptionalSequenceOfRoles
-)
+MedicalRoleT = TypeVar("MedicalRoleT", bound=MedicalRole)
+OptMedicalRole = MedicalRole | None
+OptMedicalRoleT = TypeVar("OptMedicalRoleT", bound=OptMedicalRole)
+
+
+class SimpleMedicalRoleMixin(BaseModel, Generic[OptMedicalRoleT]):
+    role: Annotated[OptMedicalRoleT, Field(..., description="Medical Role")]
+
+
+class FullMedicalRoleMixin(BaseModel, Generic[OptMedicalRoleT]):
+    medical_role: Annotated[OptMedicalRoleT, Field(..., description="Medical Role")]
+
+
+ListOfMedicalRoles = list[MedicalRole]
+ListOfMedicalRolesT = TypeVar("ListOfMedicalRolesT", bound=ListOfMedicalRoles)
+OptListOfMedicalRoles = ListOfMedicalRoles | None
+OptListOfMedicalRolesT = TypeVar("OptListOfMedicalRolesT", bound=OptListOfMedicalRoles)
+
+
+class SimpleMedicalRolesMixin(BaseModel, Generic[OptListOfMedicalRolesT]):
+    roles: Annotated[OptListOfMedicalRolesT, Field(..., description="Medical Roles")]
+
+
+class FullMedicalRolesMixin(BaseModel, Generic[OptListOfMedicalRolesT]):
+    medical_roles: Annotated[
+        OptListOfMedicalRolesT, Field(..., description="Medical Roles")
+    ]
+
+
+SeqOfMedicalRoles = Sequence[MedicalRole]
+SeqOfMedicalRolesT = TypeVar("SeqOfMedicalRolesT", bound=SeqOfMedicalRoles)
+OptSeqOfMedicalRoles = SeqOfMedicalRoles | None
+OptSeqOfMedicalRolesT = TypeVar("OptSeqOfMedicalRolesT", bound=OptSeqOfMedicalRoles)
 
 
-class Service(StrEnum):
+class MedicalService(StrEnum):
     EMERGENCY = "emergency"
     INPATIENT = "inpatient"
     INTENSIVE = "intensive"
     OUTPATIENT = "outpatient"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ServiceT = TypeVar("ServiceT", bound=Service)
-OptionalService = Optional[Service]
-OptionalServiceT = TypeVar("OptionalServiceT", bound=OptionalService)
-ListOfServices = List[Service]
-ListOfServicesT = TypeVar("ListOfServicesT", bound=ListOfServices)
-OptionalListOfServices = Optional[ListOfServices]
-OptionalListOfServicesT = TypeVar(
-    "OptionalListOfServicesT", bound=OptionalListOfServices
+MedicalServiceT = TypeVar("MedicalServiceT", bound=MedicalService)
+OptMedicalService = MedicalService | None
+OptMedicalServiceT = TypeVar("OptMedicalServiceT", bound=OptMedicalService)
+
+
+class SimpleMedicalServiceMixin(BaseModel, Generic[OptMedicalServiceT]):
+    service: Annotated[OptMedicalServiceT, Field(..., description="Medical Service")]
+
+
+class FullMedicalServiceMixin(BaseModel, Generic[OptMedicalServiceT]):
+    medical_service: Annotated[
+        OptMedicalServiceT, Field(..., description="Medical Service")
+    ]
+
+
+ListOfMedicalServices = list[MedicalService]
+ListOfMedicalServicesT = TypeVar("ListOfMedicalServicesT", bound=ListOfMedicalServices)
+OptListOfMedicalServices = ListOfMedicalServices | None
+OptListOfMedicalServicesT = TypeVar(
+    "OptListOfMedicalServicesT", bound=OptListOfMedicalServices
 )
-SequenceOfServices = Sequence[Service]
-SequenceOfServicesT = TypeVar("SequenceOfServicesT", bound=SequenceOfServices)
-OptionalSequenceOfServices = Optional[SequenceOfServices]
-OptionalSequenceOfServicesT = TypeVar(
-    "OptionalSequenceOfServicesT", bound=OptionalSequenceOfServices
+
+
+class SimpleMedicalServicesMixin(BaseModel, Generic[OptListOfMedicalServicesT]):
+    services: Annotated[
+        OptListOfMedicalServicesT, Field(..., description="Medical Services")
+    ]
+
+
+class FullMedicalServicesMixin(BaseModel, Generic[OptListOfMedicalServicesT]):
+    medical_services: Annotated[
+        OptListOfMedicalServicesT, Field(..., description="Medical Services")
+    ]
+
+
+SeqOfMedicalServices = Sequence[MedicalService]
+SeqOfMedicalServicesT = TypeVar("SeqOfMedicalServicesT", bound=SeqOfMedicalServices)
+OptSeqOfMedicalServices = SeqOfMedicalServices | None
+OptSeqOfMedicalServicesT = TypeVar(
+    "OptSeqOfMedicalServicesT", bound=OptSeqOfMedicalServices
 )

maleo/enums/order.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-from maleo.types.string import ListOfStrings
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
 
 
 class Order(StrEnum):
@@ -8,20 +9,30 @@ class Order(StrEnum):
     DESC = "desc"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 OrderT = TypeVar("OrderT", bound=Order)
-OptionalOrder = Optional[Order]
-OptionalOrderT = TypeVar("OptionalOrderT", bound=OptionalOrder)
-ListOfOrders = List[Order]
+OptOrder = Order | None
+OptOrderT = TypeVar("OptOrderT", bound=OptOrder)
+
+
+class OrderMixin(BaseModel, Generic[OptOrderT]):
+    order: Annotated[OptOrderT, Field(..., description="Order")]
+
+
+ListOfOrders = list[Order]
 ListOfOrdersT = TypeVar("ListOfOrdersT", bound=ListOfOrders)
-OptionalListOfOrders = Optional[ListOfOrders]
-OptionalListOfOrdersT = TypeVar("OptionalListOfOrdersT", bound=OptionalListOfOrders)
-SequenceOfOrders = Sequence[Order]
-SequenceOfOrdersT = TypeVar("SequenceOfOrdersT", bound=SequenceOfOrders)
-OptionalSequenceOfOrders = Optional[SequenceOfOrders]
-OptionalSequenceOfOrdersT = TypeVar(
-    "OptionalSequenceOfOrdersT", bound=OptionalSequenceOfOrders
-)
+OptListOfOrders = ListOfOrders | None
+OptListOfOrdersT = TypeVar("OptListOfOrdersT", bound=OptListOfOrders)
+
+
+class OrdersMixin(BaseModel, Generic[OptListOfOrdersT]):
+    orders: Annotated[OptListOfOrdersT, Field(..., description="Orders")]
+
+
+SeqOfOrders = Sequence[Order]
+SeqOfOrdersT = TypeVar("SeqOfOrdersT", bound=SeqOfOrders)
+OptSeqOfOrders = SeqOfOrders | None
+OptSeqOfOrdersT = TypeVar("OptSeqOfOrdersT", bound=OptSeqOfOrders)

maleo/enums/organization.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-from maleo.types.string import ListOfStrings
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
 
 
 class OrganizationType(StrEnum):
@@ -17,7 +18,7 @@ class OrganizationType(StrEnum):
     INSURANCE_PROVIDER = "insurance_provider"
     INTERNAL = "internal"
     LABORATORY = "laboratory"
-    MEDICAL_GROUP = "medical_group"
+    MEDICAL_GROUP = "organization_group"
     NETWORK = "network"
     PARTNER = "partner"
     PHARMACY = "pharmacy"
@@ -32,34 +33,58 @@ class OrganizationType(StrEnum):
     VENDOR = "vendor"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 OrganizationTypeT = TypeVar("OrganizationTypeT", bound=OrganizationType)
-OptionalOrganizationType = Optional[OrganizationType]
-OptionalOrganizationTypeT = TypeVar(
-    "OptionalOrganizationTypeT", bound=OptionalOrganizationType
-)
-ListOfOrganizationTypes = List[OrganizationType]
+OptOrganizationType = OrganizationType | None
+OptOrganizationTypeT = TypeVar("OptOrganizationTypeT", bound=OptOrganizationType)
+
+
+class SimpleOrganizationTypeMixin(BaseModel, Generic[OptOrganizationTypeT]):
+    type: Annotated[OptOrganizationTypeT, Field(..., description="Organization Type")]
+
+
+class FullOrganizationTypeMixin(BaseModel, Generic[OptOrganizationTypeT]):
+    organization_type: Annotated[
+        OptOrganizationTypeT, Field(..., description="Organization Type")
+    ]
+
+
+ListOfOrganizationTypes = list[OrganizationType]
 ListOfOrganizationTypesT = TypeVar(
     "ListOfOrganizationTypesT", bound=ListOfOrganizationTypes
 )
-OptionalListOfOrganizationTypes = Optional[ListOfOrganizationTypes]
-OptionalListOfOrganizationTypesT = TypeVar(
-    "OptionalListOfOrganizationTypesT", bound=OptionalListOfOrganizationTypes
+OptListOfOrganizationTypes = ListOfOrganizationTypes | None
+OptListOfOrganizationTypesT = TypeVar(
+    "OptListOfOrganizationTypesT", bound=OptListOfOrganizationTypes
 )
-SequenceOfOrganizationTypes = Sequence[OrganizationType]
-SequenceOfOrganizationTypesT = TypeVar(
-    "SequenceOfOrganizationTypesT", bound=SequenceOfOrganizationTypes
+
+
+class SimpleOrganizationTypesMixin(BaseModel, Generic[OptListOfOrganizationTypesT]):
+    types: Annotated[
+        OptListOfOrganizationTypesT, Field(..., description="Organization Types")
+    ]
+
+
+class FullOrganizationTypesMixin(BaseModel, Generic[OptListOfOrganizationTypesT]):
+    organization_types: Annotated[
+        OptListOfOrganizationTypesT, Field(..., description="Organization Types")
+    ]
+
+
+SeqOfOrganizationTypes = Sequence[OrganizationType]
+SeqOfOrganizationTypesT = TypeVar(
+    "SeqOfOrganizationTypesT", bound=SeqOfOrganizationTypes
 )
-OptionalSequenceOfOrganizationTypes = Optional[SequenceOfOrganizationTypes]
-OptionalSequenceOfOrganizationTypesT = TypeVar(
-    "OptionalSequenceOfOrganizationTypesT", bound=OptionalSequenceOfOrganizationTypes
+OptSeqOfOrganizationTypes = SeqOfOrganizationTypes | None
+OptSeqOfOrganizationTypesT = TypeVar(
+    "OptSeqOfOrganizationTypesT", bound=OptSeqOfOrganizationTypes
 )
 
 
-class Relation(StrEnum):
+class OrganizationRelation(StrEnum):
     AFFILIATE = "affiliate"
     APPLICATION = "application"
     BRANCH = "branch"
@@ -73,47 +98,119 @@ class Relation(StrEnum):
     VENDOR = "vendor"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-RelationT = TypeVar("RelationT", bound=Relation)
-OptionalRelation = Optional[Relation]
-OptionalRelationT = TypeVar("OptionalRelationT", bound=OptionalRelation)
-ListOfRelations = List[Relation]
-ListOfRelationsT = TypeVar("ListOfRelationsT", bound=ListOfRelations)
-OptionalListOfRelations = Optional[ListOfRelations]
-OptionalListOfRelationsT = TypeVar(
-    "OptionalListOfRelationsT", bound=OptionalListOfRelations
+OrganizationRelationT = TypeVar("OrganizationRelationT", bound=OrganizationRelation)
+OptOrganizationRelation = OrganizationRelation | None
+OptOrganizationRelationT = TypeVar(
+    "OptOrganizationRelationT", bound=OptOrganizationRelation
 )
-SequenceOfRelations = Sequence[Relation]
-SequenceOfRelationsT = TypeVar("SequenceOfRelationsT", bound=SequenceOfRelations)
-OptionalSequenceOfRelations = Optional[SequenceOfRelations]
-OptionalSequenceOfRelationsT = TypeVar(
-    "OptionalSequenceOfRelationsT", bound=OptionalSequenceOfRelations
+
+
+class SimpleOrganizationRelationMixin(BaseModel, Generic[OptOrganizationRelationT]):
+    relation: Annotated[
+        OptOrganizationRelationT, Field(..., description="Organization Relation")
+    ]
+
+
+class FullOrganizationRelationMixin(BaseModel, Generic[OptOrganizationRelationT]):
+    organization_relation: Annotated[
+        OptOrganizationRelationT, Field(..., description="Organization Relation")
+    ]
+
+
+ListOfOrganizationRelations = list[OrganizationRelation]
+ListOfOrganizationRelationsT = TypeVar(
+    "ListOfOrganizationRelationsT", bound=ListOfOrganizationRelations
+)
+OptListOfOrganizationRelations = ListOfOrganizationRelations | None
+OptListOfOrganizationRelationsT = TypeVar(
+    "OptListOfOrganizationRelationsT", bound=OptListOfOrganizationRelations
 )
 
 
-class Role(StrEnum):
+class SimpleOrganizationRelationsMixin(
+    BaseModel, Generic[OptListOfOrganizationRelationsT]
+):
+    relations: Annotated[
+        OptListOfOrganizationRelationsT,
+        Field(..., description="Organization Relations"),
+    ]
+
+
+class FullOrganizationRelationsMixin(
+    BaseModel, Generic[OptListOfOrganizationRelationsT]
+):
+    organization_relations: Annotated[
+        OptListOfOrganizationRelationsT,
+        Field(..., description="Organization Relations"),
+    ]
+
+
+SeqOfOrganizationRelations = Sequence[OrganizationRelation]
+SeqOfOrganizationRelationsT = TypeVar(
+    "SeqOfOrganizationRelationsT", bound=SeqOfOrganizationRelations
+)
+OptSeqOfOrganizationRelations = SeqOfOrganizationRelations | None
+OptSeqOfOrganizationRelationsT = TypeVar(
+    "OptSeqOfOrganizationRelationsT", bound=OptSeqOfOrganizationRelations
+)
+
+
+class OrganizationRole(StrEnum):
     OWNER = "owner"
     ADMINISTRATOR = "administrator"
     USER = "user"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-RoleT = TypeVar("RoleT", bound=Role)
-OptionalRole = Optional[Role]
-OptionalRoleT = TypeVar("OptionalRoleT", bound=OptionalRole)
-ListOfRoles = List[Role]
-ListOfRolesT = TypeVar("ListOfRolesT", bound=ListOfRoles)
-OptionalListOfRoles = Optional[ListOfRoles]
-OptionalListOfRolesT = TypeVar("OptionalListOfRolesT", bound=OptionalListOfRoles)
-SequenceOfRoles = Sequence[Role]
-SequenceOfRolesT = TypeVar("SequenceOfRolesT", bound=SequenceOfRoles)
-OptionalSequenceOfRoles = Optional[SequenceOfRoles]
-OptionalSequenceOfRolesT = TypeVar(
-    "OptionalSequenceOfRolesT", bound=OptionalSequenceOfRoles
+OrganizationRoleT = TypeVar("OrganizationRoleT", bound=OrganizationRole)
+OptOrganizationRole = OrganizationRole | None
+OptOrganizationRoleT = TypeVar("OptOrganizationRoleT", bound=OptOrganizationRole)
+
+
+class SimpleOrganizationRoleMixin(BaseModel, Generic[OptOrganizationRoleT]):
+    role: Annotated[OptOrganizationRoleT, Field(..., description="Organization Role")]
+
+
+class FullOrganizationRoleMixin(BaseModel, Generic[OptOrganizationRoleT]):
+    organization_role: Annotated[
+        OptOrganizationRoleT, Field(..., description="Organization Role")
+    ]
+
+
+ListOfOrganizationRoles = list[OrganizationRole]
+ListOfOrganizationRolesT = TypeVar(
+    "ListOfOrganizationRolesT", bound=ListOfOrganizationRoles
+)
+OptListOfOrganizationRoles = ListOfOrganizationRoles | None
+OptListOfOrganizationRolesT = TypeVar(
+    "OptListOfOrganizationRolesT", bound=OptListOfOrganizationRoles
+)
+
+
+class SimpleOrganizationRolesMixin(BaseModel, Generic[OptListOfOrganizationRolesT]):
+    roles: Annotated[
+        OptListOfOrganizationRolesT, Field(..., description="Organization Roles")
+    ]
+
+
+class FullOrganizationRolesMixin(BaseModel, Generic[OptListOfOrganizationRolesT]):
+    organization_roles: Annotated[
+        OptListOfOrganizationRolesT, Field(..., description="Organization Roles")
+    ]
+
+
+SeqOfOrganizationRoles = Sequence[OrganizationRole]
+SeqOfOrganizationRolesT = TypeVar(
+    "SeqOfOrganizationRolesT", bound=SeqOfOrganizationRoles
+)
+OptSeqOfOrganizationRoles = SeqOfOrganizationRoles | None
+OptSeqOfOrganizationRolesT = TypeVar(
+    "OptSeqOfOrganizationRolesT", bound=OptSeqOfOrganizationRoles
 )