fastapi-gen-newone 0.1.1__tar.gz

fastapi_gen_newone-0.1.1/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mouad
+
+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.

fastapi_gen_newone-0.1.1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: fastapi-gen-newone
+Version: 0.1.1
+Summary: ⚡ Scaffold production-ready FastAPI projects instantly
+Author: Mouad Sadik
+License: MIT
+Keywords: fastapi,cli,generator,backend,python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Dynamic: license-file
+
+# fastapi-gen ⚡
+
+> Create production-ready FastAPI projects in seconds.
+
+## Install
+```bash
+pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ fastapi-gen-newone
+```
+
+Or run directly with `pipx`:
+```bash
+pipx run fastapi-gen-newone my-app
+```
+
+## Usage
+
+### Interactive (recommended)
+```bash
+fastapi-gen my-app
+```
+
+You'll be prompted to select features:
+```
+⚡ FastAPI Project Generator
+Scaffold a production-ready FastAPI app in seconds
+
+? Project name: my-app
+? Include SQLAlchemy (database models): Yes
+? Include Alembic (database migrations): Yes
+? Include JWT Auth (login/register routes): Yes
+? Include Docker (Dockerfile + docker-compose): Yes
+? Include Pytest (test suite): Yes
+```
+
+### With flags (non-interactive)
+```bash
+fastapi-gen my-app --db --auth --docker --alembic --tests
+```
+
+### Skip prompts entirely
+```bash
+fastapi-gen my-app -y            # bare project, no extras
+fastapi-gen my-app -y --auth     # just auth, no prompts
+```
+
+## Generated structure
+```
+my-app/
+├── src/
+│   ├── main.py            ← FastAPI app entrypoint
+│   ├── core/
+│   │   └── config.py    ← pydantic-settings
+│   ├── api/v1/
+│   │   ├── router.py
+│   │   └── endpoints/
+│   │       └── health.py   
+│   ├── db/                ← (if --db)
+│   │   └── session.py
+│   ├── models/            ← (if --db)
+│   └── schemas/           ← (if --db)
+├── alembic/               ← (if --alembic)
+├── tests/                 ← (if --tests)
+├── Dockerfile             ← (if --docker)
+├── docker-compose.yml     ← (if --docker)
+├── pyproject.toml
+├── .env.example
+└── README.md
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--db` | SQLAlchemy async ORM + aiosqlite |
+| `--alembic` | Alembic migration setup |
+| `--docker` | Dockerfile + docker-compose |
+| `--tests` | pytest + httpx async test suite |
+| `-y / --no-interactive` | Skip all prompts |

fastapi_gen_newone-0.1.1/README.md

@@ -0,0 +1,78 @@
+# fastapi-gen ⚡
+
+> Create production-ready FastAPI projects in seconds.
+
+## Install
+```bash
+pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ fastapi-gen-newone
+```
+
+Or run directly with `pipx`:
+```bash
+pipx run fastapi-gen-newone my-app
+```
+
+## Usage
+
+### Interactive (recommended)
+```bash
+fastapi-gen my-app
+```
+
+You'll be prompted to select features:
+```
+⚡ FastAPI Project Generator
+Scaffold a production-ready FastAPI app in seconds
+
+? Project name: my-app
+? Include SQLAlchemy (database models): Yes
+? Include Alembic (database migrations): Yes
+? Include JWT Auth (login/register routes): Yes
+? Include Docker (Dockerfile + docker-compose): Yes
+? Include Pytest (test suite): Yes
+```
+
+### With flags (non-interactive)
+```bash
+fastapi-gen my-app --db --auth --docker --alembic --tests
+```
+
+### Skip prompts entirely
+```bash
+fastapi-gen my-app -y            # bare project, no extras
+fastapi-gen my-app -y --auth     # just auth, no prompts
+```
+
+## Generated structure
+```
+my-app/
+├── src/
+│   ├── main.py            ← FastAPI app entrypoint
+│   ├── core/
+│   │   └── config.py    ← pydantic-settings
+│   ├── api/v1/
+│   │   ├── router.py
+│   │   └── endpoints/
+│   │       └── health.py   
+│   ├── db/                ← (if --db)
+│   │   └── session.py
+│   ├── models/            ← (if --db)
+│   └── schemas/           ← (if --db)
+├── alembic/               ← (if --alembic)
+├── tests/                 ← (if --tests)
+├── Dockerfile             ← (if --docker)
+├── docker-compose.yml     ← (if --docker)
+├── pyproject.toml
+├── .env.example
+└── README.md
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--db` | SQLAlchemy async ORM + aiosqlite |
+| `--alembic` | Alembic migration setup |
+| `--docker` | Dockerfile + docker-compose |
+| `--tests` | pytest + httpx async test suite |
+| `-y / --no-interactive` | Skip all prompts |

fastapi_gen_newone-0.1.1/fastapi_gen/cli.py

@@ -0,0 +1,82 @@
+import typer
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from rich.text import Text
+from rich import print as rprint
+import re
+
+from .generator import generate_project
+from .config import ProjectConfig
+
+app = typer.Typer(add_completion=False)
+console = Console()
+
+
+def validate_name(name: str) -> str:
+    if not re.match(r'^[a-z][a-z0-9_-]*$', name):
+        raise typer.BadParameter(
+            "Project name must be lowercase, start with a letter, and contain only letters, numbers, hyphens, or underscores."
+        )
+    return name
+
+
+@app.command()
+def create(
+    project_name: str = typer.Argument(None, help="Name of the project to create"),
+    db: bool = typer.Option(False, "--db", help="Add SQLAlchemy + database support"),
+    docker: bool = typer.Option(False, "--docker", help="Add Dockerfile & docker-compose"),
+    alembic: bool = typer.Option(False, "--alembic", help="Add Alembic migrations"),
+    tests: bool = typer.Option(False, "--tests", help="Add pytest test suite"),
+    no_interactive: bool = typer.Option(False, "--no-interactive", "-y", help="Skip prompts, use defaults/flags"),
+):
+    """
+    ⚡ Create a new FastAPI project.
+    """
+    console.print()
+    console.print(Panel.fit(
+        Text.from_markup(
+            "[bold cyan]⚡ FastAPI Project Generator[/bold cyan]\n"
+            "[dim]Scaffold a production-ready FastAPI app in seconds[/dim]"
+        ),
+        border_style="cyan",
+        padding=(0, 2),
+    ))
+    console.print()
+
+    # --- Project name ---
+    if project_name is None:
+        project_name = Prompt.ask("[bold]? Project name[/bold]", default="my-fastapi-app")
+    try:
+        validate_name(project_name.replace("-", "_").replace(" ", "_"))
+    except typer.BadParameter as e:
+        console.print(f"[red]✗ {e}[/red]")
+        raise typer.Exit(1)
+
+    # --- Interactive prompts (unless -y) ---
+    if not no_interactive:
+        console.print()
+        console.print("[dim]Select features to include:[/dim]")
+        if not db:
+            db = Confirm.ask("  [bold]? Include SQLAlchemy[/bold] (database models)", default=False)
+        if db and not alembic:
+            alembic = Confirm.ask("  [bold]? Include Alembic[/bold] (database migrations)", default=False)
+        if not docker:
+            docker = Confirm.ask("  [bold]? Include Docker[/bold] (Dockerfile + docker-compose)", default=False)
+        if not tests:
+            tests = Confirm.ask("  [bold]? Include Pytest[/bold] (test suite)", default=False)
+
+    config = ProjectConfig(
+        name=project_name,
+        db=db,
+        docker=docker,
+        alembic=alembic,
+        tests=tests,
+    )
+
+    console.print()
+    generate_project(config, console)
+
+
+if __name__ == "__main__":
+    app()

fastapi_gen_newone-0.1.1/fastapi_gen/config.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ProjectConfig:
+    name: str
+    db: bool = False
+    docker: bool = False
+    alembic: bool = False
+    tests: bool = False
+
+    @property
+    def slug(self) -> str:
+        """Snake_case version of the project name for Python modules."""
+        return self.name.replace("-", "_").lower()

fastapi_gen_newone-0.1.1/fastapi_gen/generator.py

@@ -0,0 +1,148 @@
+import os
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.tree import Tree
+from rich import print as rprint
+import time
+
+from .config import ProjectConfig
+from . import templates
+
+
+def write(path: Path, content: str):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def generate_project(config: ProjectConfig, console: Console):
+    base = Path(config.name)
+
+    if base.exists():
+        console.print(f"[red]✗ Directory '{config.name}' already exists.[/red]")
+        raise SystemExit(1)
+
+    files: dict[str, str] = {}
+
+    # --- Core app files ---
+    files["src/main.py"]                      = templates.main_py(config)
+    files["src/core/__init__.py"]             = ""
+    files["src/core/config.py"]               = templates.core_config(config)
+    files["src/api/__init__.py"]              = ""
+    files["src/api/v1/__init__.py"]           = ""
+    files["src/api/v1/router.py"]             = templates.api_router(config)
+    files["src/api/v1/endpoints/__init__.py"] = ""
+    files["src/api/v1/endpoints/health.py"]   = templates.health_endpoint()
+
+    # --- DB / models ---
+    if config.db:
+        files["src/db/__init__.py"]        = ""
+        files["src/db/session.py"]         = templates.db_session(config)
+        files["src/db/base.py"]            = templates.db_base()
+        files["src/models/__init__.py"]    = ""
+        files["src/models/base.py"]        = templates.model_base()
+        files["src/schemas/__init__.py"]   = ""
+
+    # --- Alembic ---
+    if config.alembic:
+        files["alembic.ini"]               = templates.alembic_ini(config)
+        files["alembic/env.py"]            = templates.alembic_env(config)
+        files["alembic/versions/.gitkeep"] = ""
+
+    # --- Tests ---
+    if config.tests:
+        files["tests/__init__.py"]         = ""
+        files["tests/conftest.py"]         = templates.conftest(config)
+        files["tests/test_health.py"]      = templates.test_health()
+
+    # --- Docker ---
+    if config.docker:
+        files["Dockerfile"]                = templates.dockerfile(config)
+        files["docker-compose.yml"]        = templates.docker_compose(config)
+        files[".dockerignore"]             = templates.dockerignore()
+
+    # --- Project root ---
+    files["pyproject.toml"]                = templates.pyproject_toml(config)
+    files[".env.example"]                  = templates.env_example(config)
+    files[".gitignore"]                    = templates.gitignore()
+    files["README.md"]                     = templates.readme(config)
+    files["src/__init__.py"]               = ""
+
+    # --- Write files with progress ---
+    with Progress(
+        SpinnerColumn(spinner_name="dots", style="cyan"),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        task = progress.add_task("Creating project...", total=len(files))
+        for rel_path, content in files.items():
+            write(base / rel_path, content)
+            progress.advance(task)
+            time.sleep(0.015)
+
+    # --- Print file tree ---
+    console.print(_build_tree(config))
+    console.print()
+
+    # --- Next steps ---
+    console.print("[bold green]✓ Project created successfully![/bold green]")
+    console.print()
+    console.print("[bold]Next steps:[/bold]")
+    console.print(f"  [cyan]cd {config.name}[/cyan]")
+    console.print(f"  [cyan]python -m venv .venv && source .venv/bin/activate[/cyan]")
+    console.print(f"  [cyan]pip install -e .[/cyan]")
+    if config.alembic:
+        console.print(f"  [cyan]alembic upgrade head[/cyan]")
+    if config.docker:
+        console.print(f"  [cyan]docker-compose up --build[/cyan]")
+    else:
+        console.print(f"  [cyan]uvicorn src.main:app --reload[/cyan]")
+    console.print()
+    console.print(f"  Docs -> http://localhost:8000/docs")
+    console.print()
+
+
+def _build_tree(config: ProjectConfig) -> Tree:
+    tree = Tree(f"[bold cyan]{config.name}/[/bold cyan]")
+
+    src = tree.add("[bold yellow]src/[/bold yellow]")
+    src.add("[dim]__init__.py[/dim]")
+    src.add("[green]main.py[/green]  [dim]<- app entrypoint[/dim]")
+
+    core = src.add("[bold yellow]core/[/bold yellow]")
+    core.add("config.py  [dim]<- settings[/dim]")
+
+    api = src.add("[bold yellow]api/v1/[/bold yellow]")
+    api.add("router.py")
+    ep = api.add("[bold yellow]endpoints/[/bold yellow]")
+    ep.add("health.py")
+
+    if config.db:
+        db = src.add("[bold yellow]db/[/bold yellow]")
+        db.add("session.py  [dim]<- DB engine[/dim]")
+        db.add("base.py")
+        src.add("[bold yellow]models/[/bold yellow]").add("[dim](add models here)[/dim]")
+        src.add("[bold yellow]schemas/[/bold yellow]").add("[dim](add schemas here)[/dim]")
+
+    if config.alembic:
+        alembic = tree.add("[bold yellow]alembic/[/bold yellow]")
+        alembic.add("env.py")
+        alembic.add("[bold yellow]versions/[/bold yellow]")
+        tree.add("alembic.ini")
+
+    if config.tests:
+        tests = tree.add("[bold yellow]tests/[/bold yellow]")
+        tests.add("conftest.py")
+        tests.add("test_health.py")
+
+    if config.docker:
+        tree.add("Dockerfile")
+        tree.add("docker-compose.yml")
+        tree.add(".dockerignore")
+
+    tree.add("pyproject.toml  [dim]<- deps & metadata[/dim]")
+    tree.add(".env.example")
+    tree.add(".gitignore")
+    tree.add("README.md")
+    return tree

fastapi_gen_newone-0.1.1/fastapi_gen/templates.py

@@ -0,0 +1,412 @@
+"""
+All file content templates for generated projects.
+"""
+from .config import ProjectConfig
+
+
+# -- Core ---------------------------------------------------------------------
+
+def main_py(c: ProjectConfig) -> str:
+    router_import = "from src.api.v1.router import router as api_router"
+    db_lifespan = ""
+    if c.db:
+        db_lifespan = """
+from contextlib import asynccontextmanager
+from src.db.session import engine
+from src.db.base import Base
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield
+"""
+    lifespan_arg = "lifespan=lifespan" if c.db else ""
+
+    return f'''from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from src.core.config import settings
+{router_import}
+{db_lifespan}
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    version=settings.VERSION,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    {lifespan_arg}
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api_router, prefix="/api/v1")
+
+
+@app.get("/", tags=["root"])
+async def root():
+    return {{"message": f"Welcome to {{settings.PROJECT_NAME}}"}}
+'''
+
+
+def core_config(c: ProjectConfig) -> str:
+    db_field = '\n    DATABASE_URL: str = "sqlite+aiosqlite:///./dev.db"' if c.db else ""
+    return f'''from pydantic_settings import BaseSettings
+from typing import List
+
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "{c.name}"
+    VERSION: str = "0.1.0"
+    ALLOWED_ORIGINS: List[str] = ["http://localhost:3000", "http://localhost:8000"]{db_field}
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()
+'''
+
+
+def api_router(c: ProjectConfig) -> str:
+    return '''from fastapi import APIRouter
+from src.api.v1.endpoints.health import router as health_router
+
+router = APIRouter()
+router.include_router(health_router, prefix="/health", tags=["health"])
+'''
+
+
+def health_endpoint() -> str:
+    return '''from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("")
+async def health_check():
+    return {"status": "ok"}
+'''
+
+
+# -- Database -----------------------------------------------------------------
+
+def db_session(c: ProjectConfig) -> str:
+    return '''from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+from src.core.config import settings
+
+engine = create_async_engine(settings.DATABASE_URL, echo=False)
+AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
+
+
+async def get_db() -> AsyncSession:
+    async with AsyncSessionLocal() as session:
+        yield session
+'''
+
+
+def db_base() -> str:
+    return '''from src.models.base import Base
+
+__all__ = ["Base"]
+'''
+
+
+def model_base() -> str:
+    return '''from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass
+'''
+
+
+# -- Alembic ------------------------------------------------------------------
+
+def alembic_ini(c: ProjectConfig) -> str:
+    return f'''[alembic]
+script_location = alembic
+sqlalchemy.url = sqlite:///./dev.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
+'''
+
+
+def alembic_env(c: ProjectConfig) -> str:
+    return '''from alembic import context
+from sqlalchemy import engine_from_config, pool
+from src.db.base import Base
+from src.core.config import settings
+
+config = context.config
+config.set_main_option("sqlalchemy.url", settings.DATABASE_URL.replace("+aiosqlite", ""))
+target_metadata = Base.metadata
+
+
+def run_migrations_offline():
+    context.configure(
+        url=config.get_main_option("sqlalchemy.url"),
+        target_metadata=target_metadata,
+        literal_binds=True,
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    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()
+'''
+
+
+# -- Tests --------------------------------------------------------------------
+
+def conftest(c: ProjectConfig) -> str:
+    return '''import pytest
+from httpx import AsyncClient, ASGITransport
+from src.main import app
+
+
+@pytest.fixture
+async def client():
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
+        yield ac
+'''
+
+
+def test_health() -> str:
+    return '''import pytest
+
+
+@pytest.mark.anyio
+async def test_health(client):
+    response = await client.get("/api/v1/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+'''
+
+
+# -- Docker -------------------------------------------------------------------
+
+def dockerfile(c: ProjectConfig) -> str:
+    return '''FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY pyproject.toml .
+RUN pip install --no-cache-dir -e .
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]
+'''
+
+
+def docker_compose(c: ProjectConfig) -> str:
+    db_service = """
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: appdb
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+volumes:
+  pgdata:
+""" if c.db else ""
+
+    db_depends = "\n    depends_on:\n      - postgres" if c.db else ""
+
+    return f'''version: "3.9"
+
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    volumes:
+      - .:/app{db_depends}
+{db_service}'''
+
+
+def dockerignore() -> str:
+    return '''.venv
+__pycache__
+*.pyc
+*.pyo
+.git
+.env
+*.egg-info
+dist
+build
+.pytest_cache
+'''
+
+
+# -- Project root -------------------------------------------------------------
+
+def pyproject_toml(c: ProjectConfig) -> str:
+    extras = [
+        "fastapi[standard]",
+        "pydantic-settings",
+        "uvicorn[standard]",
+    ]
+    if c.db:
+        extras += ["sqlalchemy[asyncio]", "aiosqlite"]
+    if c.alembic:
+        extras.append("alembic")
+    if c.tests:
+        extras += ["pytest", "pytest-anyio", "httpx"]
+
+    deps = "\n".join(f'  "{dep}",' for dep in extras)
+
+    return f'''[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{c.name}"
+version = "0.1.0"
+description = "A FastAPI application"
+requires-python = ">=3.11"
+dependencies = [
+{deps}
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+'''
+
+
+def env_example(c: ProjectConfig) -> str:
+    lines = ['PROJECT_NAME="My FastAPI App"']
+    if c.db:
+        lines.append('DATABASE_URL="sqlite+aiosqlite:///./dev.db"')
+    return "\n".join(lines) + "\n"
+
+
+def gitignore() -> str:
+    return '''.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.env
+*.db
+*.sqlite3
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+'''
+
+
+def readme(c: ProjectConfig) -> str:
+    features = ["- FastAPI with async support"]
+    if c.db:
+        features.append("- SQLAlchemy async ORM")
+    if c.alembic:
+        features.append("- Alembic migrations")
+    if c.docker:
+        features.append("- Docker + docker-compose")
+    if c.tests:
+        features.append("- Pytest async test suite")
+
+    feature_block = "\n".join(features)
+    run_cmd = "docker-compose up --build" if c.docker else "uvicorn src.main:app --reload"
+
+    return f'''# {c.name}
+
+## Features
+
+{feature_block}
+
+## Getting started
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+cp .env.example .env
+{"alembic upgrade head" + chr(10) if c.alembic else ""}{run_cmd}
+```
+
+Open http://localhost:8000/docs for the interactive API docs.
+
+## Project structure
+
+```
+src/
+  main.py            # App entrypoint
+  core/
+    config.py        # Settings (pydantic-settings)
+  api/v1/
+    router.py
+    endpoints/
+      health.py
+{"  db/" + chr(10) + "    session.py" + chr(10) + "  models/" + chr(10) + "  schemas/" if c.db else ""}
+```
+'''

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: fastapi-gen-newone
+Version: 0.1.1
+Summary: ⚡ Scaffold production-ready FastAPI projects instantly
+Author: Mouad Sadik
+License: MIT
+Keywords: fastapi,cli,generator,backend,python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Dynamic: license-file
+
+# fastapi-gen ⚡
+
+> Create production-ready FastAPI projects in seconds.
+
+## Install
+```bash
+pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ fastapi-gen-newone
+```
+
+Or run directly with `pipx`:
+```bash
+pipx run fastapi-gen-newone my-app
+```
+
+## Usage
+
+### Interactive (recommended)
+```bash
+fastapi-gen my-app
+```
+
+You'll be prompted to select features:
+```
+⚡ FastAPI Project Generator
+Scaffold a production-ready FastAPI app in seconds
+
+? Project name: my-app
+? Include SQLAlchemy (database models): Yes
+? Include Alembic (database migrations): Yes
+? Include JWT Auth (login/register routes): Yes
+? Include Docker (Dockerfile + docker-compose): Yes
+? Include Pytest (test suite): Yes
+```
+
+### With flags (non-interactive)
+```bash
+fastapi-gen my-app --db --auth --docker --alembic --tests
+```
+
+### Skip prompts entirely
+```bash
+fastapi-gen my-app -y            # bare project, no extras
+fastapi-gen my-app -y --auth     # just auth, no prompts
+```
+
+## Generated structure
+```
+my-app/
+├── src/
+│   ├── main.py            ← FastAPI app entrypoint
+│   ├── core/
+│   │   └── config.py    ← pydantic-settings
+│   ├── api/v1/
+│   │   ├── router.py
+│   │   └── endpoints/
+│   │       └── health.py   
+│   ├── db/                ← (if --db)
+│   │   └── session.py
+│   ├── models/            ← (if --db)
+│   └── schemas/           ← (if --db)
+├── alembic/               ← (if --alembic)
+├── tests/                 ← (if --tests)
+├── Dockerfile             ← (if --docker)
+├── docker-compose.yml     ← (if --docker)
+├── pyproject.toml
+├── .env.example
+└── README.md
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--db` | SQLAlchemy async ORM + aiosqlite |
+| `--alembic` | Alembic migration setup |
+| `--docker` | Dockerfile + docker-compose |
+| `--tests` | pytest + httpx async test suite |
+| `-y / --no-interactive` | Skip all prompts |

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENCE
+README.md
+pyproject.toml
+fastapi_gen/__init__.py
+fastapi_gen/cli.py
+fastapi_gen/config.py
+fastapi_gen/generator.py
+fastapi_gen/templates.py
+fastapi_gen_newone.egg-info/PKG-INFO
+fastapi_gen_newone.egg-info/SOURCES.txt
+fastapi_gen_newone.egg-info/dependency_links.txt
+fastapi_gen_newone.egg-info/entry_points.txt
+fastapi_gen_newone.egg-info/requires.txt
+fastapi_gen_newone.egg-info/top_level.txt

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fastapi-gen = fastapi_gen.cli:app

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/requires.txt

@@ -0,0 +1,2 @@
+typer>=0.12
+rich>=13

fastapi_gen_newone-0.1.1/fastapi_gen_newone.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_gen

fastapi_gen_newone-0.1.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-gen-newone"
+version = "0.1.1"
+description = "⚡ Scaffold production-ready FastAPI projects instantly"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+dependencies = [
+  "typer>=0.12",
+  "rich>=13",
+]
+authors = [{name = "Mouad Sadik"}]
+keywords = ["fastapi", "cli", "generator", "backend", "python"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+fastapi-gen = "fastapi_gen.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["fastapi_gen*"]

fastapi_gen_newone-0.1.1/setup.cfg

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