fastai-stack 0.1.0__tar.gz

fastai_stack-0.1.0/LICENSE

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

fastai_stack-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: fastai-stack
+Version: 0.1.0
+Summary: Interactive CLI generator for production-ready FastAPI AI stacks
+Home-page: https://github.com/HarshG1308/fastai-stack
+License: MIT
+Keywords: fastapi,cli,scaffold,ai,ml,generator
+Author: Harsh Gautam
+Author-email: hgqeir@gmai.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Dist: jinja2 (>=3.1.4)
+Requires-Dist: rich (>=13.7.0)
+Requires-Dist: typer (>=0.12.0)
+Project-URL: Repository, https://github.com/HarshG1308/fastai-stack
+Description-Content-Type: text/markdown
+
+# fastai-stack
+
+fastai-stack is an interactive CLI for generating production-ready FastAPI backends tailored to AI/ML workflows.
+
+## Vision
+
+Build the best FastAPI scaffolding experience for AI developers by 2026: async-first, type-safe, and deployment-ready.
+
+## Install
+
+```bash
+pip install fastai-stack
+```
+
+## Quickstart
+
+```bash
+fastai-stack create myapp --interactive
+```
+
+Generate without prompts:
+
+```bash
+fastai-stack create myapp --non-interactive --db sqlite --auth none --ai openai --vector-db pgvector
+```
+
+## What Gets Generated
+
+- FastAPI app skeleton with modular package layout
+- Pydantic v2 settings + async-ready API router
+- Optional auth, tasks, AI, vector DB, and monitoring integrations
+- Dockerfile + docker-compose (CPU/GPU-aware)
+- Poetry-managed app dependencies
+- Tests and CI workflow scaffolding
+
+## Development
+
+```bash
+poetry install
+poetry run pytest
+poetry run fastai-stack --help
+```
+
+## Publish
+
+```bash
+poetry build
+poetry publish
+```
+
+## License
+
+MIT
+

fastai_stack-0.1.0/README.md

@@ -0,0 +1,53 @@
+# fastai-stack
+
+fastai-stack is an interactive CLI for generating production-ready FastAPI backends tailored to AI/ML workflows.
+
+## Vision
+
+Build the best FastAPI scaffolding experience for AI developers by 2026: async-first, type-safe, and deployment-ready.
+
+## Install
+
+```bash
+pip install fastai-stack
+```
+
+## Quickstart
+
+```bash
+fastai-stack create myapp --interactive
+```
+
+Generate without prompts:
+
+```bash
+fastai-stack create myapp --non-interactive --db sqlite --auth none --ai openai --vector-db pgvector
+```
+
+## What Gets Generated
+
+- FastAPI app skeleton with modular package layout
+- Pydantic v2 settings + async-ready API router
+- Optional auth, tasks, AI, vector DB, and monitoring integrations
+- Dockerfile + docker-compose (CPU/GPU-aware)
+- Poetry-managed app dependencies
+- Tests and CI workflow scaffolding
+
+## Development
+
+```bash
+poetry install
+poetry run pytest
+poetry run fastai-stack --help
+```
+
+## Publish
+
+```bash
+poetry build
+poetry publish
+```
+
+## License
+
+MIT

fastai_stack-0.1.0/fastforge/__init__.py

@@ -0,0 +1,4 @@
+"""FastForge package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

fastai_stack-0.1.0/fastforge/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app()

fastai_stack-0.1.0/fastforge/cli.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from .generator import render_project
+from .models import (AIChoice, AuthChoice, DatabaseChoice, DockerChoice,
+                     FrontendChoice, MonitoringChoice, ProjectConfig,
+                     TaskChoice, VectorDBChoice)
+
+app = typer.Typer(help="fastai-stack: Generate production-ready FastAPI stacks for AI developers.")
+console = Console()
+
+
+def _slugify(value: str) -> str:
+    slug = re.sub(r"[^a-zA-Z0-9]+", "-", value.strip().lower()).strip("-")
+    return slug or "fastforge-app"
+
+
+def _prompt_enum(label: str, enum_type: type, default: str) -> str:
+    choices = ", ".join(item.value for item in enum_type)
+    return typer.prompt(f"{label} [{choices}]", default=default)
+
+
+@app.command()
+def create(
+    project_name: str = typer.Argument(..., help="Project name or slug."),
+    interactive: bool = typer.Option(True, "--interactive/--non-interactive", help="Prompt for stack options."),
+    db: DatabaseChoice = typer.Option(DatabaseChoice.postgres, help="Database backend."),
+    auth: AuthChoice = typer.Option(AuthChoice.none, help="Authentication mode."),
+    tasks: TaskChoice = typer.Option(TaskChoice.none, help="Background tasks setup."),
+    ai: AIChoice = typer.Option(AIChoice.none, help="AI integration provider."),
+    vector_db: VectorDBChoice = typer.Option(VectorDBChoice.none, "--vector-db", help="Vector database option."),
+    docker: DockerChoice = typer.Option(DockerChoice.cpu, help="Docker runtime profile."),
+    monitoring: MonitoringChoice = typer.Option(MonitoringChoice.none, help="Monitoring integration."),
+    frontend: FrontendChoice = typer.Option(FrontendChoice.none, help="Frontend starter option."),
+    output_dir: Path = typer.Option(Path("."), "--output-dir", help="Directory where the project will be generated."),
+) -> None:
+    """Create a new FastAPI AI stack project."""
+    final_project_name = project_name
+    final_project_slug = _slugify(project_name)
+
+    if interactive:
+        console.print(Panel("fastai-stack interactive setup", style="bold cyan"))
+        final_project_name = typer.prompt("Project name", default=project_name)
+        final_project_slug = typer.prompt("Project slug", default=_slugify(final_project_name))
+
+        db = DatabaseChoice(_prompt_enum("DB", DatabaseChoice, db.value))
+        auth = AuthChoice(_prompt_enum("Auth", AuthChoice, auth.value))
+        tasks = TaskChoice(_prompt_enum("Tasks", TaskChoice, tasks.value))
+        ai = AIChoice(_prompt_enum("AI", AIChoice, ai.value))
+        vector_db = VectorDBChoice(_prompt_enum("Vector DB", VectorDBChoice, vector_db.value))
+        docker = DockerChoice(_prompt_enum("Docker", DockerChoice, docker.value))
+        monitoring = MonitoringChoice(_prompt_enum("Monitoring", MonitoringChoice, monitoring.value))
+        frontend = FrontendChoice(_prompt_enum("Frontend", FrontendChoice, frontend.value))
+
+    config = ProjectConfig(
+        project_name=final_project_name,
+        project_slug=final_project_slug,
+        db=db,
+        auth=auth,
+        tasks=tasks,
+        ai=ai,
+        vector_db=vector_db,
+        docker=docker,
+        monitoring=monitoring,
+        frontend=frontend,
+    )
+
+    try:
+        project_dir = render_project(config=config, destination=output_dir.resolve())
+    except FileExistsError as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print("\n[bold green]Project created successfully![/bold green]")
+    console.print(f"Location: [cyan]{project_dir}[/cyan]")
+    console.print("\nNext steps:")
+    console.print(f"  cd {config.project_slug}")
+    console.print("  poetry install")
+    console.print("  poetry run uvicorn app.main:app --reload")
+
+
+@app.command()
+def version() -> None:
+    """Show CLI version."""
+    console.print("fastai-stack 0.1.0")
+
+
+if __name__ == "__main__":
+    app()

fastai_stack-0.1.0/fastforge/generator.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from .models import ProjectConfig
+
+TEMPLATE_ROOT = Path(__file__).resolve().parent.parent / "templates" / "project"
+
+
+def _base_dependencies(config: ProjectConfig) -> list[str]:
+    deps = [
+        "fastapi>=0.115.0",
+        "uvicorn>=0.30.0",
+        "pydantic>=2.7.0",
+        "pydantic-settings>=2.3.0",
+        "python-dotenv>=1.0.1",
+    ]
+
+    if config.use_postgres:
+        deps += ["sqlalchemy>=2.0.30", "asyncpg>=0.29.0", "alembic>=1.13.1"]
+    elif config.use_sqlite:
+        deps += ["sqlalchemy>=2.0.30", "aiosqlite>=0.20.0"]
+    elif config.use_mongodb:
+        deps += ["motor>=3.5.1", "beanie>=1.26.0"]
+
+    if config.use_jwt or config.use_oauth2:
+        deps.append("fastapi-users>=13.0.0")
+
+    if config.use_ai:
+        deps += ["httpx>=0.27.0", "sse-starlette>=2.1.0"]
+    if config.ai.value == "openai":
+        deps.append("openai>=1.35.0")
+    if config.ai.value == "langchain":
+        deps += ["langchain>=0.2.6", "langchain-openai>=0.1.14"]
+    if config.ai.value == "huggingface":
+        deps += ["transformers>=4.42.0", "accelerate>=0.32.0"]
+
+    if config.use_celery:
+        deps += ["celery>=5.4.0", "redis>=5.0.7", "flower>=2.0.1"]
+
+    if config.use_pgvector:
+        deps.append("pgvector>=0.2.5")
+    if config.use_weaviate:
+        deps.append("weaviate-client>=4.6.7")
+
+    if config.use_sentry:
+        deps.append("sentry-sdk>=2.7.1")
+    if config.use_prometheus:
+        deps.append("prometheus-fastapi-instrumentator>=7.0.0")
+
+    if config.use_frontend:
+        deps.append("jinja2>=3.1.4")
+
+    return deps
+
+
+def _dev_dependencies() -> list[str]:
+    return [
+        "pytest>=8.2.0",
+        "pytest-asyncio>=0.23.8",
+        "httpx>=0.27.0",
+        "factory-boy>=3.3.0",
+        "black>=24.4.2",
+        "ruff>=0.5.0",
+        "mypy>=1.10.0",
+        "pre-commit>=3.7.1",
+        "commitizen>=3.27.0",
+    ]
+
+
+def _template_map(config: ProjectConfig) -> list[tuple[str, str]]:
+    mapping = [
+        ("README.md.j2", "README.md"),
+        ("pyproject.toml.j2", "pyproject.toml"),
+        (".env.example.j2", ".env.example"),
+        ("Dockerfile.j2", "Dockerfile"),
+        ("docker-compose.yml.j2", "docker-compose.yml"),
+        ("app/__init__.py.j2", "app/__init__.py"),
+        ("app/main.py.j2", "app/main.py"),
+        ("app/core/config.py.j2", "app/core/config.py"),
+        ("app/core/deps.py.j2", "app/core/deps.py"),
+        ("app/core/security.py.j2", "app/core/security.py"),
+        ("app/api/__init__.py.j2", "app/api/__init__.py"),
+        ("app/api/v1/__init__.py.j2", "app/api/v1/__init__.py"),
+        ("app/api/v1/deps.py.j2", "app/api/v1/deps.py"),
+        ("app/api/v1/endpoints/__init__.py.j2", "app/api/v1/endpoints/__init__.py"),
+        ("app/api/v1/endpoints/health.py.j2", "app/api/v1/endpoints/health.py"),
+        ("app/models/__init__.py.j2", "app/models/__init__.py"),
+        ("app/schemas/__init__.py.j2", "app/schemas/__init__.py"),
+        ("app/crud/__init__.py.j2", "app/crud/__init__.py"),
+        ("tests/conftest.py.j2", "tests/conftest.py"),
+        ("tests/test_api/test_health.py.j2", "tests/test_api/test_health.py"),
+        (".github/workflows/ci.yml.j2", ".github/workflows/ci.yml"),
+        (".gitignore.j2", ".gitignore"),
+    ]
+
+    if config.use_postgres:
+        mapping.append(("migrations/.gitkeep.j2", "migrations/.gitkeep"))
+
+    if config.use_ai:
+        mapping += [
+            ("app/api/v1/endpoints/ai/__init__.py.j2", "app/api/v1/endpoints/ai/__init__.py"),
+            ("app/api/v1/endpoints/ai/chat.py.j2", "app/api/v1/endpoints/ai/chat.py"),
+            ("app/api/v1/endpoints/ai/embeddings.py.j2", "app/api/v1/endpoints/ai/embeddings.py"),
+        ]
+
+    if config.use_celery:
+        mapping.append(("app/tasks.py.j2", "app/tasks.py"))
+
+    if config.use_frontend:
+        mapping += [
+            ("frontend/package.json.j2", "frontend/package.json"),
+            ("frontend/index.html.j2", "frontend/index.html"),
+            ("frontend/src/main.js.j2", "frontend/src/main.js"),
+        ]
+
+    return mapping
+
+
+def render_project(config: ProjectConfig, destination: Path) -> Path:
+    project_dir = destination / config.project_slug
+    if project_dir.exists():
+        raise FileExistsError(f"Directory already exists: {project_dir}")
+
+    project_dir.mkdir(parents=True, exist_ok=False)
+
+    env = Environment(
+        loader=FileSystemLoader(str(TEMPLATE_ROOT)),
+        autoescape=False,
+        trim_blocks=True,
+        lstrip_blocks=True,
+        undefined=StrictUndefined,
+    )
+
+    context: dict[str, Any] = {
+        "config": config,
+        "project_name": config.project_name,
+        "project_slug": config.project_slug,
+        "dependencies": _base_dependencies(config),
+        "dev_dependencies": _dev_dependencies(),
+    }
+
+    for source_name, target_name in _template_map(config):
+        template = env.get_template(source_name)
+        rendered = template.render(**context)
+        target = project_dir / target_name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(rendered.rstrip() + "\n", encoding="utf-8")
+
+    return project_dir

fastai_stack-0.1.0/fastforge/models.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class DatabaseChoice(str, Enum):
+    postgres = "postgres"
+    mongodb = "mongodb"
+    sqlite = "sqlite"
+
+
+class AuthChoice(str, Enum):
+    none = "none"
+    jwt = "jwt"
+    oauth2 = "oauth2"
+
+
+class TaskChoice(str, Enum):
+    none = "none"
+    celery_redis = "celery+redis"
+
+
+class AIChoice(str, Enum):
+    none = "none"
+    openai = "openai"
+    langchain = "langchain"
+    huggingface = "huggingface"
+
+
+class VectorDBChoice(str, Enum):
+    none = "none"
+    pgvector = "pgvector"
+    weaviate = "weaviate"
+
+
+class DockerChoice(str, Enum):
+    cpu = "cpu"
+    gpu = "gpu"
+
+
+class MonitoringChoice(str, Enum):
+    none = "none"
+    sentry = "sentry"
+    prometheus = "prometheus"
+
+
+class FrontendChoice(str, Enum):
+    none = "none"
+    htmx_vite = "htmx+vite"
+
+
+@dataclass
+class ProjectConfig:
+    project_name: str
+    project_slug: str
+    db: DatabaseChoice
+    auth: AuthChoice
+    tasks: TaskChoice
+    ai: AIChoice
+    vector_db: VectorDBChoice
+    docker: DockerChoice
+    monitoring: MonitoringChoice
+    frontend: FrontendChoice
+
+    @property
+    def use_ai(self) -> bool:
+        return self.ai != AIChoice.none
+
+    @property
+    def use_postgres(self) -> bool:
+        return self.db == DatabaseChoice.postgres
+
+    @property
+    def use_mongodb(self) -> bool:
+        return self.db == DatabaseChoice.mongodb
+
+    @property
+    def use_sqlite(self) -> bool:
+        return self.db == DatabaseChoice.sqlite
+
+    @property
+    def use_jwt(self) -> bool:
+        return self.auth == AuthChoice.jwt
+
+    @property
+    def use_oauth2(self) -> bool:
+        return self.auth == AuthChoice.oauth2
+
+    @property
+    def use_celery(self) -> bool:
+        return self.tasks == TaskChoice.celery_redis
+
+    @property
+    def use_pgvector(self) -> bool:
+        return self.vector_db == VectorDBChoice.pgvector
+
+    @property
+    def use_weaviate(self) -> bool:
+        return self.vector_db == VectorDBChoice.weaviate
+
+    @property
+    def use_gpu(self) -> bool:
+        return self.docker == DockerChoice.gpu
+
+    @property
+    def use_sentry(self) -> bool:
+        return self.monitoring == MonitoringChoice.sentry
+
+    @property
+    def use_prometheus(self) -> bool:
+        return self.monitoring == MonitoringChoice.prometheus
+
+    @property
+    def use_frontend(self) -> bool:
+        return self.frontend == FrontendChoice.htmx_vite

fastai_stack-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "fastai-stack"
+version = "0.1.0"
+description = "Interactive CLI generator for production-ready FastAPI AI stacks"
+authors = ["Harsh Gautam <hgqeir@gmai.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "fastforge" }]
+homepage = "https://github.com/HarshG1308/fastai-stack"
+repository = "https://github.com/HarshG1308/fastai-stack"
+keywords = ["fastapi", "cli", "scaffold", "ai", "ml", "generator"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "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",
+  "Topic :: Software Development :: Code Generators"
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+typer = ">=0.12.0"
+rich = ">=13.7.0"
+jinja2 = ">=3.1.4"
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=8.2.0"
+ruff = ">=0.5.0"
+mypy = ">=1.10.0"
+
+[tool.poetry.scripts]
+fastai-stack = "fastforge.cli:app"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]
+
+[build-system]
+requires = ["poetry-core>=1.9.0"]
+build-backend = "poetry.core.masonry.api"