cashing2fast-fastapi 0.1.0__py3-none-any.whl

cashing2fast_fastapi/__init__.py

@@ -0,0 +1,12 @@
+from .__version__ import __version__
+from .settings import settings
+from .dependencies import require_billing_checks
+from .utils.redis_client import get_redis_client, close_redis
+
+__all__ = [
+    "__version__",
+    "settings",
+    "require_billing_checks",
+    "get_redis_client",
+    "close_redis",
+]

cashing2fast_fastapi/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cashing2fast_fastapi/dependencies.py

@@ -0,0 +1,91 @@
+from typing import Any
+from datetime import datetime, timezone
+from fastapi import Depends, HTTPException, status, Request
+from sqlmodel.ext.asyncio.session import AsyncSession
+from oauth2fast_fastapi.dependencies import get_auth_session, oauth2_dependency
+from oauth2fast_fastapi.utils.token_utils import verify_token
+from tools2fast_fastapi import APIResponse
+
+from .settings import settings
+from .services import billing_service
+from .exceptions import PaymentRequiredException
+
+async def require_billing_checks(
+    request: Request,
+    token: str = Depends(oauth2_dependency),
+    session: AsyncSession = Depends(get_auth_session)
+):
+    """
+    Dependency to check if the user has billing limits.
+    """
+    # 1. Decode token to get email without hitting User DB yet
+    payload = verify_token(token)
+    if not payload:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token inválido",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    email = payload.get("sub")
+    if not email:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token sin identificador",
+        )
+        
+    # 2. Get User ID and created_at (cached in Redis)
+    try:
+        user_info = await billing_service.get_user_billing_info(email, session)
+    except Exception:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Usuario no encontrado",
+        )
+        
+    user_id = user_info["id"]
+    created_at = datetime.fromisoformat(user_info["created_at"])
+    if created_at.tzinfo is None:
+        created_at = created_at.replace(tzinfo=timezone.utc)
+    
+    # 3. Calculate elapsed minutes
+    now = datetime.now(timezone.utc)
+    elapsed_minutes = (now - created_at).total_seconds() / 60
+    
+    # 4. Evaluate phases
+    
+    # Phase 1: Unlimited (Free period)
+    if elapsed_minutes <= settings.free_minutes:
+        return True
+        
+    # Phase 2: Tracked (Redirect period)
+    if elapsed_minutes <= (settings.free_minutes + settings.redirect_minutes):
+        count = await billing_service.increment_request_count(user_id)
+        if count > settings.max_requests:
+            # Reseteo el valor en el redis para que la pueda seguir ocupando 
+            # hasta llegar a ese número nuevamente después de la redirección
+            await billing_service.reset_request_count(user_id)
+            # Raise exception to stop execution and return 402
+            raise PaymentRequiredException(
+                message="Límite de peticiones alcanzado. Por favor, realiza un pago."
+            )
+        return True
+        
+    # Phase 3: Blocked (Expired)
+    raise PaymentRequiredException(
+        message="Su periodo de uso ha expirado. Por favor, realice un pago para continuar."
+    )
+
+def register_billing_exception_handler(app: Any):
+    """
+    Register the global exception handler for PaymentRequiredException.
+    """
+    from fastapi import Request
+    from fastapi.responses import JSONResponse
+    
+    @app.exception_handler(PaymentRequiredException)
+    async def billing_exception_handler(request: Request, exc: PaymentRequiredException):
+        return APIResponse.payment_required(
+            message=exc.message,
+            error=exc.error
+        )

cashing2fast_fastapi/exceptions.py

@@ -0,0 +1,6 @@
+from typing import Any
+
+class PaymentRequiredException(Exception):
+    def __init__(self, message: str = "Pago Requerido", error: Any = None):
+        self.message = message
+        self.error = error

cashing2fast_fastapi/services/__init__.py

@@ -0,0 +1,7 @@
+from .billing_service import get_user_billing_info, increment_request_count, reset_request_count
+
+__all__ = [
+    "get_user_billing_info",
+    "increment_request_count",
+    "reset_request_count",
+]

cashing2fast_fastapi/services/billing_service.py

@@ -0,0 +1,62 @@
+import json
+from datetime import datetime
+from typing import TypedDict, Any
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+from oauth2fast_fastapi import User
+from ..utils.redis_client import get_redis_client
+from ..settings import settings
+
+class UserAuthCache(TypedDict):
+    id: int
+    created_at: str
+
+async def get_user_billing_info(email: str, session: AsyncSession) -> UserAuthCache:
+    """
+    Obtiene id y created_at del usuario, priorizando Redis.
+    Si no está en Redis, consulta DB y lo guarda.
+    """
+    redis = get_redis_client()
+    key = f"cashing:user_auth:{email}"
+    
+    cached_data = await redis.get(key)
+    if cached_data:
+        try:
+            return json.loads(cached_data)
+        except json.JSONDecodeError:
+            pass
+            
+    # Si no hay caché, buscar en DB
+    result = await session.exec(select(User).where(User.email == email))
+    user = result.one_or_none()
+    
+    if not user:
+        raise ValueError(f"User with email {email} not found")
+        
+    info: UserAuthCache = {
+        "id": user.id,
+        "created_at": user.created_at.isoformat()
+    }
+    
+    # Guardar en caché
+    await redis.setex(
+        key,
+        settings.user_cache_ttl,
+        json.dumps(info)
+    )
+    
+    return info
+
+async def increment_request_count(user_id: int) -> int:
+    """Incrementa el contador de peticiones del usuario en Redis."""
+    redis = get_redis_client()
+    key = f"cashing:{user_id}:requests"
+    
+    # Incrementa y devuelve el nuevo valor
+    return await redis.incr(key)
+
+async def reset_request_count(user_id: int):
+    """Resetea el contador de peticiones del usuario en Redis."""
+    redis = get_redis_client()
+    key = f"cashing:{user_id}:requests"
+    await redis.set(key, 0)

cashing2fast_fastapi/settings.py

@@ -0,0 +1,68 @@
+"""
+Cashing2Fast FastAPI Settings
+
+Configuration for cashing2fast-fastapi module using pydantic-settings.
+Reads from environment variables with CASHING_ prefix.
+"""
+
+import os
+from pydantic import BaseModel, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Look for .env in the current working directory (where the app is running)
+DOTENV_PATH = os.path.join(os.getcwd(), ".env")
+
+class RedisSettings(BaseModel):
+    """Redis configuration for caching billing info."""
+    host: str = "localhost"
+    port: int = 6379
+    db: int = 0
+    password: SecretStr | None = None
+    decode_responses: bool = True
+
+class Settings(BaseSettings):
+    """Billing and request limit configuration settings."""
+
+    model_config = SettingsConfigDict(
+        env_file=DOTENV_PATH,
+        env_file_encoding="utf-8",
+        env_prefix="CASHING_",
+        env_nested_delimiter="__",
+        extra="ignore",
+    )
+
+    # Redis settings
+    redis: RedisSettings = RedisSettings()
+
+    # Feature flags
+    redis_enabled: bool = True
+
+    # Billing Logic Limits
+    # Period where users are never penalized/redirected (in minutes)
+    free_minutes: int = 0
+    # Period following the free minutes where users are tracked (in minutes)
+    redirect_minutes: int = 60
+    # Number of allowed requests during the redirect_minutes phase
+    max_requests: int = 100
+
+    # Cache settings
+    # Default TTL for cached user info (created_at)
+    user_cache_ttl: int = 86400  # 24 hours
+
+try:
+    settings = Settings()
+except Exception as e:
+    # Use log2fast_fastapi for proper error logging if available
+    try:
+        from log2fast_fastapi import get_logger
+        logger = get_logger(__name__)
+        logger.exception(
+            "🚨 Error loading Cashing2Fast configuration",
+            extra_data={
+                "error": str(e),
+                "dotenv_path": DOTENV_PATH,
+            },
+        )
+    except ImportError:
+        print(f"🚨 Error loading Cashing2Fast configuration: {e}")
+    raise

cashing2fast_fastapi/utils/__init__.py

@@ -0,0 +1,6 @@
+from .redis_client import get_redis_client, close_redis
+
+__all__ = [
+    "get_redis_client",
+    "close_redis",
+]

cashing2fast_fastapi/utils/redis_client.py

@@ -0,0 +1,25 @@
+from redis.asyncio import Redis
+from ..settings import settings
+
+# Global redis pool
+_redis_client: Redis | None = None
+
+def get_redis_client() -> Redis:
+    """Get or initialize the Redis client from settings."""
+    global _redis_client
+    if _redis_client is None:
+        _redis_client = Redis(
+            host=settings.redis.host,
+            port=settings.redis.port,
+            db=settings.redis.db,
+            password=settings.redis.password.get_secret_value() if settings.redis.password else None,
+            decode_responses=settings.redis.decode_responses,
+        )
+    return _redis_client
+
+async def close_redis() -> None:
+    """Close the Redis connection pool."""
+    global _redis_client
+    if _redis_client is not None:
+        await _redis_client.aclose()
+        _redis_client = None

cashing2fast_fastapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: cashing2fast-fastapi
+Version: 0.1.0
+Summary: Billing and request limit control for FastAPI
+Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Angel Daniel Sanchez Castillo
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: fastapi,billing,request-limit,redis,oauth2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oauth2fast-fastapi>=0.3.0
+Requires-Dist: tools2fast-fastapi>=0.1.5
+Requires-Dist: redis>=5.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Dynamic: license-file
+
+# cashing2fast-fastapi
+🚀 Simple and fast cashing tools for FastAPI with minimal configuration
+
+## Documentación
+
+- [Guía de Uso (Usage Guide)](docs/usage.md)
+- [Ejemplos de configuración](examples/.env.examples)
+
+## Instalación
+
+```bash
+uv add cashing2fast-fastapi
+```
+
+## Características
+
+- 🎯 **Lógica de 3 Fases:** Tiempo gratuito, periodo de cobro por peticiones y bloqueo final.
+- ⚡ **Redis Native:** Contadores atómicos y caché de usuario para evitar cargas innecesarias a DB.
+- 🛡️ **Tools2Fast Integration:** Respuestas con formato estándar y código HTTP 402.

cashing2fast_fastapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cashing2fast_fastapi/__init__.py,sha256=w9yMZm1ibdJn_sAzHQL_D55dGdslRAClI4GeT815HsA,302
+cashing2fast_fastapi/__version__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+cashing2fast_fastapi/dependencies.py,sha256=90EwjQvKKsoi_Lrx12iT6ioP6AApH8SD1TmXQDU-AtA,3346
+cashing2fast_fastapi/exceptions.py,sha256=l8BcuZ4RzXWMNx23qWF9VYe6fSfjYvcIp6Aq-VZRAV4,201
+cashing2fast_fastapi/settings.py,sha256=FE1s9WTDjDKWIK1rX0s4rCAkWpBcYzX135CfvYB_O88,2017
+cashing2fast_fastapi/services/__init__.py,sha256=njESeZgOSorh96QTNZswD-CaAUas0koe4LwDagrv0nM,199
+cashing2fast_fastapi/services/billing_service.py,sha256=1aMOWWoNK_f63HEZcm58mWwbieEi1iWWXaAfUjELioM,1793
+cashing2fast_fastapi/utils/__init__.py,sha256=peCIbzMM-kRaltBlo2vriO_llMWKmiIcLi5D6RtMk_0,114
+cashing2fast_fastapi/utils/redis_client.py,sha256=dBw9V2y3CZ6OSlVfRsggn2db7DOyMedSAof9KZ9dVmc,811
+cashing2fast_fastapi-0.1.0.dist-info/licenses/LICENSE,sha256=CkISX1hNEwxxrPTOXet3IYMEH28Bn7SoUyKniRjg68I,1086
+cashing2fast_fastapi-0.1.0.dist-info/METADATA,sha256=ihueuBUDENqJ7xFhlPWNcG6Wnin8lzqSzB2bOzDcFEo,2814
+cashing2fast_fastapi-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cashing2fast_fastapi-0.1.0.dist-info/top_level.txt,sha256=RhBlMDmmnW5ILWHO0Kn5P15VI_TqDYQ7JuZ6XvKhvRM,21
+cashing2fast_fastapi-0.1.0.dist-info/RECORD,,

cashing2fast_fastapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cashing2fast_fastapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Angel Daniel Sanchez Castillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cashing2fast_fastapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cashing2fast_fastapi