nexo-schemas 0.0.16__py3-none-any.whl

nexo/schemas/exception/handlers.py

@@ -0,0 +1,110 @@
+from typing import Awaitable, Callable
+from fastapi import Request, Response, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import (
+    HTTPException,
+    RequestValidationError,
+    WebSocketRequestValidationError,
+    ResponseValidationError,
+)
+from fastapi.requests import HTTPConnection
+from fastapi.responses import JSONResponse
+from pydantic import ValidationError
+from starlette.authentication import AuthenticationError
+from nexo.logging.logger import Exception as ExceptionLogger
+from nexo.utils.exception import extract_details
+from ..error.constants import ERROR_CODE_STATUS_CODE_MAP
+from ..error.enums import ErrorCode
+from ..google import ListOfPublisherHandlers
+from ..response import (
+    UnauthorizedResponse,
+    UnprocessableEntityResponse,
+    InternalServerErrorResponse,
+    ErrorResponseFactory,
+)
+from .exc import MaleoException, AnyException
+
+
+def authentication_error_handler(
+    conn: HTTPConnection, exc: AuthenticationError
+) -> JSONResponse:
+    return JSONResponse(
+        content=UnauthorizedResponse(other=extract_details(exc)).model_dump(
+            mode="json"
+        ),
+        status_code=status.HTTP_401_UNAUTHORIZED,
+    )
+
+
+async def validation_error_handler(
+    request: Request,
+    exc: (
+        RequestValidationError
+        | WebSocketRequestValidationError
+        | ResponseValidationError
+        | ValidationError
+    ),
+) -> JSONResponse:
+    return JSONResponse(
+        content=UnprocessableEntityResponse(
+            other=jsonable_encoder(exc.errors())
+        ).model_dump(mode="json"),
+        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+    )
+
+
+async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+    return JSONResponse(
+        content=(
+            ErrorResponseFactory.cls_from_code(exc.status_code)(
+                other=extract_details(exc)
+            ).model_dump(mode="json")
+        ),
+        status_code=exc.status_code,
+    )
+
+
+def create_maleo_exception_handler(
+    logger: ExceptionLogger,
+    publishers: ListOfPublisherHandlers = [],
+) -> Callable[[Request, MaleoException], Awaitable[JSONResponse]]:
+    async def maleo_exception_handler(
+        request: Request, exc: MaleoException | AnyException
+    ) -> JSONResponse:
+        exc.log_and_publish_operation(logger, publishers)
+
+        return JSONResponse(
+            content=exc.response.model_dump(mode="json"),
+            status_code=exc.error.spec.status_code,
+        )
+
+    return maleo_exception_handler
+
+
+async def general_exception_handler(request: Request, exc: Exception) -> Response:
+    other = extract_details(exc)
+
+    # Get the first arg as a potential ErrorCode
+    code = exc.args[0] if exc.args else None
+
+    if isinstance(code, ErrorCode):
+        error_code = code
+    elif isinstance(code, str) and code in ErrorCode:
+        error_code = ErrorCode[code]
+    else:
+        error_code = None
+
+    if error_code is not None:
+        status_code = ERROR_CODE_STATUS_CODE_MAP.get(error_code, None)
+
+        if status_code is not None:
+            response_cls = ErrorResponseFactory.cls_from_code(status_code)
+            return JSONResponse(
+                content=response_cls(other=other).model_dump(mode="json"),
+                status_code=status_code,
+            )
+
+    return JSONResponse(
+        content=InternalServerErrorResponse(other=other).model_dump(mode="json"),
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+    )

nexo/schemas/google.py

@@ -0,0 +1,14 @@
+from google.cloud.pubsub_v1 import PublisherClient
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Annotated
+
+
+class PublisherHandler(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    client: Annotated[PublisherClient, Field(..., description="Publisher client")]
+    project_id: Annotated[str, Field(..., description="Project ID")]
+    topic_id: Annotated[str, Field(..., description="Topic ID")]
+
+
+ListOfPublisherHandlers = list[PublisherHandler]

nexo/schemas/key/rsa.py

@@ -0,0 +1,131 @@
+from abc import ABC, abstractmethod
+from Crypto.Cipher import PKCS1_OAEP
+from Crypto.PublicKey import RSA
+from functools import cached_property
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Self
+from nexo.crypto.key.rsa.enums import KeyType
+from nexo.crypto.key.rsa.loader import with_cryptography
+from nexo.types.misc import PathOrStr
+from nexo.types.string import OptStr
+
+
+class Key(BaseModel, ABC):
+    raw: Annotated[str, Field(..., description="Raw key")]
+
+    @abstractmethod
+    def _validate_raw(self):
+        """Validate raw key"""
+
+    @model_validator(mode="after")
+    def validate_raw(self) -> Self:
+        self._validate_raw()
+        return self
+
+    @cached_property
+    def as_rsa(self) -> RSA.RsaKey:
+        """Convert raw to RSA"""
+        self._validate_raw()
+        passphrase = getattr(self, "password", None)
+        return RSA.import_key(extern_key=self.raw, passphrase=passphrase)
+
+
+class Private(Key):
+    password: Annotated[OptStr, Field(None, description="Key's password")] = None
+
+    def _validate_raw(self):
+        if not RSA.import_key(
+            extern_key=self.raw, passphrase=self.password
+        ).has_private():
+            raise ValueError(
+                "Invalid key type, the private key did not have private inside it"
+            )
+
+
+class Public(Key):
+    def _validate_raw(self):
+        if RSA.import_key(extern_key=self.raw).has_private():
+            raise ValueError("Invalid key type, the public key had private inside it")
+
+
+class Keys(BaseModel):
+    private: Annotated[Private, Field(..., description="Private key")]
+    public: Annotated[Public, Field(..., description="Public key")]
+
+    @model_validator(mode="after")
+    def validate_complete_keys(self) -> Self:
+        try:
+            # Import private key with password
+            private_key = self.private.as_rsa
+
+            # Import public key
+            public_key = self.public.as_rsa
+
+            # Validate keys match by comparing public components
+            if (
+                private_key.publickey().n != public_key.n
+                or private_key.publickey().e != public_key.e
+            ):
+                raise ValueError("Public key does not match the private key")
+
+            # Optional: Test encrypt/decrypt functionality
+            test_message = b"validation_test"
+            try:
+                # Encrypt with public key
+                cipher = PKCS1_OAEP.new(public_key)
+                encrypted = cipher.encrypt(test_message)
+
+                # Decrypt with private key
+                cipher = PKCS1_OAEP.new(private_key)
+                decrypted = cipher.decrypt(encrypted)
+
+                if decrypted != test_message:
+                    raise ValueError(
+                        "Keys do not work together for encryption/decryption"
+                    )
+
+            except Exception as e:
+                raise ValueError(f"Keys failed encryption/decryption test: {str(e)}")
+
+        except ValueError:
+            raise  # Re-raise validation errors
+        except Exception as e:
+            raise ValueError(f"Key validation failed: {str(e)}")
+
+        return self
+
+    @classmethod
+    def from_path(
+        cls,
+        private: PathOrStr,
+        public: PathOrStr,
+        password: OptStr = None,
+    ) -> Self:
+        raw_private = with_cryptography(
+            KeyType.PRIVATE,
+            path=private,
+            password=password,
+        )
+        raw_public = with_cryptography(
+            KeyType.PUBLIC,
+            path=public,
+        )
+        return cls(
+            private=Private(raw=raw_private, password=password),
+            public=Public(raw=raw_public),
+        )
+
+    @classmethod
+    def from_string(
+        cls,
+        private: str,
+        public: str,
+        password: OptStr = None,
+    ) -> Self:
+        return cls(
+            private=Private(raw=private, password=password), public=Public(raw=public)
+        )
+
+
+class KeysMixin(BaseModel):
+    keys: Annotated[Keys, Field(..., description="RSA Keys")]

nexo/schemas/metadata.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel, Field
+from typing import Generic, TypeVar
+from .mixins.general import Success, Descriptor, Other
+
+
+AnyMetadataT = TypeVar("AnyMetadataT")
+ModelMetadataT = TypeVar("ModelMetadataT", bound=BaseModel | None)
+
+
+class MetadataMixin(BaseModel, Generic[AnyMetadataT]):
+    metadata: AnyMetadataT = Field(..., description="Metadata")
+
+
+class FieldExpansionMetadata(Other, Descriptor[str], Success[bool]):
+    pass
+
+
+class FieldExpansionMetadataMixin(BaseModel):
+    field_expansion: str | dict[str, FieldExpansionMetadata] | None = Field(
+        None, description="Field expansion metadata"
+    )

nexo/schemas/mixins/filter.py

@@ -0,0 +1,140 @@
+import re
+from datetime import datetime
+from pydantic import BaseModel, Field, field_validator, model_validator
+from typing import Annotated, Self, TypeGuard, overload
+from nexo.types.datetime import OptDatetime
+from nexo.types.string import ListOfStrs
+from .identity import Name
+from .timestamp import FromTimestamp, ToTimestamp
+
+
+DATE_FILTER_REGEX = (
+    r"^(?P<name>[a-z_]+)"
+    r"(?:\|from::(?P<from>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})))?"
+    r"(?:\|to::(?P<to>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})))?$"
+)
+DATE_FILTER_PATTERN = re.compile(DATE_FILTER_REGEX)
+
+
+class DateFilter(
+    ToTimestamp[OptDatetime],
+    FromTimestamp[OptDatetime],
+    Name[str],
+):
+    name: Annotated[str, Field(..., description="Name", min_length=1)]
+    from_date: Annotated[OptDatetime, Field(None, description="From date")] = None
+    to_date: Annotated[OptDatetime, Field(None, description="To date")] = None
+
+    def _validate_timestamps(self):
+        if self.from_date is None and self.to_date is None:
+            raise ValueError("Either 'from_date' or 'to_date' must have value")
+        if self.from_date is not None and self.to_date is not None:
+            if self.to_date < self.from_date:
+                raise ValueError("Attribute 'from_date' can not be more than 'to_date'")
+
+    @model_validator(mode="after")
+    def validate_timestamps(self) -> Self:
+        self._validate_timestamps()
+        return self
+
+    @classmethod
+    def from_string(cls, filter: str) -> "DateFilter":
+        match = DATE_FILTER_PATTERN.match(filter)
+        if not match:
+            raise ValueError(f"Invalid date filter format: {filter!r}")
+
+        name = match.group("name")
+        from_raw = match.group("from")
+        to_raw = match.group("to")
+
+        from_date = datetime.fromisoformat(from_raw) if from_raw else None
+        to_date = datetime.fromisoformat(to_raw) if to_raw else None
+
+        if from_date is None and to_date is None:
+            raise ValueError("Either 'from_date' or 'to_date' must be provided")
+
+        return cls(name=name, from_date=from_date, to_date=to_date)
+
+    def to_string(self) -> str:
+        self._validate_timestamps()
+        filter_string = self.name
+        if self.from_date:
+            filter_string += f"|from::{self.from_date.isoformat()}"
+        if self.to_date:
+            filter_string += f"|to::{self.to_date.isoformat()}"
+        return filter_string
+
+
+OptDateFilter = DateFilter | None
+ListOfDateFilters = list[DateFilter]
+OptListOfDateFilters = OptDateFilter | None
+
+
+AnyFilters = ListOfDateFilters | ListOfStrs
+
+
+def is_date_filters(
+    filters: AnyFilters,
+) -> TypeGuard[ListOfDateFilters]:
+    return all(isinstance(filter, DateFilter) for filter in filters)
+
+
+def is_filters(
+    filters: AnyFilters,
+) -> TypeGuard[ListOfStrs]:
+    return all(isinstance(filter, str) for filter in filters)
+
+
+class Filters(BaseModel):
+    filters: Annotated[
+        ListOfStrs,
+        Field(
+            list[str](),
+            description="Date range filters with '<COLUMN_NAME>|from::<ISO_DATETIME>|to::<ISO_DATETIME>' format",
+        ),
+    ] = list[str]()
+
+    @field_validator("filters", mode="after")
+    @classmethod
+    def validate_filters_pattern(cls, value: ListOfStrs) -> ListOfStrs:
+        for v in value:
+            match = DATE_FILTER_PATTERN.match(v)
+            if not match:
+                raise ValueError(f"Invalid date filter format: {v!r}")
+        return value
+
+    @classmethod
+    def from_date_filters(cls, date_filters: ListOfDateFilters) -> "Filters":
+        return cls(filters=[filter.to_string() for filter in date_filters])
+
+    @property
+    def date_filters(self) -> ListOfDateFilters:
+        return [DateFilter.from_string(filter) for filter in self.filters]
+
+
+class DateFilters(BaseModel):
+    date_filters: Annotated[
+        ListOfDateFilters,
+        Field(list[DateFilter](), description="Date filters to be applied"),
+    ] = list[DateFilter]()
+
+    @classmethod
+    def from_filters(cls, filters: ListOfStrs) -> "DateFilters":
+        return cls(date_filters=[DateFilter.from_string(filter) for filter in filters])
+
+    @property
+    def filters(self) -> ListOfStrs:
+        return [filter.to_string() for filter in self.date_filters]
+
+
+@overload
+def convert(filters: ListOfDateFilters) -> ListOfStrs: ...
+@overload
+def convert(filters: ListOfStrs) -> ListOfDateFilters: ...
+def convert(filters: AnyFilters) -> AnyFilters:
+    if is_date_filters(filters):
+        return [filter.to_string() for filter in filters]
+    elif is_filters(filters):
+        return [DateFilter.from_string(filter) for filter in filters]
+    else:
+        raise ValueError("Filter type is neither DateFilter nor string")

nexo/schemas/mixins/general.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Any, Generic
+from nexo.types.boolean import BoolT, OptBoolT
+from nexo.types.enum import OptStrEnumT
+from nexo.types.misc import (
+    OptFloatOrIntT,
+    OptIntOrStrEnumT,
+    OptStrOrStrEnumT,
+    OptListOfStrsOrStrEnumsT,
+)
+from nexo.types.string import OptStrT
+
+
+class StatusCode(BaseModel):
+    status_code: Annotated[int, Field(..., description="Status code", ge=100, le=600)]
+
+
+class Success(BaseModel, Generic[BoolT]):
+    success: BoolT = Field(..., description="Success")
+
+
+class Code(BaseModel, Generic[OptStrOrStrEnumT]):
+    code: OptStrOrStrEnumT = Field(..., description="Code")
+
+
+class Codes(BaseModel, Generic[OptListOfStrsOrStrEnumsT]):
+    codes: OptListOfStrsOrStrEnumsT = Field(..., description="Codes")
+
+
+class Message(BaseModel):
+    message: str = Field(..., description="Message")
+
+
+class Description(BaseModel):
+    description: str = Field(..., description="Description")
+
+
+class Descriptor(
+    Description, Message, Code[OptStrOrStrEnumT], Generic[OptStrOrStrEnumT]
+):
+    pass
+
+
+class Order(BaseModel, Generic[OptIntOrStrEnumT]):
+    order: OptIntOrStrEnumT = Field(..., description="Order")
+
+
+class Level(BaseModel, Generic[OptStrEnumT]):
+    level: OptStrEnumT = Field(..., description="Level")
+
+
+class Note(BaseModel, Generic[OptStrT]):
+    note: OptStrT = Field(..., description="Note")
+
+
+class IsDefault(BaseModel, Generic[OptBoolT]):
+    is_default: OptBoolT = Field(..., description="Whether is default")
+
+
+class Other(BaseModel):
+    other: Annotated[Any, Field(None, description="Other")] = None
+
+
+class Age(BaseModel, Generic[OptFloatOrIntT]):
+    age: OptFloatOrIntT = Field(..., ge=0, description="Age")

nexo/schemas/mixins/hierarchy.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field
+from typing import Generic
+from nexo.types.boolean import OptBoolT
+
+
+class IsRoot(BaseModel, Generic[OptBoolT]):
+    is_root: OptBoolT = Field(..., description="Whether is root")
+
+
+class IsParent(BaseModel, Generic[OptBoolT]):
+    is_parent: OptBoolT = Field(..., description="Whether is parent")
+
+
+class IsChild(BaseModel, Generic[OptBoolT]):
+    is_child: OptBoolT = Field(..., description="Whether is child")
+
+
+class IsLeaf(BaseModel, Generic[OptBoolT]):
+    is_leaf: OptBoolT = Field(..., description="Whether is leaf")