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

maleo/enums/service.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 ServiceType(StrEnum):
@@ -8,56 +9,102 @@ class ServiceType(StrEnum):
     FRONTEND = "frontend"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 ServiceTypeT = TypeVar("ServiceTypeT", bound=ServiceType)
-OptionalServiceType = Optional[ServiceType]
-OptionalServiceTypeT = TypeVar("OptionalServiceTypeT", bound=OptionalServiceType)
-ListOfServiceTypes = List[ServiceType]
+OptServiceType = ServiceType | None
+OptServiceTypeT = TypeVar("OptServiceTypeT", bound=OptServiceType)
+
+
+class SimpleServiceTypeMixin(BaseModel, Generic[OptServiceTypeT]):
+    type: Annotated[OptServiceTypeT, Field(..., description="Service Type")]
+
+
+class FullServiceTypeMixin(BaseModel, Generic[OptServiceTypeT]):
+    service_type: Annotated[OptServiceTypeT, Field(..., description="Service Type")]
+
+
+ListOfServiceTypes = list[ServiceType]
 ListOfServiceTypesT = TypeVar("ListOfServiceTypesT", bound=ListOfServiceTypes)
-OptionalListOfServiceTypes = Optional[ListOfServiceTypes]
-OptionalListOfServiceTypesT = TypeVar(
-    "OptionalListOfServiceTypesT", bound=OptionalListOfServiceTypes
-)
-SequenceOfServiceTypes = Sequence[ServiceType]
-SequenceOfServiceTypesT = TypeVar(
-    "SequenceOfServiceTypesT", bound=SequenceOfServiceTypes
-)
-OptionalSequenceOfServiceTypes = Optional[SequenceOfServiceTypes]
-OptionalSequenceOfServiceTypesT = TypeVar(
-    "OptionalSequenceOfServiceTypesT", bound=OptionalSequenceOfServiceTypes
-)
+OptListOfServiceTypes = ListOfServiceTypes | None
+OptListOfServiceTypesT = TypeVar("OptListOfServiceTypesT", bound=OptListOfServiceTypes)
+
+
+class SimpleServiceTypesMixin(BaseModel, Generic[OptListOfServiceTypesT]):
+    types: Annotated[OptListOfServiceTypesT, Field(..., description="Service Types")]
 
 
-class Category(StrEnum):
+class FullServiceTypesMixin(BaseModel, Generic[OptListOfServiceTypesT]):
+    service_types: Annotated[
+        OptListOfServiceTypesT, Field(..., description="Service Types")
+    ]
+
+
+SeqOfServiceTypes = Sequence[ServiceType]
+SeqOfServiceTypesT = TypeVar("SeqOfServiceTypesT", bound=SeqOfServiceTypes)
+OptSeqOfServiceTypes = SeqOfServiceTypes | None
+OptSeqOfServiceTypesT = TypeVar("OptSeqOfServiceTypesT", bound=OptSeqOfServiceTypes)
+
+
+class ServiceCategory(StrEnum):
     CORE = "core"
     AI = "ai"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-CategoryT = TypeVar("CategoryT", bound=Category)
-OptionalCategory = Optional[Category]
-OptionalCategoryT = TypeVar("OptionalCategoryT", bound=OptionalCategory)
-ListOfCategories = List[Category]
-ListOfCategoriesT = TypeVar("ListOfCategoriesT", bound=ListOfCategories)
-OptionalListOfCategories = Optional[ListOfCategories]
-OptionalListOfCategoriesT = TypeVar(
-    "OptionalListOfCategoriesT", bound=OptionalListOfCategories
+ServiceCategoryT = TypeVar("ServiceCategoryT", bound=ServiceCategory)
+OptServiceCategory = ServiceCategory | None
+OptServiceCategoryT = TypeVar("OptServiceCategoryT", bound=OptServiceCategory)
+
+
+class SimpleServiceCategoryMixin(BaseModel, Generic[OptServiceCategoryT]):
+    category: Annotated[OptServiceCategoryT, Field(..., description="Service Category")]
+
+
+class FullServiceCategoryMixin(BaseModel, Generic[OptServiceCategoryT]):
+    service_category: Annotated[
+        OptServiceCategoryT, Field(..., description="Service Category")
+    ]
+
+
+ListOfServiceCategories = list[ServiceCategory]
+ListOfServiceCategoriesT = TypeVar(
+    "ListOfServiceCategoriesT", bound=ListOfServiceCategories
 )
-SequenceOfCategories = Sequence[Category]
-SequenceOfCategoriesT = TypeVar("SequenceOfCategoriesT", bound=SequenceOfCategories)
-OptionalSequenceOfCategories = Optional[SequenceOfCategories]
-OptionalSequenceOfCategoriesT = TypeVar(
-    "OptionalSequenceOfCategoriesT", bound=OptionalSequenceOfCategories
+OptListOfServiceCategories = ListOfServiceCategories | None
+OptListOfServiceCategoriesT = TypeVar(
+    "OptListOfServiceCategoriesT", bound=OptListOfServiceCategories
 )
 
 
-class ShortKey(StrEnum):
+class SimpleServiceCategoriesMixin(BaseModel, Generic[OptListOfServiceCategoriesT]):
+    categories: Annotated[
+        OptListOfServiceCategoriesT, Field(..., description="Service Categories")
+    ]
+
+
+class FullServiceCategoriesMixin(BaseModel, Generic[OptListOfServiceCategoriesT]):
+    service_categories: Annotated[
+        OptListOfServiceCategoriesT, Field(..., description="Service Categories")
+    ]
+
+
+SeqOfServiceCategories = Sequence[ServiceCategory]
+SeqOfServiceCategoriesT = TypeVar(
+    "SeqOfServiceCategoriesT", bound=SeqOfServiceCategories
+)
+OptSeqOfServiceCategories = SeqOfServiceCategories | None
+OptSeqOfServiceCategoriesT = TypeVar(
+    "OptSeqOfServiceCategoriesT", bound=OptSeqOfServiceCategories
+)
+
+
+class ShortServiceKey(StrEnum):
     STUDIO = "studio"
     NEXUS = "nexus"
     TELEMETRY = "telemetry"
@@ -76,28 +123,52 @@ class ShortKey(StrEnum):
     MCU = "mcu"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ShortKeyT = TypeVar("ShortKeyT", bound=ShortKey)
-OptionalShortKey = Optional[ShortKey]
-OptionalShortKeyT = TypeVar("OptionalShortKeyT", bound=OptionalShortKey)
-ListOfShortKeys = List[ShortKey]
-ListOfShortKeysT = TypeVar("ListOfShortKeysT", bound=ListOfShortKeys)
-OptionalListOfShortKeys = Optional[ListOfShortKeys]
-OptionalListOfShortKeysT = TypeVar(
-    "OptionalListOfShortKeysT", bound=OptionalListOfShortKeys
+ShortServiceKeyT = TypeVar("ShortServiceKeyT", bound=ShortServiceKey)
+OptShortServiceKey = ShortServiceKey | None
+OptShortServiceKeyT = TypeVar("OptShortServiceKeyT", bound=OptShortServiceKey)
+
+
+class SimpleShortServiceKeyMixin(BaseModel, Generic[OptShortServiceKeyT]):
+    key: Annotated[OptShortServiceKeyT, Field(..., description="Service Key")]
+
+
+class FullShortServiceKeyMixin(BaseModel, Generic[OptShortServiceKeyT]):
+    service_key: Annotated[OptShortServiceKeyT, Field(..., description="Service Key")]
+
+
+ListOfShortServiceKeys = list[ShortServiceKey]
+ListOfShortServiceKeysT = TypeVar(
+    "ListOfShortServiceKeysT", bound=ListOfShortServiceKeys
+)
+OptListOfShortServiceKeys = ListOfShortServiceKeys | None
+OptListOfShortServiceKeysT = TypeVar(
+    "OptListOfShortServiceKeysT", bound=OptListOfShortServiceKeys
 )
-SequenceOfShortKeys = Sequence[ShortKey]
-SequenceOfShortKeysT = TypeVar("SequenceOfShortKeysT", bound=SequenceOfShortKeys)
-OptionalSequenceOfShortKeys = Optional[SequenceOfShortKeys]
-OptionalSequenceOfShortKeysT = TypeVar(
-    "OptionalSequenceOfShortKeysT", bound=OptionalSequenceOfShortKeys
+
+
+class SimpleShortServiceKeysMixin(BaseModel, Generic[OptListOfShortServiceKeysT]):
+    keys: Annotated[OptListOfShortServiceKeysT, Field(..., description="Service Keys")]
+
+
+class FullShortServiceKeysMixin(BaseModel, Generic[OptListOfShortServiceKeysT]):
+    service_keys: Annotated[
+        OptListOfShortServiceKeysT, Field(..., description="Service Keys")
+    ]
+
+
+SeqOfShortServiceKeys = Sequence[ShortServiceKey]
+SeqOfShortServiceKeysT = TypeVar("SeqOfShortServiceKeysT", bound=SeqOfShortServiceKeys)
+OptSeqOfShortServiceKeys = SeqOfShortServiceKeys | None
+OptSeqOfShortServiceKeysT = TypeVar(
+    "OptSeqOfShortServiceKeysT", bound=OptSeqOfShortServiceKeys
 )
 
 
-class Key(StrEnum):
+class ServiceKey(StrEnum):
     STUDIO = "maleo-studio"
     NEXUS = "maleo-nexus"
     TELEMETRY = "maleo-telemetry"
@@ -116,26 +187,46 @@ class Key(StrEnum):
     MCU = "maleo-mcu"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-KeyT = TypeVar("KeyT", bound=Key)
-OptionalKey = Optional[Key]
-OptionalKeyT = TypeVar("OptionalKeyT", bound=OptionalKey)
-ListOfKeys = List[Key]
-ListOfKeysT = TypeVar("ListOfKeysT", bound=ListOfKeys)
-OptionalListOfKeys = Optional[ListOfKeys]
-OptionalListOfKeysT = TypeVar("OptionalListOfKeysT", bound=OptionalListOfKeys)
-SequenceOfKeys = Sequence[Key]
-SequenceOfKeysT = TypeVar("SequenceOfKeysT", bound=SequenceOfKeys)
-OptionalSequenceOfKeys = Optional[SequenceOfKeys]
-OptionalSequenceOfKeysT = TypeVar(
-    "OptionalSequenceOfKeysT", bound=OptionalSequenceOfKeys
-)
+ServiceKeyT = TypeVar("ServiceKeyT", bound=ServiceKey)
+OptServiceKey = ServiceKey | None
+OptServiceKeyT = TypeVar("OptServiceKeyT", bound=OptServiceKey)
+
+
+class SimpleServiceKeyMixin(BaseModel, Generic[OptServiceKeyT]):
+    key: Annotated[OptServiceKeyT, Field(..., description="Service Key")]
+
+
+class FullServiceKeyMixin(BaseModel, Generic[OptServiceKeyT]):
+    service_key: Annotated[OptServiceKeyT, Field(..., description="Service Key")]
+
+
+ListOfServiceKeys = list[ServiceKey]
+ListOfServiceKeysT = TypeVar("ListOfServiceKeysT", bound=ListOfServiceKeys)
+OptListOfServiceKeys = ListOfServiceKeys | None
+OptListOfServiceKeysT = TypeVar("OptListOfServiceKeysT", bound=OptListOfServiceKeys)
+
+
+class SimpleServiceKeysMixin(BaseModel, Generic[OptListOfServiceKeysT]):
+    keys: Annotated[OptListOfServiceKeysT, Field(..., description="Service Keys")]
+
 
+class FullServiceKeysMixin(BaseModel, Generic[OptListOfServiceKeysT]):
+    service_keys: Annotated[
+        OptListOfServiceKeysT, Field(..., description="Service Keys")
+    ]
 
-class ShortName(StrEnum):
+
+SeqOfServiceKeys = Sequence[ServiceKey]
+SeqOfServiceKeysT = TypeVar("SeqOfServiceKeysT", bound=SeqOfServiceKeys)
+OptSeqOfServiceKeys = SeqOfServiceKeys | None
+OptSeqOfServiceKeysT = TypeVar("OptSeqOfServiceKeysT", bound=OptSeqOfServiceKeys)
+
+
+class ShortServiceName(StrEnum):
     STUDIO = "Studio"
     NEXUS = "Nexus"
     TELEMETRY = "Telemetry"
@@ -154,28 +245,58 @@ class ShortName(StrEnum):
     MCU = "MCU"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ShortNameT = TypeVar("ShortNameT", bound=ShortName)
-OptionalShortName = Optional[ShortName]
-OptionalShortNameT = TypeVar("OptionalShortNameT", bound=OptionalShortName)
-ListOfShortNames = List[ShortName]
-ListOfShortNamesT = TypeVar("ListOfShortNamesT", bound=ListOfShortNames)
-OptionalListOfShortNames = Optional[ListOfShortNames]
-OptionalListOfShortNamesT = TypeVar(
-    "OptionalListOfShortNamesT", bound=OptionalListOfShortNames
+ShortServiceNameT = TypeVar("ShortServiceNameT", bound=ShortServiceName)
+OptShortServiceName = ShortServiceName | None
+OptShortServiceNameT = TypeVar("OptShortServiceNameT", bound=OptShortServiceName)
+
+
+class SimpleShortServiceNameMixin(BaseModel, Generic[OptShortServiceNameT]):
+    name: Annotated[OptShortServiceNameT, Field(..., description="Service Name")]
+
+
+class FullShortServiceNameMixin(BaseModel, Generic[OptShortServiceNameT]):
+    service_name: Annotated[
+        OptShortServiceNameT, Field(..., description="Service Name")
+    ]
+
+
+ListOfShortServiceNames = list[ShortServiceName]
+ListOfShortServiceNamesT = TypeVar(
+    "ListOfShortServiceNamesT", bound=ListOfShortServiceNames
 )
-SequenceOfShortNames = Sequence[ShortName]
-SequenceOfShortNamesT = TypeVar("SequenceOfShortNamesT", bound=SequenceOfShortNames)
-OptionalSequenceOfShortNames = Optional[SequenceOfShortNames]
-OptionalSequenceOfShortNamesT = TypeVar(
-    "OptionalSequenceOfShortNamesT", bound=OptionalSequenceOfShortNames
+OptListOfShortServiceNames = ListOfShortServiceNames | None
+OptListOfShortServiceNamesT = TypeVar(
+    "OptListOfShortServiceNamesT", bound=OptListOfShortServiceNames
 )
 
 
-class Name(StrEnum):
+class SimpleShortServiceNamesMixin(BaseModel, Generic[OptListOfShortServiceNamesT]):
+    names: Annotated[
+        OptListOfShortServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+class FullShortServiceNamesMixin(BaseModel, Generic[OptListOfShortServiceNamesT]):
+    service_names: Annotated[
+        OptListOfShortServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+SeqOfShortServiceNames = Sequence[ShortServiceName]
+SeqOfShortServiceNamesT = TypeVar(
+    "SeqOfShortServiceNamesT", bound=SeqOfShortServiceNames
+)
+OptSeqOfShortServiceNames = SeqOfShortServiceNames | None
+OptSeqOfShortServiceNamesT = TypeVar(
+    "OptSeqOfShortServiceNamesT", bound=OptSeqOfShortServiceNames
+)
+
+
+class ServiceName(StrEnum):
     STUDIO = "MaleoStudio"
     NEXUS = "MaleoNexus"
     TELEMETRY = "MaleoTelemetry"
@@ -194,20 +315,40 @@ class Name(StrEnum):
     MCU = "MaleoMCU"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-NameT = TypeVar("NameT", bound=Name)
-OptionalName = Optional[Name]
-OptionalNameT = TypeVar("OptionalNameT", bound=OptionalName)
-ListOfNames = List[Name]
-ListOfNamesT = TypeVar("ListOfNamesT", bound=ListOfNames)
-OptionalListOfNames = Optional[ListOfNames]
-OptionalListOfNamesT = TypeVar("OptionalListOfNamesT", bound=OptionalListOfNames)
-SequenceOfNames = Sequence[Name]
-SequenceOfNamesT = TypeVar("SequenceOfNamesT", bound=SequenceOfNames)
-OptionalSequenceOfNames = Optional[SequenceOfNames]
-OptionalSequenceOfNamesT = TypeVar(
-    "OptionalSequenceOfNamesT", bound=OptionalSequenceOfNames
-)
+ServiceNameT = TypeVar("ServiceNameT", bound=ServiceName)
+OptServiceName = ServiceName | None
+OptServiceNameT = TypeVar("OptServiceNameT", bound=OptServiceName)
+
+
+class SimpleServiceNameMixin(BaseModel, Generic[OptServiceNameT]):
+    name: Annotated[OptServiceNameT, Field(..., description="Service Name")]
+
+
+class FullServiceNameMixin(BaseModel, Generic[OptServiceNameT]):
+    service_name: Annotated[OptServiceNameT, Field(..., description="Service Name")]
+
+
+ListOfServiceNames = list[ServiceName]
+ListOfServiceNamesT = TypeVar("ListOfServiceNamesT", bound=ListOfServiceNames)
+OptListOfServiceNames = ListOfServiceNames | None
+OptListOfServiceNamesT = TypeVar("OptListOfServiceNamesT", bound=OptListOfServiceNames)
+
+
+class SimpleServiceNamesMixin(BaseModel, Generic[OptListOfServiceNamesT]):
+    names: Annotated[OptListOfServiceNamesT, Field(..., description="Service Names")]
+
+
+class FullServiceNamesMixin(BaseModel, Generic[OptListOfServiceNamesT]):
+    service_names: Annotated[
+        OptListOfServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+SeqOfServiceNames = Sequence[ServiceName]
+SeqOfServiceNamesT = TypeVar("SeqOfServiceNamesT", bound=SeqOfServiceNames)
+OptSeqOfServiceNames = SeqOfServiceNames | None
+OptSeqOfServiceNamesT = TypeVar("OptSeqOfServiceNamesT", bound=OptSeqOfServiceNames)

maleo/enums/status.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 DataStatus(StrEnum):
@@ -9,36 +10,50 @@ class DataStatus(StrEnum):
     ACTIVE = "active"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 DataStatusT = TypeVar("DataStatusT", bound=DataStatus)
-OptionalDataStatus = Optional[DataStatus]
-OptionalDataStatusT = TypeVar("OptionalDataStatusT", bound=OptionalDataStatus)
-ListOfDataStatuses = List[DataStatus]
+OptDataStatus = DataStatus | None
+OptDataStatusT = TypeVar("OptDataStatusT", bound=OptDataStatus)
+
+
+class SimpleDataStatusMixin(BaseModel, Generic[OptDataStatusT]):
+    status: Annotated[OptDataStatusT, Field(..., description="Status")]
+
+
+class FullDataStatusMixin(BaseModel, Generic[OptDataStatusT]):
+    data_status: Annotated[OptDataStatusT, Field(..., description="Status")]
+
+
+ListOfDataStatuses = list[DataStatus]
 ListOfDataStatusesT = TypeVar("ListOfDataStatusesT", bound=ListOfDataStatuses)
-OptionalListOfDataStatuses = Optional[ListOfDataStatuses]
-OptionalListOfDataStatusesT = TypeVar(
-    "OptionalListOfDataStatusesT", bound=OptionalListOfDataStatuses
-)
-SequenceOfDataStatuses = Sequence[DataStatus]
-SequenceOfDataStatusesT = TypeVar(
-    "SequenceOfDataStatusesT", bound=SequenceOfDataStatuses
-)
-OptionalSequenceOfDataStatuses = Optional[SequenceOfDataStatuses]
-OptionalSequenceOfDataStatusesT = TypeVar(
-    "OptionalSequenceOfDataStatusesT", bound=OptionalSequenceOfDataStatuses
-)
-
-
-FULL_DATA_STATUSES: SequenceOfDataStatuses = (
+OptListOfDataStatuses = ListOfDataStatuses | None
+OptListOfDataStatusesT = TypeVar("OptListOfDataStatusesT", bound=OptListOfDataStatuses)
+
+
+class SimpleDataStatusesMixin(BaseModel, Generic[OptListOfDataStatusesT]):
+    statuses: Annotated[OptListOfDataStatusesT, Field(..., description="Statuses")]
+
+
+class FullDataStatusesMixin(BaseModel, Generic[OptListOfDataStatusesT]):
+    data_statuses: Annotated[OptListOfDataStatusesT, Field(..., description="Statuses")]
+
+
+SeqOfDataStatuses = Sequence[DataStatus]
+SeqOfDataStatusesT = TypeVar("SeqOfDataStatusesT", bound=SeqOfDataStatuses)
+OptSeqOfDataStatuses = SeqOfDataStatuses | None
+OptSeqOfDataStatusesT = TypeVar("OptSeqOfDataStatusesT", bound=OptSeqOfDataStatuses)
+
+
+FULL_DATA_STATUSES: ListOfDataStatuses = [
     DataStatus.ACTIVE,
     DataStatus.INACTIVE,
     DataStatus.DELETED,
-)
+]
 
-BASIC_DATA_STATUSES: SequenceOfDataStatuses = (
+BASIC_DATA_STATUSES: ListOfDataStatuses = [
     DataStatus.ACTIVE,
     DataStatus.INACTIVE,
-)
+]

maleo/enums/system.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 SystemRole(StrEnum):
     ADMINISTRATOR = "administrator"
     ANALYST = "analyst"
     ENGINEER = "engineer"
@@ -17,20 +18,40 @@ class Role(StrEnum):
     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
-)
+SystemRoleT = TypeVar("SystemRoleT", bound=SystemRole)
+OptSystemRole = SystemRole | None
+OptSystemRoleT = TypeVar("OptSystemRoleT", bound=OptSystemRole)
+
+
+class SimpleSystemRoleMixin(BaseModel, Generic[OptSystemRoleT]):
+    role: Annotated[OptSystemRoleT, Field(..., description="System Role")]
+
+
+class FullSystemRoleMixin(BaseModel, Generic[OptSystemRoleT]):
+    system_role: Annotated[OptSystemRoleT, Field(..., description="System Role")]
+
+
+ListOfSystemRoles = list[SystemRole]
+ListOfSystemRolesT = TypeVar("ListOfSystemRolesT", bound=ListOfSystemRoles)
+OptListOfSystemRoles = ListOfSystemRoles | None
+OptListOfSystemRolesT = TypeVar("OptListOfSystemRolesT", bound=OptListOfSystemRoles)
+
+
+class SimpleSystemRolesMixin(BaseModel, Generic[OptListOfSystemRolesT]):
+    roles: Annotated[OptListOfSystemRolesT, Field(..., description="System Roles")]
+
+
+class FullSystemRolesMixin(BaseModel, Generic[OptListOfSystemRolesT]):
+    system_roles: Annotated[
+        OptListOfSystemRolesT, Field(..., description="System Roles")
+    ]
+
+
+SeqOfSystemRoles = Sequence[SystemRole]
+SeqOfSystemRolesT = TypeVar("SeqOfSystemRolesT", bound=SeqOfSystemRoles)
+OptSeqOfSystemRoles = SeqOfSystemRoles | None
+OptSeqOfSystemRolesT = TypeVar("OptSeqOfSystemRolesT", bound=OptSeqOfSystemRoles)

maleo/enums/user.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 UserType(StrEnum):
@@ -9,22 +10,38 @@ class UserType(StrEnum):
     SERVICE = "service"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 UserTypeT = TypeVar("UserTypeT", bound=UserType)
-OptionalUserType = Optional[UserType]
-OptionalUserTypeT = TypeVar("OptionalUserTypeT", bound=OptionalUserType)
-ListOfUserTypes = List[UserType]
+OptUserType = UserType | None
+OptUserTypeT = TypeVar("OptUserTypeT", bound=OptUserType)
+
+
+class SimpleUserTypeMixin(BaseModel, Generic[OptUserTypeT]):
+    type: Annotated[OptUserTypeT, Field(..., description="User Type")]
+
+
+class FullUserTypeMixin(BaseModel, Generic[OptUserTypeT]):
+    user_type: Annotated[OptUserTypeT, Field(..., description="User Type")]
+
+
+ListOfUserTypes = list[UserType]
 ListOfUserTypesT = TypeVar("ListOfUserTypesT", bound=ListOfUserTypes)
-OptionalListOfUserTypes = Optional[ListOfUserTypes]
-OptionalListOfUserTypesT = TypeVar(
-    "OptionalListOfUserTypesT", bound=OptionalListOfUserTypes
-)
-SequenceOfUserTypes = Sequence[UserType]
-SequenceOfUserTypesT = TypeVar("SequenceOfUserTypesT", bound=SequenceOfUserTypes)
-OptionalSequenceOfUserTypes = Optional[SequenceOfUserTypes]
-OptionalSequenceOfUserTypesT = TypeVar(
-    "OptionalSequenceOfUserTypesT", bound=OptionalSequenceOfUserTypes
-)
+OptListOfUserTypes = ListOfUserTypes | None
+OptListOfUserTypesT = TypeVar("OptListOfUserTypesT", bound=OptListOfUserTypes)
+
+
+class SimpleUserTypesMixin(BaseModel, Generic[OptListOfUserTypesT]):
+    types: Annotated[OptListOfUserTypesT, Field(..., description="User Types")]
+
+
+class FullUserTypesMixin(BaseModel, Generic[OptListOfUserTypesT]):
+    user_types: Annotated[OptListOfUserTypesT, Field(..., description="User Types")]
+
+
+SeqOfUserTypes = Sequence[UserType]
+SeqOfUserTypesT = TypeVar("SeqOfUserTypesT", bound=SeqOfUserTypes)
+OptSeqOfUserTypes = SeqOfUserTypes | None
+OptSeqOfUserTypesT = TypeVar("OptSeqOfUserTypesT", bound=OptSeqOfUserTypes)

{maleo_enums-0.0.28.dist-info → maleo_enums-0.0.32.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: maleo-enums
-Version: 0.0.28
+Version: 0.0.32
 Summary: Enums package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: annotated-types>=0.7.0
 Requires-Dist: black>=25.1.0
 Requires-Dist: cfgv>=3.4.0
 Requires-Dist: click>=8.2.1
@@ -14,14 +15,18 @@ Requires-Dist: colorama>=0.4.6
 Requires-Dist: distlib>=0.4.0
 Requires-Dist: filelock>=3.19.1
 Requires-Dist: identify>=2.6.13
-Requires-Dist: maleo-types>=0.0.8
+Requires-Dist: maleo-types>=0.0.12
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: packaging>=25.0
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: platformdirs>=4.4.0
 Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: pydantic>=2.12.2
+Requires-Dist: pydantic_core>=2.41.4
 Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: typing-inspection>=0.4.2
+Requires-Dist: typing_extensions>=4.15.0
 Requires-Dist: virtualenv>=20.34.0
 Dynamic: license-file