ES

DocsPython marcos

De Flask a Nexy

En Nexy, una vista Flask se convierte en un archivo en src/routes/: un archivo .py para JSON, un archivo .nexy para HTML, con Jinja2 conservado y los decoradores, planos y request globales desaparecidos.

Cada sección a continuación muestra un hábito Flask, luego lo mismo en Nexy.

una ruta

aplicación.py
from flask import Flask app = Flask(__name__)  @app.get("/api/hello")def hello():    return {"message": "Hello"}

La ruta del archivo es la URL y el nombre de la función es el método:

src/rutas/api/hola.py
async def GET():    return {"message": "Hello"}

variables de URL

aplicación.py
@app.get("/api/users/<int:id>")def get_user(id):    return {"id": id}

El convertidor se convierte en una anotación de tipo y la variable en un segmento [id]:

src/rutas/api/usuarios/[id].py
async def GET(id: int):    return {"id": id}

<path:rest> es un segmento general, [...rest].py.

cadenas de consulta

aplicación.py
from flask import request  @app.get("/api/search")def search():    q = request.args.get("q", "")    page = request.args.get("page", 1, type=int)    return {"q": q, "page": page}

No existe request global: un parámetro de consulta es un parámetro de función, convertido y validado:

src/rutas/api/search.py
async def GET(q: str = "", page: int = 1):    return {"q": q, "page": page}

Un cuerpo JSON

aplicación.py
@app.post("/api/items")def create_item():    data = request.get_json()    if "name" not in data:        return {"error": "name is required"}, 400    return {"created": data["name"]}, 201

Un modelo Pydantic valida el cuerpo y uno malo responde 422 por sí solo:

src/rutas/api/items.py
from pydantic import BaseModel from nexy.http import JSONResponse  class NewItem(BaseModel):    name: str  async def POST(item: NewItem):    return JSONResponse({"created": item.name}, status_code=201)

Varios métodos en una URL

aplicación.py
@app.route("/api/notes/<int:id>", methods=["GET", "DELETE"])def note(id):    if request.method == "DELETE":        return {"deleted": id}    return {"id": id}

Una función por método, en el mismo archivo:

src/rutas/api/notes/[id].py
async def GET(id: int):    return {"id": id}  async def DELETE(id: int):    return {"deleted": id}

Plantillas

aplicación.py
from flask import render_template  @app.get("/users")def users():    return render_template("users.html", users=[{"name": "Ada"}, {"name": "Alan"}])

La vista y su plantilla son un archivo .nexy: Python encima de la línea ---, el mismo Jinja2 debajo:

src/rutas/usuarios.nexy
---users = [{"name": "Ada"}, {"name": "Alan"}]---<ul>  {% for user in users %}  <li>{{ user.name }}</li>  {% endfor %}</ul>

Una plantilla base

plantillas/base.html
<!DOCTYPE html><html>  <body>{% block content %}{% endblock %}</body></html>

Un layout.nexy envuelve cada página de su carpeta y debajo; las páginas no {% extends %} lo:

src/rutas/layout.nexy
---children: prop[NexyElement]---<!DOCTYPE html><html>  <body>{{ children | safe }}</body></html>

Macros e incluye

plantillas/macros.html
{% macro card(title) %}<article><h2>{{ title }}</h2>{{ caller() }}</article>{% endmacro %}

Un componente es un archivo .nexy con accesorios, importado en el frontmatter:

src/components/Card.nexy
---title: prop[str]---<article>  <h2>{{ title }}</h2>  <Slot /></article>
src/rutas/index.nexy
---from "@/components/Card.nexy" import Card---<Card title="Latest">  <p>Everything published this week.</p></Card>

@ es src/: nx new escribe useAliases = {"@": "src"} en nexyconfig.py.

Planos

administrador.py
from flask import Blueprint admin = Blueprint("admin", __name__, url_prefix="/admin")  @admin.get("/stats")def stats():    return {"users": 3}  app.register_blueprint(admin)

Una carpeta es el prefijo y no queda nada registrado:

src/rutas/admin/stats.py
async def GET():    return {"users": 3}

before_request

administrador.py
from flask import abort  @admin.before_requestdef require_admin():    if request.headers.get("X-Role") != "admin":        abort(403)

Un dependencies.py se ejecuta antes de cada ruta de su carpeta y debajo:

src/rutas/admin/dependencias.py
from nexy.http import Header, HTTPException  def require_admin(x_role: str = Header("")) -> None:    if x_role != "admin":        raise HTTPException(status_code=403, detail="Admins only")  dependencies = [require_admin]

after_request

aplicación.py
@app.after_requestdef add_header(response):    response.headers["X-App"] = "demo"    return response

Un middleware.py ve la solicitud antes de la ruta y la respuesta después de ella:

src/rutas/middleware.py
from nexy.http import Request  async def middleware(request: Request, call_next):    response = await call_next(request)    response.headers["x-app"] = "demo"    return response

Formularios y redirecciones

aplicación.py
from flask import redirect, url_for  @app.post("/notes")def add_note():    NOTES.append(request.form["title"])    return redirect(url_for("notes"))

Una acción es una Python función en la que se publica el formulario. Nexy le proporciona una ruta, lee los campos del formulario como parámetros y envía al visitante de regreso a la página con un 303:

src/acciones/notas.py
from nexy.decorators import Action NOTES: list[str] = []  @Actionasync def add_note(title: str) -> None:    NOTES.append(title)
src/rutas/notas.nexy
---from src.actions.notes import NOTES---<form method="post" action="{{ __actions_path['add_note'] }}">  <input name="title">  <button type="submit">Add</button></form><ul>  {% for note in NOTES %}  <li>{{ note }}</li>  {% endfor %}</ul>

Sesiones

aplicación.py
from flask import session app.secret_key = "change-me"  @app.post("/api/login")def login():    session["user"] = request.json["name"]    return {"user": session["user"]}

El secreto se mueve a nexyconfig.py y la sesión cuelga de la solicitud:

nexyconfig.py
from nexy.core.models import NexyConfigModel  class NexyConfig(NexyConfigModel):    useSession = {"secret_key": "change-me"}
src/rutas/api/login.py
from pydantic import BaseModel from nexy.http import Request  class Login(BaseModel):    name: str  async def POST(request: Request, body: Login):    request.session["user"] = body.name    return {"user": body.name}

Una página lo lee con useSession():

src/rutas/cuenta.nexy
---from nexy import useSession user = useSession().get("user", "guest")---<h1>Hello {{ user }}</h1>

abort(404) y controladores de errores

aplicación.py
@app.errorhandler(404)def not_found(error):    return render_template("404.html"), 404  @app.get("/posts/<slug>")def post(slug):    if slug not in POSTS:        abort(404)    return render_template("post.html", post=POSTS[slug])

notFound() detiene la página y notfound.nexy extrae la respuesta:

src/rutas/publicaciones/[slug].nexy
---from nexy import notFound POSTS = {"hello": "Hello, world"} slug: prop[str]if slug not in POSTS:    notFound()---<h1>{{ POSTS[slug] }}</h1>
src/rutas/notfound.nexy
<h1>Not found</h1><p><a href="/">Back home</a></p>

Archivos estáticos

static/logo.png        Flask:  /static/logo.pngpublic/logo.png        Nexy:   /logo.png

Matraz-CORS

aplicación.py
from flask_cors import CORS CORS(app, origins=["https://example.com"])
nexyconfig.py
from nexy.core.models import NexyConfigModel  class NexyConfig(NexyConfigModel):    useCORS = {"allow_origins": ["https://example.com"]}

Pruebas

pruebas/test_app.py
from app import app  def test_hello():    assert app.test_client().get("/api/hello").json == {"message": "Hello"}
pruebas/test_hello.py
from fastapi.testclient import TestClient from nexy.app import app  def test_hello():    assert TestClient(app).get("/api/hello").json() == {"message": "Hello"}

corriendo

Flask nexy
flask run --debug nx dev
gunicorn app:app nx build, luego nx start
flask db migrate (Flask-Migrate) nx migrate -m "message"
sin documentos API /docs, enumerando cada .py ruta

Próximos pasos

Editar en GitHub

Enter abre el resultado, Esc lo cierra.