Python Foundational

# Classes: PascalCase
class ModelTrainer:
    pass

# Functions and variables: snake_case
def train_model():
    training_data = []

# Constants: UPPER_SNAKE_CASE
MAX_SEQUENCE_LENGTH = 2048
DEFAULT_LEARNING_RATE = 1e-4

# Private members: leading underscore
def _internal_helper():
    pass

_internal_cache = {}

# 1. Standard library
import os
import sys
from pathlib import Path

# 2. Third-party
import numpy as np
from anthropic import Anthropic

# 3. Local
from myproject.core.trainer import Trainer
from myproject.utils.config import load_config

def train(data: list, learning_rate: float = 1e-4, batch_size: int = 32):
    pass

# Caller can silently swap learning_rate and batch_size
train(data, 32, 1e-4)

def train(
    data: list,
    *,
    learning_rate: float = 1e-4,
    batch_size: int = 32,
) -> None:
    pass

# Caller must name each optional parameter
train(data, learning_rate=1e-3, batch_size=64)

def fetch_records(
    query: str,
    *,
    limit: int = 100,
    include_deleted: bool = False,
) -> list[dict[str, str]]:
    """Fetch records matching a query."""
    ...


def find_user(user_id: int) -> User | None:
    """Return the user or None if not found."""
    ...

from dataclasses import dataclass, field
from typing import ClassVar


@dataclass
class TrainingConfig:
    """Configuration for a training run."""

    model_name: str
    learning_rate: float = 1e-4
    batch_size: int = 32
    tags: list[str] = field(default_factory=list)

    MAX_EPOCHS: ClassVar[int] = 100

def process_data(
    data: list[dict],
    *,
    batch_size: int = 32,
    validate: bool = True,
) -> ProcessResult:
    """Process data with validation and batching.

    Args:
        data: Input data as list of dicts with 'id' and 'content' keys.
        batch_size: Number of items to process per batch.
        validate: Whether to validate input data.

    Returns:
        ProcessResult containing processed items, errors, and metrics.

    Raises:
        ValueError: If data is empty or has an invalid format.
    """

class DataProcessor:
    """Data processing orchestrator for batch operations.

    Handles the complete data processing workflow including validation,
    transformation, batching, and error handling.

    Args:
        config: Processing configuration.
        batch_size: Number of items per batch.

    Attributes:
        config: Processing configuration.
        batch_size: Configured batch size.
        metrics: Processing metrics tracker.
    """

    def __init__(self, config: APIConfig, *, batch_size: int = 32) -> None:
        self.config = config
        self.batch_size = batch_size
        self.metrics = MetricsTracker()

def load_config(path):
    if not path.exists():
        raise FileNotFoundError("File not found")

def load_config(path: Path) -> dict:
    """Load configuration file."""
    if not path.exists():
        raise FileNotFoundError(
            f"Config file not found: {path}\n"
            f"Expected YAML file with keys: model, data, training\n"
            f"See example: docs/examples/config.yaml"
        )

    try:
        with open(path) as f:
            return yaml.safe_load(f)
    except yaml.YAMLError as e:
        raise ValueError(
            f"Invalid YAML in config file: {path}\n"
            f"Error: {e}"
        ) from e

class AppError(Exception):
    """Base exception for the application."""

class ConfigError(AppError):
    """Configuration error."""

class ValidationError(AppError):
    """Validation error."""

def validate_config(config: dict) -> None:
    """Validate configuration."""
    required = ["database", "api_key", "settings"]
    missing = [k for k in required if k not in config]
    if missing:
        raise ConfigError(
            f"Missing required config keys: {missing}\n"
            f"Required: {required}"
        )

class Model:
    """Model class."""

    # 1. Class variables
    DEFAULT_LR = 1e-4

    # 2. __init__
    def __init__(self, name: str) -> None:
        self.name = name

    # 3. Public methods
    def train(self, data: list) -> None:
        """Public training method."""
        pass

    # 4. Private methods
    def _prepare_data(self, data: list) -> list:
        """Private helper method."""
        pass

    # 5. Properties
    @property
    def num_parameters(self) -> int:
        """Number of trainable parameters."""
        return sum(p.size for p in self.parameters())