coder-music-cli 0.1.0__py3-none-any.whl

music_cli/player/ffplay.py

@@ -0,0 +1,179 @@
+"""FFplay-based audio player implementation."""
+
+import asyncio
+import logging
+import shutil
+import signal
+
+from .base import Player, PlayerState, TrackInfo
+
+logger = logging.getLogger(__name__)
+
+
+class FFplayPlayer(Player):
+    """Audio player using ffplay (part of FFmpeg)."""
+
+    def __init__(self):
+        super().__init__()
+        self._process: asyncio.subprocess.Process | None = None
+        self._monitor_task: asyncio.Task | None = None
+        self._paused = False
+
+        # Verify ffplay is available
+        if not shutil.which("ffplay"):
+            logger.warning("ffplay not found in PATH. Please install FFmpeg.")
+
+    async def play(self, track: TrackInfo) -> bool:
+        """Start playing a track using ffplay."""
+        # Stop any current playback
+        await self.stop()
+
+        self._state = PlayerState.LOADING
+        self._current_track = track
+
+        try:
+            # Build ffplay command
+            cmd = [
+                "ffplay",
+                "-nodisp",  # No display window
+                "-autoexit",  # Exit when done (for files)
+                "-loglevel",
+                "quiet",  # Suppress output
+                "-volume",
+                str(self._volume),
+            ]
+
+            # For streams, add reconnect options
+            if track.source_type == "radio":
+                cmd.extend(
+                    [
+                        "-reconnect",
+                        "1",
+                        "-reconnect_streamed",
+                        "1",
+                        "-reconnect_delay_max",
+                        "5",
+                    ]
+                )
+
+            cmd.append(track.source)
+
+            logger.info(f"Starting playback: {track.source}")
+
+            self._process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdin=asyncio.subprocess.DEVNULL,
+                stdout=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+
+            self._state = PlayerState.PLAYING
+            self._paused = False
+
+            # Start monitoring for process end
+            self._monitor_task = asyncio.create_task(self._monitor_playback())
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to start playback: {e}")
+            self._state = PlayerState.ERROR
+            return False
+
+    async def _monitor_playback(self) -> None:
+        """Monitor the ffplay process and handle completion."""
+        if self._process is None:
+            return
+
+        try:
+            await self._process.wait()
+
+            # Only trigger callback if we weren't stopped manually
+            if self._state == PlayerState.PLAYING:
+                self._state = PlayerState.STOPPED
+                self._current_track = None
+
+                if self._on_track_end:
+                    self._on_track_end()
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"Error monitoring playback: {e}")
+
+    async def stop(self) -> None:
+        """Stop playback."""
+        if self._monitor_task:
+            self._monitor_task.cancel()
+            try:
+                await self._monitor_task
+            except asyncio.CancelledError:
+                pass
+            self._monitor_task = None
+
+        if self._process:
+            try:
+                self._process.terminate()
+                try:
+                    await asyncio.wait_for(self._process.wait(), timeout=2.0)
+                except asyncio.TimeoutError:
+                    self._process.kill()
+                    await self._process.wait()
+            except ProcessLookupError:
+                pass  # Process already ended
+            self._process = None
+
+        self._state = PlayerState.STOPPED
+        self._current_track = None
+        self._paused = False
+
+    async def pause(self) -> None:
+        """Pause playback by sending SIGSTOP to ffplay."""
+        if self._process and self._state == PlayerState.PLAYING:
+            try:
+                self._process.send_signal(signal.SIGSTOP)
+                self._state = PlayerState.PAUSED
+                self._paused = True
+            except ProcessLookupError:
+                pass
+
+    async def resume(self) -> None:
+        """Resume playback by sending SIGCONT to ffplay."""
+        if self._process and self._state == PlayerState.PAUSED:
+            try:
+                self._process.send_signal(signal.SIGCONT)
+                self._state = PlayerState.PLAYING
+                self._paused = False
+            except ProcessLookupError:
+                pass
+
+    async def set_volume(self, volume: int) -> None:
+        """Set volume. Note: ffplay doesn't support runtime volume changes.
+
+        Volume will apply to the next track.
+        """
+        self._volume = max(0, min(100, volume))
+        # ffplay doesn't support dynamic volume changes
+        # The volume will be applied when the next track starts
+        logger.info(f"Volume set to {self._volume}% (applies to next track)")
+
+    async def get_position(self) -> float:
+        """Get current playback position.
+
+        Note: ffplay doesn't provide easy position tracking.
+        This is a limitation of the ffplay approach.
+        """
+        # ffplay doesn't expose position information easily
+        # For accurate position tracking, we'd need mpv or VLC
+        return 0.0
+
+    def get_status(self) -> dict:
+        """Get current player status."""
+        status = super().get_status()
+        status["backend"] = "ffplay"
+        return status
+
+
+def check_ffplay_available() -> bool:
+    """Check if ffplay is available in PATH."""
+    return shutil.which("ffplay") is not None

music_cli/sources/__init__.py

@@ -0,0 +1,6 @@
+"""Music source modules for music-cli."""
+
+from .local import LocalSource
+from .radio import RadioSource
+
+__all__ = ["LocalSource", "RadioSource"]

music_cli/sources/ai_generator.py

@@ -0,0 +1,219 @@
+"""AI music generation using MusicGen (optional feature)."""
+
+import logging
+import tempfile
+from pathlib import Path
+
+from ..player.base import TrackInfo
+
+logger = logging.getLogger(__name__)
+
+# Flag to track if AI dependencies are available
+_AI_AVAILABLE: bool | None = None
+_musicgen_model = None
+
+
+def is_ai_available() -> bool:
+    """Check if AI music generation dependencies are available."""
+    global _AI_AVAILABLE
+
+    if _AI_AVAILABLE is not None:
+        return _AI_AVAILABLE
+
+    try:
+        import torch  # noqa: F401
+        from audiocraft.models import MusicGen  # noqa: F401
+
+        _AI_AVAILABLE = True
+        logger.info("AI music generation is available")
+    except ImportError as e:
+        _AI_AVAILABLE = False
+        logger.info(f"AI music generation not available: {e}")
+
+    return _AI_AVAILABLE
+
+
+def _get_model():
+    """Lazy-load the MusicGen model."""
+    global _musicgen_model
+
+    if not is_ai_available():
+        return None
+
+    if _musicgen_model is None:
+        try:
+            from audiocraft.models import MusicGen
+
+            logger.info("Loading MusicGen model (this may take a moment)...")
+            # Use the small model for faster loading and lower memory usage
+            _musicgen_model = MusicGen.get_pretrained("facebook/musicgen-small")
+            _musicgen_model.set_generation_params(duration=30)  # 30 seconds default
+            logger.info("MusicGen model loaded successfully")
+        except Exception as e:
+            logger.error(f"Failed to load MusicGen model: {e}")
+            return None
+
+    return _musicgen_model
+
+
+class AIGenerator:
+    """Generates music using Meta's MusicGen model."""
+
+    def __init__(self, output_dir: Path | None = None):
+        """Initialize AI generator.
+
+        Args:
+            output_dir: Directory to save generated audio files.
+                       Defaults to a temp directory.
+        """
+        if output_dir is None:
+            output_dir = Path(tempfile.gettempdir()) / "music-cli-ai"
+        self.output_dir = output_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def available(self) -> bool:
+        """Check if AI generation is available."""
+        return is_ai_available()
+
+    def generate(
+        self,
+        prompt: str,
+        duration: int = 30,
+        filename: str | None = None,
+    ) -> TrackInfo | None:
+        """Generate music from a text prompt.
+
+        Args:
+            prompt: Text description of the music to generate.
+            duration: Duration in seconds (5-300).
+            filename: Optional output filename.
+
+        Returns:
+            TrackInfo for the generated audio, or None if generation failed.
+        """
+        model = _get_model()
+        if model is None:
+            logger.warning("AI model not available")
+            return None
+
+        try:
+            import scipy.io.wavfile
+
+            # Clamp duration
+            duration = max(5, min(300, duration))
+            model.set_generation_params(duration=duration)
+
+            logger.info(f"Generating {duration}s of music: {prompt[:50]}...")
+
+            # Generate audio
+            wav = model.generate([prompt])
+
+            # Generate filename if not provided
+            if filename is None:
+                import hashlib
+                import time
+
+                hash_input = f"{prompt}{time.time()}"
+                short_hash = hashlib.md5(  # noqa: S324
+                    hash_input.encode(), usedforsecurity=False
+                ).hexdigest()[:8]
+                filename = f"ai_music_{short_hash}.wav"
+
+            # Save to file
+            output_path = self.output_dir / filename
+
+            # Get the audio tensor and sample rate
+            audio = wav[0].cpu().numpy()
+            sample_rate = model.sample_rate
+
+            # Save as WAV
+            scipy.io.wavfile.write(str(output_path), sample_rate, audio.T)
+
+            logger.info(f"Generated audio saved to: {output_path}")
+
+            return TrackInfo(
+                source=str(output_path),
+                source_type="ai",
+                title=f"AI: {prompt[:40]}...",
+                metadata={
+                    "prompt": prompt,
+                    "duration": duration,
+                    "model": "musicgen-small",
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to generate music: {e}")
+            return None
+
+    def generate_for_context(
+        self,
+        mood_prompt: str | None = None,
+        temporal_prompt: str | None = None,
+        duration: int = 30,
+    ) -> TrackInfo | None:
+        """Generate context-appropriate music.
+
+        Args:
+            mood_prompt: Mood-based prompt component.
+            temporal_prompt: Time-based prompt component.
+            duration: Duration in seconds.
+
+        Returns:
+            TrackInfo for the generated audio.
+        """
+        prompts = []
+
+        if mood_prompt:
+            prompts.append(mood_prompt)
+        if temporal_prompt:
+            prompts.append(temporal_prompt)
+
+        if not prompts:
+            prompts.append("ambient background music")
+
+        full_prompt = ", ".join(prompts)
+        return self.generate(full_prompt, duration)
+
+    def cleanup_old_files(self, max_age_hours: int = 24) -> int:
+        """Clean up old generated files.
+
+        Args:
+            max_age_hours: Maximum age of files to keep.
+
+        Returns:
+            Number of files deleted.
+        """
+        import time
+
+        deleted = 0
+        cutoff = time.time() - (max_age_hours * 3600)
+
+        for f in self.output_dir.glob("ai_music_*.wav"):
+            if f.stat().st_mtime < cutoff:
+                try:
+                    f.unlink()
+                    deleted += 1
+                except OSError:
+                    pass
+
+        return deleted
+
+
+# Provide helpful error message if AI is not available
+def get_ai_install_instructions() -> str:
+    """Get instructions for installing AI dependencies."""
+    return """
+AI music generation requires additional dependencies.
+Install them with:
+
+    pip install 'music-cli[ai]'
+
+Or install manually:
+
+    pip install torch transformers audiocraft
+
+Note: This requires significant disk space (~5GB) and RAM (~8GB minimum).
+The first generation will download the MusicGen model (~3GB).
+"""

music_cli/sources/local.py

@@ -0,0 +1,75 @@
+"""Local MP3 file source."""
+
+import random
+from pathlib import Path
+
+from ..player.base import TrackInfo
+
+
+class LocalSource:
+    """Handles local MP3 file playback."""
+
+    SUPPORTED_EXTENSIONS = {".mp3", ".m4a", ".flac", ".wav", ".ogg", ".opus"}
+
+    def __init__(self, music_dir: Path | None = None):
+        """Initialize with optional music directory."""
+        if music_dir is None:
+            # Default to ~/Music
+            music_dir = Path("~/Music").expanduser()
+        self.music_dir = music_dir
+
+    def get_track(self, path: str) -> TrackInfo | None:
+        """Get track info for a specific file path."""
+        file_path = Path(path)
+
+        if not file_path.is_absolute():
+            # Try relative to music dir
+            file_path = self.music_dir / file_path
+
+        if not file_path.exists():
+            return None
+
+        if file_path.suffix.lower() not in self.SUPPORTED_EXTENSIONS:
+            return None
+
+        return TrackInfo(
+            source=str(file_path),
+            source_type="local",
+            title=file_path.stem,
+            metadata={"filename": file_path.name},
+        )
+
+    def scan_directory(self, directory: Path | None = None) -> list[Path]:
+        """Scan a directory for music files."""
+        if directory is None:
+            directory = self.music_dir
+
+        if not directory.exists():
+            return []
+
+        files: list[Path] = []
+        for ext in self.SUPPORTED_EXTENSIONS:
+            files.extend(directory.rglob(f"*{ext}"))
+
+        return sorted(files)
+
+    def get_random_track(self, directory: Path | None = None) -> TrackInfo | None:
+        """Get a random track from the directory."""
+        files = self.scan_directory(directory)
+        if not files:
+            return None
+
+        chosen = random.choice(files)
+        return self.get_track(str(chosen))
+
+    def list_tracks(self, directory: Path | None = None, limit: int = 50) -> list[TrackInfo]:
+        """List tracks in a directory."""
+        files = self.scan_directory(directory)
+        tracks = []
+
+        for f in files[:limit]:
+            track = self.get_track(str(f))
+            if track:
+                tracks.append(track)
+
+        return tracks

music_cli/sources/radio.py

@@ -0,0 +1,90 @@
+"""Radio streaming source."""
+
+import random
+
+from ..config import get_config
+from ..player.base import TrackInfo
+
+
+class RadioSource:
+    """Handles radio stream playback."""
+
+    def __init__(self):
+        """Initialize radio source."""
+        self.config = get_config()
+
+    def get_stations(self) -> list[tuple[str, str]]:
+        """Get list of (name, url) tuples for all configured stations."""
+        return self.config.get_radios()
+
+    def get_track(self, url: str, name: str | None = None) -> TrackInfo:
+        """Create a track info for a radio stream."""
+        if name is None:
+            # Try to find name in config
+            for station_name, station_url in self.get_stations():
+                if station_url == url:
+                    name = station_name
+                    break
+            if name is None:
+                name = url
+
+        return TrackInfo(
+            source=url,
+            source_type="radio",
+            title=name,
+            metadata={"stream_url": url},
+        )
+
+    def get_station_by_name(self, name: str) -> TrackInfo | None:
+        """Get a station by its name (case-insensitive partial match)."""
+        name_lower = name.lower()
+
+        for station_name, url in self.get_stations():
+            if name_lower in station_name.lower():
+                return self.get_track(url, station_name)
+
+        return None
+
+    def get_station_by_index(self, index: int) -> TrackInfo | None:
+        """Get a station by its index (1-based)."""
+        stations = self.get_stations()
+        if 1 <= index <= len(stations):
+            name, url = stations[index - 1]
+            return self.get_track(url, name)
+        return None
+
+    def get_random_station(self) -> TrackInfo | None:
+        """Get a random station."""
+        stations = self.get_stations()
+        if not stations:
+            return None
+
+        name, url = random.choice(stations)
+        return self.get_track(url, name)
+
+    def get_mood_station(self, mood: str) -> TrackInfo | None:
+        """Get a station for a specific mood."""
+        url = self.config.get_mood_radio(mood)
+        if url:
+            return self.get_track(url, f"{mood.capitalize()} Radio")
+        return None
+
+    def get_time_station(self, time_period: str) -> TrackInfo | None:
+        """Get a station for a time period (morning/afternoon/evening/night)."""
+        url = self.config.get_time_radio(time_period)
+        if url:
+            return self.get_track(url, f"{time_period.capitalize()} Radio")
+        return None
+
+    def list_stations(self) -> list[dict]:
+        """List all stations with their indices."""
+        stations = []
+        for i, (name, url) in enumerate(self.get_stations(), 1):
+            stations.append(
+                {
+                    "index": i,
+                    "name": name,
+                    "url": url,
+                }
+            )
+        return stations