fastapi-fastio 0.1.2__tar.gz

fastapi_fastio-0.1.2/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build
+        run: |
+          uv sync --group dev
+          uv run python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

fastapi_fastio-0.1.2/.gitignore

@@ -0,0 +1 @@
+apps

fastapi_fastio-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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_fastio-0.1.2/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: fastapi-fastio
+Version: 0.1.2
+Summary: Opinionated FastAPI project scaffolding CLI for services, monoliths, and monorepos.
+Project-URL: Homepage, https://github.com/goloodev/fastio
+Project-URL: Repository, https://github.com/goloodev/fastio
+Project-URL: Issues, https://github.com/goloodev/fastio/issues
+Author-email: goloodev@gmail.com
+License: MIT
+License-File: LICENSE
+Keywords: cli,fastapi,microservices,monolith,scaffold,template,uv
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1.0
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: rich>=13.7.1
+Requires-Dist: typer>=0.12.5
+Description-Content-Type: text/markdown
+
+# fastio
+
+`fastio` is an opinionated Python CLI that generates FastAPI projects for three shapes:
+
+- single service
+- modular monolith
+- monorepo microservices
+
+It is designed around your standards:
+
+- Python + FastAPI
+- `uv`
+- Alembic
+- SQLAlchemy
+- Swagger at `/docs`
+- SQLAdmin
+- Celery + Redis
+- clean architecture
+- thin routers
+- business logic in `services/`
+- versioned APIs under `/api/v1`
+
+## Install
+
+### Local development
+```bash
+uv sync
+uv run fastio --help
+```
+
+### Editable install
+```bash
+uv pip install -e .
+fastio --help
+```
+
+## Quick start
+
+Create a CRUD service:
+
+```bash
+uv run fastio create my-service --mode service --blueprint crud-service
+```
+
+Create a user service:
+
+```bash
+uv run fastio create user-service --mode service --blueprint user-service
+```
+
+Create a modular monolith:
+
+```bash
+uv run fastio create my-app --mode monolith
+```
+
+Create a monorepo:
+
+```bash
+uv run fastio create platform --mode monorepo
+```
+
+## Publishing to PyPI
+
+The project includes a GitHub Actions publish workflow using PyPI Trusted Publishing.
+PyPI’s docs recommend Trusted Publishing via OIDC because it avoids long-lived API tokens, and a pending publisher can create a new project on first release. Also note that a pending publisher does **not** reserve the name before first publish.
+
+## Commands
+
+### `fastio create`
+
+Generate a new FastAPI project.
+
+```bash
+fastio create NAME [OPTIONS]
+```
+
+**Arguments:**
+- `NAME` - Project directory name (required)
+
+**Options:**
+- `--mode {service,monolith,monorepo}` - Project shape (default: service)
+- `--blueprint {base,crud-service,user-service}` - Project template (default: base for monolith/monorepo, crud-service for service)
+- `--database {sqlite,postgres}` - Database backend (default: sqlite)
+- `--sqlalchemy {sync,async}` - SQLAlchemy mode (default: sync, async for user-service)
+- `--sqladmin/--no-sqladmin` - Include SQLAdmin (default: enabled)
+- `--celery/--no-celery` - Include Celery + Redis (default: enabled)
+- `--docker/--no-docker` - Include Dockerfile (default: enabled)
+- `--tests/--no-tests` - Include test suite (default: enabled)
+- `--ci/--no-ci` - Include GitHub Actions CI workflow (default: enabled)
+- `--output-dir, -o` - Output directory (default: current directory)
+- `--interactive` - Interactive mode with prompts for all options
+
+**Blueprints:**
+- `base` - Minimal FastAPI project with core structure
+- `crud-service` - Full CRUD API with models, schemas, and services
+- `user-service` - User management service with authentication, OAuth, and FastAPI-Users
+
+### `fastio version`
+
+Display the installed version.
+
+```bash
+fastio version
+```
+
+## Usage Examples
+
+### Interactive mode
+```bash
+uv run fastio create my-project --interactive
+```
+
+### CRUD service with PostgreSQL
+```bash
+uv run fastio create my-api --mode service --blueprint crud-service --database postgres
+```
+
+### Async monolith
+```bash
+uv run fastio create my-app --mode monolith --sqlalchemy async
+```
+
+### Minimal service without extras
+```bash
+uv run fastio create my-service --mode service --no-celery --no-sqladmin
+```
+
+### Monorepo with custom output
+```bash
+uv run fastio create platform --mode monorepo --output-dir ./projects
+```

fastapi_fastio-0.1.2/README.md

@@ -0,0 +1,132 @@
+# fastio
+
+`fastio` is an opinionated Python CLI that generates FastAPI projects for three shapes:
+
+- single service
+- modular monolith
+- monorepo microservices
+
+It is designed around your standards:
+
+- Python + FastAPI
+- `uv`
+- Alembic
+- SQLAlchemy
+- Swagger at `/docs`
+- SQLAdmin
+- Celery + Redis
+- clean architecture
+- thin routers
+- business logic in `services/`
+- versioned APIs under `/api/v1`
+
+## Install
+
+### Local development
+```bash
+uv sync
+uv run fastio --help
+```
+
+### Editable install
+```bash
+uv pip install -e .
+fastio --help
+```
+
+## Quick start
+
+Create a CRUD service:
+
+```bash
+uv run fastio create my-service --mode service --blueprint crud-service
+```
+
+Create a user service:
+
+```bash
+uv run fastio create user-service --mode service --blueprint user-service
+```
+
+Create a modular monolith:
+
+```bash
+uv run fastio create my-app --mode monolith
+```
+
+Create a monorepo:
+
+```bash
+uv run fastio create platform --mode monorepo
+```
+
+## Publishing to PyPI
+
+The project includes a GitHub Actions publish workflow using PyPI Trusted Publishing.
+PyPI’s docs recommend Trusted Publishing via OIDC because it avoids long-lived API tokens, and a pending publisher can create a new project on first release. Also note that a pending publisher does **not** reserve the name before first publish.
+
+## Commands
+
+### `fastio create`
+
+Generate a new FastAPI project.
+
+```bash
+fastio create NAME [OPTIONS]
+```
+
+**Arguments:**
+- `NAME` - Project directory name (required)
+
+**Options:**
+- `--mode {service,monolith,monorepo}` - Project shape (default: service)
+- `--blueprint {base,crud-service,user-service}` - Project template (default: base for monolith/monorepo, crud-service for service)
+- `--database {sqlite,postgres}` - Database backend (default: sqlite)
+- `--sqlalchemy {sync,async}` - SQLAlchemy mode (default: sync, async for user-service)
+- `--sqladmin/--no-sqladmin` - Include SQLAdmin (default: enabled)
+- `--celery/--no-celery` - Include Celery + Redis (default: enabled)
+- `--docker/--no-docker` - Include Dockerfile (default: enabled)
+- `--tests/--no-tests` - Include test suite (default: enabled)
+- `--ci/--no-ci` - Include GitHub Actions CI workflow (default: enabled)
+- `--output-dir, -o` - Output directory (default: current directory)
+- `--interactive` - Interactive mode with prompts for all options
+
+**Blueprints:**
+- `base` - Minimal FastAPI project with core structure
+- `crud-service` - Full CRUD API with models, schemas, and services
+- `user-service` - User management service with authentication, OAuth, and FastAPI-Users
+
+### `fastio version`
+
+Display the installed version.
+
+```bash
+fastio version
+```
+
+## Usage Examples
+
+### Interactive mode
+```bash
+uv run fastio create my-project --interactive
+```
+
+### CRUD service with PostgreSQL
+```bash
+uv run fastio create my-api --mode service --blueprint crud-service --database postgres
+```
+
+### Async monolith
+```bash
+uv run fastio create my-app --mode monolith --sqlalchemy async
+```
+
+### Minimal service without extras
+```bash
+uv run fastio create my-service --mode service --no-celery --no-sqladmin
+```
+
+### Monorepo with custom output
+```bash
+uv run fastio create platform --mode monorepo --output-dir ./projects
+```

fastapi_fastio-0.1.2/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fastapi-fastio"
+version = "0.1.2"
+description = "Opinionated FastAPI project scaffolding CLI for services, monoliths, and monorepos."
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+  { email = "goloodev@gmail.com" }
+]
+keywords = ["fastapi", "cli", "template", "scaffold", "uv", "microservices", "monolith"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Code Generators",
+]
+dependencies = [
+  "typer>=0.12.5",
+  "click>=8.1.0",
+  "rich>=13.7.1",
+  "jinja2>=3.1.4",
+  "pydantic>=2.8.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/goloodev/fastio"
+Repository = "https://github.com/goloodev/fastio"
+Issues = "https://github.com/goloodev/fastio/issues"
+
+[project.scripts]
+fastio = "fastio.main:run"
+
+[dependency-groups]
+dev = [
+  "pytest>=8.3.2",
+  "ruff>=0.6.5",
+  "mypy>=1.11.2",
+  "build>=1.2.2.post1",
+  "twine>=5.1.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fastio"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/README.md",
+  "/LICENSE",
+  "/.github",
+  "/tests",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "N", "C4"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+packages = ["fastio"]

fastapi_fastio-0.1.2/src/fastio/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.1.2"

fastapi_fastio-0.1.2/src/fastio/cli/app.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import click
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from fastio import __version__
+from fastio.generators.monolith import MonolithGenerator
+from fastio.generators.monorepo import MonorepoGenerator
+from fastio.generators.service import ServiceGenerator
+from fastio.models.options import AlchemyMode, Blueprint, Database, Mode, ProjectOptions, TelegramTemplate
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help="Opinionated FastAPI scaffolding CLI for services, monoliths, and monorepos.",
+)
+console = Console()
+
+
+def _build_options(
+    name: str,
+    output_dir: Path,
+    mode: Optional[Mode],
+    blueprint: Optional[Blueprint],
+    database: Optional[Database],
+    sqlalchemy_mode: Optional[AlchemyMode],
+    sqladmin: Optional[bool],
+    celery: Optional[bool],
+    docker: Optional[bool],
+    tests: Optional[bool],
+    ci: Optional[bool],
+    interactive: bool,
+    telegram_template: Optional[TelegramTemplate] = None,
+) -> ProjectOptions:
+    if interactive or mode is None:
+        mode = typer.prompt("Mode", type=click.Choice(["service", "monolith", "monorepo"], case_sensitive=False), default="service")
+    if interactive or blueprint is None:
+        default_blueprint = "base" if mode != "service" else "crud-service"
+        blueprint = typer.prompt("Blueprint", type=click.Choice(["base", "crud-service", "user-service", "telegram-bot"], case_sensitive=False), default=default_blueprint)
+    if interactive or database is None:
+        database = typer.prompt("Database", type=click.Choice(["sqlite", "postgres"], case_sensitive=False), default="sqlite")
+    if interactive or sqlalchemy_mode is None:
+        default_sqlalchemy = "async" if blueprint == "user-service" else "sync"
+        sqlalchemy_mode = typer.prompt("SQLAlchemy mode", type=click.Choice(["sync", "async"], case_sensitive=False), default=default_sqlalchemy)
+    if interactive or sqladmin is None:
+        sqladmin = typer.confirm("Include SQLAdmin?", default=True)
+    if interactive or celery is None:
+        celery = typer.confirm("Include Celery?", default=True)
+    if interactive or docker is None:
+        docker = typer.confirm("Include Dockerfile?", default=True)
+    if interactive or tests is None:
+        tests = typer.confirm("Include tests?", default=True)
+    if interactive or ci is None:
+        ci = typer.confirm("Include CI workflow?", default=True)
+    if blueprint == "telegram-bot" and (interactive or telegram_template is None):
+        telegram_template = typer.prompt(
+            "Telegram Template",
+            type=click.Choice(["membership", "police-group", "airdrop", "ecommerce"], case_sensitive=False),
+            default="membership",
+        )
+
+    return ProjectOptions(
+        name=name,
+        output_dir=output_dir,
+        mode=mode,
+        blueprint=blueprint,
+        database=database,
+        sqlalchemy_mode=sqlalchemy_mode,
+        use_sqladmin=bool(sqladmin),
+        use_celery=bool(celery),
+        use_docker=bool(docker),
+        use_tests=bool(tests),
+        use_ci=bool(ci),
+        telegram_template=telegram_template,
+    )
+
+
+@app.command()
+def version() -> None:
+    console.print(f"fastio {__version__}")
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Project directory name."),
+    output_dir: Annotated[Path, typer.Option("--output-dir", "-o", dir_okay=True, file_okay=False)] = Path.cwd(),
+    mode: Annotated[Optional[Mode], typer.Option("--mode")] = None,
+    blueprint: Annotated[Optional[Blueprint], typer.Option("--blueprint")] = None,
+    database: Annotated[Optional[Database], typer.Option("--database")] = None,
+    sqlalchemy_mode: Annotated[Optional[AlchemyMode], typer.Option("--sqlalchemy")] = None,
+    sqladmin: Annotated[Optional[bool], typer.Option("--sqladmin/--no-sqladmin")] = None,
+    celery: Annotated[Optional[bool], typer.Option("--celery/--no-celery")] = None,
+    docker: Annotated[Optional[bool], typer.Option("--docker/--no-docker")] = None,
+    tests: Annotated[Optional[bool], typer.Option("--tests/--no-tests")] = None,
+    ci: Annotated[Optional[bool], typer.Option("--ci/--no-ci")] = None,
+    interactive: Annotated[bool, typer.Option("--interactive/--no-interactive")] = False,
+    telegram_template: Annotated[Optional[TelegramTemplate], typer.Option("--telegram-template")] = None,
+) -> None:
+    options = _build_options(
+        name=name,
+        output_dir=output_dir,
+        mode=mode,
+        blueprint=blueprint,
+        database=database,
+        sqlalchemy_mode=sqlalchemy_mode,
+        sqladmin=sqladmin,
+        celery=celery,
+        docker=docker,
+        tests=tests,
+        ci=ci,
+        interactive=interactive,
+        telegram_template=telegram_template,
+    ).normalized()
+
+    if options.project_dir.exists():
+        raise typer.BadParameter(f"Destination already exists: {options.project_dir}")
+
+    generator_map = {
+        "service": ServiceGenerator,
+        "monolith": MonolithGenerator,
+        "monorepo": MonorepoGenerator,
+    }
+    generator = generator_map[options.mode](options)
+    generator.generate()
+
+    if options.use_ci:
+        workflow_path = options.project_dir / ".github" / "workflows" / "publish.yml"
+        workflow_path.parent.mkdir(parents=True, exist_ok=True)
+        workflow_path.write_text(generator.render("common/publish.yml.j2"), encoding="utf-8")
+
+    console.print(
+        Panel.fit(
+            "\n".join(
+                [
+                    f"[bold green]Created[/bold green] {options.project_dir}",
+                    f"mode = {options.mode}",
+                    f"blueprint = {options.blueprint}",
+                    "",
+                    "Next steps:",
+                    f"  cd {options.project_dir.name}",
+                    "  uv sync",
+                    "  uv run fastapi dev app.main:app",
+                ]
+            ),
+            title="fastio",
+        )
+    )

fastapi_fastio-0.1.2/src/fastio/generators/base.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastio.models.options import ProjectOptions
+from fastio.renderers.jinja import get_environment
+from fastio.renderers.writer import write_text
+
+
+class BaseGenerator:
+    def __init__(self, options: ProjectOptions) -> None:
+        self.options = options.normalized()
+        self.env = get_environment()
+
+    def render(self, template_name: str, **context: Any) -> str:
+        template = self.env.get_template(template_name)
+        merged = {
+            "project": self.options,
+            "project_name": self.options.name,
+            "package_name": self.options.package_name,
+            **context,
+        }
+        return template.render(**merged)
+
+    def write(self, relative_path: str, template_name: str, **context: Any) -> None:
+        destination = self.options.project_dir / relative_path
+        content = self.render(template_name, **context)
+        write_text(destination, content)
+
+    def ensure_root(self) -> Path:
+        self.options.project_dir.mkdir(parents=True, exist_ok=False)
+        return self.options.project_dir

fastapi_fastio-0.1.2/src/fastio/generators/monolith.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from fastio.generators.base import BaseGenerator
+
+
+class MonolithGenerator(BaseGenerator):
+    def generate(self) -> None:
+        self.ensure_root()
+        self.write(".gitignore", "common/gitignore.j2")
+        self.write("README.md", "monolith/README.md.j2")
+        self.write("pyproject.toml", "monolith/pyproject.toml.j2")
+        self.write(".env.example", "common/env.example.j2")
+        if self.options.use_docker:
+            self.write("Dockerfile", "common/Dockerfile.j2")
+            self.write("compose.yml", "common/compose.yml.j2")
+        self.write("app/__init__.py", "common/empty.py.j2")
+        self.write("app/main.py", "monolith/app/main.py.j2")
+        self.write("app/core/__init__.py", "common/empty.py.j2")
+        self.write("app/core/config.py", "monolith/app/core/config.py.j2")
+        self.write("app/modules/__init__.py", "common/empty.py.j2")
+        self.write("app/modules/users/__init__.py", "common/empty.py.j2")
+        self.write("app/modules/users/api.py", "monolith/app/modules/users/api.py.j2")
+        self.write("app/modules/users/models.py", "monolith/app/modules/users/models.py.j2")
+        self.write("app/modules/users/schemas.py", "monolith/app/modules/users/schemas.py.j2")
+        self.write("app/modules/users/service.py", "monolith/app/modules/users/service.py.j2")
+        if self.options.use_celery:
+            self.write("app/tasks/__init__.py", "common/empty.py.j2")
+            self.write("app/tasks/celery_app.py", "monolith/app/tasks/celery_app.py.j2")
+        self.write("alembic.ini", "monolith/alembic.ini.j2")
+        if self.options.use_tests:
+            self.write("tests/test_smoke.py", "common/test_smoke.py.j2")