maleo-foundation 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

maleo_foundation/models/responses.py

@@ -0,0 +1,99 @@
+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
+
+class BaseResponses:
+    class Fail(BaseResultSchemas.Fail):
+        other:Optional[Any] = Field("Please try again later or contact administrator.", description="Response's other information")
+
+    class Unauthorized(Fail):
+        code:str = "MAL-ATH-001"
+        message:str = "Unauthorized Request"
+        description:str = "You are unauthorized to request this resource"
+
+    class Forbidden(Fail):
+        code:str = "MAL-ATH-002"
+        message:str = "Forbidden Request"
+        description:str = "You are forbidden from requesting this resource"
+
+    class NotFound(Fail):
+        code:str = "MAL-NTF-001"
+        message:str = "Not Found Error"
+        description:str = "The resource you requested can not be found. Ensure your request is correct."
+
+    class ValidationError(Fail):
+        code:str = "MAL-VLD-001"
+        message:str = "Validation Error"
+        description:str = "Request validation failed due to missing or invalid fields. Check other for more info."
+
+    class RateLimitExceeded(Fail):
+        code:str = "MAL-RTL-001"
+        message:str = "Rate Limit Exceeded"
+        description:str = "This resource is requested too many times. Please try again later."
+
+    class ServerError(Fail):
+        code:str = "MAL-EXC-001"
+        message:str = "Unexpected Server Error"
+        description:str = "An unexpected error occurred while processing your request."
+
+    class NoData(BaseResultSchemas.NoData): pass
+
+    class SingleData(BaseResultSchemas.SingleData): pass
+
+    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData): pass
+
+    class PaginatedMultipleData(BaseResultSchemas.PaginatedMultipleData):
+        @model_validator(mode="before")
+        @classmethod
+        def calculate_pagination(cls, values: dict) -> dict:
+            """Calculates pagination metadata before validation."""
+            total_data = values.get("total_data", 0)
+            data = values.get("data", [])
+
+            #* Get pagination values from inherited SimplePagination
+            page = values.get("page", 1)
+            limit = values.get("limit", 10)
+
+            #* Calculate total pages
+            total_pages = (total_data // limit) + (1 if total_data % limit > 0 else 0)
+
+            #* Assign computed pagination object before validation
+            values["pagination"] = BaseGeneralSchemas.ExtendedPagination(
+                page=page,
+                limit=limit,
+                data_count=len(data),
+                total_data=total_data,
+                total_pages=total_pages
+            )
+            return values
+
+    #* ----- ----- Responses Class ----- ----- *#
+    other_responses={
+        status.HTTP_401_UNAUTHORIZED: {
+            "description": "Unauthorized Response",
+            "model": Unauthorized
+        },
+        status.HTTP_403_FORBIDDEN: {
+            "description": "Forbidden Response",
+            "model": Forbidden
+        },
+        status.HTTP_404_NOT_FOUND: {
+            "description": "Not Found Response",
+            "model": NotFound
+        },
+        status.HTTP_422_UNPROCESSABLE_ENTITY: {
+            "description": "Validation Error Response",
+            "model": ValidationError
+        },
+        status.HTTP_429_TOO_MANY_REQUESTS: {
+            "description": "Rate Limit Exceeded Response",
+            "model": RateLimitExceeded
+        },
+        status.HTTP_500_INTERNAL_SERVER_ERROR: {
+            "description": "Internal Server Error Response",
+            "model": ServerError
+        }
+    }

maleo_foundation/models/schemas/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from .general import BaseGeneralSchemas
+from .parameter import BaseParameterSchemas
+from .result import BaseResultSchemas
+
+class BaseSchemas:
+    General = BaseGeneralSchemas
+    Parameter = BaseParameterSchemas
+    Result = BaseResultSchemas

maleo_foundation/models/schemas/general.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+from datetime import date, datetime, timedelta, timezone
+from pydantic import BaseModel, Field, model_validator, field_serializer, FieldSerializationInfo
+from typing import Optional, Any
+from uuid import UUID
+from maleo_foundation.models.enums import BaseEnums
+from maleo_foundation.constants import REFRESH_TOKEN_DURATION_DAYS, ACCESS_TOKEN_DURATION_MINUTES
+
+class BaseGeneralSchemas:
+    class IDs(BaseModel):
+        ids:Optional[list[int]] = Field(None, description="Specific IDs")
+
+    class Search(BaseModel):
+        search:Optional[str] = Field(None, description="Search parameter string.")
+
+    class DateFilter(BaseModel):
+        name:str = Field(..., description="Column name.")
+        from_date:Optional[datetime] = Field(None, description="From date.")
+        to_date:Optional[datetime] = Field(None, description="To date.")
+
+    class Statuses(BaseModel):
+        statuses:Optional[list[BaseEnums.StatusType]] = Field(None, description="Data's status")
+
+    class SortColumn(BaseModel):
+        name:str = Field(..., description="Column name.")
+        order:BaseEnums.SortOrder = Field(..., description="Sort order.")
+
+    class SimplePagination(BaseModel):
+        page:int = Field(1, ge=1, description="Page number, must be >= 1.")
+        limit:int = Field(10, ge=1, le=100, description="Page size, must be 1 <= limit <= 100.")
+
+    class ExtendedPagination(SimplePagination):
+        data_count:int = Field(..., description="Fetched data count")
+        total_data:int = Field(..., description="Total data count")
+        total_pages:int = Field(..., description="Total pages count")
+
+    class StatusUpdate(BaseModel):
+        action:BaseEnums.StatusUpdateAction = Field(..., description="Status update's action to be executed")
+
+    class Expand(BaseModel):
+        expand:Optional[list[str]] = Field(None, description="Expanded field(s)")
+
+    class PrivateKey(BaseModel):
+        private_key:str = Field(..., description="Private key in str format.")
+
+    class PublicKey(BaseModel):
+        public_key:str = Field(..., description="Public key in str format.")
+
+    class KeyPair(PublicKey, PrivateKey): pass
+
+    class TokenPayload(BaseModel):
+        t:BaseEnums.TokenType = Field(..., description="Token Type")
+        sr:UUID = Field(..., description="System role")
+        u:UUID = Field(..., description="user")
+        o:Optional[UUID] = Field(..., description="Organization")
+        uor:Optional[list[UUID]] = Field(..., description="User Organization Role")
+        iat_dt:datetime = Field(datetime.now(timezone.utc), description="Issued at (datetime)")
+        iat:int = Field(None, description="Issued at (integer)")
+        exp_dt:datetime = Field(None, description="Expired at (datetime)")
+        exp:int = Field(None, description="Expired at (integet)")
+
+        @model_validator(mode="before")
+        @classmethod
+        def set_iat_and_exp(cls, values:dict):
+            iat_dt = values.get("iat_dt", None)
+            if not iat_dt:
+                iat_dt = datetime.now(timezone.utc)
+            else:
+                if not isinstance(iat_dt, datetime):
+                    iat_dt = datetime.fromisoformat(iat_dt)
+            values["iat_dt"] = iat_dt
+            #* Convert `iat` to timestamp (int)
+            values["iat"] = int(iat_dt.timestamp())
+            exp_dt = values.get("exp_dt", None)
+            if not exp_dt:
+                if values["t"] == BaseEnums.TokenType.REFRESH:
+                    exp_dt = iat_dt + timedelta(days=REFRESH_TOKEN_DURATION_DAYS)
+                elif values["t"] == BaseEnums.TokenType.ACCESS:
+                    exp_dt = iat_dt + timedelta(minutes=ACCESS_TOKEN_DURATION_MINUTES)
+            else:
+                if not isinstance(exp_dt, datetime):
+                    exp_dt = datetime.fromisoformat(exp_dt)
+            values["exp_dt"] = exp_dt
+            #* Convert `exp_dt` to timestamp (int)
+            values["exp"] = int(exp_dt.timestamp())
+            return values
+        
+        @field_serializer('*')
+        def serialize_fields(self, value, info: FieldSerializationInfo) -> Any:
+            """Recursively serialize UUIDs, datetimes, and dates in complex structures."""
+
+            def serialize(v: Any) -> Any:
+                if isinstance(v, UUID):
+                    return str(v)
+                if isinstance(v, (datetime, date)):
+                    return v.isoformat()
+                if isinstance(v, list):
+                    return [serialize(item) for item in v]
+                if isinstance(v, tuple):
+                    return tuple(serialize(item) for item in v)
+                if isinstance(v, dict):
+                    return {serialize(k): serialize(val) for k, val in v.items()}
+                return v
+
+            return serialize(value)

maleo_foundation/models/schemas/parameter.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+from maleo_foundation.models.enums import BaseEnums
+from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+
+class BaseParameterSchemas:
+    class Filters(BaseModel):
+        filters:list[str] = Field([], description="Filters for date range, e.g. 'created_at|from::<ISO_DATETIME>|to::<ISO_DATETIME>'.")
+
+    class DateFilters(BaseModel):
+        date_filters:list[BaseGeneralSchemas.DateFilter] = Field([], description="Date filters to be applied")
+
+    class Sorts(BaseModel):
+        sorts:list[str] = Field(["id.asc"], description="Sorting columns in 'column_name.asc' or 'column_name.desc' format.")
+
+    class SortColumns(BaseModel):
+        sort_columns:list[BaseGeneralSchemas.SortColumn] = Field([BaseGeneralSchemas.SortColumn(name="id", order=BaseEnums.SortOrder.ASC)], description="List of columns to be sorted")

maleo_foundation/models/schemas/result.py

@@ -0,0 +1,89 @@
+from datetime import datetime, date
+from pydantic import BaseModel, FieldSerializationInfo, Field, field_serializer, field_validator
+from typing import Literal, Optional, Union, Any
+from uuid import UUID
+from maleo_foundation.models.enums import BaseEnums
+from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+
+class BaseResultSchemas:
+    class Identifiers(BaseModel):
+        id:int = Field(..., ge=1, description="Data's ID, must be >= 1.")
+        uuid:UUID = Field(..., description="Data's UUID.")
+
+        @field_serializer('uuid')
+        def serialize_uuid(self, value:UUID, info:FieldSerializationInfo) -> str:
+            """Serializes UUID to a hex string."""
+            return str(value)
+
+    class Timestamps(BaseModel):
+        created_at:datetime = Field(..., description="Data's created_at timestamp")
+        updated_at:datetime = Field(..., description="Data's updated_at timestamp")
+        deleted_at:Optional[datetime] = Field(..., description="Data's deleted_at timestamp")
+        restored_at:Optional[datetime] = Field(..., description="Data's restored_at timestamp")
+        deactivated_at:Optional[datetime] = Field(..., description="Data's deactivated_at timestamp")
+        activated_at:datetime = Field(..., description="Data's activated_at timestamp")
+
+        @field_serializer('created_at', 'updated_at', 'deleted_at', 'restored_at', 'deactivated_at', 'activated_at')
+        def serialize_timestamps(self, value:Union[datetime, date], info:FieldSerializationInfo) -> str:
+            """Serializes datetime/date fields to ISO format."""
+            return value.isoformat()
+
+    class Status(BaseModel):
+        status:BaseEnums.StatusType = Field(..., description="Data's status")
+
+    class Row(Status, Timestamps, Identifiers):
+        @field_validator('*', mode="before")
+        def set_none(cls, values):
+            if isinstance(values, str) and (values == "" or len(values) == 0):
+                return None
+            return values
+        
+        @field_serializer('*')
+        def serialize_fields(self, value, info:FieldSerializationInfo) -> Any:
+            """Serializes all unique-typed fields."""
+            if isinstance(value, UUID):
+                return str(value)
+            if isinstance(value, datetime) or isinstance(value, date):
+                return value.isoformat()
+            return value
+
+        class Config:
+            from_attributes=True
+
+    #* ----- ----- ----- Base ----- ----- ----- *#
+    class Base(BaseModel):
+        success:bool = Field(..., description="Success status")
+        code:Optional[str] = Field(None, description="Optional result code")
+        message:Optional[str] = Field(None, description="Optional message")
+        description:Optional[str] = Field(None, description="Optional description")
+        data:Any = Field(..., description="Data")
+        other:Optional[Any] = Field(None, description="Optional other information")
+
+    #* ----- ----- ----- Intermediary ----- ----- ----- *#
+    class Fail(Base):
+        success:Literal[False] = Field(False, description="Success status")
+        data:None = Field(None, description="No data")
+
+    class Success(Base):
+        success:Literal[True] = Field(True, description="Success status")
+        data:Any = Field(..., description="Data")
+
+    #* ----- ----- ----- Derived ----- ----- ----- *#
+    class NoData(Success):
+        success:Literal[True] = Field(True, description="Success status")
+        data:None = Field(None, description="No data")
+
+    class SingleData(Success):
+        success:Literal[True] = Field(True, description="Success status")
+        data:Any = Field(..., description="Fetched single data")
+
+    class UnpaginatedMultipleData(Success):
+        success:Literal[True] = Field(True, description="Success status")
+        data:list[Any] = Field(..., description="Unpaginated multiple data")
+
+    class PaginatedMultipleData(
+        UnpaginatedMultipleData,
+        BaseGeneralSchemas.SimplePagination
+    ):
+        total_data:int = Field(..., description="Total data count")
+        pagination:BaseGeneralSchemas.ExtendedPagination = Field(..., description="Pagination metadata")

maleo_foundation/models/transfers/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from .parameters import BaseParametersTransfers
+from .results import BaseResultsTransfers
+
+class BaseTransfers:
+    Parameters = BaseParametersTransfers
+    Results = BaseResultsTransfers

maleo_foundation/models/transfers/parameters/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from .general import BaseGeneralParametersTransfers
+from .service import BaseServiceParametersTransfers
+from .client import BaseClientParametersTransfers
+
+class BaseParametersTransfers:
+    General = BaseGeneralParametersTransfers
+    Service = BaseServiceParametersTransfers
+    Client = BaseClientParametersTransfers

maleo_foundation/models/transfers/parameters/client.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from pydantic import model_validator
+from typing import Any
+from typing import Self
+from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+from maleo_foundation.models.schemas.parameter import BaseParameterSchemas
+
+class BaseClientParametersTransfers:
+    class GetMultiple(
+        BaseParameterSchemas.DateFilters,
+        BaseParameterSchemas.SortColumns,
+        BaseGeneralSchemas.Search,
+        BaseGeneralSchemas.SimplePagination,
+        BaseGeneralSchemas.Statuses
+    ):
+        pass
+
+    class GetMultipleQuery(
+        BaseParameterSchemas.Filters,
+        BaseParameterSchemas.Sorts,
+        GetMultiple
+    ):
+        @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.sort = 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.filter = filter
+
+            return self
+            
+        def to_query_params(self) -> dict[str, Any]:
+            params = {
+                "page": self.page,
+                "limit": self.limit,
+                "search": self.search,
+                "sort": self.sort,
+                "filter": self.filter,
+            }
+            if hasattr(self, "statuses") and self.statuses is not None:
+                params["statuses"] = self.statuses
+            return params

maleo_foundation/models/transfers/parameters/general.py

@@ -0,0 +1,13 @@
+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
+
+class BaseGeneralParametersTransfers:
+    class GetSingleQuery(BaseGeneralSchemas.Statuses): pass
+
+    class GetSingle(BaseGeneralSchemas.Statuses):
+        identifier:BaseEnums.UniqueIdentifiers = Field(..., description="Identifier")
+        value:Union[int, UUID] = Field(..., description="Value")

maleo_foundation/models/transfers/parameters/service.py

@@ -0,0 +1,121 @@
+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 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
+
+class BaseServiceParametersTransfers:
+    class GetMultipleQuery(
+        BaseParameterSchemas.Filters,
+        BaseParameterSchemas.Sorts,
+        BaseGeneralSchemas.Search,
+        BaseGeneralSchemas.SimplePagination,
+        BaseGeneralSchemas.Statuses
+    ):
+        @field_validator("sort")
+        @classmethod
+        def validate_sort_columns(cls, values):
+            if not isinstance(values, list):
+                return ["id.asc"]
+            return [value for value in values if SORT_COLUMN_PATTERN.match(value)]
+
+        @field_validator("filter")
+        @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(
+        BaseParameterSchemas.DateFilters,
+        BaseParameterSchemas.SortColumns,
+        GetMultipleQuery
+    ):
+        @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 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")
+        nullable:bool = Field(False, description="Whether to allow null field's value")
+        suggestion:Optional[str] = Field(None, description="Suggestion on discrepancy")
+
+    UniqueFieldChecks = list[UniqueFieldCheck]
+
+    status_update_criterias:dict[
+        BaseEnums.StatusUpdateAction,
+        Optional[list[BaseEnums.StatusType]]
+    ] = {
+        BaseEnums.StatusUpdateAction.DELETE: None,
+        BaseEnums.StatusUpdateAction.RESTORE: None,
+        BaseEnums.StatusUpdateAction.DEACTIVATE: [
+            BaseEnums.StatusType.INACTIVE,
+            BaseEnums.StatusType.ACTIVE,
+        ],
+        BaseEnums.StatusUpdateAction.ACTIVATE: [
+            BaseEnums.StatusType.INACTIVE,
+            BaseEnums.StatusType.ACTIVE,
+        ]
+    }

maleo_foundation/models/transfers/results/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from .service import BaseServiceResultsTransfers
+from .client import BaseClientResultsTransfers
+
+class BaseResultsTransfers:
+    Service = BaseServiceResultsTransfers
+    Client = BaseClientResultsTransfers

maleo_foundation/models/transfers/results/client/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from .service import BaseClientServiceResultsTransfers
+from .controllers import BaseClientControllersResultsTransfers
+
+class BaseClientResultsTransfers:
+    Service = BaseClientServiceResultsTransfers
+    Controller = BaseClientControllersResultsTransfers

maleo_foundation/models/transfers/results/client/controllers/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+from .http import BaseClientHTTPControllerResults
+
+class BaseClientControllersResultsTransfers:
+    HTTP = BaseClientHTTPControllerResults

maleo_foundation/models/transfers/results/client/controllers/http.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from httpx import Response
+from pydantic import BaseModel, Field, model_validator
+from typing import Any
+
+class BaseClientHTTPControllerResults(BaseModel):
+    response:Response = Field(..., description="Client's HTTP Controller response")
+    status_code:int = Field(..., description="Client's HTTP Controller response status code")
+    content:Any = Field(..., description="Client's HTTP Controller response content")
+    success:bool = Field(..., description="Client's HTTP Controller success status")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+    @model_validator(mode="before")
+    @classmethod
+    def process_response(cls, values:dict) -> dict:
+        """Process the response to set status_code, content, and success."""
+        response:Response = values.get("response")
+
+        if response:
+            values["status_code"] = response.status_code
+            values["success"] = response.is_success
+
+            #* Determine content type and parse accordingly
+            content_type:str = response.headers.get("content-type", "")
+            content_type = content_type.lower()
+            if "application/json" in content_type:
+                values["content"] = response.json()
+            elif "text/" in content_type or "application/xml" in content_type:
+                values["content"] = response.text
+            else:
+                values["content"] = response.content  #* Raw bytes for unknown types
+
+        return values

maleo_foundation/models/transfers/results/client/service.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from pydantic import model_validator
+from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+from maleo_foundation.models.schemas.result import BaseResultSchemas
+
+class BaseClientServiceResultsTransfers:
+    class Fail(BaseResultSchemas.Fail): pass
+
+    class NoData(BaseResultSchemas.NoData): pass
+
+    class SingleData(BaseResultSchemas.SingleData): pass
+
+    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData): pass
+
+    class PaginatedMultipleData(BaseResultSchemas.PaginatedMultipleData):
+        @model_validator(mode="before")
+        @classmethod
+        def calculate_pagination_component(cls, values: dict) -> dict:
+            """Extracts pagination components (page, limit, total_data) before validation."""
+            pagination = values.get("pagination")
+
+            if isinstance(pagination, BaseGeneralSchemas.ExtendedPagination):
+                values["page"] = pagination.page
+                values["limit"] = pagination.limit
+                values["total_data"] = pagination.total_data
+
+            return values

maleo_foundation/models/transfers/results/service/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from .general import BaseServiceGeneralResultsTransfers
+from .query import BaseServiceQueryResultsTransfers
+from .controllers import BaseServiceControllerResultsTransfers
+
+class BaseServiceResultsTransfers:
+    General = BaseServiceGeneralResultsTransfers
+    Query = BaseServiceQueryResultsTransfers
+    Controller = BaseServiceControllerResultsTransfers

maleo_foundation/models/transfers/results/service/controllers/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+from .rest import BaseServiceRESTControllerResults
+
+class BaseServiceControllerResultsTransfers:
+    REST = BaseServiceRESTControllerResults