maleo-foundation 0.0.33__py3-none-any.whl → 0.0.34__py3-none-any.whl

maleo_foundation/models/expanded_types/client.py

@@ -4,36 +4,61 @@ from maleo_foundation.models.transfers.parameters.client import BaseClientParame
 from maleo_foundation.models.transfers.results.client.service import BaseClientServiceResultsTransfers
 
 class ExpandedClientTypes:
-    GetMultipleParameter = BaseClientParametersTransfers.GetMultiple
+    #* Unpaginated multiple data
+    GetUnpaginatedMultipleParameter = BaseClientParametersTransfers.GetUnpaginatedMultiple
+    GetUnpaginatedMultipleResult = Union[
+        BaseClientServiceResultsTransfers.Fail,
+        BaseClientServiceResultsTransfers.NoData,
+        BaseClientServiceResultsTransfers.UnpaginatedMultipleData
+    ]
+    SyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        GetUnpaginatedMultipleResult
+    ]
+    AsyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        Awaitable[GetUnpaginatedMultipleResult]
+    ]
 
-    GetMultipleResult = Union[
+    #* Paginated multiple data
+    GetPaginatedMultipleParameter = BaseClientParametersTransfers.GetPaginatedMultiple
+    GetPaginatedMultipleResult = Union[
         BaseClientServiceResultsTransfers.Fail,
         BaseClientServiceResultsTransfers.NoData,
-        BaseClientServiceResultsTransfers.UnpaginatedMultipleData,
         BaseClientServiceResultsTransfers.PaginatedMultipleData
     ]
+    SyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        GetPaginatedMultipleResult
+    ]
+    AsyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        Awaitable[GetPaginatedMultipleResult]
+    ]
 
-    SyncGetMultipleFunction = Callable[[GetMultipleParameter], GetMultipleResult]
-
-    AsyncGetMultipleFunction = Callable[[GetMultipleParameter], Awaitable[GetMultipleResult]]
-
+    #* Single data
     GetSingleParameter = BaseGeneralParametersTransfers.GetSingle
-
     GetSingleResult = Union[
         BaseClientServiceResultsTransfers.Fail,
         BaseClientServiceResultsTransfers.NoData,
         BaseClientServiceResultsTransfers.SingleData
     ]
+    SyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        GetSingleResult
+    ]
+    AsyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        Awaitable[GetSingleResult]
+    ]
 
-    SyncGetSingleFunction = Callable[[GetSingleParameter], GetSingleResult]
-
-    AsyncGetSingleFunction = Callable[[GetSingleParameter], Awaitable[GetSingleResult]]
-
+    #* Create or Update
     CreateOrUpdateResult = Union[
         BaseClientServiceResultsTransfers.Fail,
         BaseClientServiceResultsTransfers.SingleData
     ]
 
+    #* Status Update
     StatusUpdateResult = Union[
         BaseClientServiceResultsTransfers.Fail,
         BaseClientServiceResultsTransfers.SingleData

maleo_foundation/models/expanded_types/query.py

@@ -4,36 +4,61 @@ from maleo_foundation.models.transfers.parameters.service import BaseServicePara
 from maleo_foundation.models.transfers.results.service.query import BaseServiceQueryResultsTransfers
 
 class ExpandedQueryTypes:
-    GetMultipleParameter = BaseServiceParametersTransfers.GetMultiple
+    #* Unpaginated multiple data
+    GetUnpaginatedMultipleParameter = BaseServiceParametersTransfers.GetUnpaginatedMultiple
+    GetUnpaginatedMultipleResult = Union[
+        BaseServiceQueryResultsTransfers.Fail,
+        BaseServiceQueryResultsTransfers.NoData,
+        BaseServiceQueryResultsTransfers.UnpaginatedMultipleData
+    ]
+    SyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        GetUnpaginatedMultipleResult
+    ]
+    AsyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        Awaitable[GetUnpaginatedMultipleResult]
+    ]
 
-    GetMultipleResult = Union[
+    #* Paginated multiple data
+    GetPaginatedMultipleParameter = BaseServiceParametersTransfers.GetPaginatedMultiple
+    GetPaginatedMultipleResult = Union[
         BaseServiceQueryResultsTransfers.Fail,
         BaseServiceQueryResultsTransfers.NoData,
-        BaseServiceQueryResultsTransfers.UnpaginatedMultipleData,
         BaseServiceQueryResultsTransfers.PaginatedMultipleData
     ]
+    SyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        GetPaginatedMultipleResult
+    ]
+    AsyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        Awaitable[GetPaginatedMultipleResult]
+    ]
 
-    SyncGetMultipleFunction = Callable[[GetMultipleParameter], GetMultipleResult]
-
-    AsyncGetMultipleFunction = Callable[[GetMultipleParameter], Awaitable[GetMultipleResult]]
-
+    #* Single data
     GetSingleParameter = BaseGeneralParametersTransfers.GetSingle
-
     GetSingleResult = Union[
         BaseServiceQueryResultsTransfers.Fail,
         BaseServiceQueryResultsTransfers.NoData,
         BaseServiceQueryResultsTransfers.SingleData
     ]
+    SyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        GetSingleResult
+    ]
+    AsyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        Awaitable[GetSingleResult]
+    ]
 
-    SyncGetSingleFunction = Callable[[GetSingleParameter], GetSingleResult]
-
-    AsyncGetSingleFunction = Callable[[GetSingleParameter], Awaitable[GetSingleResult]]
-
+    #* Create or Update
     CreateOrUpdateResult = Union[
         BaseServiceQueryResultsTransfers.Fail,
         BaseServiceQueryResultsTransfers.SingleData
     ]
 
+    #* Status update
     StatusUpdateResult = Union[
         BaseServiceQueryResultsTransfers.Fail,
         BaseServiceQueryResultsTransfers.SingleData

maleo_foundation/models/expanded_types/service.py

@@ -4,36 +4,61 @@ from maleo_foundation.models.transfers.parameters.service import BaseServicePara
 from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
 
 class ExpandedServiceTypes:
-    GetMultipleParameter = BaseServiceParametersTransfers.GetMultiple
+    #* Unpaginated multiple data
+    GetUnpaginatedMultipleParameter = BaseServiceParametersTransfers.GetUnpaginatedMultiple
+    GetUnpaginatedMultipleResult = Union[
+        BaseServiceGeneralResultsTransfers.Fail,
+        BaseServiceGeneralResultsTransfers.NoData,
+        BaseServiceGeneralResultsTransfers.UnpaginatedMultipleData
+    ]
+    SyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        GetUnpaginatedMultipleResult
+    ]
+    AsyncGetUnpaginatedMultipleFunction = Callable[
+        [GetUnpaginatedMultipleParameter],
+        Awaitable[GetUnpaginatedMultipleResult]
+    ]
 
-    GetMultipleResult = Union[
+    #* Paginated multiple data
+    GetPaginatedMultipleParameter = BaseServiceParametersTransfers.GetPaginatedMultiple
+    GetPaginatedMultipleResult = Union[
         BaseServiceGeneralResultsTransfers.Fail,
         BaseServiceGeneralResultsTransfers.NoData,
-        BaseServiceGeneralResultsTransfers.UnpaginatedMultipleData,
         BaseServiceGeneralResultsTransfers.PaginatedMultipleData
     ]
+    SyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        GetPaginatedMultipleResult
+    ]
+    AsyncGetPaginatedMultipleFunction = Callable[
+        [GetPaginatedMultipleParameter],
+        Awaitable[GetPaginatedMultipleResult]
+    ]
 
-    SyncGetMultipleFunction = Callable[[GetMultipleParameter], GetMultipleResult]
-
-    AsyncGetMultipleFunction = Callable[[GetMultipleParameter], Awaitable[GetMultipleResult]]
-
+    #* Single data
     GetSingleParameter = BaseGeneralParametersTransfers.GetSingle
-
     GetSingleResult = Union[
         BaseServiceGeneralResultsTransfers.Fail,
         BaseServiceGeneralResultsTransfers.NoData,
         BaseServiceGeneralResultsTransfers.SingleData
     ]
+    SyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        GetSingleResult
+    ]
+    AsyncGetSingleFunction = Callable[
+        [GetSingleParameter],
+        Awaitable[GetSingleResult]
+    ]
 
-    SyncGetSingleFunction = Callable[[GetSingleParameter], GetSingleResult]
-
-    AsyncGetSingleFunction = Callable[[GetSingleParameter], Awaitable[GetSingleResult]]
-
+    #* Create or Update
     CreateOrUpdateResult = Union[
         BaseServiceGeneralResultsTransfers.Fail,
         BaseServiceGeneralResultsTransfers.SingleData
     ]
 
+    #* Status update
     StatusUpdateResult = Union[
         BaseServiceGeneralResultsTransfers.Fail,
         BaseServiceGeneralResultsTransfers.SingleData

maleo_foundation/models/responses.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 from fastapi import status
 from pydantic import Field, model_validator
-from typing import Optional, Any
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
 from maleo_foundation.models.schemas.result import BaseResultSchemas
+from maleo_foundation.models.types import BaseTypes
 
 class BaseResponses:
     class Fail(BaseResultSchemas.Fail):
-        other:Optional[Any] = Field("Please try again later or contact administrator.", description="Response's other information")
+        other:BaseTypes.OptionalAny = Field("Please try again later or contact administrator.", description="Response's other information")
 
     class Unauthorized(Fail):
         code:str = "MAL-ATH-001"

maleo_foundation/models/schemas/parameter.py

@@ -1,4 +1,7 @@
-from pydantic import BaseModel, Field
+import re
+import urllib.parse
+from pydantic import BaseModel, Field, field_validator
+from maleo_foundation.constants import SORT_COLUMN_PATTERN, DATE_FILTER_PATTERN
 from maleo_foundation.models.enums import BaseEnums
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
 from maleo_foundation.models.types import BaseTypes
@@ -8,11 +11,30 @@ class BaseParameterSchemas:
     class Filters(BaseModel):
         filters:BaseTypes.ListOfStrings = Field([], description="Filters for date range, e.g. 'created_at|from::<ISO_DATETIME>|to::<ISO_DATETIME>'.")
 
+        @field_validator("filters")
+        @classmethod
+        def validate_date_filters(cls, values):
+            if isinstance(values, list):
+                decoded_values = [urllib.parse.unquote(value) for value in values]
+                #* Replace space followed by 2 digits, colon, 2 digits with + and those digits
+                fixed_values = []
+                for value in decoded_values:
+                    #* Look for the pattern: space followed by 2 digits, colon, 2 digits
+                    fixed_value = re.sub(r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+) (\d{2}:\d{2})', r'\1+\2', value)
+                    fixed_values.append(fixed_value)
+                final_values = [value for value in fixed_values if DATE_FILTER_PATTERN.match(value)]
+                return final_values
+
     class DateFilters(BaseModel):
         date_filters:ExtendedTypes.ListOfDateFilters = Field([], description="Date filters to be applied")
 
     class Sorts(BaseModel):
         sorts:BaseTypes.ListOfStrings = Field(["id.asc"], description="Sorting columns in 'column_name.asc' or 'column_name.desc' format.")
 
+        @field_validator("sorts")
+        @classmethod
+        def validate_sorts(cls, values):
+            return [value for value in values if SORT_COLUMN_PATTERN.match(value)]
+
     class SortColumns(BaseModel):
         sort_columns:ExtendedTypes.ListOfSortColumns = Field([BaseGeneralSchemas.SortColumn(name="id", order=BaseEnums.SortOrder.ASC)], description="List of columns to be sorted")

maleo_foundation/models/transfers/parameters/client.py

@@ -6,8 +6,7 @@ from maleo_foundation.models.schemas.general import BaseGeneralSchemas
 from maleo_foundation.models.schemas.parameter import BaseParameterSchemas
 
 class BaseClientParametersTransfers:
-    class GetMultiple(
-        BaseGeneralSchemas.SimplePagination,
+    class GetUnpaginatedMultiple(
         BaseParameterSchemas.SortColumns,
         BaseGeneralSchemas.Search,
         BaseGeneralSchemas.Statuses,
@@ -16,10 +15,63 @@ class BaseClientParametersTransfers:
     ):
         pass
 
-    class GetMultipleQuery(
+    class GetUnpaginatedMultipleQuery(
+        BaseParameterSchemas.Sorts,
+        BaseParameterSchemas.Filters,
+        GetUnpaginatedMultiple
+    ):
+        @model_validator(mode="after")
+        def set_sort(self) -> Self:
+            #* Process sort_columns parameters
+            sort = []
+            for item in self.sort_columns:
+                sort.append(f"{item.name}.{item.order.value}")
+
+            #* Only update if we have valid sort, otherwise keep the default
+            if sort:
+                self.sorts = sort
+
+            return self
+
+        @model_validator(mode="after")
+        def set_filter(self) -> Self:
+            #* Process filter parameters
+            filter = []
+            for item in self.date_filters:
+                if item.from_date or item.to_date:
+                    filter_string = item.name
+                    if item.from_date:
+                        filter_string += f"|from::{item.from_date.isoformat()}"
+                    if item.to_date:
+                        filter_string += f"|to::{item.to_date.isoformat()}"
+                    filter.append(filter_string)
+
+            #* Only update if we have valid filter, otherwise keep the default
+            if filter:
+                self.filters = filter
+
+            return self
+            
+        def to_query_params(self) -> dict[str, Any]:
+            params = {
+                "search": self.search,
+                "sorts": self.sorts,
+                "filters": self.filters,
+            }
+            if hasattr(self, "statuses") and self.statuses is not None:
+                params["statuses"] = self.statuses
+            return params
+
+    class GetPaginatedMultiple(
+        BaseGeneralSchemas.SimplePagination,
+        GetUnpaginatedMultiple
+    ):
+        pass
+
+    class GetPaginatedMultipleQuery(
         BaseParameterSchemas.Sorts,
         BaseParameterSchemas.Filters,
-        GetMultiple
+        GetPaginatedMultiple
     ):
         @model_validator(mode="after")
         def set_sort(self) -> Self:

maleo_foundation/models/transfers/parameters/general.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 from pydantic import Field
-from typing import Union
-from uuid import UUID
 from maleo_foundation.models.enums import BaseEnums
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+from maleo_foundation.models.types import BaseTypes
 
 class BaseGeneralParametersTransfers:
     class GetSingleQuery(BaseGeneralSchemas.Statuses): pass
 
     class GetSingle(BaseGeneralSchemas.Statuses):
         identifier:BaseEnums.UniqueIdentifiers = Field(..., description="Identifier")
-        value:Union[int, UUID] = Field(..., description="Value")
+        value:BaseTypes.IdentifierValue = Field(..., description="Value")

maleo_foundation/models/transfers/parameters/service.py

@@ -1,48 +1,86 @@
 from __future__ import annotations
-import re
-import urllib.parse
 from datetime import datetime
-from pydantic import BaseModel, Field, field_validator, model_validator
-from typing import Optional, Self, Any
+from pydantic import BaseModel, Field, model_validator
+from typing import Optional, Self
 from maleo_foundation.models.enums import BaseEnums
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
 from maleo_foundation.models.schemas.parameter import BaseParameterSchemas
-from maleo_foundation.constants import SORT_COLUMN_PATTERN, DATE_FILTER_PATTERN
+from maleo_foundation.models.types import BaseTypes
 
 class BaseServiceParametersTransfers:
-    class GetMultipleQuery(
-        BaseGeneralSchemas.SimplePagination,
+    class GetUnpaginatedMultipleQuery(
         BaseParameterSchemas.Sorts,
         BaseGeneralSchemas.Search,
         BaseGeneralSchemas.Statuses,
         BaseParameterSchemas.Filters,
         BaseGeneralSchemas.IDs
+    ): pass
+
+    class GetUnpaginatedMultiple(
+        BaseParameterSchemas.SortColumns,
+        BaseParameterSchemas.DateFilters,
+        GetUnpaginatedMultipleQuery
     ):
-        @field_validator("sorts")
-        @classmethod
-        def validate_sorts(cls, values):
-            if not isinstance(values, list):
-                return ["id.asc"]
-            return [value for value in values if SORT_COLUMN_PATTERN.match(value)]
-
-        @field_validator("filters")
-        @classmethod
-        def validate_date_filters(cls, values):
-            if isinstance(values, list):
-                decoded_values = [urllib.parse.unquote(value) for value in values]
-                #* Replace space followed by 2 digits, colon, 2 digits with + and those digits
-                fixed_values = []
-                for value in decoded_values:
-                    #* Look for the pattern: space followed by 2 digits, colon, 2 digits
-                    fixed_value = re.sub(r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+) (\d{2}:\d{2})', r'\1+\2', value)
-                    fixed_values.append(fixed_value)
-                final_values = [value for value in fixed_values if DATE_FILTER_PATTERN.match(value)]
-                return final_values
-
-    class GetMultiple(
+        @model_validator(mode="after")
+        def set_sort_columns(self) -> Self:
+            #* Process sort parameters
+            sort_columns = []
+            for item in self.sorts:
+                parts = item.split('.')
+                if len(parts) == 2 and parts[1].lower() in ["asc", "desc"]:
+                    try:
+                        sort_columns.append(BaseGeneralSchemas.SortColumn(name=parts[0], order=BaseEnums.SortOrder(parts[1].lower())))
+                    except ValueError:
+                        continue
+
+            #* Only update if we have valid sort columns, otherwise keep the default
+            if sort_columns:
+                self.sort_columns = sort_columns
+            return self
+
+        @model_validator(mode="after")
+        def set_date_filters(self) -> Self:
+            #* Process filter parameters
+            date_filters = []
+            for filter_item in self.filters:
+                parts = filter_item.split('|')
+                if len(parts) >= 2 and parts[0]:
+                    name = parts[0]
+                    from_date = None
+                    to_date = None
+
+                    #* Process each part to extract from and to dates
+                    for part in parts[1:]:
+                        if part.startswith('from::'):
+                            try:
+                                from_date_str = part.replace('from::', '')
+                                from_date = datetime.fromisoformat(from_date_str)
+                            except ValueError:
+                                continue
+                        elif part.startswith('to::'):
+                            try:
+                                to_date_str = part.replace('to::', '')
+                                to_date = datetime.fromisoformat(to_date_str)
+                            except ValueError:
+                                continue
+
+                    #* Only add filter if at least one date is specified
+                    if from_date or to_date:
+                        date_filters.append(BaseGeneralSchemas.DateFilter(name=name, from_date=from_date, to_date=to_date))
+
+            #* Update date_filters
+            self.date_filters = date_filters
+            return self
+
+    class GetPaginatedMultipleQuery(
+        BaseGeneralSchemas.SimplePagination,
+        GetUnpaginatedMultipleQuery
+    ): pass
+
+    class GetPaginatedMultiple(
         BaseParameterSchemas.SortColumns,
         BaseParameterSchemas.DateFilters,
-        GetMultipleQuery
+        GetPaginatedMultipleQuery
     ):
         @model_validator(mode="after")
         def set_sort_columns(self) -> Self:
@@ -98,10 +136,10 @@ class BaseServiceParametersTransfers:
     class UniqueFieldCheck(BaseModel):
         operation:BaseEnums.OperationType = Field(..., description="Operation to be conducted")
         field:BaseEnums.UniqueIdentifiers = Field(..., description="Field to be checked")
-        new_value:Optional[Any] = Field(..., description="New field's value")
-        old_value:Optional[Any] = Field(None, description="Old field's value")
+        new_value:BaseTypes.OptionalAny = Field(..., description="New field's value")
+        old_value:BaseTypes.OptionalAny = Field(None, description="Old field's value")
         nullable:bool = Field(False, description="Whether to allow null field's value")
-        suggestion:Optional[str] = Field(None, description="Suggestion on discrepancy")
+        suggestion:BaseTypes.OptionalString = Field(None, description="Suggestion on discrepancy")
 
     UniqueFieldChecks = list[UniqueFieldCheck]
 

maleo_foundation/query.py

@@ -3,14 +3,14 @@ from sqlalchemy.orm import Query
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.sql.expression import or_, asc, cast, desc
 from sqlalchemy.types import DATE, String, TEXT, TIMESTAMP
-from typing import Optional, Type
+from typing import Type
 from maleo_foundation.db import DatabaseManager
-from maleo_foundation.models.enums import BaseEnums
-from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+from maleo_foundation.models.types import BaseTypes
+from maleo_foundation.models.extended_types import ExtendedTypes
 
 class BaseQuery:
     @staticmethod
-    def filter_ids(query:Query, table:Type[DatabaseManager.Base], column:str, ids:Optional[list[int]]) -> Query:
+    def filter_ids(query:Query, table:Type[DatabaseManager.Base], column:str, ids:BaseTypes.OptionalListOfIntegers) -> Query:
         if ids is not None:
             column_attr = getattr(table, column, None)
             if column_attr:
@@ -19,7 +19,7 @@ class BaseQuery:
         return query
     
     @staticmethod
-    def filter_timestamps(query:Query, table:Type[DatabaseManager.Base], date_filters:list[BaseGeneralSchemas.DateFilter]) -> Query:
+    def filter_timestamps(query:Query, table:Type[DatabaseManager.Base], date_filters:ExtendedTypes.ListOfDateFilters) -> Query:
         if date_filters and len(date_filters) > 0:
             for date_filter in date_filters:
                 try:
@@ -38,14 +38,14 @@ class BaseQuery:
         return query
     
     @staticmethod
-    def filter_statuses(query:Query, table:Type[DatabaseManager.Base], statuses:Optional[list[BaseEnums.StatusType]]) -> Query:
+    def filter_statuses(query:Query, table:Type[DatabaseManager.Base], statuses:BaseTypes.OptionalListOfStatuses) -> Query:
         if statuses is not None:
             status_filters = [table.status == status for status in statuses]
             query = query.filter(or_(*status_filters))
         return query
     
     @staticmethod
-    def filter_search(query:Query, table:Type[DatabaseManager.Base], search:Optional[str]) -> Query:
+    def filter_search(query:Query, table:Type[DatabaseManager.Base], search:BaseTypes.OptionalString) -> Query:
         if search:
             search_term = f"%{search}%" #* Use wildcard for partial matching
             search_filters = []
@@ -64,7 +64,7 @@ class BaseQuery:
         return query
     
     @staticmethod
-    def sort(query:Query, table:Type[DatabaseManager.Base], sort_columns:list[BaseGeneralSchemas.SortColumn]) -> Query:
+    def sort(query:Query, table:Type[DatabaseManager.Base], sort_columns:ExtendedTypes.ListOfSortColumns) -> Query:
         for sort_column in sort_columns:
             try:
                 sort_col = getattr(table, sort_column.name)

{maleo_foundation-0.0.33.dist-info → maleo_foundation-0.0.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.0.33
+Version: 0.0.34
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.0.33.dist-info → maleo_foundation-0.0.34.dist-info}/RECORD

@@ -1,7 +1,7 @@
 maleo_foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/constants.py,sha256=l6WQp0nu2y4Ucs8bFcEdzVUJfR1dRM_nveuHGMhe3rY,424
 maleo_foundation/controller.py,sha256=Z5WbsrkTFYqC7GrnXR-gsqTN6IC_jz-wrOK3mU4GaU0,3005
-maleo_foundation/query.py,sha256=Wv9smUNuAa8ZMvb9KiG_sUqyNFG9KXFo3JX6kpxjWQ4,3868
+maleo_foundation/query.py,sha256=theAgfJy88CsNeloApotzTsJMSG8j2v3CykMGrVR2PI,3864
 maleo_foundation/clients/__init__.py,sha256=W8vydJYeDEi6gdmOZSBFSSDsfZJtb8C05CHErZgsZ30,188
 maleo_foundation/clients/general/__init__.py,sha256=l9eQrBeLW4aXtGU5aK3i6fD-msVR4526W7D9V8WCXIg,91
 maleo_foundation/clients/general/http.py,sha256=Awvs470hgdhZSZW_uoIFJGcJ5hcfDEIX0A2yUaP9UCA,1353
@@ -20,21 +20,21 @@ maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG
 maleo_foundation/models/__init__.py,sha256=HTiSh5eRZ6_iBR2fmylLw_UZNE82GsmzHG3HFBqH2uE,500
 maleo_foundation/models/enums.py,sha256=Ob2v312JxypHEq7hTKZKOV462FEeLkIjIhpx-YF6Jdw,2203
 maleo_foundation/models/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBmdc-L4,301
-maleo_foundation/models/responses.py,sha256=1Rs3EflBJdsTC8PSbaOFbbTyxwRwK031eU3qLEj21sU,4215
+maleo_foundation/models/responses.py,sha256=pAHlRzbLJtlu9TwMtLBK7nbtjsvKnV0cJtbvtQH2l8E,4242
 maleo_foundation/models/types.py,sha256=rg9AoNwwECJ2BhYdoz3DiUMlBgFRWVEl4KGrfTCntnI,1213
 maleo_foundation/models/expanded_types/__init__.py,sha256=RohoIQCiMvo2g6Jacq2dlqNXg3WLmRc-TD8nvMsyDKs,275
-maleo_foundation/models/expanded_types/client.py,sha256=FlZnuPmYmjexXe8afxKXUzWX2Eq7Xw4tsyekZbVAHts,1582
-maleo_foundation/models/expanded_types/query.py,sha256=0rNLdaqKL-QGzd5EX1RRphJQpXb1XCZQfEfVFIIdBUc,1571
-maleo_foundation/models/expanded_types/service.py,sha256=N-HT6DXah839YefCHuLUB63Zpl1YUogzcHbVwdW2vXA,1599
+maleo_foundation/models/expanded_types/client.py,sha256=To0kRXp3QTmuSu5rWKaCiTsMK9qkYiyYKYbHfw-y1fY,2396
+maleo_foundation/models/expanded_types/query.py,sha256=0yUG-JIVsanzB7KAkrRz_OsrhP6J0bRqD9Q3l3atQnk,2384
+maleo_foundation/models/expanded_types/service.py,sha256=q8jpKdbCbLWwH1UPQavKpVE14rC5rveduk2cFWzuhGw,2416
 maleo_foundation/models/schemas/__init__.py,sha256=Xj8Ahsqyra-fmEaVcGPok5GOOsPQlKcknHYMvbjvENA,277
 maleo_foundation/models/schemas/general.py,sha256=JwsAP-rLO_o4lgPUi9gYHGhwzV7KVzsg8axAJZNyxlw,6680
-maleo_foundation/models/schemas/parameter.py,sha256=LN-MNuvACMYTCZoxojC-Bqo4YYMmAYCriVnLy85dH6c,1012
+maleo_foundation/models/schemas/parameter.py,sha256=YixHZXszx9dtmiSGypf9cNxaHw7NS78VJcrTDhGlBpg,2121
 maleo_foundation/models/schemas/result.py,sha256=69JsTor9gNTVhUErFsFWN8CC9SZ9aXUO08kziGbXxsY,1754
 maleo_foundation/models/transfers/__init__.py,sha256=B8oCZHE3NTsrJ_rviSXaDsuc-gc25jpjuhJO40lpQiE,222
 maleo_foundation/models/transfers/parameters/__init__.py,sha256=oKW4RPIEISISRjsJzD8lsCGY1HhZRTzshPpWHcJu86k,353
-maleo_foundation/models/transfers/parameters/client.py,sha256=Q43A-Z7JPXcxb_v7iUKoA1_WV8AMdEaeSl9Z39WSF_8,2287
-maleo_foundation/models/transfers/parameters/general.py,sha256=TDDUAc7GsKA9jhpan5BqoGVpOcwJPHpV34atXEd0D60,532
-maleo_foundation/models/transfers/parameters/service.py,sha256=4_khFthR0JD5FklRYQNCG_8gMJmLTfAno7kQFEK1An4,5358
+maleo_foundation/models/transfers/parameters/client.py,sha256=GjRYMDO9I0ZEfFPFJTn1CIFHYX1tvEF6kY5olD2xqR0,4059
+maleo_foundation/models/transfers/parameters/general.py,sha256=FYCqrTAuYwdyxpVlMGz_h7PXeUnnGyrEWWlxPOGPs9w,546
+maleo_foundation/models/transfers/parameters/service.py,sha256=OS4cAKwE4rh_w-Crp_bIlbTUx4QzYwwDgHfs86MoD0o,6773
 maleo_foundation/models/transfers/results/__init__.py,sha256=0_8uJ1IQW87RZ4nIxzWkQVi3Fxb7B8myZTngXfoxgNc,241
 maleo_foundation/models/transfers/results/client/__init__.py,sha256=xBRuY0NUIPpQEGQ2qoBnqLZGX4W1YSrQ0VnDf5OYJBo,290
 maleo_foundation/models/transfers/results/client/service.py,sha256=TO_U53vmUEnFWiiyuu33ao3BUidt6KFxvk3GC9uo8JE,1108
@@ -50,7 +50,7 @@ maleo_foundation/utils/exceptions.py,sha256=mcvBwHm6uWpVQkPtO1T2j-GaTYEiyPOeGxiD
 maleo_foundation/utils/logger.py,sha256=ICrFi0MxuAjDy8KTRL7pex1miwzZqZX-HHArgN3niJM,2453
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
-maleo_foundation-0.0.33.dist-info/METADATA,sha256=fGpHuBcoyjtBsKgInq1DNYKzuZ-N4pmxwaCzqzF74Fo,3160
-maleo_foundation-0.0.33.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-maleo_foundation-0.0.33.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.0.33.dist-info/RECORD,,
+maleo_foundation-0.0.34.dist-info/METADATA,sha256=RE3ZQqM5i5l8sxHwG6V8ox_WeoVDVOAKO0bkL6veLLY,3160
+maleo_foundation-0.0.34.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+maleo_foundation-0.0.34.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.0.34.dist-info/RECORD,,