hypern 0.1.0__cp310-cp310-manylinux_2_34_x86_64.whl

hypern/db/nosql/addons/password.py

@@ -0,0 +1,134 @@
+from mongoengine.base import BaseField
+import weakref
+from passlib.context import CryptContext
+import re
+from typing import Optional, Any
+
+
+class PasswordField(BaseField):
+    """
+    A custom password field using passlib for hashing and weakref for reference management.
+    Supports multiple hashing schemes and automatic upgrade of hash algorithms.
+    """
+
+    # Class-level password context - shared across all instances
+    pwd_context = CryptContext(
+        # List of hashing schemes in order of preference
+        schemes=["argon2", "pbkdf2_sha256", "bcrypt_sha256"],
+        # Mark argon2 as default
+        default="argon2",
+        # Argon2 parameters
+        argon2__rounds=4,
+        argon2__memory_cost=65536,
+        argon2__parallelism=2,
+        # PBKDF2 parameters
+        pbkdf2_sha256__rounds=29000,
+    )
+
+    def __init__(
+        self,
+        min_length: int = 8,
+        require_number: bool = False,
+        require_special: bool = False,
+        require_uppercase: bool = False,
+        require_lowercase: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize the password field with validation rules.
+
+        Args:
+            min_length: Minimum password length
+            require_number: Require at least one number
+            require_special: Require at least one special character
+            require_uppercase: Require at least one uppercase letter
+            require_lowercase: Require at least one lowercase letter
+        """
+        self.min_length = min_length
+        self.require_number = require_number
+        self.require_special = require_special
+        self.require_uppercase = require_uppercase
+        self.require_lowercase = require_lowercase
+
+        # Use weakref to store references to parent documents
+        self.instances = weakref.WeakKeyDictionary()
+
+        kwargs["required"] = True
+        super(PasswordField, self).__init__(**kwargs)
+
+    def validate_password(self, password: str) -> tuple[bool, str]:
+        """Validate password strength."""
+
+        if len(password) < self.min_length:
+            return False, f"Password must be at least {self.min_length} characters long"
+
+        if self.require_number and not re.search(r"\d", password):
+            return False, "Password must contain at least one number"
+
+        if self.require_special and not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
+            return False, "Password must contain at least one special character"
+
+        if self.require_uppercase and not re.search(r"[A-Z]", password):
+            return False, "Password must contain at least one uppercase letter"
+
+        if self.require_lowercase and not re.search(r"[a-z]", password):
+            return False, "Password must contain at least one lowercase letter"
+
+        return True, ""
+
+    def hash_password(self, password: str) -> str:
+        """Hash password using the configured passlib context."""
+        return self.pwd_context.hash(password)
+
+    def verify_password(self, password: str, hash: str) -> tuple[bool, Optional[str]]:
+        """
+        Verify password and return tuple of (is_valid, new_hash).
+        new_hash is provided if the hash needs to be upgraded.
+        """
+        try:
+            is_valid = self.pwd_context.verify(password, hash)
+            # Check if the hash needs to be upgraded
+            if is_valid and self.pwd_context.needs_update(hash):
+                return True, self.hash_password(password)
+            return is_valid, None
+        except Exception:
+            return False, None
+
+    def __get__(self, instance, owner):
+        """Custom getter using weakref."""
+        if instance is None:
+            return self
+        return self.instances.get(instance)
+
+    def __set__(self, instance, value):
+        """Custom setter using weakref."""
+        if value and isinstance(value, str):
+            # Validate and hash new password
+            is_valid, error = self.validate_password(value)
+            if not is_valid:
+                raise ValueError(error)
+            hashed = self.hash_password(value)
+            self.instances[instance] = hashed
+            instance._data[self.name] = hashed
+        else:
+            # If it's already hashed or None
+            self.instances[instance] = value
+            instance._data[self.name] = value
+
+    def to_mongo(self, value: str) -> Optional[str]:
+        """Convert to MongoDB-compatible value."""
+        if value is None:
+            return None
+        return self.hash_password(value)
+
+    def to_python(self, value: str) -> str:
+        """Convert from MongoDB to Python."""
+        return value
+
+    def prepare_query_value(self, op, value: Any) -> Optional[str]:
+        """Prepare value for database operations."""
+        if value is None:
+            return None
+        if op == "exact":
+            return self.hash_password(value)
+        return value

hypern/db/nosql/addons/unicode.py

@@ -0,0 +1,10 @@
+from mongoengine import StringField
+
+
+class UnicodeField(StringField):
+    def validate(self, value):
+        try:
+            value.encode("utf-8")
+        except UnicodeEncodeError:
+            self.error("Value must be valid Unicode")
+        return True

hypern/db/sql/__init__.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+from datetime import datetime
+from contextvars import ContextVar, Token
+from typing import Union, Optional, Dict
+import traceback
+import threading
+
+from robyn import Request, Response
+from sqlalchemy.ext.asyncio import AsyncSession, async_scoped_session, AsyncEngine
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.sql.expression import Delete, Insert, Update
+from contextlib import asynccontextmanager
+from .repository import Model, PostgresRepository
+from uuid import uuid4
+
+
+class ContextStore:
+    def __init__(self, cleanup_interval: int = 300, max_age: int = 3600):
+        """
+        Initialize ContextStore with automatic session cleanup.
+
+        :param cleanup_interval: Interval between cleanup checks (in seconds)
+        :param max_age: Maximum age of a session before it's considered expired (in seconds)
+        """
+        self._session_times: Dict[str, datetime] = {}
+        self.session_var = ContextVar("session_id", default=None)
+
+        self._max_age = max_age
+        self._cleanup_interval = cleanup_interval
+        self._cleanup_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+        # Start the cleanup thread
+        self._start_cleanup_thread()
+
+    def _start_cleanup_thread(self):
+        """Start a background thread for periodic session cleanup."""
+
+        def cleanup_worker():
+            while not self._stop_event.is_set():
+                self._perform_cleanup()
+                self._stop_event.wait(self._cleanup_interval)
+
+        self._cleanup_thread = threading.Thread(
+            target=cleanup_worker,
+            daemon=True,  # Allows the thread to be automatically terminated when the main program exits
+        )
+        self._cleanup_thread.start()
+
+    def _perform_cleanup(self):
+        """Perform cleanup of expired sessions."""
+        current_time = datetime.now()
+        expired_sessions = [
+            session_id for session_id, timestamp in list(self._session_times.items()) if (current_time - timestamp).total_seconds() > self._max_age
+        ]
+
+        for session_id in expired_sessions:
+            self.remove_session(session_id)
+
+    def remove_session(self, session_id: str):
+        """Remove a specific session."""
+        self._session_times.pop(session_id, None)
+
+    def set_context(self, session_id: str):
+        """
+        Context manager for setting and resetting session context.
+
+        :param session_id: Unique identifier for the session
+        :return: Context manager for session
+        """
+        self.session_var.set(session_id)
+        self._session_times[session_id] = datetime.now()
+
+    def get_context(self) -> str:
+        """
+        Get the current session context.
+
+        :return: Current session ID
+        :raises RuntimeError: If no session context is available
+        """
+        return self.session_var.get()
+
+    def reset_context(self):
+        """Reset the session context."""
+        token = self.get_context()
+        if token is not None:
+            self.session_var.reset(token)
+
+    def stop_cleanup(self):
+        """
+        Stop the cleanup thread.
+        Useful for graceful shutdown of the application.
+        """
+        self._stop_event.set()
+        if self._cleanup_thread:
+            self._cleanup_thread.join()
+
+    def __del__(self):
+        """
+        Ensure cleanup thread is stopped when the object is deleted.
+        """
+        self.stop_cleanup()
+
+
+class SqlConfig:
+    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,
+        }
+        self.session_store = ContextStore()
+
+        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: Union[AsyncSession, async_scoped_session] = async_scoped_session(
+            session_factory=async_session_factory,
+            scopefunc=self.session_store.get_context,
+        )
+
+        @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
+        self._context_token: Optional[Token] = None
+
+    def before_request(self, request: Request):
+        token = str(uuid4())
+        self.session_store.set_context(token)
+        return request
+
+    def after_request(self, response: Response):
+        self.session_store.reset_context()
+        return response
+
+    def init_app(self, app):
+        app.inject_global(get_session=self.get_session)
+        app.before_request(endpoint=None)(self.before_request)
+        app.after_request(endpoint=None)(self.after_request)
+
+
+__all__ = ["Model", "PostgresRepository", "SqlConfig"]

hypern/db/sql/addons/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+from .ts_vector import TSVector
+from .datetime import DatetimeType
+from .password import PasswordType
+from .encrypted import StringEncryptType, LargeBinaryEncryptType, AESEngine
+
+__all__ = [
+    "TSVector",
+    "DatetimeType",
+    "PasswordType",
+    "StringEncryptType",
+    "LargeBinaryEncryptType",
+    "AESEngine",
+]

hypern/db/sql/addons/color.py

@@ -0,0 +1,15 @@
+from sqlalchemy.types import TypeDecorator, String
+import re
+
+
+class ColorField(TypeDecorator):
+    impl = String
+
+    def process_bind_param(self, value, dialect):
+        color_regex = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"
+        if not re.match(color_regex, value):
+            raise ValueError("Invalid color format. Use hexadecimal color codes (e.g., #FF0000)")
+        return value
+
+    def process_result_value(self, value, dialect):
+        return value

hypern/db/sql/addons/daterange.py

@@ -0,0 +1,22 @@
+from sqlalchemy.types import TypeDecorator
+from sqlalchemy.dialects.postgresql import DATERANGE
+from datetime import datetime
+
+
+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 -*-
+from cryptography.hazmat.primitives import padding
+from sqlalchemy.types import TypeDecorator, LargeBinary, String
+
+from hypern.security import EDEngine, AESEngine
+
+import os
+import typing
+
+
+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,170 @@
+# -*- coding: utf-8 -*-
+
+from sqlalchemy import types
+from sqlalchemy.dialects import oracle, postgresql, sqlite
+from sqlalchemy.ext.mutable import Mutable
+from passlib.context import LazyCryptContext
+import weakref
+import passlib
+
+
+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