Generator szkieletu Flask

GENERATOR SZKIELETU FLASK
Folder projektu: acme-flask-api
Pakiet Python: acme_flask_api
Szablon: api
Python: 3.12
Opcje: SQLAlchemy, Hooki JWT auth, Bez Celery, Docker, pytest, ruff

DRZEWO PROJEKTU
----------------
acme-flask-api/
  .env.example
  .gitignore
  Dockerfile
  README.md
  acme_flask_api/
    __init__.py
    blueprints/
      __init__.py
      api_v1/
        __init__.py
        routes.py
      health/
        __init__.py
        routes.py
    config.py
    extensions.py
    models.py
  docker-compose.yml
  pyproject.toml
  requirements-dev.txt
  requirements.txt
  run.py
  tests/
    __init__.py
    test_api_v1.py
    test_health.py
  wsgi.py

PLIKI
-----

=== .env.example ===
FLASK_ENV=development
SECRET_KEY=dev-secret-change-me
PORT=5000
DATABASE_URL=sqlite:///app.db
JWT_SECRET_KEY=dev-jwt-secret-change-me


=== .gitignore ===
.venv/
__pycache__/
*.pyc
*.pyo
*.pyd
*.sqlite3
*.db
.env
.pytest_cache/
.coverage
htmlcov/
dist/
build/
*.egg-info/
.DS_Store


=== Dockerfile ===
FROM python:3.12-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

COPY . /app

EXPOSE 5000

CMD ["gunicorn", "-b", "0.0.0.0:5000", "wsgi:app"]


=== README.md ===
# acme-flask-api

Ten projekt został wygenerowany za pomocą generatora szkieletu Flask.

## Co otrzymujesz

Szablon API zawiera wersjonowany blueprint API z endpointami JSON.

- Baza danych: włączona (Flask-SQLAlchemy + Flask-Migrate)
- Szkielet JWT: włączony (Flask-JWT-Extended)
- Szkielet Celery: wyłączony
- Pliki Docker: dołączone
- Testy: dołączony szkielet pytest
- Linter: dołączona konfiguracja ruff

## Szybki start (lokalnie)

1. Utwórz wirtualne środowisko i zainstaluj zależności:

   - Utwórz venv: `python -m venv .venv`
   - Aktywuj je, a następnie zainstaluj: `pip install -e .`

2. Skopiuj plik środowiskowy i ustaw sekrety:

   - `cp .env.example .env`

3. Uruchom aplikację:

   - `python run.py`

Otwórz http://127.0.0.1:5000/health, aby zweryfikować, że działa.

## Punkt wejścia WSGI

Na produkcji możesz uruchomić Gunicorn:

   - `gunicorn wsgi:app`

## Struktura pakietu

- Główny pakiet: `acme_flask_api/`
- Blueprinty: `acme_flask_api/blueprints/`
- Konfiguracja: `acme_flask_api/config.py`
- Rozszerzenia: `acme_flask_api/extensions.py`


=== acme_flask_api/__init__.py ===
from flask import Flask

from .config import Config
from .extensions import db
from .extensions import jwt
from .blueprints.health.routes import bp as health_bp
from .blueprints.api_v1.routes import bp as api_v1_bp

def create_app(config_object=Config) -> Flask:
    app = Flask(__name__)
    app.config.from_object(config_object)

    # Inicjalizacja rozszerzeń
    db.init_app(app)
    jwt.init_app(app)

    # Rejestracja blueprintów
    register_blueprints(app)

    return app


def register_blueprints(app: Flask) -> None:
    app.register_blueprint(health_bp)
    app.register_blueprint(api_v1_bp, url_prefix="/api/v1")


=== acme_flask_api/blueprints/__init__.py ===



=== acme_flask_api/blueprints/api_v1/__init__.py ===



=== acme_flask_api/blueprints/api_v1/routes.py ===
from flask_jwt_extended import jwt_required

from flask import Blueprint, jsonify, request

bp = Blueprint("api_v1", __name__)

@bp.get("/ping")
@jwt_required(optional=True)
def ping():
    return jsonify({"ok": True, "message": "pong", "ip": request.remote_addr})


=== acme_flask_api/blueprints/health/__init__.py ===



=== acme_flask_api/blueprints/health/routes.py ===
from flask import Blueprint, jsonify

bp = Blueprint("health", __name__)

@bp.get("/health")
def health():
    return jsonify({"status": "ok"})


=== acme_flask_api/config.py ===
import os

class Config:
    SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-change-me")
    JSON_SORT_KEYS = False
    SQLALCHEMY_DATABASE_URI = os.getenv("DATABASE_URL", "sqlite:///app.db")
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", SECRET_KEY)


=== acme_flask_api/extensions.py ===
from __future__ import annotations

from flask import Flask

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

from flask_jwt_extended import JWTManager

jwt = JWTManager()

def init_extensions(app: Flask) -> None:
    db.init_app(app)
    jwt.init_app(app)


=== acme_flask_api/models.py ===
from __future__ import annotations

from .extensions import db


class Example(db.Model):
    __tablename__ = "examples"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(120), nullable=False)

    def __repr__(self) -> str:
        return f"<Example {self.id} {self.name}>"


=== docker-compose.yml ===
services:
  app:
    build: .
    ports:
      - "5000:5000"
    env_file:
      - .env


=== pyproject.toml ===
[project]
name = "acme-flask-api"
version = "0.1.0"
description = "Generated Flask starter project"
requires-python = ">=3.12"
dependencies = [
  "Flask>=3.0",
  "Flask-SQLAlchemy>=3.1",
  "Flask-Migrate>=4.0",
  "Flask-JWT-Extended>=4.6",
  "python-dotenv>=1.0"
]

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"


[project.optional-dependencies]
dev = [
  "pytest>=8.0",
  "pytest-cov>=5.0",
  "ruff>=0.4"
]


[tool.ruff]
line-length = 100
select = ["E", "F", "I"]


=== requirements-dev.txt ===
pytest>=8.0
pytest-cov>=5.0
ruff>=0.4


=== requirements.txt ===
Flask>=3.0
Flask-SQLAlchemy>=3.1
Flask-Migrate>=4.0
Flask-JWT-Extended>=4.6
python-dotenv>=1.0


=== run.py ===
import os

from dotenv import load_dotenv

from acme_flask_api import create_app

load_dotenv()

app = create_app()

if __name__ == "__main__":
    port = int(os.getenv("PORT", "5000"))
    app.run(host="0.0.0.0", port=port, debug=True)


=== tests/__init__.py ===



=== tests/test_api_v1.py ===
from acme_flask_api import create_app


def test_api_ping():
    app = create_app()
    client = app.test_client()
    resp = client.get("/api/v1/ping")
    assert resp.status_code == 200
    payload = resp.get_json()
    assert payload.get("ok") is True


=== tests/test_health.py ===
from acme_flask_api import create_app


def test_health_ok():
    app = create_app()
    client = app.test_client()
    resp = client.get("/health")
    assert resp.status_code == 200
    assert resp.get_json()["status"] == "ok"


=== wsgi.py ===
from acme_flask_api import create_app

app = create_app()