generate-model

Génération Model SQLAlchemy

Tu es un développeur Python senior. Tu dois générer un model SQLAlchemy complet avec relations, validations et migration Alembic.

Arguments

$ARGUMENTS

Arguments :

• Nom du model (ex: User, Product, Order)
• (Optionnel) Champs au format field:type (ex: name:str email:str:unique)

Exemple : /python:generate-model Product name:str price:decimal category_id:uuid:fk

MISSION

Étape 1 : Analyser les Besoins

Identifier :

• Nom du model et de la table
• Champs et leurs types
• Relations (ForeignKey, OneToMany, ManyToMany)
• Index et contraintes
• Validations

Étape 2 : Model SQLAlchemy 2.0

# app/models/{model}.py
from datetime import datetime
from decimal import Decimal
from typing import TYPE_CHECKING, Optional
from uuid import UUID, uuid4

from sqlalchemy import (
    Boolean,
    CheckConstraint,
    Column,
    DateTime,
    ForeignKey,
    Index,
    Numeric,
    String,
    Text,
    UniqueConstraint,
)
from sqlalchemy.dialects.postgresql import UUID as PGUUID
from sqlalchemy.orm import Mapped, mapped_column, relationship

from app.db.base_class import Base

if TYPE_CHECKING:
    from app.models.category import Category
    from app.models.order_item import OrderItem


class {Model}(Base):
    """
    Model {Model}.

    Représente {description}.

    Attributes:
        id: Identifiant unique UUID
        name: Nom du {model}
        description: Description optionnelle
        price: Prix du {model}
        is_active: Statut actif/inactif
        category_id: ID de la catégorie parente
        created_at: Date de création
        updated_at: Date de dernière modification
    """
    __tablename__ = "{model}s"

    # Contraintes de table
    __table_args__ = (
        UniqueConstraint("name", "category_id", name="uq_{model}_name_category"),
        CheckConstraint("price >= 0", name="ck_{model}_price_positive"),
        Index("ix_{model}s_category_active", "category_id", "is_active"),
    )

    # Colonnes
    id: Mapped[UUID] = mapped_column(
        PGUUID(as_uuid=True),
        primary_key=True,
        default=uuid4,
    )
    name: Mapped[str] = mapped_column(
        String(255),
        nullable=False,
        index=True,
    )
    slug: Mapped[str] = mapped_column(
        String(255),
        nullable=False,
        unique=True,
        index=True,
    )
    description: Mapped[Optional[str]] = mapped_column(
        Text,
        nullable=True,
    )
    price: Mapped[Decimal] = mapped_column(
        Numeric(10, 2),
        nullable=False,
        default=Decimal("0.00"),
    )
    quantity: Mapped[int] = mapped_column(
        default=0,
    )
    is_active: Mapped[bool] = mapped_column(
        Boolean,
        default=True,
        index=True,
    )

    # Foreign Keys
    category_id: Mapped[Optional[UUID]] = mapped_column(
        PGUUID(as_uuid=True),
        ForeignKey("categories.id", ondelete="SET NULL"),
        nullable=True,
        index=True,
    )

    # Timestamps
    created_at: Mapped[datetime] = mapped_column(
        DateTime,
        default=datetime.utcnow,
    )
    updated_at: Mapped[datetime] = mapped_column(
        DateTime,
        default=datetime.utcnow,
        onupdate=datetime.utcnow,
    )

    # Relations
    category: Mapped[Optional["Category"]] = relationship(
        "Category",
        back_populates="{model}s",
        lazy="selectin",
    )
    order_items: Mapped[list["OrderItem"]] = relationship(
        "OrderItem",
        back_populates="{model}",
        cascade="all, delete-orphan",
    )

    def __repr__(self) -> str:
        return f"<{Model}(id={self.id}, name={self.name}, price={self.price})>"

    @property
    def is_in_stock(self) -> bool:
        """Vérifie si le {model} est en stock."""
        return self.quantity > 0

    def update_stock(self, quantity_change: int) -> None:
        """Met à jour le stock."""
        new_quantity = self.quantity + quantity_change
        if new_quantity < 0:
            raise ValueError("Stock insuffisant")
        self.quantity = new_quantity