cashing2fast-fastapi 0.1.0__tar.gz

cashing2fast_fastapi-0.1.0/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/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+recursive-include examples *.examples
+recursive-include docs *.md

cashing2fast_fastapi-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,19 @@
+# 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/docs/usage.md

@@ -0,0 +1,76 @@
+# Guía de Uso: Cashing2Fast FastAPI
+
+`cashing2fast-fastapi` es una extensión para gestionar límites de peticiones y control de facturación en aplicaciones FastAPI, utilizando Redis para alta velocidad y minimizando consultas a la base de datos.
+
+## 1. Configuración de Entorno (.env)
+
+Asegúrate de tener las siguientes variables en tu archivo `.env`. Puedes ver un ejemplo completo en [examples/.env.examples](../examples/.env.examples).
+
+```env
+# Límites de Facturación (en minutos)
+CASHING_FREE_MINUTES=5       # Minutos gratis después de crear la cuenta
+CASHING_REDIRECT_MINUTES=60  # Minutos en fase de cobro/conteo
+CASHING_MAX_REQUESTS=10      # Máximo de peticiones en fase de cobro
+
+# Redis para el contador y caché
+CASHING_REDIS__HOST=localhost
+CASHING_REDIS__PORT=6379
+```
+
+## 2. Registro del Manejador de Excepciones
+
+Para que tu API responda con el formato estándar (402 Payment Required) y el esquema de `tools2fast`, debes registrar el manejador de excepciones en tu archivo `main.py`:
+
+```python
+from fastapi import FastAPI
+from cashing2fast_fastapi.dependencies import register_billing_exception_handler
+
+app = FastAPI()
+
+# Esto permite que la excepción PaymentRequiredException 
+# se convierta automáticamente en una respuesta Tools2Fast
+register_billing_exception_handler(app)
+```
+
+## 3. Uso de la Dependencia en Routers
+
+Para proteger un endpoint o un router completo, simplemente utiliza la dependencia `require_billing_checks`.
+
+### Proteger un Endpoint Individual:
+
+```python
+from fastapi import APIRouter, Depends
+from cashing2fast_fastapi import require_billing_checks
+
+router = APIRouter()
+
+@router.get("/data-limitada", dependencies=[Depends(require_billing_checks)])
+async def get_protected_data():
+    return {"message": "Has pasado el filtro de facturación correctamente"}
+```
+
+### Proteger un Router Completo:
+
+```python
+router = APIRouter(
+    prefix="/api/premium",
+    dependencies=[Depends(require_billing_checks)]
+)
+```
+
+## 4. ¿Cómo funciona internamente?
+
+La dependencia sigue una lógica de **3 fases** basada en la fecha de creación del usuario (`user.created_at`):
+
+1.  **Fase Gratuita:** Si el tiempo desde la creación es menor o igual a `CASHING_FREE_MINUTES`, el usuario puede navegar libremente.
+2.  **Fase de Conteo:** Si el tiempo es mayor a los minutos gratis pero menor al tiempo de redirección (`FREE + REDIRECT`):
+    *   Se cuenta cada petición en Redis.
+    *   Si se supera el `CASHING_MAX_REQUESTS`, se lanza un error **402**.
+    *   **Importante:** Al lanzar el error, el contador se resetea a 0 para que el usuario pueda volver a navegar tras ser redireccionado por el frontend.
+3.  **Fase Bloqueada:** Si el tiempo total expira, el acceso se bloquea permanentemente con un error **402** hasta que se realice un pago.
+
+## 5. Optimización (Redis)
+
+La librería minimiza el uso de la base de datos:
+*   La primera vez que un usuario hace una petición, se busca su `id` y `created_at` en la DB y se guarda en Redis.
+*   En todas las peticiones siguientes, la información se extrae directamente de Redis usando el token Bearer, ahorrando una consulta SQL por cada request.

cashing2fast_fastapi-0.1.0/examples/.env.examples

@@ -0,0 +1,18 @@
+# Cashing2Fast FastAPI configuration example
+SECRET_KEY=yoursecretkeyhere
+
+# Database connections (Standard for your apps)
+DB_CONNECTIONS__AUTH__HOST=localhost
+DB_CONNECTIONS__AUTH__PORT=5432
+DB_CONNECTIONS__AUTH__USERNAME=postgres
+DB_CONNECTIONS__AUTH__PASSWORD=postgres
+DB_CONNECTIONS__AUTH__DATABASE=postgres
+
+# Billing Logic
+CASHING_FREE_MINUTES=0
+CASHING_REDIRECT_MINUTES=60
+CASHING_MAX_REQUESTS=100
+
+# Redis Connection
+CASHING_REDIS__HOST=localhost
+CASHING_REDIS__PORT=6379

cashing2fast_fastapi-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cashing2fast-fastapi"
+version = "0.1.0"
+description = "Billing and request limit control for FastAPI"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {file = "LICENSE"}
+authors = [
+    {name = "Angel Daniel Sanchez Castillo", email = "angeldaniel.sanchezcastillo@gmail.com"}
+]
+keywords = ["fastapi", "billing", "request-limit", "redis", "oauth2"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Framework :: FastAPI",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "oauth2fast-fastapi>=0.3.0",
+    "tools2fast-fastapi>=0.1.5",
+    "redis>=5.0.0",
+    "pydantic-settings>=2.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "black",
+    "ruff",
+    "mypy>=1.0.0",
+    "pre-commit",
+    "build",
+    "twine",
+]
+test = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+    "httpx>=0.24.0",
+    "python-dotenv>=1.0.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["cashing2fast_fastapi*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false

cashing2fast_fastapi-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cashing2fast_fastapi-0.1.0/src/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-0.1.0/src/cashing2fast_fastapi/__version__.py

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

cashing2fast_fastapi-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/src/cashing2fast_fastapi.egg-info/PKG-INFO

@@ -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/src/cashing2fast_fastapi.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+docs/usage.md
+examples/.env.examples
+src/cashing2fast_fastapi/__init__.py
+src/cashing2fast_fastapi/__version__.py
+src/cashing2fast_fastapi/dependencies.py
+src/cashing2fast_fastapi/exceptions.py
+src/cashing2fast_fastapi/settings.py
+src/cashing2fast_fastapi.egg-info/PKG-INFO
+src/cashing2fast_fastapi.egg-info/SOURCES.txt
+src/cashing2fast_fastapi.egg-info/dependency_links.txt
+src/cashing2fast_fastapi.egg-info/requires.txt
+src/cashing2fast_fastapi.egg-info/top_level.txt
+src/cashing2fast_fastapi/services/__init__.py
+src/cashing2fast_fastapi/services/billing_service.py
+src/cashing2fast_fastapi/utils/__init__.py
+src/cashing2fast_fastapi/utils/redis_client.py
+tests/test_billing.py

cashing2fast_fastapi-0.1.0/src/cashing2fast_fastapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cashing2fast_fastapi-0.1.0/src/cashing2fast_fastapi.egg-info/requires.txt

@@ -0,0 +1,4 @@
+oauth2fast-fastapi>=0.3.0
+tools2fast-fastapi>=0.1.5
+redis>=5.0.0
+pydantic-settings>=2.0.0

cashing2fast_fastapi-0.1.0/src/cashing2fast_fastapi.egg-info/top_level.txt

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

cashing2fast_fastapi-0.1.0/tests/test_billing.py

@@ -0,0 +1,104 @@
+import pytest
+from datetime import datetime, timezone, timedelta
+from unittest.mock import AsyncMock, patch
+from fastapi import FastAPI, Depends
+from httpx import AsyncClient, ASGITransport
+from cashing2fast_fastapi import require_billing_checks, settings
+from cashing2fast_fastapi.dependencies import register_billing_exception_handler
+
+# Mock app
+app = FastAPI()
+register_billing_exception_handler(app)
+
+@app.get("/test")
+async def test_route(dep = Depends(require_billing_checks)):
+    return {"message": "success"}
+
+@pytest.fixture
+def mock_redis():
+    with patch("cashing2fast_fastapi.services.billing_service.get_redis_client") as mock:
+        client = AsyncMock()
+        mock.return_value = client
+        yield client
+
+@pytest.fixture
+def mock_verify_token():
+    with patch("cashing2fast_fastapi.dependencies.verify_token") as mock:
+        yield mock
+
+@pytest.mark.asyncio
+async def test_phase_1_free(mock_redis, mock_verify_token):
+    """Phase 1: User created recently, should allow without counting."""
+    mock_verify_token.return_value = {"sub": "test@example.com"}
+    
+    # Mock user info in Redis (Phase 1: now - 5 mins)
+    created_at = datetime.now(timezone.utc) - timedelta(minutes=5)
+    mock_redis.get.return_value = '{"id": 1, "created_at": "' + created_at.isoformat() + '"}'
+    
+    # Settings: free=10, redirect=60
+    with patch.object(settings, "free_minutes", 10):
+        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+            response = await ac.get("/test", headers={"Authorization": "Bearer token"})
+            
+    assert response.status_code == 200
+    assert response.json() == {"message": "success"}
+    # Should NOT increment count in phase 1
+    mock_redis.incr.assert_not_called()
+
+@pytest.mark.asyncio
+async def test_phase_2_tracked_ok(mock_redis, mock_verify_token):
+    """Phase 2: User in tracking period, should count and allow if below max."""
+    mock_verify_token.return_value = {"sub": "test@example.com"}
+    
+    # Mock user info in Redis (Phase 2: now - 20 mins, where free=10)
+    created_at = datetime.now(timezone.utc) - timedelta(minutes=20)
+    mock_redis.get.return_value = '{"id": 1, "created_at": "' + created_at.isoformat() + '"}'
+    # Current count = 1
+    mock_redis.incr.return_value = 1
+    
+    with patch.object(settings, "free_minutes", 10):
+        with patch.object(settings, "redirect_minutes", 60):
+            with patch.object(settings, "max_requests", 5):
+                async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+                    response = await ac.get("/test", headers={"Authorization": "Bearer token"})
+            
+    assert response.status_code == 200
+    mock_redis.incr.assert_called_once_with("cashing:1:requests")
+
+@pytest.mark.asyncio
+async def test_phase_2_tracked_limit_reached(mock_redis, mock_verify_token):
+    """Phase 2: User reached limit, should return 402 and reset."""
+    mock_verify_token.return_value = {"sub": "test@example.com"}
+    
+    created_at = datetime.now(timezone.utc) - timedelta(minutes=20)
+    mock_redis.get.return_value = '{"id": 1, "created_at": "' + created_at.isoformat() + '"}'
+    # Current count = 6 (limit is 5)
+    mock_redis.incr.return_value = 6
+    
+    with patch.object(settings, "free_minutes", 10):
+        with patch.object(settings, "redirect_minutes", 60):
+            with patch.object(settings, "max_requests", 5):
+                async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+                    response = await ac.get("/test", headers={"Authorization": "Bearer token"})
+            
+    assert response.status_code == 402
+    assert response.json()["message"] == "Límite de peticiones alcanzado. Por favor, realiza un pago."
+    # Should reset count
+    mock_redis.set.assert_called_with("cashing:1:requests", 0)
+
+@pytest.mark.asyncio
+async def test_phase_3_expired(mock_redis, mock_verify_token):
+    """Phase 3: Period expired, should block always."""
+    mock_verify_token.return_value = {"sub": "test@example.com"}
+    
+    # Phase 3: now - 100 mins (free=10 + redirect=60 = 70 mins total period)
+    created_at = datetime.now(timezone.utc) - timedelta(minutes=100)
+    mock_redis.get.return_value = '{"id": 1, "created_at": "' + created_at.isoformat() + '"}'
+    
+    with patch.object(settings, "free_minutes", 10):
+        with patch.object(settings, "redirect_minutes", 60):
+            async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+                response = await ac.get("/test", headers={"Authorization": "Bearer token"})
+            
+    assert response.status_code == 402
+    assert "expirado" in response.json()["message"]