API Runtime

API Runtime

El runtime de PyGo proporciona los tipos y funciones principales disponibles en archivos .pgo.

Importaciones Principales

from pygo import App, model, route, Optional, Array, Map

App

La clase principal de la aplicación.

Métodos

app.run(port, host)

Iniciar el servidor HTTP.

if __name__ == "__main__":
    app.run(port=8080)

app.on_error(handler)

Registrar un manejador de errores global.

@app.on_error
def handle_error(error: Exception, scope: dict) -> dict:
    return {"error": str(error), "status": 500}

app.middleware(handler)

Añadir un middleware al pipeline de peticiones.

@app.middleware
async def auth_middleware(request, next):
    token = request.headers.get("Authorization")
    if not validate_token(token):
        return {"error": "Unauthorized", "status": 401}
    return await next(request)

Decorador Route

Definir rutas HTTP.

@route("/")
def index():
    return {"message": "Hello, World!"}

@route("/users/{id}")
def get_user(id: str):
    user = User.get(id=id)
    return user.to_dict()

Parámetros de Ruta

@route("/users/{user_id:int}")
def get_user(user_id: int):
    return User.get(id=user_id)

@route("/posts/{slug:str}")
def get_post(slug: str):
    return Post.get(slug=slug)

Métodos HTTP

@route("/users", methods=["GET"])
def list_users():
    return User.all()

@route("/users", methods=["POST"])
def create_user(data: dict):
    return User.create(**data)

Decorador Model

Definir modelos de datos con mapeo automático de base de datos.

from pygo import model, field
from uuid import UUID
from datetime import DateTime

@model
class User:
    id: UUID(auto=True)
    name: str
    email: str
    created_at: DateTime(auto_now_add=True)

Tipos de Campo

Tipos Básicos

Tipo Python	Tipo Go	Tipo DB
str	string	TEXT
int	int	INTEGER
float	float64	REAL
bool	bool	BOOLEAN
UUID	uuid.UUID	UUID
Email	string	TEXT
DateTime	time.Time	TIMESTAMP

Tipos Genéricos

Tipo PyGo	Equivalente Python	Equivalente Go
Array[T]	list[T]	[]T
Map[K, V]	dict[K, V]	map[K]V
Optional[T]	T | None	*T

Métodos de Modelo

Model.get(**kwargs)

Obtener un registro único por valores de campo.

user = User.get(id="12345678-1234-5678-1234-567812345678")

Model.all(select_related=None)

Obtener todos los registros.

users = User.all()
users_with_posts = User.all(select_related=['posts'])

Model.filter(**kwargs)

Filtrar registros por valores de campo.

active_users = User.filter(is_active=True)
admin_users = User.filter(role="admin", is_active=True)

Model.create(**kwargs)

Crear un nuevo registro.

user = User.create(name="Alice", email="alice@example.com")

Model.update(**kwargs)

Actualizar registros que coinciden con los criterios de filtro.

User.filter(role="user").update(is_premium=True)

Model.delete(**kwargs)

Eliminar registros que coinciden con los criterios de filtro.

User.filter(is_active=False).delete()

Model.count()

Contar registros coincidentes.

count = User.filter(is_active=True).count()

Funciones de Respuesta

render(template, **context)

Renderizar una plantilla HTML.

@route("/")
def index():
    return render("index", title="Home", users=User.all())

json(data)

Devolver una respuesta JSON.

@route("/api/users")
def api_users():
    return json([u.to_dict() for u in User.all()])

redirect(url, status=302)

Devolver una respuesta de redirección.

@route("/old-page")
def old_page():
    return redirect("/new-page", status=301)