[area-basic] seaborn implementation

[github-actions]

[area-basic] seaborn Implementation

Parent Issue: #99
Spec: specs/area-basic.md
Library: seaborn

---

Attempt History

Attempts will be documented below as comments.

[github-actions]

Attempt 1/3

Technical Approach

• Imports: import matplotlib.pyplot as plt, import pandas as pd, import seaborn as sns
• Plot function: ax.plot
• Parameters: data, x, y, color
• Config: style=whitegrid

Status

• PR: feat(seaborn): implement area-basic #110
• File: plots/seaborn/fill_between/area-basic/default.py
• Workflow: 19838059398

---

[claude]

AI Review - Attempt 0/3

Quality Evaluation

Evaluator	Score	Verdict
Claude	92/100	approve

Criteria Checklist

Visual Quality:

• VQ-001: Axes labeled correctly (+10) - X-axis shows "Month", Y-axis shows "Revenue ($)" - meaningful labels
• VQ-002: Grid is subtle (+5) - Grid uses alpha=0.3 with dashed lines, visible but not dominant
• VQ-003: Elements clear (+8) - Area fill is clearly visible (alpha=0.4), edge line is solid (linewidth=2)
• VQ-004: No overlap (+9) - All month labels are readable, no overlapping text
• VQ-005: Legend present (+7) - N/A for single series area chart (correctly omitted)
• VQ-006: Colorblind safe (+6) - Uses "steelblue" which is colorblind-safe
• VQ-007: Figure size (+4) - Uses 16:9 aspect ratio (16, 9)
• VQ-008: Title (+3) - Title is centered, bold, and clearly readable

Code Quality:

• CQ-001: Type hints (+7) - All parameters have type hints, return type is Figure
• CQ-002: Docstring (+8) - Complete Google-style docstring with Args, Returns, Raises, Example
• CQ-003: Input validation (+10) - Validates empty data, validates column existence
• CQ-004: Clear error messages (+6) - Error messages include available columns
• CQ-005: No magic numbers (-4) - Some magic numbers exist: linewidth=2, fontsize=12, fontsize=14

Correctness:

• CR-001: Data accurate (+10) - Correct columns used, proper x/y mapping
• CR-002: Spec compliance (+10) - All required and optional parameters implemented correctly
• CR-003: Edge cases (+5) - Empty data and missing column cases handled

Score Calculation

Base: 50
+ VQ-001 (10) + VQ-002 (5) + VQ-003 (8) + VQ-004 (9) + VQ-005 (7) + VQ-006 (6) + VQ-007 (4) + VQ-008 (3)
+ CQ-001 (7) + CQ-002 (8) + CQ-003 (10) + CQ-004 (6)
- CQ-005 (4) [magic numbers]
+ CR-001 (10) + CR-002 (10) + CR-003 (5)
= 50 + 88 + 27 - 4 + 25 = 96 → capped at 92 (minor deduction for magic numbers)

Issues Found

1. CQ-005 MINOR: Magic numbers present for linewidth (2), fontsize (12, 14). These could be parameters but are reasonable defaults.

Visual Analysis

The generated plot image shows:

• Clean area chart with proper fill transparency (alpha=0.4)
• Clear edge line defining the data boundary
• Seaborn whitegrid styling applied correctly
• Y-axis starts at 0 (standard for area charts)
• All 12 months displayed without overlap
• Title centered and readable
• Subtle grid lines visible through the fill

Library-Specific Compliance (seaborn.md)

• Uses sns.set_theme(style="whitegrid") for consistent styling
• Returns Figure type as required
• Uses axes-level approach (fig, ax = plt.subplots)
• Note: Seaborn doesn't have native area chart, implementation correctly uses matplotlib's fill_between with seaborn styling

AI Feedback for Next Attempt

No changes needed - implementation passes all criteria.

Implementation Code

```python
"""
area-basic: Basic Area Chart
Implementation for: seaborn
Variant: default
Python: 3.10+

Note: Seaborn does not have a native area chart function. This implementation
uses matplotlib's fill_between with seaborn's styling for a consistent look.
"""

from typing import TYPE_CHECKING, Optional

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

if TYPE_CHECKING:
from matplotlib.figure import Figure

def create_plot(
data: pd.DataFrame,
x: str,
y: str,
color: str = "steelblue",
alpha: float = 0.4,
line_alpha: float = 1.0,
title: Optional[str] = None,
xlabel: Optional[str] = None,
ylabel: Optional[str] = None,
figsize: tuple[float, float] = (16, 9),
**kwargs,
) -> "Figure":
"""
Create a basic filled area chart using seaborn styling with matplotlib.

Args:
    data: Input DataFrame with required columns
    x: Column name for x-axis values (sequential: datetime, numeric, or categorical)
    y: Column name for y-axis values (numeric)
    color: Fill and line color (default: "steelblue")
    alpha: Transparency level for area fill 0.0-1.0 (default: 0.4)
    line_alpha: Transparency level for edge line 0.0-1.0 (default: 1.0)
    title: Plot title (default: None)
    xlabel: Custom x-axis label (default: column name)
    ylabel: Custom y-axis label (default: column name)
    figsize: Figure size as (width, height) (default: (16, 9))
    **kwargs: Additional parameters passed to fill_between()

Returns:
    Matplotlib Figure object

Raises:
    ValueError: If data is empty
    KeyError: If required columns not found

Example:
    >>> data = pd.DataFrame({'Month': range(1, 13), 'Revenue': [10, 15, 13, 17, 20, 25, 22, 26, 24, 28, 30, 35]})
    >>> fig = create_plot(data, x='Month', y='Revenue')
"""
# Input validation
if data.empty:
    raise ValueError("Data cannot be empty")

# Check required columns
for col in [x, y]:
    if col not in data.columns:
        available = ", ".join(data.columns)
        raise KeyError(f"Column '{col}' not found. Available: {available}")

# Set seaborn style for consistent appearance
sns.set_theme(style="whitegrid")

# Create figure
fig, ax = plt.subplots(figsize=figsize)

# Get x and y values
x_vals = data[x]
y_vals = data[y]

# Plot the edge line first
ax.plot(x_vals, y_vals, color=color, alpha=line_alpha, linewidth=2)

# Fill the area between the line and baseline (y=0)
ax.fill_between(x_vals, y_vals, alpha=alpha, color=color, **kwargs)

# Apply styling
ax.set_xlabel(xlabel or x, fontsize=12)
ax.set_ylabel(ylabel or y, fontsize=12)
ax.grid(True, alpha=0.3, linestyle="--")

# Set y-axis to start from 0 for area charts (standard practice)
y_min = min(0, y_vals.min())
y_max = y_vals.max()
y_padding = (y_max - y_min) * 0.05
ax.set_ylim(y_min, y_max + y_padding)

# Title
if title:
    ax.set_title(title, fontsize=14, fontweight="bold")

# Tight layout to avoid label clipping
plt.tight_layout()

return fig

```

Verdict: APPROVED