fabrik-fastapi 1.0.0__py3-none-any.whl

fabrik/__init__.py

@@ -0,0 +1,18 @@
+"""
+Fabrik -- Generateur de projet FastAPI async + opinionated.
+
+Usage CLI :
+    fabrik new mon-api
+    fabrik add videos
+    fabrik upgrade
+    fabrik test-self
+
+Voir : https://github.com/FalandyJEAN/fabrik
+"""
+__version__ = "1.0.0"
+__author__ = "Falandy Jean"
+__license__ = "MIT"
+
+from fabrik.scaffold import SCAFFOLD_VERSION, build_files, main
+
+__all__ = ["SCAFFOLD_VERSION", "build_files", "main", "__version__"]

fabrik/__main__.py

@@ -0,0 +1,8 @@
+"""
+Permet d'invoquer Fabrik via : `python -m fabrik new mon-api`
+(equivalent a la commande `fabrik` installee via pip).
+"""
+from fabrik.scaffold import main
+
+if __name__ == "__main__":
+    main()

fabrik/core/.dockerignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.db
+.env
+venv/
+alembic/versions/
+.pytest_cache/

fabrik/core/.env.example

@@ -0,0 +1,9 @@
+SECRET_KEY=your_secret_key_here
+DATABASE_URL=sqlite:///./app.db
+# PostgreSQL: DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+# (le driver asyncpg/aiosqlite est ajoute automatiquement au runtime)
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+REFRESH_TOKEN_EXPIRE_DAYS=7
+# Origines autorisees (CORS) -- separees par des virgules
+# En prod : https://mon-front.com,https://app.mon-front.com
+BACKEND_CORS_ORIGINS=http://localhost:3000,http://localhost:5173,http://localhost:8080

fabrik/core/.gitignore

@@ -0,0 +1,12 @@
+venv/
+.venv/
+__pycache__/
+*.pyc
+.env
+*.db
+alembic/versions/
+.vscode/
+.idea/
+.pytest_cache/
+htmlcov/
+.coverage

fabrik/core/_templates/Dockerfile.tpl

@@ -0,0 +1,7 @@
+FROM python:3.13-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE ${port}
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "${port}"]

fabrik/core/_templates/env.tpl

@@ -0,0 +1,8 @@
+SECRET_KEY=${secret_key}
+DATABASE_URL=${db_url}
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+REFRESH_TOKEN_EXPIRE_DAYS=7
+BACKEND_CORS_ORIGINS=http://localhost:3000,http://localhost:5173,http://localhost:8080
+# Background tasks (ARQ + Redis). Si Redis est down, l'API marche quand meme
+# (les routes qui veulent enqueue renvoient 503 Service Unavailable).
+REDIS_URL=redis://localhost:6379

fabrik/core/_templates/main.py.tpl

@@ -0,0 +1,86 @@
+import asyncio
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import logging
+import uvicorn
+
+from arq import create_pool
+from arq.connections import RedisSettings
+
+from src.users.router import router as users_router
+from src.admin.router import router as admin_router
+from src.database import engine, Base
+from src.core.config import settings
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Cree les tables au demarrage (utile en dev ; en prod, prefere Alembic)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    # Pool Redis pour ARQ (background tasks)
+    # Si Redis est down, l'API marche quand meme : les routes qui veulent
+    # enqueue renvoient 503 (voir src/tasks.py:get_arq).
+    # asyncio.wait_for(timeout=2) protege contre un hang (Redis injoignable
+    # mais TCP qui ne fail pas vite, ex: derriere un firewall qui drop).
+    app.state.arq_pool = None
+    try:
+        redis_settings = RedisSettings.from_dsn(settings.REDIS_URL)
+        # Force un conn_timeout court pour fail-fast en CI / dev sans Redis
+        redis_settings.conn_timeout = 2
+        app.state.arq_pool = await asyncio.wait_for(
+            create_pool(redis_settings),
+            timeout=3.0,
+        )
+        logger.info("ARQ pool connecte a %s", settings.REDIS_URL)
+    except (asyncio.TimeoutError, Exception) as e:
+        logger.warning("Redis indisponible (%s) -- background tasks desactives",
+                       type(e).__name__)
+
+    yield
+
+    if app.state.arq_pool is not None:
+        await app.state.arq_pool.close()
+    await engine.dispose()
+
+
+app = FastAPI(title="${title}", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/admin/static", StaticFiles(directory="src/admin/static"), name="admin_static")
+
+app.include_router(users_router)
+app.include_router(admin_router)
+
+# ── Tes modules ici ──────────────────────────────────────────────────────────
+# from src.videos.router import router as videos_router
+# app.include_router(videos_router)
+# (les modules sont detectes automatiquement dans l'admin via Base.registry)
+
+@app.get("/")
+async def health_check():
+    arq_pool = getattr(app.state, "arq_pool", None)
+    return {
+        "status": "ok",
+        "project": "${title}",
+        "background_tasks": arq_pool is not None,
+    }
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="127.0.0.1", port=${port}, reload=True)

fabrik/core/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

fabrik/core/alembic/env.py

@@ -0,0 +1,42 @@
+from logging.config import fileConfig
+from sqlalchemy import engine_from_config, pool
+from alembic import context
+from src.core.config import settings
+from src.database import Base
+import src.users.models  # noqa: F401
+# import src.videos.models  # noqa: F401  <-- ajoute tes modules ici
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
+target_metadata = Base.metadata
+
+
+def run_migrations_offline() -> None:
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=target_metadata,
+        literal_binds=True, dialect_opts={"paramstyle": "named"},
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.", poolclass=pool.NullPool,
+    )
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

fabrik/core/alembic/script.py.mako

@@ -0,0 +1,23 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+"""
+from typing import Sequence, Union
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

fabrik/core/alembic.ini

@@ -0,0 +1,39 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+sqlalchemy.url = sqlite:///./app.db
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

fabrik/core/create_superuser.py

@@ -0,0 +1,56 @@
+"""
+Cree un super-utilisateur (admin) pour acceder a /admin
+
+Usage : python create_superuser.py
+"""
+import asyncio
+from getpass import getpass
+from sqlalchemy import select
+from src.database import AsyncSessionLocal, engine, Base
+from src.users.models import User
+from src.core.security import get_password_hash
+
+
+async def main():
+    # S'assurer que les tables existent
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    print("\n=== Creation d'un super-utilisateur ===\n")
+    email = input("Email : ").strip()
+    password = getpass("Mot de passe : ")
+    confirm  = getpass("Confirmer       : ")
+
+    if password != confirm:
+        print("[!] Les mots de passe ne correspondent pas.")
+        return
+    if len(password) < 6:
+        print("[!] Mot de passe trop court (min 6 caracteres).")
+        return
+
+    async with AsyncSessionLocal() as db:
+        result = await db.execute(select(User).where(User.email == email))
+        existing = result.scalar_one_or_none()
+        if existing:
+            existing.password = get_password_hash(password)
+            existing.is_superuser = True
+            existing.is_active = True
+            await db.commit()
+            print(f"\n  [OK] {email} promu super-utilisateur.")
+        else:
+            user = User(
+                email=email,
+                password=get_password_hash(password),
+                is_active=True,
+                is_superuser=True,
+            )
+            db.add(user)
+            await db.commit()
+            print(f"\n  [OK] Super-utilisateur cree : {email}")
+        print("  Connectez-vous sur http://127.0.0.1:8000/admin/login\n")
+
+    await engine.dispose()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fabrik/core/docker-compose.yml

@@ -0,0 +1,34 @@
+# Services de developpement (Redis pour ARQ, PostgreSQL optionnel).
+# Demarre avec : docker compose up -d
+# Arrete avec  : docker compose down
+
+services:
+  redis:
+    image: redis:7-alpine
+    container_name: fabrik_redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+
+  # Decommente si tu veux PostgreSQL en local au lieu de SQLite.
+  # Pense aussi a mettre a jour DATABASE_URL dans .env :
+  #   DATABASE_URL=postgresql://fabrik:fabrik@localhost:5432/fabrik
+  #
+  # postgres:
+  #   image: postgres:16-alpine
+  #   container_name: fabrik_postgres
+  #   environment:
+  #     POSTGRES_USER: fabrik
+  #     POSTGRES_PASSWORD: fabrik
+  #     POSTGRES_DB: fabrik
+  #   ports:
+  #     - "5432:5432"
+  #   volumes:
+  #     - pg_data:/var/lib/postgresql/data
+  #   restart: unless-stopped
+
+volumes:
+  redis_data:
+  # pg_data:

fabrik/core/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+asyncio_mode = auto
+testpaths = tests

fabrik/core/requirements.txt

@@ -0,0 +1,38 @@
+# Bornes minimales avec caps majeurs : pip resout vers la derniere version
+# compatible. Plus robuste qu'un pin exact (qui peut pointer vers une version
+# non publiee si on regenere des annees plus tard).
+
+# FastAPI stack
+fastapi>=0.115,<1.0
+uvicorn>=0.30,<1.0
+
+# Database (async)
+sqlalchemy>=2.0,<3.0
+alembic>=1.13,<2.0
+aiosqlite>=0.20,<1.0
+asyncpg>=0.29,<1.0
+greenlet>=3.0,<4.0
+
+# Validation & config
+pydantic>=2.9,<3.0
+pydantic-settings>=2.5,<3.0
+
+# Auth
+pyjwt>=2.9,<3.0
+bcrypt>=4.2,<6.0
+
+# Background tasks
+arq>=0.26,<1.0
+redis>=5.0,<6.0
+
+# Tests
+pytest>=8.0,<9.0
+pytest-asyncio>=0.24,<1.0
+httpx>=0.27,<1.0
+
+# Templates
+jinja2>=3.1,<4.0
+
+# Divers
+python-dotenv>=1.0,<2.0
+python-multipart>=0.0.12