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

music_cli/client.py

@@ -0,0 +1,161 @@
+"""Client for communicating with the music-cli daemon."""
+
+import json
+import logging
+import socket
+from typing import Any
+
+from .config import get_config
+
+logger = logging.getLogger(__name__)
+
+# Constants
+SOCKET_BUFFER_SIZE = 4096
+MAX_RESPONSE_SIZE = 10 * 1024 * 1024  # 10MB limit
+
+
+class DaemonClient:
+    """Client for sending commands to the daemon."""
+
+    def __init__(self):
+        self.config = get_config()
+        self.socket_path = str(self.config.socket_path)
+
+    def send_command(self, command: str, args: dict | None = None) -> dict[str, Any]:
+        """Send a command to the daemon and get response.
+
+        Args:
+            command: Command name (play, stop, pause, resume, status, etc.)
+            args: Command arguments
+
+        Returns:
+            Response dictionary from daemon
+
+        Raises:
+            ConnectionError: If daemon is not running
+        """
+        if args is None:
+            args = {}
+
+        request = {
+            "command": command,
+            "args": args,
+        }
+
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        try:
+            sock.settimeout(10.0)
+            sock.connect(self.socket_path)
+
+            sock.sendall(json.dumps(request).encode())
+
+            # Receive response with size limit
+            response_data = b""
+            while len(response_data) < MAX_RESPONSE_SIZE:
+                chunk = sock.recv(SOCKET_BUFFER_SIZE)
+                if not chunk:
+                    break
+                response_data += chunk
+
+            if len(response_data) >= MAX_RESPONSE_SIZE:
+                logger.warning("Response from daemon exceeded size limit")
+                return {"error": "Response too large from daemon"}
+
+            if response_data:
+                return json.loads(response_data.decode())
+            else:
+                return {"error": "Empty response from daemon"}
+
+        except FileNotFoundError as e:
+            raise ConnectionError("Daemon not running (socket not found)") from e
+        except ConnectionRefusedError as e:
+            raise ConnectionError("Daemon not running (connection refused)") from e
+        except socket.timeout as e:
+            raise ConnectionError("Daemon not responding (timeout)") from e
+        except json.JSONDecodeError as e:
+            logger.warning(f"Invalid JSON response from daemon: {e}")
+            return {"error": "Invalid response from daemon"}
+        finally:
+            sock.close()
+
+    def ping(self) -> bool:
+        """Check if daemon is running and responsive."""
+        try:
+            response = self.send_command("ping")
+            return response.get("status") == "ok"
+        except ConnectionError:
+            return False
+
+    def play(
+        self,
+        mode: str = "radio",
+        source: str | None = None,
+        mood: str | None = None,
+        auto: bool = False,
+        duration: int = 30,
+        index: int | None = None,
+    ) -> dict:
+        """Start playback.
+
+        Args:
+            mode: Playback mode (local, radio, ai, context, history)
+            source: Source path/URL/name
+            mood: Mood tag (happy, sad, focus, etc.)
+            auto: Enable auto-play for local files
+            duration: Duration for AI generation (seconds)
+            index: History entry index (for mode=history)
+        """
+        args = {"mode": mode, "auto": auto}
+        if source:
+            args["source"] = source
+        if mood:
+            args["mood"] = mood
+        if duration:
+            args["duration"] = duration
+        if index:
+            args["index"] = index
+        return self.send_command("play", args)
+
+    def stop(self) -> dict:
+        """Stop playback."""
+        return self.send_command("stop")
+
+    def pause(self) -> dict:
+        """Pause playback."""
+        return self.send_command("pause")
+
+    def resume(self) -> dict:
+        """Resume playback."""
+        return self.send_command("resume")
+
+    def status(self) -> dict:
+        """Get current status."""
+        return self.send_command("status")
+
+    def next_track(self) -> dict:
+        """Skip to next track (auto-play mode)."""
+        return self.send_command("next")
+
+    def set_volume(self, level: int) -> dict:
+        """Set volume level (0-100)."""
+        return self.send_command("volume", {"level": level})
+
+    def get_volume(self) -> int:
+        """Get current volume level."""
+        response = self.send_command("volume")
+        return response.get("volume", 80)
+
+    def list_radios(self) -> list[dict]:
+        """List available radio stations."""
+        response = self.send_command("list_radios")
+        return response.get("stations", [])
+
+    def list_history(self, limit: int = 20) -> list[dict]:
+        """List playback history."""
+        response = self.send_command("list_history", {"limit": limit})
+        return response.get("history", [])
+
+
+def get_client() -> DaemonClient:
+    """Get a daemon client instance."""
+    return DaemonClient()

music_cli/config.py

@@ -0,0 +1,181 @@
+"""Configuration management for music-cli."""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+import tomli_w
+
+logger = logging.getLogger(__name__)
+
+
+class Config:
+    """Manages music-cli configuration files and directories."""
+
+    DEFAULT_CONFIG = {
+        "player": {
+            "backend": "ffplay",
+            "volume": 80,
+        },
+        "daemon": {
+            "socket_path": "~/.config/music-cli/music-cli.sock",
+            "pid_file": "~/.config/music-cli/music-cli.pid",
+        },
+        "context": {
+            "enabled": True,
+            "use_ai": False,  # Requires optional AI dependencies
+        },
+        "mood_radio_map": {
+            "focus": "https://streams.ilovemusic.de/iloveradio17.mp3",
+            "happy": "https://streams.ilovemusic.de/iloveradio1.mp3",
+            "sad": "https://streams.ilovemusic.de/iloveradio5.mp3",
+            "excited": "https://streams.ilovemusic.de/iloveradio2.mp3",
+        },
+        "time_radio_map": {
+            "morning": "https://streams.ilovemusic.de/iloveradio17.mp3",
+            "afternoon": "https://streams.ilovemusic.de/iloveradio1.mp3",
+            "evening": "https://streams.ilovemusic.de/iloveradio5.mp3",
+            "night": "https://streams.ilovemusic.de/iloveradio9.mp3",
+        },
+    }
+
+    def __init__(self, config_dir: Path | None = None):
+        """Initialize config with optional custom directory."""
+        if config_dir is None:
+            config_dir = Path("~/.config/music-cli").expanduser()
+        self.config_dir = config_dir
+        self.config_file = self.config_dir / "config.toml"
+        self.radios_file = self.config_dir / "radios.txt"
+        self.history_file = self.config_dir / "history.jsonl"
+        self.socket_path = self.config_dir / "music-cli.sock"
+        self.pid_file = self.config_dir / "music-cli.pid"
+        self._config: dict[str, Any] = {}
+        self._ensure_config_dir()
+        self._load_config()
+
+    def _ensure_config_dir(self) -> None:
+        """Create config directory and default files if they don't exist."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        if not self.config_file.exists():
+            self._write_default_config()
+
+        if not self.radios_file.exists():
+            self._write_default_radios()
+
+        if not self.history_file.exists():
+            self.history_file.touch()
+
+    def _write_default_config(self) -> None:
+        """Write default configuration file."""
+        with self.config_file.open("wb") as f:
+            tomli_w.dump(self.DEFAULT_CONFIG, f)
+
+    def _write_default_radios(self) -> None:
+        """Write default radio stations file."""
+        default_radios = """# Radio stations for music-cli
+# Add one URL per line. Lines starting with # are comments.
+# Format: URL or "name|URL"
+
+# Chill/Lo-fi
+ChillHop|https://streams.ilovemusic.de/iloveradio17.mp3
+
+# Electronic
+Deep House|https://streams.ilovemusic.de/iloveradio14.mp3
+
+# Pop
+Top Hits|https://streams.ilovemusic.de/iloveradio1.mp3
+
+# Rock
+Rock Radio|https://streams.ilovemusic.de/iloveradio3.mp3
+
+# Classical
+Classical|http://stream.srg-ssr.ch/m/rsc_de/mp3_128
+"""
+        self.radios_file.write_text(default_radios)
+
+    def _load_config(self) -> None:
+        """Load configuration from file."""
+        try:
+            with self.config_file.open("rb") as f:
+                self._config = tomllib.load(f)
+        except (OSError, tomllib.TOMLDecodeError) as e:
+            logger.warning(f"Failed to load config from {self.config_file}: {e}")
+            self._config = self.DEFAULT_CONFIG.copy()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a config value using dot notation (e.g., 'player.volume')."""
+        keys = key.split(".")
+        value: Any = self._config
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+            else:
+                return default
+            if value is None:
+                return default
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a config value using dot notation and save."""
+        keys = key.split(".")
+        config = self._config
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        config[keys[-1]] = value
+        self.save()
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        with self.config_file.open("wb") as f:
+            tomli_w.dump(self._config, f)
+
+    def get_radios(self) -> list[tuple[str, str]]:
+        """Load radio stations from radios.txt.
+
+        Returns list of (name, url) tuples.
+        """
+        radios: list[tuple[str, str]] = []
+        if not self.radios_file.exists():
+            return radios
+
+        for line in self.radios_file.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "|" in line:
+                name, url = line.split("|", 1)
+                radios.append((name.strip(), url.strip()))
+            else:
+                radios.append((line, line))
+        return radios
+
+    def get_mood_radio(self, mood: str) -> str | None:
+        """Get radio URL for a specific mood."""
+        mood_map = self.get("mood_radio_map", {})
+        return mood_map.get(mood.lower())
+
+    def get_time_radio(self, time_period: str) -> str | None:
+        """Get radio URL for a time period (morning/afternoon/evening/night)."""
+        time_map = self.get("time_radio_map", {})
+        return time_map.get(time_period.lower())
+
+
+# Global config instance
+_config: Config | None = None
+
+
+def get_config() -> Config:
+    """Get the global config instance."""
+    global _config
+    if _config is None:
+        _config = Config()
+    return _config

music_cli/context/__init__.py

@@ -0,0 +1,6 @@
+"""Context-aware music selection for music-cli."""
+
+from .mood import MoodContext
+from .temporal import TemporalContext
+
+__all__ = ["TemporalContext", "MoodContext"]

music_cli/context/mood.py

@@ -0,0 +1,134 @@
+"""Mood-based music selection."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class Mood(Enum):
+    """Supported mood types."""
+
+    HAPPY = "happy"
+    SAD = "sad"
+    EXCITED = "excited"
+    FOCUS = "focus"
+    RELAXED = "relaxed"
+    ENERGETIC = "energetic"
+    MELANCHOLIC = "melancholic"
+    PEACEFUL = "peaceful"
+
+
+@dataclass
+class MoodInfo:
+    """Mood context information."""
+
+    mood: Mood
+    intensity: float  # 0.0 to 1.0
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "mood": self.mood.value,
+            "intensity": self.intensity,
+        }
+
+
+class MoodContext:
+    """Manages mood-based music selection."""
+
+    # Music characteristics for each mood
+    MOOD_CHARACTERISTICS = {
+        Mood.HAPPY: {
+            "tempo": "upbeat",
+            "key": "major",
+            "energy": "high",
+            "genres": ["pop", "indie", "funk"],
+        },
+        Mood.SAD: {
+            "tempo": "slow",
+            "key": "minor",
+            "energy": "low",
+            "genres": ["acoustic", "ambient", "classical"],
+        },
+        Mood.EXCITED: {
+            "tempo": "fast",
+            "key": "major",
+            "energy": "very high",
+            "genres": ["electronic", "rock", "dance"],
+        },
+        Mood.FOCUS: {
+            "tempo": "medium",
+            "key": "any",
+            "energy": "medium",
+            "genres": ["lo-fi", "ambient", "classical", "instrumental"],
+        },
+        Mood.RELAXED: {
+            "tempo": "slow",
+            "key": "any",
+            "energy": "low",
+            "genres": ["chill", "ambient", "jazz"],
+        },
+        Mood.ENERGETIC: {
+            "tempo": "fast",
+            "key": "major",
+            "energy": "high",
+            "genres": ["electronic", "rock", "hip-hop"],
+        },
+        Mood.MELANCHOLIC: {
+            "tempo": "slow",
+            "key": "minor",
+            "energy": "low",
+            "genres": ["indie", "classical", "folk"],
+        },
+        Mood.PEACEFUL: {
+            "tempo": "very slow",
+            "key": "any",
+            "energy": "very low",
+            "genres": ["ambient", "nature", "meditation"],
+        },
+    }
+
+    # AI prompts for each mood
+    MOOD_PROMPTS = {
+        Mood.HAPPY: "cheerful, uplifting, feel-good music with major chords and upbeat rhythm",
+        Mood.SAD: "melancholic, emotional, slow tempo music with minor chords",
+        Mood.EXCITED: "high energy, fast tempo, exciting electronic or rock music",
+        Mood.FOCUS: "lo-fi hip hop, ambient, instrumental music for concentration",
+        Mood.RELAXED: "chill, relaxing, smooth jazz or ambient soundscapes",
+        Mood.ENERGETIC: "powerful, driving beats, high BPM electronic or rock",
+        Mood.MELANCHOLIC: "bittersweet, nostalgic, acoustic or indie music",
+        Mood.PEACEFUL: "serene, calm, nature sounds mixed with soft ambient music",
+    }
+
+    @classmethod
+    def parse_mood(cls, mood_str: str) -> Mood | None:
+        """Parse a mood string to Mood enum."""
+        mood_str = mood_str.lower().strip()
+        try:
+            return Mood(mood_str)
+        except ValueError:
+            # Try matching partial
+            for mood in Mood:
+                if mood.value.startswith(mood_str):
+                    return mood
+            return None
+
+    @classmethod
+    def get_all_moods(cls) -> list[str]:
+        """Get list of all supported moods."""
+        return [m.value for m in Mood]
+
+    @classmethod
+    def get_characteristics(cls, mood: Mood) -> dict:
+        """Get music characteristics for a mood."""
+        return cls.MOOD_CHARACTERISTICS.get(mood, {})
+
+    @classmethod
+    def get_prompt(cls, mood: Mood) -> str:
+        """Get AI music generation prompt for a mood."""
+        return cls.MOOD_PROMPTS.get(mood, "background music")
+
+    @classmethod
+    def get_combined_prompt(cls, mood: Mood, temporal_prompt: str) -> str:
+        """Combine mood and temporal prompts for AI generation."""
+        mood_prompt = cls.get_prompt(mood)
+        return f"{mood_prompt}, {temporal_prompt}"

music_cli/context/temporal.py

@@ -0,0 +1,171 @@
+"""Temporal context detection for music selection."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+
+
+class TimePeriod(Enum):
+    """Time periods of the day."""
+
+    MORNING = "morning"  # 6:00 - 12:00
+    AFTERNOON = "afternoon"  # 12:00 - 17:00
+    EVENING = "evening"  # 17:00 - 21:00
+    NIGHT = "night"  # 21:00 - 6:00
+
+
+class DayType(Enum):
+    """Types of days."""
+
+    WEEKDAY = "weekday"
+    WEEKEND = "weekend"
+
+
+class Season(Enum):
+    """Seasons of the year."""
+
+    SPRING = "spring"
+    SUMMER = "summer"
+    AUTUMN = "autumn"
+    WINTER = "winter"
+
+
+@dataclass
+class TemporalInfo:
+    """Complete temporal context information."""
+
+    time_period: TimePeriod
+    day_type: DayType
+    season: Season
+    is_holiday: bool
+    hour: int
+    day_of_week: int  # 0 = Monday, 6 = Sunday
+    month: int
+    day: int
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "time_period": self.time_period.value,
+            "day_type": self.day_type.value,
+            "season": self.season.value,
+            "is_holiday": self.is_holiday,
+            "hour": self.hour,
+            "day_of_week": self.day_of_week,
+            "month": self.month,
+            "day": self.day,
+        }
+
+
+class TemporalContext:
+    """Detects temporal context for music selection."""
+
+    # Major US holidays (month, day)
+    HOLIDAYS = {
+        (1, 1): "New Year's Day",
+        (2, 14): "Valentine's Day",
+        (7, 4): "Independence Day",
+        (10, 31): "Halloween",
+        (12, 24): "Christmas Eve",
+        (12, 25): "Christmas",
+        (12, 31): "New Year's Eve",
+    }
+
+    def __init__(self, now: datetime | None = None):
+        """Initialize with optional custom datetime for testing."""
+        self._now = now
+
+    @property
+    def now(self) -> datetime:
+        """Get current datetime."""
+        return self._now or datetime.now()
+
+    def get_time_period(self) -> TimePeriod:
+        """Get current time period of the day."""
+        hour = self.now.hour
+
+        if 6 <= hour < 12:
+            return TimePeriod.MORNING
+        elif 12 <= hour < 17:
+            return TimePeriod.AFTERNOON
+        elif 17 <= hour < 21:
+            return TimePeriod.EVENING
+        else:
+            return TimePeriod.NIGHT
+
+    def get_day_type(self) -> DayType:
+        """Get current day type (weekday/weekend)."""
+        if self.now.weekday() >= 5:  # Saturday = 5, Sunday = 6
+            return DayType.WEEKEND
+        return DayType.WEEKDAY
+
+    def get_season(self) -> Season:
+        """Get current season (Northern Hemisphere)."""
+        month = self.now.month
+
+        if month in (3, 4, 5):
+            return Season.SPRING
+        elif month in (6, 7, 8):
+            return Season.SUMMER
+        elif month in (9, 10, 11):
+            return Season.AUTUMN
+        else:
+            return Season.WINTER
+
+    def is_holiday(self) -> bool:
+        """Check if today is a holiday."""
+        return (self.now.month, self.now.day) in self.HOLIDAYS
+
+    def get_holiday_name(self) -> str | None:
+        """Get the name of today's holiday, if any."""
+        return self.HOLIDAYS.get((self.now.month, self.now.day))
+
+    def get_info(self) -> TemporalInfo:
+        """Get complete temporal context information."""
+        return TemporalInfo(
+            time_period=self.get_time_period(),
+            day_type=self.get_day_type(),
+            season=self.get_season(),
+            is_holiday=self.is_holiday(),
+            hour=self.now.hour,
+            day_of_week=self.now.weekday(),
+            month=self.now.month,
+            day=self.now.day,
+        )
+
+    def get_music_prompt(self) -> str:
+        """Generate a music prompt based on temporal context.
+
+        Used for AI music generation.
+        """
+        info = self.get_info()
+        parts = []
+
+        # Time of day
+        time_moods = {
+            TimePeriod.MORNING: "uplifting, energizing morning",
+            TimePeriod.AFTERNOON: "focused, productive afternoon",
+            TimePeriod.EVENING: "relaxing, unwinding evening",
+            TimePeriod.NIGHT: "calm, peaceful night",
+        }
+        parts.append(time_moods[info.time_period])
+
+        # Day type
+        if info.day_type == DayType.WEEKEND:
+            parts.append("weekend vibes")
+
+        # Season
+        season_moods = {
+            Season.SPRING: "fresh spring",
+            Season.SUMMER: "warm summer",
+            Season.AUTUMN: "cozy autumn",
+            Season.WINTER: "serene winter",
+        }
+        parts.append(season_moods[info.season])
+
+        # Holiday
+        holiday = self.get_holiday_name()
+        if holiday:
+            parts.append(f"{holiday} celebration")
+
+        return ", ".join(parts) + " music"