hypern 0.3.1__cp311-cp311-win_amd64.whl → 0.3.3__cp311-cp311-win_amd64.whl

hypern/caching/strategies.py

@@ -1,101 +1,188 @@
-from typing import Any, Optional, Callable, TypeVar
-from datetime import datetime
 import asyncio
+import time
+from abc import ABC, abstractmethod
+from typing import Callable, Generic, Optional, TypeVar
+
 import orjson
 
-from hypern.logging import logger
+from .backend import BaseBackend
 
 T = TypeVar("T")
 
 
-class CacheEntry:
-    def __init__(self, value: Any, expires_at: int, stale_at: Optional[int] = None):
+class CacheStrategy(ABC, Generic[T]):
+    """Base class for cache strategies"""
+
+    @abstractmethod
+    async def get(self, key: str) -> Optional[T]:
+        pass
+
+    @abstractmethod
+    async def set(self, key: str, value: T, ttl: Optional[int] = None) -> None:
+        pass
+
+    @abstractmethod
+    async def delete(self, key: str) -> None:
+        pass
+
+
+class CacheEntry(Generic[T]):
+    """Represents a cached item with metadata"""
+
+    def __init__(self, value: T, created_at: float, ttl: int, revalidate_after: Optional[int] = None):
         self.value = value
-        self.expires_at = expires_at
-        self.stale_at = stale_at or expires_at
+        self.created_at = created_at
+        self.ttl = ttl
+        self.revalidate_after = revalidate_after
         self.is_revalidating = False
 
-    def to_json(self) -> str:
-        return orjson.dumps({"value": self.value, "expires_at": self.expires_at, "stale_at": self.stale_at, "is_revalidating": self.is_revalidating})
+    def is_stale(self) -> bool:
+        """Check if entry is stale and needs revalidation"""
+        now = time.time()
+        return self.revalidate_after is not None and now > (self.created_at + self.revalidate_after)
+
+    def is_expired(self) -> bool:
+        """Check if entry has completely expired"""
+        now = time.time()
+        return now > (self.created_at + self.ttl)
+
+    def to_json(self) -> bytes:
+        """Serialize entry to JSON"""
+        return orjson.dumps(
+            {
+                "value": self.value,
+                "created_at": self.created_at,
+                "ttl": self.ttl,
+                "revalidate_after": self.revalidate_after,
+                "is_revalidating": self.is_revalidating,
+            }
+        )
 
     @classmethod
-    def from_json(cls, data: str) -> "CacheEntry":
-        data_dict = orjson.loads(data)
-        entry = cls(value=data_dict["value"], expires_at=data_dict["expires_at"], stale_at=data_dict["stale_at"])
-        entry.is_revalidating = data_dict["is_revalidating"]
-        return entry
+    def from_json(cls, data: bytes) -> "CacheEntry[T]":
+        """Deserialize entry from JSON"""
+        parsed = orjson.loads(data)
+        return cls(value=parsed["value"], created_at=parsed["created_at"], ttl=parsed["ttl"], revalidate_after=parsed["revalidate_after"])
+
 
+class StaleWhileRevalidateStrategy(CacheStrategy[T]):
+    """
+    Implements stale-while-revalidate caching strategy.
+    Allows serving stale content while revalidating in the background.
+    """
 
-class CacheStrategy:
-    def __init__(self, backend: Any):
+    def __init__(self, backend: BaseBackend, revalidate_after: int, ttl: int, revalidate_fn: Callable[..., T]):
+        """
+        Initialize the caching strategy.
+
+        Args:
+            backend (BaseBackend): The backend storage for caching.
+            revalidate_after (int): The time in seconds after which the cache should be revalidated.
+            ttl (int): The time-to-live for cache entries in seconds.
+            revalidate_fn (Callable[..., T]): The function to call for revalidating the cache.
+
+        Attributes:
+            backend (BaseBackend): The backend storage for caching.
+            revalidate_after (int): The time in seconds after which the cache should be revalidated.
+            ttl (int): The time-to-live for cache entries in seconds.
+            revalidate_fn (Callable[..., T]): The function to call for revalidating the cache.
+            _revalidation_locks (dict): A dictionary to manage revalidation locks.
+        """
         self.backend = backend
+        self.revalidate_after = revalidate_after
+        self.ttl = ttl
+        self.revalidate_fn = revalidate_fn
+        self._revalidation_locks: dict = {}
 
-    async def get(self, key: str, loader: Callable[[], T]) -> T:
-        raise NotImplementedError
+    async def get(self, key: str) -> Optional[T]:
+        entry = await self.backend.get(key)
+        if not entry:
+            return None
 
+        if isinstance(entry, bytes):
+            entry = CacheEntry.from_json(entry)
 
-class StaleWhileRevalidateStrategy(CacheStrategy):
-    def __init__(self, backend: Any, stale_ttl: int, cache_ttl: int):
-        super().__init__(backend)
-        self.stale_ttl = stale_ttl
-        self.cache_ttl = cache_ttl
+        # If entry is stale but not expired, trigger background revalidation
+        if entry.is_stale() and not entry.is_expired():
+            if not entry.is_revalidating:
+                entry.is_revalidating = True
+                await self.backend.set(key, entry.to_json())
+                asyncio.create_task(self._revalidate(key))
+            return entry.value
 
-    async def get(self, key: str, loader: Callable[[], T]) -> T:
-        now = int(datetime.now().timestamp())
+        # If entry is expired, return None
+        if entry.is_expired():
+            return None
 
-        # Try to get from cache
-        cached_data = await self.backend.get(key)
-        if cached_data:
-            entry = CacheEntry.from_json(cached_data)
+        return entry.value
 
-            if now < entry.stale_at:
-                # Cache is fresh
-                return entry.value
+    async def set(self, key: str, value: T, ttl: Optional[int] = None) -> None:
+        entry = CacheEntry(value=value, created_at=time.time(), ttl=ttl or self.ttl, revalidate_after=self.revalidate_after)
+        await self.backend.set(key, entry.to_json(), ttl=ttl)
 
-            if now < entry.expires_at and not entry.is_revalidating:
-                # Cache is stale but usable - trigger background revalidation
-                entry.is_revalidating = True
-                await self.backend.set(key, entry.to_json(), self.cache_ttl)
-                asyncio.create_task(self._revalidate(key, loader))
-                return entry.value
-
-        # Cache miss or expired - load fresh data
-        value = await loader()
-        entry = CacheEntry(value=value, expires_at=now + self.cache_ttl, stale_at=now + (self.cache_ttl - self.stale_ttl))
-        await self.backend.set(key, entry.to_json(), self.cache_ttl)
-        return value
+    async def delete(self, key: str) -> None:
+        await self.backend.delete(key)
 
-    async def _revalidate(self, key: str, loader: Callable[[], T]):
+    async def _revalidate(self, key: str) -> None:
+        """Background revalidation of cached data"""
         try:
-            value = await loader()
-            now = int(datetime.now().timestamp())
-            entry = CacheEntry(value=value, expires_at=now + self.cache_ttl, stale_at=now + (self.cache_ttl - self.stale_ttl))
-            await self.backend.set(key, entry.to_json(), self.cache_ttl)
-        except Exception as e:
-            logger.error(f"Revalidation failed for key {key}: {e}")
+            # Prevent multiple simultaneous revalidations
+            if key in self._revalidation_locks:
+                return
+            self._revalidation_locks[key] = True
 
+            # Get fresh data
+            fresh_value = await self.revalidate_fn(key)
 
-class CacheAsideStrategy(CacheStrategy):
-    def __init__(self, backend: Any, ttl: int):
-        super().__init__(backend)
-        self.ttl = ttl
+            # Update cache with fresh data
+            await self.set(key, fresh_value)
+        finally:
+            self._revalidation_locks.pop(key, None)
 
-    async def get(self, key: str, loader: Callable[[], T]) -> T:
-        # Try to get from cache
-        cached_data = await self.backend.get(key)
-        if cached_data:
-            entry = CacheEntry.from_json(cached_data)
-            if entry.expires_at > int(datetime.now().timestamp()):
-                return entry.value
-
-        # Cache miss or expired - load from source
-        value = await loader()
-        entry = CacheEntry(value=value, expires_at=int(datetime.now().timestamp()) + self.ttl)
-        await self.backend.set(key, entry.to_json(), self.ttl)
+
+class CacheAsideStrategy(CacheStrategy[T]):
+    """
+    Implements cache-aside (lazy loading) strategy.
+    Data is loaded into cache only when requested.
+    """
+
+    def __init__(self, backend: BaseBackend, load_fn: Callable[[str], T], ttl: int, write_through: bool = False):
+        self.backend = backend
+        self.load_fn = load_fn
+        self.ttl = ttl
+        self.write_through = write_through
+
+    async def get(self, key: str) -> Optional[T]:
+        # Try to get from cache first
+        value = await self.backend.get(key)
+        if value:
+            if isinstance(value, bytes):
+                value = orjson.loads(value)
+            return value
+
+        # On cache miss, load from source
+        value = await self.load_fn(key)
+        if value is not None:
+            await self.set(key, value)
         return value
 
+    async def set(self, key: str, value: T, ttl: Optional[int] = None) -> None:
+        await self.backend.set(key, value, ttl or self.ttl)
+
+        # If write-through is enabled, update the source
+        if self.write_through:
+            await self._write_to_source(key, value)
+
+    async def delete(self, key: str) -> None:
+        await self.backend.delete(key)
 
-def cache_with_strategy(strategy: CacheStrategy, key_prefix: str = None):
+    async def _write_to_source(self, key: str, value: T) -> None:
+        """Write to the source in write-through mode"""
+        if hasattr(self.load_fn, "write"):
+            await self.load_fn.write(key, value)
+
+
+def cache_with_strategy(strategy: CacheStrategy, key_prefix: str | None = None, ttl: int = 3600):
     """
     Decorator for using cache strategies
     """
@@ -105,10 +192,16 @@ def cache_with_strategy(strategy: CacheStrategy, key_prefix: str = None):
             # Generate cache key
             cache_key = f"{key_prefix or func.__name__}:{hash(str(args) + str(kwargs))}"
 
-            async def loader():
-                return await func(*args, **kwargs)
+            result = await strategy.get(cache_key)
+            if result is not None:
+                return result
+
+            # Execute function and cache result
+            result = await func(*args, **kwargs)
+            if result is not None:
+                await strategy.set(cache_key, result, ttl)
 
-            return await strategy.get(cache_key, loader)
+            return result
 
         return wrapper
 

hypern/config.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
 import os
+
+# -*- coding: utf-8 -*-
+import threading
 import typing
 import warnings
+from contextvars import ContextVar
+from datetime import datetime
 from pathlib import Path
+from typing import Dict, Optional
 
 """
 
@@ -147,3 +153,94 @@ class Config:
             return cast(value)
         except (TypeError, ValueError):
             raise ValueError(f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}.")
+
+
+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()
+
+
+context_store = ContextStore()

hypern/db/addons/__init__.py

@@ -0,0 +1,5 @@
+from . import sqlalchemy
+
+__all__ = [
+    "sqlalchemy",
+]

hypern/db/addons/sqlalchemy/__init__.py

@@ -0,0 +1,71 @@
+# -*- 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
+
+from .repository import Model, PostgresRepository
+
+
+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)
+
+
+__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

hypern/db/sql/__init__.py

@@ -1,179 +1,13 @@
-# -*- coding: utf-8 -*-
-import asyncio
-import threading
-import traceback
-from contextlib import asynccontextmanager
-from contextvars import ContextVar, Token
-from datetime import datetime
-from typing import Dict, Optional, Union
-from uuid import uuid4
-
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_session
-from sqlalchemy.orm import Session, sessionmaker
-from sqlalchemy.sql.expression import Delete, Insert, Update
-
-from hypern.hypern import Request, Response
-
-from .repository import Model, PostgresRepository
-
-
-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=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
-        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("get_session", self.get_session)
-        app.before_request()(self.before_request)
-        app.after_request()(self.after_request)
-
-
-__all__ = ["Model", "PostgresRepository", "SqlConfig"]
+# from .context import SqlConfig, DatabaseType
+from .field import CharField, IntegerField
+from .model import Model
+from .query import F, Q, QuerySet
+
+__all__ = [
+    "CharField",
+    "IntegerField",
+    "Model",
+    "Q",
+    "F",
+    "QuerySet",
+]