Code Review

For each function/method:

• Function signature has type hints for all parameters
• Return type is annotated
• Complex variables (lists, dicts) have type hints
• Use grep_search to find function definitions and verify

Docstring Check (Google Style)

# ✓ CORRECT
def enlarge_and_crop_image(image: np.ndarray) -> np.ndarray:
    """Upscale then center-crop image.
    
    Args:
        image: Input image array (HxWxC).
    
    Returns:
        Processed image with target dimensions.
    
    Raises:
        ValueError: If image format is invalid.
    """

• All public functions have docstrings
• Docstring has description line
• Args section lists all parameters with types and descriptions
• Returns section describes return value and type
• Raises section lists possible exceptions
• No private function docstrings unless complex logic

String Formatting Check

• Only double quotes used (except to avoid escaping)

  # ✓ CORRECT
  message = "Hello world"
  # ✗ WRONG
  message = 'Hello world'
  

Line Length Check

• All lines ≤ 120 characters
  • Use grep_search with regex to find long lines: ^.{121,}$

Import Organization Check

# ✓ CORRECT: stdlib → third-party → local
import os
import sys
from typing import Optional

import cv2
import numpy as np
from PIL import Image

from dataset_cat.core.utils import load_config
from dataset_cat.core.actions import register_action

• No mixed order of stdlib/third-party/local
• Blank lines between groups
• Alphabetically sorted within groups (Optional, Tuple, Union come after basic imports)

Naming Conventions Check

• Functions/variables: snake_case ✓
• Classes: PascalCase ✓
• Constants: UPPER_SNAKE_CASE ✓
• Private methods: _method_name or __method_name ✓
• No abbreviations in variables (use processed_image, not proc_img)

Comment Quality Check

• Comments explain "why", not "what"

  # ✓ Good
  # Center the crop region to preserve facial features
  offset_x = (upscaled_width - target_width) // 2
  
  # ✗ Bad
  # Calculate offset
  offset_x = (upscaled_width - target_width) // 2
  

Level 2: Functional Testing (20-40 min)

Goal: Verify code works correctly with test data

Unit Test Execution

cd /Users/nev4rb14su/workspace/dataset-cat-1
python -m pytest tests/ -v --tb=short

• All tests pass
• No new warnings introduced
• Code coverage acceptable for modified functions

If no tests exist, create minimal tests:

def test_enlarge_and_crop_image():
    image = np.random.randint(0, 256, (256, 256, 3), dtype=np.uint8)
    result = enlarge_and_crop_image(image, (512, 512), "model.pth")
    assert result.shape == (512, 512, 3), "Output shape mismatch"
    assert result.dtype == np.uint8, "Output dtype mismatch"

Integration Testing

• New code integrates with existing components
• Data flows correctly between functions
• Configuration system properly controls behavior
• No import errors or dependency issues

Test procedure:

# Quick integration test
from dataset_cat.postprocessing_ui import app
# Test that new UI components exist and interact properly

Error Handling Validation

For each function that can fail:

• Try with invalid inputs → proper error raised

  with pytest.raises(ValueError):
      enlarge_and_crop_image(None, (512, 512), "bad_path")
  

• Error messages are informative (not just stacktraces)
• Exceptions are caught/handled gracefully

Level 3: Integration Testing (30-60 min)

Goal: End-to-end workflow validation (most important for UI changes)

Dataset-Cat Workflow Test

1. Launch UI:

   cd /Users/nev4rb14su/workspace/dataset-cat-1
   bash webui.sh
   

2. Import Dataset:

   • Use test anime dataset
   • Verify images load correctly
   • Check metadata displays properly

3. Configure Processing:

   • All new input fields appear in UI
   • Default values are sensible
   • Parameter ranges are appropriate
   • Help text is clear and accurate

4. Execute Processing:

   • Processing starts without errors
   • Progress updates appear
   • Handles edge cases (small images, missing models)

5. Verify Output:

   • Output directory created correctly
   • All images processed (count matches input)
   • Image dimensions match configuration
   • Metadata correctly updated
   • No corrupted files

Acceptance Criteria (From .agent.md)

For postprocessing features, verify:

• Data correctly loaded
• Processing applied properly
• Output stored in correct location
• Final dimensions match specification exactly
• No over-cropping (faces not cut off)
• Upscaling effective (not blank/corrupted)
• All files successfully processed

Performance Check

• Processing doesn't freeze UI
• Memory usage reasonable (no leaks on large datasets)
• No excessive disk I/O or network calls
• Completion time acceptable (log if >10sec/image for large datasets)

Level 4: Regression Testing (10-20 min)

Goal: Ensure existing features still work

• Existing postprocessing modes still function
• UI responsiveness not degraded
• No new errors in related components
• Configuration system still works
• Output formats unchanged for existing features

Quick check:

# Run existing feature with sample data
python -c "from dataset_cat.core.actions import process_dataset; \
    process_dataset('test_data', 'output', 'original')"

Review Decision Matrix

Issue Reporting Format

When issues found, provide:

## Issue #N [Severity: CRITICAL|MAJOR|MINOR]

**Location**: `file.py`, line XXX

**Problem**: [Specific issue description]

**Example**:
```python
# Code that shows the problem

Fix Required:

1. [Specific action needed]
2. [Specific action needed]

Validation: [How to verify fix]

## Tools Usage

- `read_file`: Verify context around changes
- `grep_search`: Check patterns (type hints, docstrings, long lines)
- `run_in_terminal`: Execute tests, run UI
- `get_errors`: Check for compilation/lint errors
- `set_java_breakpoint` + debugging tools: If runtime issues occur

## Memory Documentation

Save review results to `/memories/session/review-results.md`:
```markdown
# Review Results - [Feature Name]

## Static Analysis: ✓ PASS
- All type annotations present
- Docstrings complete
- Line lengths OK
- etc.

## Functional Testing: ✓ PASS
- Unit tests pass
- Integration works
- Error handling verified

## UI Integration: ✓ PASS
- All components appear
- Processing executes
- Output correct

## Issues Found: 0

**Status**: APPROVED FOR MERGE

Timeline Expectations

• Quick features (50-100 lines): 30-45 minutes
• Medium features (200-400 lines): 1-2 hours
• Large features (500+ lines): 2-3 hours
• Complex integrations: Coordinate with Code-Migrator if blockers found

Blocking Issues

Stop review and alert Code-Migrator immediately if:

• Memory leaks detected
• Data corruption in output
• UI completely non-responsive
• Existing features broken
• Unhandled exceptions in normal workflow
• Security/safety issues