hypern 0.3.0__cp310-cp310-win_amd64.whl

hypern/db/sql/addons/daterange.py

@@ -0,0 +1,23 @@
+from datetime import datetime
+
+from sqlalchemy.dialects.postgresql import DATERANGE
+from sqlalchemy.types import TypeDecorator
+
+
+class DateRangeField(TypeDecorator):
+    impl = DATERANGE
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        elif "start" in value and "end" in value:
+            return f"['{value['start']}', '{value['end']}']"
+        else:
+            raise ValueError('DateRangeField must be a dictionary with "start" and "end" keys')
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        else:
+            start, end = value[1:-1].split(",")
+            return {"start": datetime.strptime(start.strip("'"), "%Y-%m-%d %H:%M:%S.%f"), "end": datetime.strptime(end.strip("'"), "%Y-%m-%d %H:%M:%S.%f")}

hypern/db/sql/addons/datetime.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from sqlalchemy import types
+
+
+class DatetimeType(types.TypeDecorator):
+    impl = types.DateTime
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "sqlite":
+            return dialect.type_descriptor(types.TEXT)
+        return dialect.type_descriptor(self.impl)
+
+    def process_bind_param(self, value, dialect):
+        if dialect.name == "sqlite":
+            return value.isoformat()
+        return value
+
+    def process_result_value(self, value, dialect):
+        if dialect.name != "sqlite":
+            return value.timestamp()
+        return value

hypern/db/sql/addons/encrypted.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+import os
+import typing
+
+from cryptography.hazmat.primitives import padding
+from sqlalchemy.types import LargeBinary, String, TypeDecorator
+
+from hypern.security import AESEngine, EDEngine
+
+
+class StringEncryptType(TypeDecorator):
+    impl = String
+    cache_ok = True
+
+    def __init__(self, engine: typing.Optional[EDEngine] = None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        if not engine:
+            key = os.urandom(32)
+            iv = os.urandom(16)
+            padding_class = padding.PKCS7
+            self.engine = AESEngine(secret_key=key, iv=iv, padding_class=padding_class)
+        else:
+            self.engine = engine  # type: ignore
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        if not isinstance(value, str):
+            raise ValueError("Value String Encrypt Type must be a string")
+        return self.engine.encrypt(value).decode(encoding="utf-8")
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        return self.engine.decrypt(value)
+
+
+class LargeBinaryEncryptType(StringEncryptType):
+    impl = LargeBinary
+    cache_ok = True
+
+    def __init__(self, engine: typing.Optional[EDEngine] = None, *args, **kwargs) -> None:
+        super().__init__(engine=engine, *args, **kwargs)  # type: ignore
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        value = super().process_bind_param(value, dialect)
+        if isinstance(value, str):
+            return value.encode("utf-8")
+        return value
+
+    def process_result_value(self, value, dialect):
+        if isinstance(value, bytes):
+            value = value.decode("utf-8")
+            return super().process_result_value(value, dialect)
+        return value

hypern/db/sql/addons/password.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+
+import weakref
+
+import passlib
+from passlib.context import LazyCryptContext
+from sqlalchemy import types
+from sqlalchemy.dialects import oracle, postgresql, sqlite
+from sqlalchemy.ext.mutable import Mutable
+
+
+class Password(Mutable):
+    @classmethod
+    def coerce(cls, key, value):
+        if isinstance(value, Password):
+            return value
+
+        if isinstance(value, (str, bytes)):
+            return cls(value, secret=True)
+
+        super().coerce(key, value)
+
+    def __init__(self, value, context=None, secret=False):
+        # Store the hash (if it is one).
+        self.hash = value if not secret else None
+
+        # Store the secret if we have one.
+        self.secret = value if secret else None
+
+        # The hash should be bytes.
+        if isinstance(self.hash, str):
+            self.hash = self.hash.encode("utf8")
+
+        # Save weakref of the password context (if we have one)
+        self.context = weakref.proxy(context) if context is not None else None
+
+    def __eq__(self, value):
+        if self.hash is None or value is None:
+            # Ensure that we don't continue comparison if one of us is None.
+            return self.hash is value
+
+        if isinstance(value, Password):
+            # Comparing 2 hashes isn't very useful; but this equality
+            # method breaks otherwise.
+            return value.hash == self.hash
+
+        if self.context is None:
+            # Compare 2 hashes again as we don't know how to validate.
+            return value == self
+
+        if isinstance(value, (str, bytes)):
+            valid, new = self.context.verify_and_update(value, self.hash)
+            if valid and new:
+                # New hash was calculated due to various reasons; stored one
+                # wasn't optimal, etc.
+                self.hash = new
+
+                # The hash should be bytes.
+                if isinstance(self.hash, str):
+                    self.hash = self.hash.encode("utf8")
+                    self.changed()
+
+            return valid
+
+        return False
+
+    def __ne__(self, value):
+        return self != value
+
+
+class PasswordType(types.TypeDecorator):
+    impl = types.String
+    cache_ok = True
+
+    def __init__(self, max_length=None, **kwargs):
+        # Fail if passlib is not found.
+        if passlib is None:
+            raise ImportError("'passlib' is required to use 'PasswordType'")
+
+        # Construct the passlib crypt context.
+        self.context = LazyCryptContext(**kwargs)
+        self._max_length = max_length
+
+    @property
+    def hashing_method(self):
+        return "hash" if hasattr(self.context, "hash") else "encrypt"
+
+    @property
+    def max_length(self):
+        """Get column length."""
+        if self._max_length is None:
+            self._max_length = self.calculate_max_length()
+
+        return self._max_length
+
+    def calculate_max_length(self):
+        # Calculate the largest possible encoded password.
+        # name + rounds + salt + hash + ($ * 4) of largest hash
+        max_lengths = [1024]
+        for name in self.context.schemes():
+            scheme = getattr(__import__("passlib.hash").hash, name)
+            length = 4 + len(scheme.name)
+            length += len(str(getattr(scheme, "max_rounds", "")))
+            length += getattr(scheme, "max_salt_size", 0) or 0
+            length += getattr(scheme, "encoded_checksum_size", scheme.checksum_size)
+            max_lengths.append(length)
+
+        # Return the maximum calculated max length.
+        return max(max_lengths)
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "postgresql":
+            # Use a BYTEA type for postgresql.
+            impl = postgresql.BYTEA(self.max_length)
+        elif dialect.name == "oracle":
+            # Use a RAW type for oracle.
+            impl = oracle.RAW(self.max_length)
+        elif dialect.name == "sqlite":
+            # Use a BLOB type for sqlite
+            impl = sqlite.BLOB(self.max_length)
+        else:
+            # Use a VARBINARY for all other dialects.
+            impl = types.VARBINARY(self.max_length)
+        return dialect.type_descriptor(impl)
+
+    def process_bind_param(self, value, dialect):
+        if isinstance(value, Password):
+            # If were given a password secret; hash it.
+            if value.secret is not None:
+                return self._hash(value.secret).encode("utf8")
+
+            # Value has already been hashed.
+            return value.hash
+
+        if isinstance(value, str):
+            # Assume value has not been hashed.
+            return self._hash(value).encode("utf8")
+
+    def process_result_value(self, value, dialect):
+        if value is not None:
+            return Password(value, self.context)
+
+    def _hash(self, value):
+        return getattr(self.context, self.hashing_method)(value)
+
+    def _coerce(self, value):
+        if value is None:
+            return
+
+        if not isinstance(value, Password):
+            # Hash the password using the default scheme.
+            value = self._hash(value).encode("utf8")
+            return Password(value, context=self.context)
+
+        else:
+            # If were given a password object; ensure the context is right.
+            value.context = weakref.proxy(self.context)
+
+            # If were given a password secret; hash it.
+            if value.secret is not None:
+                value.hash = self._hash(value.secret).encode("utf8")
+                value.secret = None
+
+        return value
+
+    @property
+    def python_type(self):
+        return self.impl.type.python_type
+
+
+Password.associate_with(PasswordType)

hypern/db/sql/addons/ts_vector.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+import sqlalchemy as sa
+from sqlalchemy.dialects.postgresql import TSVECTOR
+
+
+class TSVector(sa.types.TypeDecorator):
+    """
+    .. _TSVECTOR:
+    https://docs.sqlalchemy.org/en/latest/dialects/postgresql.html#full-text-search
+
+
+    class IndexModel(Model):
+        ....
+        search_vector = Column(
+            TSVector(),
+            Computed(
+                "to_tsvector('english', some_text|| ' ' ||some_text)",
+                persisted=True,
+            ),
+        )
+    session.query(IndexModel).filter(IndexModel.search_vector.match('foo'))
+
+    session.query(IndexModel).filter(
+        (IndexModel.name_vector | IndexModel.content_vector).match('foo')
+    )
+
+    """
+
+    impl = TSVECTOR
+    cache_ok = True
+
+    class comparator_factory(TSVECTOR.Comparator):
+        def match(self, other, **kwargs):
+            if "postgresql_regconfig" not in kwargs:
+                if "regconfig" in self.type.options:
+                    kwargs["postgresql_regconfig"] = self.type.options["regconfig"]
+            return TSVECTOR.Comparator.match(self, other, **kwargs)
+
+        def __or__(self, other):
+            return self.op("||")(other)
+
+    def __init__(self, *args, **kwargs):
+        self.columns = args
+        self.options = kwargs
+        super(TSVector, self).__init__()

hypern/db/sql/addons/unicode.py

@@ -0,0 +1,15 @@
+from sqlalchemy.types import TypeDecorator, Unicode
+
+
+class UnicodeField(TypeDecorator):
+    impl = Unicode
+
+    def process_bind_param(self, value, dialect):
+        try:
+            value.encode("utf-8")
+        except UnicodeEncodeError:
+            raise ValueError("Value must be valid Unicode")
+        return value
+
+    def process_result_value(self, value, dialect):
+        return value

hypern/db/sql/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/enum.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+from enum import Enum
+
+
+class ErrorCode(Enum):
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+    BAD_REQUEST = "BAD_REQUEST"
+    FORBIDDEN = "FORBIDDEN"
+    SERVER_ERROR = "SERVER_ERROR"
+    NOT_FOUND = "NOT_FOUND"
+    METHOD_NOT_ALLOW = "METHOD_NOT_ALLOW"
+    UNAUTHORIZED = "UNAUTHORIZED"
+    VALIDATION_ERROR = "VALIDATION_ERROR"