hypern 0.3.11__cp311-cp311-musllinux_1_2_armv7l.whl

hypern/database/sqlalchemy/config.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import traceback
+from contextlib import asynccontextmanager
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_session
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.sql.expression import Delete, Insert, Update
+
+
+class SqlalchemyConfig:
+    def __init__(self, default_engine: AsyncEngine | None = None, reader_engine: AsyncEngine | None = None, writer_engine: AsyncEngine | None = None):
+        """
+        Initialize the SQL configuration.
+        You can provide a default engine, a reader engine, and a writer engine.
+        If only one engine is provided (default_engine), it will be used for both reading and writing.
+        If both reader and writer engines are provided, they will be used for reading and writing respectively.
+        Note: The reader and writer engines must be different.
+        """
+
+        assert default_engine or reader_engine or writer_engine, "At least one engine must be provided."
+        assert not (reader_engine and writer_engine and id(reader_engine) == id(writer_engine)), "Reader and writer engines must be different."
+
+        engines = {
+            "writer": writer_engine or default_engine,
+            "reader": reader_engine or default_engine,
+        }
+
+        class RoutingSession(Session):
+            def get_bind(this, mapper=None, clause=None, **kwargs):
+                if this._flushing or isinstance(clause, (Update, Delete, Insert)):
+                    return engines["writer"].sync_engine
+                return engines["reader"].sync_engine
+
+        async_session_factory = sessionmaker(
+            class_=AsyncSession,
+            sync_session_class=RoutingSession,
+            expire_on_commit=False,
+        )
+
+        session_scope: AsyncSession | async_scoped_session = async_scoped_session(
+            session_factory=async_session_factory,
+            scopefunc=asyncio.current_task,
+        )
+
+        @asynccontextmanager
+        async def get_session():
+            """
+            Get the database session.
+            This can be used for dependency injection.
+
+            :return: The database session.
+            """
+            try:
+                yield session_scope
+            except Exception:
+                traceback.print_exc()
+                await session_scope.rollback()
+            finally:
+                await session_scope.remove()
+                await session_scope.close()
+
+        self.get_session = get_session
+
+    def init_app(self, app):
+        app.inject("get_session", self.get_session)

hypern/database/sqlalchemy/repository.py

@@ -0,0 +1,290 @@
+# -*- coding: utf-8 -*-
+from functools import reduce
+from typing import Any, Dict, Generic, Optional, Type, TypeVar
+
+from sqlalchemy import Select, and_, asc, between, desc, select
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+)
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+
+class Model(Base):  # type: ignore
+    __abstract__ = True
+    __table_args__ = {"extend_existing": True}
+
+    @property
+    def as_dict(self) -> Dict[str, Any]:
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+
+ModelType = TypeVar("ModelType", bound=Base)  # type: ignore
+
+
+class PostgresRepository(Generic[ModelType]):
+    """Base class for data repositories."""
+
+    def __init__(self, model: Type[ModelType], db_session: AsyncSession):
+        self.session = db_session  # type: ignore
+        self.model_class: Type[ModelType] = model
+
+    async def create(self, attributes: Optional[dict[str, Any]] = None) -> ModelType:
+        """
+        Creates the model instance.
+
+        :param attributes: The attributes to create the model with.
+        :return: The created model instance.
+        """
+        if attributes is None:
+            attributes = {}
+        model = self.model_class(**attributes)  # type: ignore
+        self.session.add(model)
+        return model
+
+    async def get_all(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        join_: set[str] | None = None,
+        where: Optional[dict] = None,
+        order_by: tuple[str, str] | None = None,
+    ) -> list[ModelType]:
+        """
+        Returns a list of model instances.
+
+        :param skip: The number of records to skip.
+        :param limit: The number of record to return.
+        :param join_: The joins to make.
+        :param where: The conditions for the WHERE clause.
+        :return: A list of model instances.
+        """
+        query = self._query(join_)
+        query = query.offset(skip).limit(limit)
+
+        if where is not None:
+            conditions = []
+            for k, v in where.items():
+                if isinstance(v, dict) and "$gt" in v and "$lt" in v:
+                    conditions.append(between(getattr(self.model_class, k), v["$gt"], v["$lt"]))
+                else:
+                    conditions.append(getattr(self.model_class, k) == v)
+            query = query.where(and_(*conditions))
+
+        if order_by is not None:
+            column, direction = order_by
+            if direction.lower() == "desc":
+                query = query.order_by(desc(getattr(self.model_class, column)))
+            else:
+                query = query.order_by(asc(getattr(self.model_class, column)))
+
+        if join_ is not None:
+            return await self.all_unique(query)
+        return await self._all(query)
+
+    async def get_by(
+        self,
+        field: str,
+        value: Any,
+        join_: set[str] | None = None,
+        unique: bool = False,
+    ) -> ModelType | list[ModelType] | None:
+        """
+        Returns the model instance matching the field and value.
+
+        :param field: The field to match.
+        :param value: The value to match.
+        :param join_: The joins to make.
+        :return: The model instance.
+        """
+        query = self._query(join_)
+        query = await self._get_by(query, field, value)
+
+        if join_ is not None:
+            return await self.all_unique(query)
+        if unique:
+            return await self._one(query)
+
+        return await self._all(query)
+
+    async def delete(self, model: ModelType) -> None:
+        """
+        Deletes the model.
+
+        :param model: The model to delete.
+        :return: None
+        """
+        await self.session.delete(model)
+
+    async def update(self, model: ModelType, attributes: dict[str, Any]) -> ModelType:
+        """
+        Updates the model.
+
+        :param model: The model to update.
+        :param attributes: The attributes to update the model with.
+        :return: The updated model instance.
+        """
+        for key, value in attributes.items():
+            if hasattr(model, key):
+                setattr(model, key, value)
+
+        self.session.add(model)
+        await self.session.commit()
+
+        return model
+
+    def _query(
+        self,
+        join_: set[str] | None = None,
+        order_: dict | None = None,
+    ) -> Select:
+        """
+        Returns a callable that can be used to query the model.
+
+        :param join_: The joins to make.
+        :param order_: The order of the results. (e.g desc, asc)
+        :return: A callable that can be used to query the model.
+        """
+        query = select(self.model_class)
+        query = self._maybe_join(query, join_)
+        query = self._maybe_ordered(query, order_)
+
+        return query
+
+    async def _all(self, query: Select) -> list[ModelType]:
+        """
+        Returns all results from the query.
+
+        :param query: The query to execute.
+        :return: A list of model instances.
+        """
+        query = await self.session.scalars(query)
+        return query.all()
+
+    async def all_unique(self, query: Select) -> list[ModelType]:
+        result = await self.session.execute(query)
+        return result.unique().scalars().all()
+
+    async def _first(self, query: Select) -> ModelType | None:
+        """
+        Returns the first result from the query.
+
+        :param query: The query to execute.
+        :return: The first model instance.
+        """
+        query = await self.session.scalars(query)
+        return query.first()
+
+    async def _one_or_none(self, query: Select) -> ModelType | None:
+        """Returns the first result from the query or None."""
+        query = await self.session.scalars(query)
+        return query.one_or_none()
+
+    async def _one(self, query: Select) -> ModelType:
+        """
+        Returns the first result from the query or raises NoResultFound.
+
+        :param query: The query to execute.
+        :return: The first model instance.
+        """
+        query = await self.session.scalars(query)
+        return query.one()
+
+    async def _count(self, query: Select) -> int:
+        """
+        Returns the count of the records.
+
+        :param query: The query to execute.
+        """
+        query = query.subquery()
+        query = await self.session.scalars(select(func.count()).select_from(query))
+        return query.one()
+
+    async def _sort_by(
+        self,
+        query: Select,
+        sort_by: str,
+        order: str | None = "asc",
+        model: Type[ModelType] | None = None,
+        case_insensitive: bool = False,
+    ) -> Select:
+        """
+        Returns the query sorted by the given column.
+
+        :param query: The query to sort.
+        :param sort_by: The column to sort by.
+        :param order: The order to sort by.
+        :param model: The model to sort.
+        :param case_insensitive: Whether to sort case insensitively.
+        :return: The sorted query.
+        """
+        model = model or self.model_class
+
+        order_column = None
+
+        if case_insensitive:
+            order_column = func.lower(getattr(model, sort_by))
+        else:
+            order_column = getattr(model, sort_by)
+
+        if order == "desc":
+            return query.order_by(order_column.desc())
+
+        return query.order_by(order_column.asc())
+
+    async def _get_by(self, query: Select, field: str, value: Any) -> Select:
+        """
+        Returns the query filtered by the given column.
+
+        :param query: The query to filter.
+        :param field: The column to filter by.
+        :param value: The value to filter by.
+        :return: The filtered query.
+        """
+        return query.where(getattr(self.model_class, field) == value)
+
+    def _maybe_join(self, query: Select, join_: set[str] | None = None) -> Select:
+        """
+        Returns the query with the given joins.
+
+        :param query: The query to join.
+        :param join_: The joins to make.
+        :return: The query with the given joins.
+        """
+        if not join_:
+            return query
+
+        if not isinstance(join_, set):
+            raise TypeError("join_ must be a set")
+
+        return reduce(self._add_join_to_query, join_, query)  # type: ignore
+
+    def _maybe_ordered(self, query: Select, order_: dict | None = None) -> Select:
+        """
+        Returns the query ordered by the given column.
+
+        :param query: The query to order.
+        :param order_: The order to make.
+        :return: The query ordered by the given column.
+        """
+        if order_:
+            if order_["asc"]:
+                for order in order_["asc"]:
+                    query = query.order_by(getattr(self.model_class, order).asc())
+            else:
+                for order in order_["desc"]:
+                    query = query.order_by(getattr(self.model_class, order).desc())
+
+        return query
+
+    def _add_join_to_query(self, query: Select, join_: str) -> Select:
+        """
+        Returns the query with the given join.
+
+        :param query: The query to join.
+        :param join_: The join to make.
+        :return: The query with the given join.
+        """
+        return getattr(self, "_join_" + join_)(query)

hypern/database/sqlx/__init__.py

@@ -0,0 +1,36 @@
+# from .context import SqlConfig, DatabaseType
+from .field import (
+    CharField,
+    IntegerField,
+    TextField,
+    FloatField,
+    BooleanField,
+    ForeignKeyField,
+    DateTimeField,
+    Field,
+    JSONField,
+    ArrayField,
+    DecimalField,
+    DateField,
+)
+from .model import Model
+from .query import F, Q, QuerySet
+
+__all__ = [
+    "CharField",
+    "IntegerField",
+    "TextField",
+    "FloatField",
+    "BooleanField",
+    "ForeignKeyField",
+    "DateTimeField",
+    "Field",
+    "JSONField",
+    "ArrayField",
+    "DecimalField",
+    "DateField",
+    "Model",
+    "Q",
+    "F",
+    "QuerySet",
+]

hypern/database/sqlx/field.py

@@ -0,0 +1,246 @@
+import json
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+from typing import Any, Optional, Union
+
+from hypern.exceptions import DBFieldValidationError
+
+
+class Field:
+    """Base field class for ORM-like field definitions."""
+
+    def __init__(
+        self,
+        field_type: str,
+        primary_key: bool = False,
+        null: bool = True,
+        default: Any = None,
+        unique: bool = False,
+        index: bool = False,
+        validators: Optional[list] = None,
+        auto_increment: bool = False,
+    ):
+        self.field_type = field_type
+        self.primary_key = primary_key
+        self.null = null
+        self.default = default
+        self.unique = unique
+        self.index = index
+        self.validators = validators or []
+        self.name = None
+        self.model = None
+        self.auto_increment = auto_increment
+
+    def validate(self, value: Any) -> None:
+        if value is None:
+            if not self.null:
+                raise DBFieldValidationError(f"Field {self.name} cannot be null")
+            return
+
+        for validator in self.validators:
+            try:
+                validator(value)
+            except Exception as e:
+                raise DBFieldValidationError(f"Validation failed for {self.name}: {str(e)}")
+
+    def sql_type(self) -> str:
+        """Return SQL type definition for the field."""
+        type_mapping = {
+            "int": "INTEGER",
+            "str": "VARCHAR(255)",
+            "float": "FLOAT",
+            "bool": "BOOLEAN",
+            "datetime": "TIMESTAMP",
+            "date": "DATE",
+            "text": "TEXT",
+            "json": "JSONB",
+            "array": "ARRAY",
+            "decimal": "DECIMAL",
+        }
+        return type_mapping.get(self.field_type, "VARCHAR(255)")
+
+
+class CharField(Field):
+    def __init__(self, max_length: int = 255, **kwargs):
+        super().__init__(field_type="str", **kwargs)
+        self.max_length = max_length
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            if not isinstance(value, str):
+                raise DBFieldValidationError(f"Field {self.name} must be a string")
+            if len(value) > self.max_length:
+                raise DBFieldValidationError(f"Field {self.name} cannot exceed {self.max_length} characters")
+
+    def sql_type(self) -> str:
+        return f"VARCHAR({self.max_length})"
+
+
+class TextField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="text", **kwargs)
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, str):
+            raise DBFieldValidationError(f"Field {self.name} must be a string")
+
+
+class IntegerField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="int", **kwargs)
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            try:
+                int(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be an integer")
+
+
+class FloatField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="float", **kwargs)
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            try:
+                float(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be a float")
+
+
+class BooleanField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="bool", **kwargs)
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, bool):
+            raise DBFieldValidationError(f"Field {self.name} must be a boolean")
+
+
+class DateTimeField(Field):
+    def __init__(self, auto_now: bool = False, auto_now_add: bool = False, **kwargs):
+        super().__init__(field_type="datetime", **kwargs)
+        self.auto_now = auto_now
+        self.auto_now_add = auto_now_add
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, datetime):
+            raise DBFieldValidationError(f"Field {self.name} must be a datetime object")
+
+
+class DateField(Field):
+    def __init__(self, auto_now: bool = False, auto_now_add: bool = False, **kwargs):
+        super().__init__(field_type="date", **kwargs)
+        self.auto_now = auto_now
+        self.auto_now_add = auto_now_add
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, date):
+            raise DBFieldValidationError(f"Field {self.name} must be a date object")
+
+
+class JSONField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="json", **kwargs)
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            try:
+                json.dumps(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be JSON serializable")
+
+
+class ArrayField(Field):
+    def __init__(self, base_field: Field, **kwargs):
+        super().__init__(field_type="array", **kwargs)
+        self.base_field = base_field
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            if not isinstance(value, (list, tuple)):
+                raise DBFieldValidationError(f"Field {self.name} must be a list or tuple")
+            for item in value:
+                self.base_field.validate(item)
+
+    def sql_type(self) -> str:
+        return f"{self.base_field.sql_type()}[]"
+
+
+class DecimalField(Field):
+    def __init__(self, max_digits: int = 10, decimal_places: int = 2, **kwargs):
+        super().__init__(field_type="decimal", **kwargs)
+        self.max_digits = max_digits
+        self.decimal_places = decimal_places
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            try:
+                decimal_value = Decimal(str(value))
+                decimal_tuple = decimal_value.as_tuple()
+                if len(decimal_tuple.digits) - (-decimal_tuple.exponent) > self.max_digits:
+                    raise DBFieldValidationError(f"Field {self.name} exceeds maximum digits {self.max_digits}")
+                if -decimal_tuple.exponent > self.decimal_places:
+                    raise DBFieldValidationError(f"Field {self.name} exceeds maximum decimal places {self.decimal_places}")
+            except InvalidOperation:
+                raise DBFieldValidationError(f"Field {self.name} must be a valid decimal number")
+
+    def sql_type(self) -> str:
+        return f"DECIMAL({self.max_digits},{self.decimal_places})"
+
+
+class ForeignKeyField(Field):
+    """Field for foreign key relationships."""
+
+    def __init__(
+        self,
+        to_model: Union[str, Any],
+        related_field: str = "id",
+        on_delete: str = "CASCADE",
+        on_update: str = "CASCADE",
+        related_name: Optional[str] = None,
+        **kwargs,
+    ):
+        if isinstance(to_model, str):
+            field_type = "int"
+        else:
+            related_field_obj = getattr(to_model, related_field, None)
+            if related_field_obj is None:
+                raise ValueError(f"Field {related_field} not found in model {to_model.__name__}")
+            field_type = related_field_obj.field_type
+
+        super().__init__(field_type=field_type, **kwargs)
+        self.to_model = to_model
+        self.related_field = related_field
+        self.on_delete = on_delete.upper()
+        self.on_update = on_update.upper()
+        self.related_name = related_name
+
+        valid_actions = {"CASCADE", "SET NULL", "RESTRICT", "NO ACTION"}
+        if self.on_delete not in valid_actions:
+            raise ValueError(f"Invalid on_delete action. Must be one of: {valid_actions}")
+        if self.on_update not in valid_actions:
+            raise ValueError(f"Invalid on_update action. Must be one of: {valid_actions}")
+
+        if (self.on_delete == "SET NULL" or self.on_update == "SET NULL") and not kwargs.get("null", True):
+            raise ValueError("Field must be nullable to use SET NULL referential action")
+
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(self.to_model, str):
+            related_field_obj = getattr(self.to_model, self.related_field)
+            try:
+                related_field_obj.validate(value)
+            except DBFieldValidationError as e:
+                raise DBFieldValidationError(f"Foreign key {self.name} validation failed: {str(e)}")