nexo-schemas 0.0.16__py3-none-any.whl

nexo/schemas/operation/system.py

@@ -0,0 +1,55 @@
+from typing import Generic, Literal
+from nexo.types.boolean import BoolT
+from ..connection import OptConnectionContext
+from ..error import (
+    OptAnyErrorT,
+    AnyErrorT,
+)
+from ..response import OptResponseT, ErrorResponseT, OptSuccessResponseT
+from .action.system import SystemOperationAction
+from .base import BaseOperation
+from .enums import OperationType
+
+
+class SystemOperation(
+    BaseOperation[
+        SystemOperationAction,
+        None,
+        BoolT,
+        OptAnyErrorT,
+        OptConnectionContext,
+        OptResponseT,
+        None,
+    ],
+    Generic[
+        BoolT,
+        OptAnyErrorT,
+        OptResponseT,
+    ],
+):
+    type: OperationType = OperationType.SYSTEM
+    resource: None = None
+    response_context: None = None
+
+
+class FailedSystemOperation(
+    SystemOperation[
+        Literal[False],
+        AnyErrorT,
+        ErrorResponseT,
+    ],
+    Generic[AnyErrorT, ErrorResponseT],
+):
+    success: Literal[False] = False
+
+
+class SuccessfulSystemOperation(
+    SystemOperation[
+        Literal[True],
+        None,
+        OptSuccessResponseT,
+    ],
+    Generic[OptSuccessResponseT],
+):
+    success: Literal[True] = True
+    error: None = None

nexo/schemas/operation/websocket.py

@@ -0,0 +1,55 @@
+from typing import Generic, Literal
+from nexo.types.boolean import BoolT
+from ..connection import OptConnectionContext
+from ..error import (
+    OptAnyErrorT,
+    AnyErrorT,
+)
+from ..response import OptResponseT, ErrorResponseT, OptSuccessResponseT
+from .action.websocket import WebSocketOperationAction
+from .base import BaseOperation
+from .enums import OperationType
+
+
+class WebSocketOperation(
+    BaseOperation[
+        WebSocketOperationAction,
+        None,
+        BoolT,
+        OptAnyErrorT,
+        OptConnectionContext,
+        OptResponseT,
+        None,
+    ],
+    Generic[
+        BoolT,
+        OptAnyErrorT,
+        OptResponseT,
+    ],
+):
+    type: OperationType = OperationType.WEBSOCKET
+    resource: None = None
+    response_context: None = None
+
+
+class FailedWebSocketOperation(
+    WebSocketOperation[
+        Literal[False],
+        AnyErrorT,
+        ErrorResponseT,
+    ],
+    Generic[AnyErrorT, ErrorResponseT],
+):
+    success: Literal[False] = False
+
+
+class SuccessfulWebSocketOperation(
+    WebSocketOperation[
+        Literal[True],
+        None,
+        OptSuccessResponseT,
+    ],
+    Generic[OptSuccessResponseT],
+):
+    success: Literal[True] = True
+    error: None = None

nexo/schemas/pagination.py

@@ -0,0 +1,67 @@
+from enum import IntEnum
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Generic, Self, TypeVar
+from nexo.types.integer import ListOfInts, OptInt
+
+
+class Limit(IntEnum):
+    LIM_10 = 10
+    LIM_20 = 20
+    LIM_50 = 50
+    LIM_100 = 100
+
+    @classmethod
+    def choices(cls) -> ListOfInts:
+        return [e.value for e in cls]
+
+
+class Page(BaseModel):
+    page: Annotated[int, Field(1, ge=1, description="Page number, must be >= 1")] = 1
+
+
+class FlexibleLimit(BaseModel):
+    limit: Annotated[
+        OptInt, Field(None, description="Page limit. (Optional)", ge=1)
+    ] = None
+
+
+class StrictLimit(BaseModel):
+    limit: Annotated[Limit, Field(Limit.LIM_10, description="Page limit")] = (
+        Limit.LIM_10
+    )
+
+
+class PageInfo(BaseModel):
+    data_count: Annotated[int, Field(0, description="Fetched data count", ge=0)] = 0
+    total_data: Annotated[int, Field(0, description="Total data count", ge=0)] = 0
+    total_pages: Annotated[int, Field(1, description="Total pages count", ge=1)] = 1
+
+
+class BaseFlexiblePagination(FlexibleLimit, Page):
+    @model_validator(mode="after")
+    def validate_page_and_limit(self) -> Self:
+        if self.limit is None:
+            self.page = 1
+        return self
+
+
+class FlexiblePagination(PageInfo, BaseFlexiblePagination):
+    pass
+
+
+class BaseStrictPagination(StrictLimit, Page):
+    pass
+
+
+class StrictPagination(PageInfo, BaseStrictPagination):
+    pass
+
+
+AnyPagination = FlexiblePagination | StrictPagination
+PaginationT = TypeVar("PaginationT", bound=AnyPagination)
+OptAnyPagination = AnyPagination | None
+OptPaginationT = TypeVar("OptPaginationT", bound=OptAnyPagination)
+
+
+class PaginationMixin(BaseModel, Generic[OptPaginationT]):
+    pagination: Annotated[OptPaginationT, Field(..., description="Pagination")]

nexo/schemas/parameter.py

@@ -0,0 +1,60 @@
+from typing import Generic
+from .mixins.filter import DateFilters
+from .mixins.identity import IdentifierMixin, IdentifierT
+from .mixins.parameter import (
+    MandatorySimpleDataStatusesMixin,
+    Search,
+    UseCache,
+)
+from .mixins.sort import SortColumns
+from .operation.action.status import StatusUpdateOperationAction
+from .pagination import BaseFlexiblePagination, BaseStrictPagination
+
+
+class ReadSingleParameter(
+    UseCache,
+    MandatorySimpleDataStatusesMixin,
+    IdentifierMixin[IdentifierT],
+    Generic[IdentifierT],
+):
+    pass
+
+
+class BaseReadMultipleParameter(
+    SortColumns,
+    Search,
+    MandatorySimpleDataStatusesMixin,
+    DateFilters,
+):
+    pass
+
+
+class ReadUnpaginatedMultipleParameter(
+    UseCache,
+    BaseFlexiblePagination,
+    BaseReadMultipleParameter,
+):
+    pass
+
+
+class ReadPaginatedMultipleParameter(
+    UseCache,
+    BaseStrictPagination,
+    BaseReadMultipleParameter,
+):
+    pass
+
+
+class StatusUpdateParameter(
+    StatusUpdateOperationAction,
+    IdentifierMixin[IdentifierT],
+    Generic[IdentifierT],
+):
+    pass
+
+
+class DeleteSingleParameter(
+    IdentifierMixin[IdentifierT],
+    Generic[IdentifierT],
+):
+    pass

nexo/schemas/payload.py

@@ -0,0 +1,116 @@
+from pydantic import BaseModel, Field
+from typing import Generic, TypeVar
+from .data import DataPair, AnyDataT, DataMixin, ModelDataT
+from .metadata import MetadataMixin, AnyMetadataT, ModelMetadataT
+from .mixins.general import Other
+from .pagination import OptPaginationT, PaginationT, PaginationMixin
+
+
+class Payload(
+    Other,
+    MetadataMixin[AnyMetadataT],
+    PaginationMixin[OptPaginationT],
+    DataMixin[AnyDataT],
+    BaseModel,
+    Generic[AnyDataT, OptPaginationT, AnyMetadataT],
+):
+    pass
+
+
+PayloadT = TypeVar("PayloadT", bound=Payload)
+
+
+class PayloadMixin(BaseModel, Generic[PayloadT]):
+    payload: PayloadT = Field(..., description="Payload")
+
+
+class NoDataPayload(
+    Payload[None, None, ModelMetadataT],
+    Generic[ModelMetadataT],
+):
+    data: None = None
+    pagination: None = None
+
+
+class SingleDataPayload(
+    Payload[ModelDataT, None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pagination: None = None
+
+
+class CreateSingleDataPayload(
+    Payload[DataPair[None, ModelDataT], None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pass
+
+
+class ReadSingleDataPayload(
+    Payload[DataPair[ModelDataT, None], None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pass
+
+
+class UpdateSingleDataPayload(
+    Payload[DataPair[ModelDataT, ModelDataT], None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pass
+
+
+class DeleteSingleDataPayload(
+    Payload[DataPair[ModelDataT, None], None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pass
+
+
+class OptSingleDataPayload(
+    Payload[ModelDataT | None, None, ModelMetadataT],
+    Generic[ModelDataT, ModelMetadataT],
+):
+    pagination: None = None
+
+
+class MultipleDataPayload(
+    Payload[list[ModelDataT], PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass
+
+
+class CreateMultipleDataPayload(
+    Payload[DataPair[None, list[ModelDataT]], PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass
+
+
+class ReadMultipleDataPayload(
+    Payload[DataPair[list[ModelDataT], None], PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass
+
+
+class UpdateMultipleDataPayload(
+    Payload[DataPair[list[ModelDataT], list[ModelDataT]], PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass
+
+
+class DeleteMultipleDataPayload(
+    Payload[DataPair[list[ModelDataT], None], PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass
+
+
+class OptMultipleDataPayload(
+    Payload[list[ModelDataT] | None, PaginationT, ModelMetadataT],
+    Generic[ModelDataT, PaginationT, ModelMetadataT],
+):
+    pass

nexo/schemas/resource.py

@@ -0,0 +1,64 @@
+from enum import StrEnum
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Literal, TypeVar, overload
+from nexo.types.dict import OptStrToAnyDict
+from nexo.types.string import ListOfStrs
+
+
+class AggregateField(StrEnum):
+    KEY = "key"
+    NAME = "name"
+    SLUG = "slug"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+class ResourceIdentifier(BaseModel):
+    key: Annotated[str, Field(..., description="Key", pattern=r"^[a-zA-Z0-9_-]+$")]
+    name: Annotated[str, Field(..., description="Name")]
+    slug: Annotated[
+        str, Field(..., description="URL Slug", pattern=r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
+    ]
+
+
+class Resource(BaseModel):
+    identifiers: Annotated[
+        list[ResourceIdentifier], Field(..., min_length=1, description="Identifiers")
+    ]
+    details: Annotated[OptStrToAnyDict, Field(None, description="Details")] = None
+
+    @overload
+    def aggregate(
+        self, field: Literal[AggregateField.KEY], *, sep: str = "_"
+    ) -> str: ...
+    @overload
+    def aggregate(
+        self, field: Literal[AggregateField.NAME], *, sep: str = " "
+    ) -> str: ...
+    @overload
+    def aggregate(
+        self, field: Literal[AggregateField.SLUG], *, sep: str = "/"
+    ) -> str: ...
+    @overload
+    def aggregate(
+        self, field: AggregateField = AggregateField.KEY, *, sep: str = "_"
+    ) -> str: ...
+    def aggregate(
+        self, field: AggregateField = AggregateField.KEY, *, sep: str = "_"
+    ) -> str:
+        if field is AggregateField.KEY:
+            return sep.join([id.key for id in self.identifiers])
+        elif field is AggregateField.NAME:
+            return sep.join([id.name for id in self.identifiers])
+        elif field is AggregateField.SLUG:
+            return sep.join([id.slug for id in self.identifiers])
+
+
+OptResource = Resource | None
+OptResourceT = TypeVar("OptResourceT", bound=OptResource)
+
+
+class ResourceMixin(BaseModel, Generic[OptResourceT]):
+    resource: OptResourceT = Field(..., description="Resource")