Coding Conventions

[tool.black]
line-length = 100
target-version = ['py310']
include = '\.pyi?$'
exclude = '''
/(
    \.git
  | \.venv
  | venv
  | __pycache__
  | migrations
)/
'''

class Color(db.Model):
    """
    Model for color catalog.
    
    Attributes:
        id_color: Unique identifier
        name: Color name
        active: Active/inactive status
    """
    __tablename__ = 'colors'  # Plural, snake_case
    
    id_color = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), nullable=False)
    active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.TIMESTAMP, server_default=func.current_timestamp())

"""
Color management module.

Provides endpoints for color catalog CRUD operations.
"""

from flask import Blueprint

colors_bp = Blueprint('colors', __name__)

from . import routes  # noqa: E402, F401

"""
Routes/Controllers for the colors module.
"""

from flask import flash, redirect, render_template, url_for

from . import colors_bp
from .forms import ColorForm
from .services import ColorService
from app.exceptions import ConflictError


@colors_bp.route('/create', methods=['GET', 'POST'])
def create_color():
    """
    Display form and create a new color.
    
    GET: Render the creation form.
    POST: Validate form, create color, and redirect.
    
    Returns:
        GET - HTML: Page with the creation form
        POST - Redirect: Redirects with flash message
    """
    form = ColorForm()

    if form.validate_on_submit():
        data = {'name': form.name.data}
        try:
            ColorService.create(data)
            flash('Color created successfully', 'success')
            return redirect(url_for('colors.create_color'))
        except ConflictError as e:
            flash(e.message, 'error')

    return render_template('colors/create.html', form=form)

"""
Forms for the colors module.
"""

from flask_wtf import FlaskForm
from wtforms import StringField
from wtforms.validators import DataRequired, Length


class ColorForm(FlaskForm):
    """Form for creating a color."""

    name = StringField(
        'Name',
        validators=[
            DataRequired(message='Color name is required'),
            Length(max=50, message='Name cannot exceed 50 characters'),
        ],
    )

"""
Business logic services for colors.
"""

from app.models.color import Color
from app.extensions import db
from app.exceptions import ConflictError, ValidationError


class ColorService:
    """Service for color-related business operations."""

    @staticmethod
    def create(data: dict) -> dict:
        """
        Create a new color.
        
        Args:
            data: Dictionary with color data
            
        Returns:
            dict: Serialized created color
            
        Raises:
            ValidationError: If name is empty
            ConflictError: If color already exists
        """
        name = data.get('name')
        if not name or not name.strip():
            raise ValidationError('Color name is required')

        existing = Color.query.filter_by(name=name.strip()).first()
        if existing:
            raise ConflictError(f"Color '{name}' already exists")

        color = Color(name=name.strip())
        db.session.add(color)
        db.session.commit()
        return color.to_dict()

class ValidationError(AppException):
    """Exception for input validation errors."""
    def __init__(self, message: str = "Invalid input data"):
        super().__init__(message, status_code=400)

class NotFoundError(AppException):
    """Exception for resources not found."""
    def __init__(self, message: str = "Resource not found"):
        super().__init__(message, status_code=404)

class ConflictError(AppException):
    """Exception for data conflicts (e.g., duplicates)."""
    def __init__(self, message: str = "Resource conflict"):
        super().__init__(message, status_code=409)