Development Environment Setup

      import pytest
import tempfile
import shutil
from pathlib import Path
from celline import Project
from celline.config import Config

@pytest.fixture
def temp_dir():
    """Create temporary directory"""
    temp_path = tempfile.mkdtemp()
    yield temp_path
    shutil.rmtree(temp_path, ignore_errors=True)

@pytest.fixture
def test_project(temp_dir):
    """Create test project"""
    # Create project structure
    project_path = Path(temp_dir) / "test_project"
    project_path.mkdir()
    
    # Create configuration files
    (project_path / "setting.toml").write_text("""
[project]
name = "test_project"
version = "1.0.0"

[execution]
system = "multithreading"
nthread = 1

[R]
r_path = "/usr/bin/R"
""")
    
    (project_path / "samples.toml").write_text("""
GSM123456 = "Test Sample 1"
GSM789012 = "Test Sample 2"
""")
    
    # Create directories
    (project_path / "data").mkdir()
    (project_path / "resources").mkdir()
    (project_path / "results").mkdir()
    
    return Project(str(project_path), "test_project")

@pytest.fixture
def mock_h5_data():
    """Mock HDF5 data for testing"""
    import numpy as np
    from unittest.mock import Mock
    
    mock_adata = Mock()
    mock_adata.n_obs = 1000
    mock_adata.n_vars = 2000
    mock_adata.X = Mock()
    mock_adata.X.toarray.return_value = np.random.rand(1000, 2000)
    mock_adata.var_names = [f"GENE_{i}" for i in range(2000)]
    mock_adata.obs_names = [f"CELL_{i}" for i in range(1000)]
    
    return mock_adata

@pytest.fixture(scope="session")
def celline_test_config():
    """Test-specific configuration"""
    original_config = {}
    
    # Store original config
    for attr in dir(Config):
        if not attr.startswith('_'):
            original_config[attr] = getattr(Config, attr)
    
    # Set test config
    Config.DEBUG = True
    Config.TEST_MODE = True
    
    yield Config
    
    # Restore original config
    for attr, value in original_config.items():
        setattr(Config, attr, value)

    

      import os
import sys
sys.path.insert(0, os.path.abspath('../src'))

project = 'Celline'
copyright = '2024, Celline Contributors'
author = 'Celline Contributors'

extensions = [
    'sphinx.ext.autodoc',
    'sphinx.ext.viewcode',
    'sphinx.ext.napoleon',
    'sphinx.ext.intersphinx',
    'myst_parser',
]

templates_path = ['_templates']
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']

html_theme = 'sphinx_rtd_theme'
html_static_path = ['_static']

# Napoleon settings
napoleon_google_docstring = True
napoleon_numpy_docstring = True
napoleon_include_init_with_doc = False

# Intersphinx mapping
intersphinx_mapping = {
    'python': ('https://docs.python.org/3/', None),
    'numpy': ('https://numpy.org/doc/stable/', None),
    'pandas': ('https://pandas.pydata.org/docs/', None),
}

    

      # Using pdb for debugging
import pdb

def problematic_function():
    data = load_data()
    pdb.set_trace()  # Debugger breakpoint
    result = process_data(data)
    return result

# Using ipdb (enhanced debugger)
pip install ipdb
import ipdb; ipdb.set_trace()

    

      # celline/log/dev_logger.py
import logging
import sys
from pathlib import Path
from rich.logging import RichHandler

def setup_dev_logging(level=logging.DEBUG):
    """Setup development logging with rich formatting"""
    
    # Create logs directory
    log_dir = Path("logs")
    log_dir.mkdir(exist_ok=True)
    
    # Root logger configuration
    root_logger = logging.getLogger()
    root_logger.setLevel(level)
    
    # Clear existing handlers
    root_logger.handlers.clear()
    
    # Rich console handler
    console_handler = RichHandler(
        rich_tracebacks=True,
        show_path=True,
        show_time=True
    )
    console_handler.setLevel(level)
    
    # File handler
    file_handler = logging.FileHandler(
        log_dir / "celline_dev.log",
        mode='a'
    )
    file_handler.setLevel(logging.DEBUG)
    
    # Formatters
    console_format = "%(message)s"
    file_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    
    console_handler.setFormatter(logging.Formatter(console_format))
    file_handler.setFormatter(logging.Formatter(file_format))
    
    # Add handlers
    root_logger.addHandler(console_handler)
    root_logger.addHandler(file_handler)
    
    # Configure specific loggers
    celline_logger = logging.getLogger("celline")
    celline_logger.setLevel(level)
    
    # Suppress verbose external libraries
    logging.getLogger("requests").setLevel(logging.WARNING)
    logging.getLogger("urllib3").setLevel(logging.WARNING)
    logging.getLogger("matplotlib").setLevel(logging.WARNING)

# Use in development
if __name__ == "__main__":
    setup_dev_logging()

    

      # celline/dev/profiling.py
import cProfile
import pstats
import io
from functools import wraps
import time

def profile_function(sort_by='cumulative', lines_to_print=20):
    """Decorator for profiling functions"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            profiler = cProfile.Profile()
            profiler.enable()
            
            start_time = time.time()
            try:
                result = func(*args, **kwargs)
            finally:
                end_time = time.time()
                profiler.disable()
                
                # Create string buffer for stats
                s = io.StringIO()
                ps = pstats.Stats(profiler, stream=s)
                ps.sort_stats(sort_by)
                ps.print_stats(lines_to_print)
                
                print(f"\n=== Profile for {func.__name__} ===")
                print(f"Total time: {end_time - start_time:.4f} seconds")
                print(s.getvalue())
                
            return result
        return wrapper
    return decorator

# Usage example
@profile_function(sort_by='tottime', lines_to_print=10)
def expensive_function():
    # Your expensive operation
    pass

    

      # Memory usage monitoring
import psutil
import os
from contextlib import contextmanager

@contextmanager
def memory_profiler(description=""):
    """Context manager for memory profiling"""
    process = psutil.Process(os.getpid())
    
    # Initial memory
    initial_memory = process.memory_info()
    print(f"=== Memory Profile: {description} ===")
    print(f"Initial memory: {initial_memory.rss / 1024 / 1024:.2f} MB")
    
    try:
        yield process
    finally:
        # Final memory
        final_memory = process.memory_info()
        memory_diff = (final_memory.rss - initial_memory.rss) / 1024 / 1024
        
        print(f"Final memory: {final_memory.rss / 1024 / 1024:.2f} MB")
        print(f"Memory difference: {memory_diff:+.2f} MB")
        print(f"Peak memory: {process.memory_info().rss / 1024 / 1024:.2f} MB")

# Usage
with memory_profiler("data processing"):
    result = process_large_dataset(data)

    

      #!/usr/bin/env python3
"""Development automation script"""

import subprocess
import sys
import argparse
from pathlib import Path

def run_command(cmd, description=""):
    """Run shell command with error handling"""
    print(f"\n{'='*50}")
    print(f"Running: {description or cmd}")
    print(f"{'='*50}")
    
    result = subprocess.run(cmd, shell=True)
    if result.returncode != 0:
        print(f"❌ Command failed: {cmd}")
        sys.exit(1)
    print(f"✅ Command succeeded: {description or cmd}")

def format_code():
    """Format code with ruff and black"""
    run_command("ruff format src/ tests/", "Format code with ruff")
    run_command("ruff check src/ tests/ --fix", "Fix ruff issues")

def type_check():
    """Run type checking with mypy"""
    run_command("mypy src/celline/", "Type checking with mypy")

def run_tests(test_type="all"):
    """Run tests"""
    if test_type == "unit":
        cmd = "pytest tests/unit/ -v"
    elif test_type == "integration":
        cmd = "pytest tests/integration/ -v"
    elif test_type == "fast":
        cmd = "pytest tests/ -v -m 'not slow'"
    else:
        cmd = "pytest tests/ -v"
    
    run_command(cmd, f"Running {test_type} tests")

def build_docs():
    """Build documentation"""
    run_command("cd docs && make clean && make html", "Build documentation")

def lint_all():
    """Run all linting tools"""
    run_command("ruff check src/ tests/", "Lint with ruff")
    run_command("mypy src/celline/", "Type check with mypy")

def full_check():
    """Run full development check"""
    format_code()
    lint_all()
    run_tests("fast")

def main():
    parser = argparse.ArgumentParser(description="Development automation")
    parser.add_argument("command", choices=[
        "format", "lint", "typecheck", "test", "test-unit", 
        "test-integration", "test-fast", "docs", "check"
    ])
    
    args = parser.parse_args()
    
    if args.command == "format":
        format_code()
    elif args.command == "lint":
        lint_all()
    elif args.command == "typecheck":
        type_check()
    elif args.command == "test":
        run_tests("all")
    elif args.command == "test-unit":
        run_tests("unit")
    elif args.command == "test-integration":
        run_tests("integration")
    elif args.command == "test-fast":
        run_tests("fast")
    elif args.command == "docs":
        build_docs()
    elif args.command == "check":
        full_check()

if __name__ == "__main__":
    main()

    

      # Fix PYTHONPATH issues
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))