The Evolution of Cursor Rules: A More Granular Approach to AI Guidance

# .cursor/rules/data-science.yaml
description: "Rules for data science module development"
patterns: ["src/models/**/*.py", "notebooks/**/*.ipynb"]
instructions: """
When working with data science modules:
- Use type hints for all function parameters and return values
- Include docstrings with numpy style documentation
- Follow scikit-learn's fit/transform pattern for transformers
- Implement proper data validation in __init__
- Use dataclasses for model configuration
- Include logging for training and inference
- Cache heavy computations using functools.lru_cache

Example structure:
```python
from dataclasses import dataclass
from typing import Optional, List, Union
import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin

@dataclass
class ModelConfig:
    n_components: int
    random_state: Optional[int] = None
    
class CustomTransformer(BaseEstimator, TransformerMixin):
    """Custom transformation for feature engineering.
    
    Parameters
    ----------
    config : ModelConfig
        Configuration parameters for the transformer
        
    Attributes
    ----------
    is_fitted_ : bool
        Flag indicating if the transformer is fitted
    """
    
    def __init__(self, config: ModelConfig):
        self.config = config
        self.is_fitted_ = False
        
    def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None) -> 'CustomTransformer':
        # Validation
        if not isinstance(X, pd.DataFrame):
            raise TypeError("X must be a pandas DataFrame")
            
        # Fit logic here
        self.is_fitted_ = True
        return self
        
    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
        # Transform logic here
        return X

# .cursor/rules/fastapi-services.yaml
description: "Guidelines for FastAPI service implementations"
patterns: ["src/api/**/*.py"]
instructions: """
For FastAPI service implementations:
- Use Pydantic models for request/response validation
- Implement proper dependency injection
- Include OpenAPI documentation
- Add proper error handling with HTTP status codes
- Use environment variables for configuration
- Implement rate limiting for public endpoints
- Add proper logging and monitoring

Example pattern:
```python
from typing import List, Optional
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field
from loguru import logger
import os

class PredictionRequest(BaseModel):
    features: List[float] = Field(..., description="Input features for prediction")
    model_version: Optional[str] = Field(None, description="Model version to use")
    
    class Config:
        schema_extra = {
            "example": {
                "features": [1.0, 2.0, 3.0],
                "model_version": "v1"
            }
        }

class PredictionResponse(BaseModel):
    prediction: float
    confidence: float
    model_version: str

async def get_model():
    # Dependency injection for model loading
    try:
        model = load_model(os.getenv("MODEL_PATH"))
        return model
    except Exception as e:
        logger.error(f"Failed to load model: {e}")
        raise HTTPException(status_code=500, detail="Model loading failed")

@app.post("/predict", response_model=PredictionResponse)
async def predict(
    request: PredictionRequest,
    model = Depends(get_model)
):
    try:
        prediction = model.predict(request.features)
        return PredictionResponse(
            prediction=float(prediction),
            confidence=0.95,  # Example
            model_version=model.version
        )
    except Exception as e:
        logger.error(f"Prediction failed: {e}")
        raise HTTPException(status_code=500, detail="Prediction failed")

# .cursor/rules/testing.yaml
description: "Testing standards and patterns"
patterns: ["tests/**/*.py"]
instructions: """
Testing guidelines:
- Use pytest as the testing framework
- Follow the Arrange-Act-Assert pattern
- Use fixtures for common setup
- Mock external dependencies with pytest-mock
- Test edge cases and error scenarios
- Use parametrize for multiple test cases
- Aim for 80% coverage minimum

Example test structure:
```python
import pytest
from unittest.mock import Mock
import pandas as pd
import numpy as np

@pytest.fixture
def sample_data():
    return pd.DataFrame({
        'feature1': np.random.randn(100),
        'feature2': np.random.randn(100)
    })

@pytest.fixture
def model_config():
    return ModelConfig(n_components=2, random_state=42)

def test_transformer_validation(sample_data, model_config):
    # Arrange
    transformer = CustomTransformer(model_config)
    
    # Act & Assert
    with pytest.raises(TypeError, match="X must be a pandas DataFrame"):
        transformer.fit(sample_data.values)  # Passing numpy array instead of DataFrame

@pytest.mark.parametrize("n_components,expected_shape", [
    (2, (100, 2)),
    (3, (100, 3)),
])
def test_transformer_output_shape(sample_data, n_components, expected_shape):
    # Arrange
    config = ModelConfig(n_components=n_components)
    transformer = CustomTransformer(config)
    
    # Act
    result = transformer.fit_transform(sample_data)
    
    # Assert
    assert result.shape == expected_shape