maleo-enums 0.0.26__tar.gz → 0.0.28__tar.gz

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-enums
-Version: 0.0.26
+Version: 0.0.28
 Summary: Enums package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -14,7 +14,7 @@ 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.6
+Requires-Dist: maleo-types>=0.0.8
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: packaging>=25.0

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/maleo_enums.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-enums
-Version: 0.0.26
+Version: 0.0.28
 Summary: Enums package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -14,7 +14,7 @@ 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.6
+Requires-Dist: maleo-types>=0.0.8
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: packaging>=25.0

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/maleo_enums.egg-info/SOURCES.txt

@@ -11,7 +11,11 @@ src/cardinality.py
 src/connection.py
 src/environment.py
 src/expiration.py
+src/identity.py
+src/medical.py
 src/order.py
-src/role.py
+src/organization.py
 src/service.py
-src/status.py
+src/status.py
+src/system.py
+src/user.py

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/maleo_enums.egg-info/requires.txt

@@ -5,7 +5,7 @@ colorama>=0.4.6
 distlib>=0.4.0
 filelock>=3.19.1
 identify>=2.6.13
-maleo-types>=0.0.6
+maleo-types>=0.0.8
 mypy_extensions>=1.1.0
 nodeenv>=1.9.1
 packaging>=25.0

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-enums"
-version = "0.0.26"
+version = "0.0.28"
 description = "Enums package for MaleoSuite"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
@@ -20,7 +20,7 @@ dependencies = [
     "distlib>=0.4.0",
     "filelock>=3.19.1",
     "identify>=2.6.13",
-    "maleo-types>=0.0.6",
+    "maleo-types>=0.0.8",
     "mypy_extensions>=1.1.0",
     "nodeenv>=1.9.1",
     "packaging>=25.0",

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/src/cardinality.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, TypeVar
 from maleo.types.string import ListOfStrings
 
 
@@ -12,11 +12,23 @@ class Cardinality(StrEnum):
         return [e.value for e in cls]
 
 
+CardinalityT = TypeVar("CardinalityT", bound=Cardinality)
 OptionalCardinality = Optional[Cardinality]
+OptionalCardinalityT = TypeVar("OptionalCardinalityT", bound=OptionalCardinality)
 ListOfCardinalities = List[Cardinality]
+ListOfCardinalitiesT = TypeVar("ListOfCardinalitiesT", bound=ListOfCardinalities)
 OptionalListOfCardinalities = Optional[ListOfCardinalities]
+OptionalListOfCardinalitiesT = TypeVar(
+    "OptionalListOfCardinalitiesT", bound=OptionalListOfCardinalities
+)
 SequenceOfCardinalities = Sequence[Cardinality]
+SequenceOfCardinalitiesT = TypeVar(
+    "SequenceOfCardinalitiesT", bound=SequenceOfCardinalities
+)
 OptionalSequenceOfCardinalities = Optional[SequenceOfCardinalities]
+OptionalSequenceOfCardinalitiesT = TypeVar(
+    "OptionalSequenceOfCardinalitiesT", bound=OptionalSequenceOfCardinalities
+)
 
 
 class Relationship(StrEnum):
@@ -46,8 +58,20 @@ class Relationship(StrEnum):
         return [e.value for e in cls]
 
 
+RelationshipT = TypeVar("RelationshipT", bound=Relationship)
 OptionalRelationship = Optional[Relationship]
+OptionalRelationshipT = TypeVar("OptionalRelationshipT", bound=OptionalRelationship)
 ListOfRelationships = List[Relationship]
+ListOfRelationshipsT = TypeVar("ListOfRelationshipsT", bound=ListOfRelationships)
 OptionalListOfRelationships = Optional[ListOfRelationships]
+OptionalListOfRelationshipsT = TypeVar(
+    "OptionalListOfRelationshipsT", bound=OptionalListOfRelationships
+)
 SequenceOfRelationships = Sequence[Relationship]
+SequenceOfRelationshipsT = TypeVar(
+    "SequenceOfRelationshipsT", bound=SequenceOfRelationships
+)
 OptionalSequenceOfRelationships = Optional[SequenceOfRelationships]
+OptionalSequenceOfRelationshipsT = TypeVar(
+    "OptionalSequenceOfRelationshipsT", bound=OptionalSequenceOfRelationships
+)

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/src/connection.py

@@ -18,9 +18,15 @@ SchemeT = TypeVar("SchemeT", bound=Scheme)
 OptionalScheme = Optional[Scheme]
 OptionalSchemeT = TypeVar("OptionalSchemeT", bound=OptionalScheme)
 ListOfSchemes = List[Scheme]
+ListOfSchemesT = TypeVar("ListOfSchemesT", bound=ListOfSchemes)
 OptionalListOfSchemes = Optional[ListOfSchemes]
+OptionalListOfSchemesT = TypeVar("OptionalListOfSchemesT", bound=OptionalListOfSchemes)
 SequenceOfSchemes = Sequence[Scheme]
+SequenceOfSchemesT = TypeVar("SequenceOfSchemesT", bound=SequenceOfSchemes)
 OptionalSequenceOfSchemes = Optional[SequenceOfSchemes]
+OptionalSequenceOfSchemesT = TypeVar(
+    "OptionalSequenceOfSchemesT", bound=OptionalSequenceOfSchemes
+)
 
 
 class Protocol(StrEnum):
@@ -64,9 +70,15 @@ MethodT = TypeVar("MethodT", bound=Method)
 OptionalMethod = Optional[Method]
 OptionalMethodT = TypeVar("OptionalMethodT", bound=OptionalMethod)
 ListOfMethods = List[Method]
+ListOfMethodsT = TypeVar("ListOfMethodsT", bound=ListOfMethods)
 OptionalListOfMethods = Optional[ListOfMethods]
+OptionalListOfMethodsT = TypeVar("OptionalListOfMethodsT", bound=OptionalListOfMethods)
 SequenceOfMethods = Sequence[Method]
+SequenceOfMethodsT = TypeVar("SequenceOfMethodsT", bound=SequenceOfMethods)
 OptionalSequenceOfMethods = Optional[SequenceOfMethods]
+OptionalSequenceOfMethodsT = TypeVar(
+    "OptionalSequenceOfMethodsT", bound=OptionalSequenceOfMethods
+)
 
 
 class Header(StrEnum):
@@ -161,6 +173,12 @@ HeaderT = TypeVar("HeaderT", bound=Header)
 OptionalHeader = Optional[Header]
 OptionalHeaderT = TypeVar("OptionalHeaderT", bound=OptionalHeader)
 ListOfHeaders = List[Header]
+ListOfHeadersT = TypeVar("ListOfHeadersT", bound=ListOfHeaders)
 OptionalListOfHeaders = Optional[ListOfHeaders]
+OptionalListOfHeadersT = TypeVar("OptionalListOfHeadersT", bound=OptionalListOfHeaders)
 SequenceOfHeaders = Sequence[Header]
+SequenceOfHeadersT = TypeVar("SequenceOfHeadersT", bound=SequenceOfHeaders)
 OptionalSequenceOfHeaders = Optional[SequenceOfHeaders]
+OptionalSequenceOfHeadersT = TypeVar(
+    "OptionalSequenceOfHeadersT", bound=OptionalSequenceOfHeaders
+)

maleo_enums-0.0.28/src/environment.py

@@ -0,0 +1,32 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class Environment(StrEnum):
+    LOCAL = "local"
+    STAGING = "staging"
+    PRODUCTION = "production"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+EnvironmentT = TypeVar("EnvironmentT", bound=Environment)
+OptionalEnvironment = Optional[Environment]
+OptionalEnvironmentT = TypeVar("OptionalEnvironmentT", bound=OptionalEnvironment)
+ListOfEnvironments = List[Environment]
+ListOfEnvironmentsT = TypeVar("ListOfEnvironmentsT", bound=ListOfEnvironments)
+OptionalListOfEnvironments = Optional[ListOfEnvironments]
+OptionalListOfEnvironmentsT = TypeVar(
+    "OptionalListOfEnvironmentsT", bound=OptionalListOfEnvironments
+)
+SequenceOfEnvironments = Sequence[Environment]
+SequenceOfEnvironmentsT = TypeVar(
+    "SequenceOfEnvironmentsT", bound=SequenceOfEnvironments
+)
+OptionalSequenceOfEnvironments = Optional[SequenceOfEnvironments]
+OptionalSequenceOfEnvironmentsT = TypeVar(
+    "OptionalSequenceOfEnvironmentsT", bound=OptionalSequenceOfEnvironments
+)

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/src/expiration.py

@@ -1,5 +1,5 @@
 from enum import IntEnum
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, TypeVar
 from maleo.types.integer import ListOfIntegers
 
 
@@ -25,8 +25,18 @@ class Expiration(IntEnum):
         return [e.value for e in cls]
 
 
+ExpirationT = TypeVar("ExpirationT", bound=Expiration)
 OptionalExpiration = Optional[Expiration]
+OptionalExpirationT = TypeVar("OptionalExpirationT", bound=OptionalExpiration)
 ListOfExpirations = List[Expiration]
+ListOfExpirationsT = TypeVar("ListOfExpirationsT", bound=ListOfExpirations)
 OptionalListOfExpirations = Optional[ListOfExpirations]
+OptionalListOfExpirationsT = TypeVar(
+    "OptionalListOfExpirationsT", bound=OptionalListOfExpirations
+)
 SequenceOfExpirations = Sequence[Expiration]
+SequenceOfExpirationsT = TypeVar("SequenceOfExpirationsT", bound=SequenceOfExpirations)
 OptionalSequenceOfExpirations = Optional[SequenceOfExpirations]
+OptionalSequenceOfExpirationsT = TypeVar(
+    "OptionalSequenceOfExpirationsT", bound=OptionalSequenceOfExpirations
+)

maleo_enums-0.0.28/src/identity.py

@@ -0,0 +1,56 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class BloodType(StrEnum):
+    A = "a"
+    B = "b"
+    AB = "ab"
+    O = "o"  # noqa: E741
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+BloodTypeT = TypeVar("BloodTypeT", bound=BloodType)
+OptionalBloodType = Optional[BloodType]
+OptionalBloodTypeT = TypeVar("OptionalBloodTypeT", bound=OptionalBloodType)
+ListOfBloodTypes = List[BloodType]
+ListOfBloodTypesT = TypeVar("ListOfBloodTypesT", bound=ListOfBloodTypes)
+OptionalListOfBloodTypes = Optional[ListOfBloodTypes]
+OptionalListOfBloodTypesT = TypeVar(
+    "OptionalListOfBloodTypesT", bound=OptionalListOfBloodTypes
+)
+SequenceOfBloodTypes = Sequence[BloodType]
+SequenceOfBloodTypesT = TypeVar("SequenceOfBloodTypesT", bound=SequenceOfBloodTypes)
+OptionalSequenceOfBloodTypes = Optional[SequenceOfBloodTypes]
+OptionalSequenceOfBloodTypesT = TypeVar(
+    "OptionalSequenceOfBloodTypesT", bound=OptionalSequenceOfBloodTypes
+)
+
+
+class Gender(StrEnum):
+    UNDISCLOSED = "undisclosed"
+    FEMALE = "female"
+    MALE = "male"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+GenderT = TypeVar("GenderT", bound=Gender)
+OptionalGender = Optional[Gender]
+OptionalGenderT = TypeVar("OptionalGenderT", bound=OptionalGender)
+ListOfGenders = List[Gender]
+ListOfGendersT = TypeVar("ListOfGendersT", bound=ListOfGenders)
+OptionalListOfGenders = Optional[ListOfGenders]
+OptionalListOfGendersT = TypeVar("OptionalListOfGendersT", bound=OptionalListOfGenders)
+SequenceOfGenders = Sequence[Gender]
+SequenceOfGendersT = TypeVar("SequenceOfGendersT", bound=SequenceOfGenders)
+OptionalSequenceOfGenders = Optional[SequenceOfGenders]
+OptionalSequenceOfGendersT = TypeVar(
+    "OptionalSequenceOfGendersT", bound=OptionalSequenceOfGenders
+)

maleo_enums-0.0.28/src/medical.py

@@ -0,0 +1,119 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class Role(StrEnum):
+    # Level 1: Director category
+    DIRECTOR = "director"
+    PRESIDENT = "president"
+    VICE_PRESIDENT = "vice_president"
+    SECRETARY = "secretary"
+    TREASURER = "treasurer"
+    # Level 1: Management category
+    HEAD = "head"
+    CEO = "ceo"
+    COO = "coo"
+    CFO = "cfo"
+    CCO = "cco"
+    # Level 1: Administration category
+    ADMINISTRATOR = "administrator"
+    ADMISSION = "admission"
+    CASHIER = "cashier"
+    CASEMIX = "casemix"
+    MEDICAL_RECORD = "medical_record"
+    # Level 1: Medical category
+    DOCTOR = "doctor"
+    NURSE = "nurse"
+    MIDWIFE = "midwife"
+    # Level 2: Doctor's specialization
+    INTERNIST = "internist"
+    PEDIATRICIAN = "pediatrician"
+    OBSTETRICIAN = "obstetrician"
+    GYNECOLOGIST = "gynecologist"
+    OBGYN = "obgyn"
+    PSYCHIATRIST = "psychiatrist"
+    DERMATOLOGIST = "dermatologist"
+    NEUROLOGIST = "neurologist"
+    CARDIOLOGIST = "cardiologist"
+    OPHTHALMOLOGIST = "ophthalmologist"
+    RADIOLOGIST = "radiologist"
+    ANESTHESIOLOGIST = "anesthesiologist"
+    HEMATOLOGIST = "hematologist"
+    ENDOCRINOLOGIST = "endocrinologist"
+    GASTROENTEROLOGIST = "gastroenterologist"
+    NEPHROLOGIST = "nephrologist"
+    UROLOGIST = "urologist"
+    PULMONOLOGIST = "pulmonologist"
+    RHEUMATOLOGIST = "rheumatologist"
+    SURGEON = "surgeon"
+    # Level 3: Surgeon's specialization
+    ORTHOPEDIC_SURGEON = "orthopedic_surgeon"
+    # Level 2: Nurse's specialization
+    SCRUB_NURSE = "scrub_nurse"
+    TRIAGE_NURSE = "triage_nurse"
+    ICU_NURSE = "icu_nurse"
+    NICU_NURSE = "nicu_nurse"
+    OR_NURSE = "or_nurse"
+    ER_NURSE = "er_nurse"
+    # Level 1: Technical category
+    TECHNICIAN = "technician"
+    LABORATORY_TECHNICIAN = "laboratory_technician"
+    RADIOGRAPHER = "radiographer"
+    SONOGRAPHER = "sonographer"
+    # Level 1: Therapeutic category
+    THERAPIST = "therapist"
+    PHYSIOTHERAPIST = "physiotherapist"
+    OCCUPATIONAL_THERAPIST = "occupational_therapist"
+    SPEECH_THERAPIST = "speech_therapist"
+    PSYCHOLOGIST = "psychologist"
+    # Level 1: Support category
+    PHARMACIST = "pharmacist"
+    NUTRITIONIST = "nutritionist"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+
+
+class Service(StrEnum):
+    EMERGENCY = "emergency"
+    INPATIENT = "inpatient"
+    INTENSIVE = "intensive"
+    OUTPATIENT = "outpatient"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+SequenceOfServices = Sequence[Service]
+SequenceOfServicesT = TypeVar("SequenceOfServicesT", bound=SequenceOfServices)
+OptionalSequenceOfServices = Optional[SequenceOfServices]
+OptionalSequenceOfServicesT = TypeVar(
+    "OptionalSequenceOfServicesT", bound=OptionalSequenceOfServices
+)

maleo_enums-0.0.28/src/order.py

@@ -0,0 +1,27 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class Order(StrEnum):
+    ASC = "asc"
+    DESC = "desc"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+OrderT = TypeVar("OrderT", bound=Order)
+OptionalOrder = Optional[Order]
+OptionalOrderT = TypeVar("OptionalOrderT", bound=OptionalOrder)
+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
+)

maleo_enums-0.0.28/src/organization.py

@@ -0,0 +1,119 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class OrganizationType(StrEnum):
+    APPLICATION = "application"
+    BRANCH = "branch"
+    CLIENT = "client"
+    CLINIC = "clinic"
+    CORPORATION = "corporation"
+    DEPARTMENT = "department"
+    DIVISION = "division"
+    GOVERNMENT = "government"
+    HOSPITAL_SYSTEM = "hospital_system"
+    HOSPITAL = "hospital"
+    INSURANCE_PROVIDER = "insurance_provider"
+    INTERNAL = "internal"
+    LABORATORY = "laboratory"
+    MEDICAL_GROUP = "medical_group"
+    NETWORK = "network"
+    PARTNER = "partner"
+    PHARMACY = "pharmacy"
+    PRIMARY_HEALTH_CARE = "primary_health_care"
+    PUBLIC_HEALTH_AGENCY = "public_health_agency"
+    REGIONAL_OFFICE = "regional_office"
+    REGULAR = "regular"
+    RESEARCH_INSTITUTE = "research_institute"
+    SUBSIDIARY = "subsidiary"
+    THIRD_PARTY_ADMINISTRATOR = "third_party_administrator"
+    UNIT = "unit"
+    VENDOR = "vendor"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+OrganizationTypeT = TypeVar("OrganizationTypeT", bound=OrganizationType)
+OptionalOrganizationType = Optional[OrganizationType]
+OptionalOrganizationTypeT = TypeVar(
+    "OptionalOrganizationTypeT", bound=OptionalOrganizationType
+)
+ListOfOrganizationTypes = List[OrganizationType]
+ListOfOrganizationTypesT = TypeVar(
+    "ListOfOrganizationTypesT", bound=ListOfOrganizationTypes
+)
+OptionalListOfOrganizationTypes = Optional[ListOfOrganizationTypes]
+OptionalListOfOrganizationTypesT = TypeVar(
+    "OptionalListOfOrganizationTypesT", bound=OptionalListOfOrganizationTypes
+)
+SequenceOfOrganizationTypes = Sequence[OrganizationType]
+SequenceOfOrganizationTypesT = TypeVar(
+    "SequenceOfOrganizationTypesT", bound=SequenceOfOrganizationTypes
+)
+OptionalSequenceOfOrganizationTypes = Optional[SequenceOfOrganizationTypes]
+OptionalSequenceOfOrganizationTypesT = TypeVar(
+    "OptionalSequenceOfOrganizationTypesT", bound=OptionalSequenceOfOrganizationTypes
+)
+
+
+class Relation(StrEnum):
+    AFFILIATE = "affiliate"
+    APPLICATION = "application"
+    BRANCH = "branch"
+    CLIENT = "client"
+    DEPARTMENT = "department"
+    DIVISION = "division"
+    NETWORK_MEMBER = "network_member"
+    PARENT = "parent"
+    PARTNER = "partner"
+    SUBSIDIARY = "subsidiary"
+    VENDOR = "vendor"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+SequenceOfRelations = Sequence[Relation]
+SequenceOfRelationsT = TypeVar("SequenceOfRelationsT", bound=SequenceOfRelations)
+OptionalSequenceOfRelations = Optional[SequenceOfRelations]
+OptionalSequenceOfRelationsT = TypeVar(
+    "OptionalSequenceOfRelationsT", bound=OptionalSequenceOfRelations
+)
+
+
+class Role(StrEnum):
+    OWNER = "owner"
+    ADMINISTRATOR = "administrator"
+    USER = "user"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)

maleo_enums-0.0.28/src/service.py

@@ -0,0 +1,213 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class ServiceType(StrEnum):
+    BACKEND = "backend"
+    FRONTEND = "frontend"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+ServiceTypeT = TypeVar("ServiceTypeT", bound=ServiceType)
+OptionalServiceType = Optional[ServiceType]
+OptionalServiceTypeT = TypeVar("OptionalServiceTypeT", bound=OptionalServiceType)
+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
+)
+
+
+class Category(StrEnum):
+    CORE = "core"
+    AI = "ai"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+SequenceOfCategories = Sequence[Category]
+SequenceOfCategoriesT = TypeVar("SequenceOfCategoriesT", bound=SequenceOfCategories)
+OptionalSequenceOfCategories = Optional[SequenceOfCategories]
+OptionalSequenceOfCategoriesT = TypeVar(
+    "OptionalSequenceOfCategoriesT", bound=OptionalSequenceOfCategories
+)
+
+
+class ShortKey(StrEnum):
+    STUDIO = "studio"
+    NEXUS = "nexus"
+    TELEMETRY = "telemetry"
+    METADATA = "metadata"
+    IDENTITY = "identity"
+    ACCESS = "access"
+    WORKSHOP = "workshop"
+    RESEARCH = "research"
+    REGISTRY = "registry"
+    SOAPIE = "soapie"
+    MEDIX = "medix"
+    DICOM = "dicom"
+    SCRIBE = "scribe"
+    CDS = "cds"
+    IMAGING = "imaging"
+    MCU = "mcu"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+SequenceOfShortKeys = Sequence[ShortKey]
+SequenceOfShortKeysT = TypeVar("SequenceOfShortKeysT", bound=SequenceOfShortKeys)
+OptionalSequenceOfShortKeys = Optional[SequenceOfShortKeys]
+OptionalSequenceOfShortKeysT = TypeVar(
+    "OptionalSequenceOfShortKeysT", bound=OptionalSequenceOfShortKeys
+)
+
+
+class Key(StrEnum):
+    STUDIO = "maleo-studio"
+    NEXUS = "maleo-nexus"
+    TELEMETRY = "maleo-telemetry"
+    METADATA = "maleo-metadata"
+    IDENTITY = "maleo-identity"
+    ACCESS = "maleo-access"
+    WORKSHOP = "maleo-workshop"
+    RESEARCH = "maleo-research"
+    REGISTRY = "maleo-registry"
+    SOAPIE = "maleo-soapie"
+    MEDIX = "maleo-medix"
+    DICOM = "maleo-dicom"
+    SCRIBE = "maleo-scribe"
+    CDS = "maleo-cds"
+    IMAGING = "maleo-imaging"
+    MCU = "maleo-mcu"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+
+
+class ShortName(StrEnum):
+    STUDIO = "Studio"
+    NEXUS = "Nexus"
+    TELEMETRY = "Telemetry"
+    METADATA = "Metadata"
+    IDENTITY = "Identity"
+    ACCESS = "Access"
+    WORKSHOP = "Workshop"
+    RESEARCH = "Research"
+    REGISTRY = "Registry"
+    SOAPIE = "SOAPIE"
+    MEDIX = "Medix"
+    DICOM = "DICON"
+    SCRIBE = "Scribe"
+    CDS = "CDS"
+    IMAGING = "Imaging"
+    MCU = "MCU"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)
+SequenceOfShortNames = Sequence[ShortName]
+SequenceOfShortNamesT = TypeVar("SequenceOfShortNamesT", bound=SequenceOfShortNames)
+OptionalSequenceOfShortNames = Optional[SequenceOfShortNames]
+OptionalSequenceOfShortNamesT = TypeVar(
+    "OptionalSequenceOfShortNamesT", bound=OptionalSequenceOfShortNames
+)
+
+
+class Name(StrEnum):
+    STUDIO = "MaleoStudio"
+    NEXUS = "MaleoNexus"
+    TELEMETRY = "MaleoTelemetry"
+    METADATA = "MaleoMetadata"
+    IDENTITY = "MaleoIdentity"
+    ACCESS = "MaleoAccess"
+    WORKSHOP = "MaleoWorkshop"
+    RESEARCH = "MaleoResearch"
+    REGISTRY = "MaleoRegistry"
+    SOAPIE = "MaleoSOAPIE"
+    MEDIX = "MaleoMedix"
+    DICOM = "MaleoDICON"
+    SCRIBE = "MaleoScribe"
+    CDS = "MaleoCDS"
+    IMAGING = "MaleoImaging"
+    MCU = "MaleoMCU"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)

{maleo_enums-0.0.26 → maleo_enums-0.0.28}/src/status.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, TypeVar
 from maleo.types.string import ListOfStrings
 
 
@@ -13,11 +13,23 @@ class DataStatus(StrEnum):
         return [e.value for e in cls]
 
 
+DataStatusT = TypeVar("DataStatusT", bound=DataStatus)
 OptionalDataStatus = Optional[DataStatus]
+OptionalDataStatusT = TypeVar("OptionalDataStatusT", bound=OptionalDataStatus)
 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 = (

maleo_enums-0.0.28/src/system.py

@@ -0,0 +1,36 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class Role(StrEnum):
+    ADMINISTRATOR = "administrator"
+    ANALYST = "analyst"
+    ENGINEER = "engineer"
+    GUEST = "guest"
+    MANAGER = "manager"
+    OFFICER = "officer"
+    OPERATIONS = "operations"
+    SECURITY = "security"
+    SUPPORT = "support"
+    TESTER = "tester"
+    USER = "user"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        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
+)

maleo_enums-0.0.28/src/user.py

@@ -0,0 +1,30 @@
+from enum import StrEnum
+from typing import List, Optional, Sequence, TypeVar
+from maleo.types.string import ListOfStrings
+
+
+class UserType(StrEnum):
+    PROXY = "proxy"
+    REGULAR = "regular"
+    SERVICE = "service"
+
+    @classmethod
+    def choices(cls) -> ListOfStrings:
+        return [e.value for e in cls]
+
+
+UserTypeT = TypeVar("UserTypeT", bound=UserType)
+OptionalUserType = Optional[UserType]
+OptionalUserTypeT = TypeVar("OptionalUserTypeT", bound=OptionalUserType)
+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
+)

maleo_enums-0.0.26/src/environment.py

@@ -1,20 +0,0 @@
-from enum import StrEnum
-from typing import List, Optional, Sequence
-from maleo.types.string import ListOfStrings
-
-
-class Environment(StrEnum):
-    LOCAL = "local"
-    STAGING = "staging"
-    PRODUCTION = "production"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalEnvironment = Optional[Environment]
-ListOfEnvironments = List[Environment]
-OptionalListOfEnvironments = Optional[ListOfEnvironments]
-SequenceOfEnvironments = Sequence[Environment]
-OptionalSequenceOfEnvironments = Optional[SequenceOfEnvironments]

maleo_enums-0.0.26/src/order.py

@@ -1,19 +0,0 @@
-from enum import StrEnum
-from typing import List, Optional, Sequence
-from maleo.types.string import ListOfStrings
-
-
-class Order(StrEnum):
-    ASC = "asc"
-    DESC = "desc"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalOrder = Optional[Order]
-ListOfOrders = List[Order]
-OptionalListOfOrders = Optional[ListOfOrders]
-SequenceOfOrders = Sequence[Order]
-OptionalSequenceOfOrders = Optional[SequenceOfOrders]

maleo_enums-0.0.26/src/role.py

@@ -1,29 +0,0 @@
-from enum import StrEnum
-from maleo.types.string import ListOfStrings
-
-
-class Organization(StrEnum):
-    OWNER = "owner"
-    ADMINISTRATOR = "administrator"
-    USER = "user"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-class System(StrEnum):
-    ADMINISTRATOR = "administrator"
-    ANALYST = "analyst"
-    ENGINEER = "engineer"
-    SUPPORT = "support"
-    MANAGER = "manager"
-    OFFICER = "officer"
-    OPERATIONS = "operations"
-    SECURITY = "security"
-    TESTER = "tester"
-    USER = "user"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]

maleo_enums-0.0.26/src/service.py

@@ -1,151 +0,0 @@
-from enum import StrEnum
-from typing import List, Optional, Sequence
-from maleo.types.string import ListOfStrings
-
-
-class ServiceType(StrEnum):
-    BACKEND = "backend"
-    FRONTEND = "frontend"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalServiceType = Optional[ServiceType]
-ListOfServiceTypes = List[ServiceType]
-OptionalListOfServiceTypes = Optional[ListOfServiceTypes]
-SequenceOfServiceTypes = Sequence[ServiceType]
-OptionalSequenceOfServiceTypes = Optional[SequenceOfServiceTypes]
-
-
-class Category(StrEnum):
-    CORE = "core"
-    AI = "ai"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalCategory = Optional[Category]
-ListOfCategories = List[Category]
-OptionalListOfCategories = Optional[ListOfCategories]
-SequenceOfCategories = Sequence[Category]
-OptionalSequenceOfCategories = Optional[SequenceOfCategories]
-
-
-class SimpleKey(StrEnum):
-    STUDIO = "studio"
-    NEXUS = "nexus"
-    TELEMETRY = "telemetry"
-    METADATA = "metadata"
-    IDENTITY = "identity"
-    ACCESS = "access"
-    WORKSHOP = "workshop"
-    RESEARCH = "research"
-    SOAPIE = "soapie"
-    MEDIX = "medix"
-    DICOM = "dicom"
-    SCRIBE = "scribe"
-    CDS = "cds"
-    IMAGING = "imaging"
-    MCU = "mcu"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalSimpleKey = Optional[SimpleKey]
-ListOfSimpleKeys = List[SimpleKey]
-OptionalListOfSimpleKeys = Optional[ListOfSimpleKeys]
-SequenceOfSimpleKeys = Sequence[SimpleKey]
-OptionalSequenceOfSimpleKeys = Optional[SequenceOfSimpleKeys]
-
-
-class Key(StrEnum):
-    STUDIO = "maleo-studio"
-    NEXUS = "maleo-nexus"
-    TELEMETRY = "maleo-telemetry"
-    METADATA = "maleo-metadata"
-    IDENTITY = "maleo-identity"
-    ACCESS = "maleo-access"
-    WORKSHOP = "maleo-workshop"
-    RESEARCH = "maleo-research"
-    SOAPIE = "maleo-soapie"
-    MEDIX = "maleo-medix"
-    DICOM = "maleo-dicom"
-    SCRIBE = "maleo-scribe"
-    CDS = "maleo-cds"
-    IMAGING = "maleo-imaging"
-    MCU = "maleo-mcu"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalKey = Optional[Key]
-ListOfKeys = List[Key]
-OptionalListOfKeys = Optional[ListOfKeys]
-SequenceOfKeys = Sequence[Key]
-OptionalSequenceOfKeys = Optional[SequenceOfKeys]
-
-
-class SimpleName(StrEnum):
-    STUDIO = "Studio"
-    NEXUS = "Nexus"
-    TELEMETRY = "Telemetry"
-    METADATA = "Metadata"
-    IDENTITY = "Identity"
-    ACCESS = "Access"
-    WORKSHOP = "Workshop"
-    RESEARCH = "Research"
-    SOAPIE = "SOAPIE"
-    MEDIX = "Medix"
-    DICOM = "DICON"
-    SCRIBE = "Scribe"
-    CDS = "CDS"
-    IMAGING = "Imaging"
-    MCU = "MCU"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalSimpleName = Optional[SimpleName]
-ListOfSimpleNames = List[SimpleName]
-OptionalListOfSimpleNames = Optional[ListOfSimpleNames]
-SequenceOfSimpleNames = Sequence[SimpleName]
-OptionalSequenceOfSimpleNames = Optional[SequenceOfSimpleNames]
-
-
-class Name(StrEnum):
-    STUDIO = "MaleoStudio"
-    NEXUS = "MaleoNexus"
-    TELEMETRY = "MaleoTelemetry"
-    METADATA = "MaleoMetadata"
-    IDENTITY = "MaleoIdentity"
-    ACCESS = "MaleoAccess"
-    WORKSHOP = "MaleoWorkshop"
-    RESEARCH = "MaleoResearch"
-    SOAPIE = "MaleoSOAPIE"
-    MEDIX = "MaleoMedix"
-    DICOM = "MaleoDICON"
-    SCRIBE = "MaleoScribe"
-    CDS = "MaleoCDS"
-    IMAGING = "MaleoImaging"
-    MCU = "MaleoMCU"
-
-    @classmethod
-    def choices(cls) -> ListOfStrings:
-        return [e.value for e in cls]
-
-
-OptionalName = Optional[Name]
-ListOfNames = List[Name]
-OptionalListOfNames = Optional[ListOfNames]
-SequenceOfNames = Sequence[Name]
-OptionalSequenceOfNames = Optional[SequenceOfNames]