# Gather system information
aurras --system-info > system-info.txt
 
# Enable debug logging
aurras --log-level debug --log-file debug.log
 
# Include both files in your issue

# Fork the repository on GitHub
# Then clone your fork
git clone https://github.com/yourusername/Aurras.git
cd Aurras
 
# Create a virtual environment
python -m venv aurras-dev
source aurras-dev/bin/activate  # Linux/macOS
# or
aurras-dev\Scripts\activate     # Windows
 
# Install dependencies
pip install -e ".[dev]"
 
# Run tests to ensure everything works
python -m pytest
 
# Start developing!
aurras --help

# Core development tools
pip install -e ".[dev]"
 
# This installs:
# - pytest (testing)
# - black (code formatting)
# - mypy (type checking)
# - flake8 (linting)
# - pre-commit (git hooks)

# Good: Clear, descriptive names
def parse_audio_metadata(file_path: Path) -> AudioMetadata:
    """Parse metadata from an audio file."""
    pass
 
# Good: Type hints
class MusicLibrary:
    def __init__(self, root_path: Path) -> None:
        self._root_path = root_path
        self._tracks: List[Track] = []
 
# Good: Docstrings
def create_playlist(name: str, tracks: List[Track]) -> Playlist:
    """Create a new playlist with the given tracks.
    
    Args:
        name: Human-readable playlist name
        tracks: List of tracks to include
        
    Returns:
        Newly created playlist instance
        
    Raises:
        PlaylistError: If playlist creation fails
    """

# Format code automatically
black aurras/
 
# Check formatting
black --check aurras/
 
# Sort imports
isort aurras/
 
# Type checking
mypy aurras/
 
# Linting
flake8 aurras/

# 1. Create a feature branch
git checkout -b feature/add-spotify-integration
 
# 2. Make your changes
# ... code, test, commit ...
 
# 3. Push to your fork
git push origin feature/add-spotify-integration
 
# 4. Create a Pull Request on GitHub

# Features
git commit -m "feat: add Spotify integration support"
 
# Bug fixes
git commit -m "fix: resolve audio crackling on Linux"
 
# Documentation
git commit -m "docs: add installation guide for Arch Linux"
 
# Performance
git commit -m "perf: optimize library scanning for large collections"
 
# Breaking changes
git commit -m "feat!: change config file format to TOML"

# Run all tests
python -m pytest
 
# Run specific test file
python -m pytest tests/test_player.py
 
# Run with coverage
python -m pytest --cov=aurras
 
# Run integration tests
python -m pytest tests/integration/

import pytest
from aurras.core.player import AudioPlayer
 
class TestAudioPlayer:
    def test_player_creation(self):
        """Test that player can be created successfully."""
        player = AudioPlayer()
        assert player is not None
        
    def test_load_audio_file(self, sample_audio_file):
        """Test loading a valid audio file."""
        player = AudioPlayer()
        result = player.load(sample_audio_file)
        assert result.is_success()
        assert player.is_loaded()
        
    @pytest.mark.asyncio
    async def test_async_playback(self):
        """Test asynchronous playback functionality."""
        player = AudioPlayer()
        await player.play_async()
        assert player.is_playing()

# Good: Non-blocking UI updates
async def update_display(self):
    """Update display without blocking audio."""
    track_info = await self.player.get_current_track()
    self.ui.update_track_display(track_info)
 
# Good: Caching
@lru_cache(maxsize=1000)
def get_album_artwork(self, album_id: str) -> bytes:
    """Get album artwork with caching."""
    return self._load_artwork(album_id)

class AudioDecoder:
    """Handles decoding of various audio formats.
    
    Supports MP3, FLAC, OGG, and other common formats through
    the MPV backend. Provides both synchronous and asynchronous
    interfaces for different use cases.
    
    Attributes:
        format_support: Dictionary of supported formats and their capabilities
        current_decoder: Active decoder instance if any
        
    Example:
        >>> decoder = AudioDecoder()
        >>> decoder.load('song.mp3')
        >>> samples = decoder.decode_chunk(1024)
    """

# 1. Update version number
# Edit aurras/__init__.py
__version__ = "1.2.0"
 
# 2. Update changelog
# Edit CHANGELOG.md
 
# 3. Create release commit
git commit -m "release: version 1.2.0"
 
# 4. Tag the release
git tag v1.2.0
 
# 5. Push to main repository
git push origin main --tags

# Enable debug logging
export AURRAS_DEBUG=1
aurras --log-level debug
 
# Use Python debugger
python -m pdb -m aurras play song.mp3
 
# Profile performance
python -m cProfile -o profile.stats -m aurras scan-library
 
# Memory profiling
python -m memory_profiler aurras_script.py