wrkmon 1.0.0__py3-none-any.whl

wrkmon/data/migrations.py

@@ -0,0 +1,134 @@
+"""Database migrations for wrkmon."""
+
+import sqlite3
+from typing import Callable
+
+# List of migrations in order
+# Each migration is a tuple of (version, description, up_sql)
+MIGRATIONS: list[tuple[int, str, str]] = [
+    (
+        1,
+        "Initial schema",
+        """
+        -- Tracks table
+        CREATE TABLE IF NOT EXISTS tracks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            video_id TEXT UNIQUE NOT NULL,
+            title TEXT NOT NULL,
+            channel TEXT NOT NULL,
+            duration INTEGER NOT NULL,
+            thumbnail_url TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE INDEX IF NOT EXISTS idx_tracks_video_id ON tracks(video_id);
+
+        -- Playlists table
+        CREATE TABLE IF NOT EXISTS playlists (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT UNIQUE NOT NULL,
+            description TEXT DEFAULT '',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+
+        -- Playlist tracks junction table
+        CREATE TABLE IF NOT EXISTS playlist_tracks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            playlist_id INTEGER NOT NULL,
+            track_id INTEGER NOT NULL,
+            position INTEGER NOT NULL,
+            added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (playlist_id) REFERENCES playlists(id) ON DELETE CASCADE,
+            FOREIGN KEY (track_id) REFERENCES tracks(id) ON DELETE CASCADE,
+            UNIQUE(playlist_id, track_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_playlist_tracks_playlist ON playlist_tracks(playlist_id);
+
+        -- History table
+        CREATE TABLE IF NOT EXISTS history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            track_id INTEGER NOT NULL,
+            played_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            play_count INTEGER DEFAULT 1,
+            last_position INTEGER DEFAULT 0,
+            completed INTEGER DEFAULT 0,
+            FOREIGN KEY (track_id) REFERENCES tracks(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_history_played_at ON history(played_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_history_track ON history(track_id);
+
+        -- Schema version table
+        CREATE TABLE IF NOT EXISTS schema_version (
+            version INTEGER PRIMARY KEY,
+            applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """,
+    ),
+]
+
+
+class MigrationManager:
+    """Manages database migrations."""
+
+    def __init__(self, conn: sqlite3.Connection):
+        self._conn = conn
+        self._ensure_version_table()
+
+    def _ensure_version_table(self) -> None:
+        """Ensure schema_version table exists."""
+        self._conn.execute("""
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER PRIMARY KEY,
+                applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        self._conn.commit()
+
+    def get_current_version(self) -> int:
+        """Get the current schema version."""
+        cursor = self._conn.execute(
+            "SELECT MAX(version) FROM schema_version"
+        )
+        result = cursor.fetchone()[0]
+        return result if result is not None else 0
+
+    def get_pending_migrations(self) -> list[tuple[int, str, str]]:
+        """Get list of pending migrations."""
+        current = self.get_current_version()
+        return [m for m in MIGRATIONS if m[0] > current]
+
+    def apply_migration(self, version: int, description: str, sql: str) -> None:
+        """Apply a single migration."""
+        # Execute migration SQL
+        self._conn.executescript(sql)
+
+        # Record the migration
+        self._conn.execute(
+            "INSERT INTO schema_version (version) VALUES (?)",
+            (version,),
+        )
+        self._conn.commit()
+
+    def migrate(self, target_version: int | None = None) -> list[int]:
+        """Run pending migrations up to target version. Returns applied versions."""
+        applied = []
+        pending = self.get_pending_migrations()
+
+        for version, description, sql in pending:
+            if target_version is not None and version > target_version:
+                break
+
+            self.apply_migration(version, description, sql)
+            applied.append(version)
+
+        return applied
+
+    def needs_migration(self) -> bool:
+        """Check if there are pending migrations."""
+        return len(self.get_pending_migrations()) > 0
+
+
+def run_migrations(conn: sqlite3.Connection) -> list[int]:
+    """Convenience function to run all pending migrations."""
+    manager = MigrationManager(conn)
+    return manager.migrate()

wrkmon/data/models.py

@@ -0,0 +1,144 @@
+"""Data models for wrkmon."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class Track:
+    """Represents a track/video."""
+
+    video_id: str
+    title: str
+    channel: str
+    duration: int  # seconds
+    thumbnail_url: Optional[str] = None
+    id: Optional[int] = None
+
+    @property
+    def url(self) -> str:
+        """Get YouTube URL."""
+        return f"https://www.youtube.com/watch?v={self.video_id}"
+
+    @property
+    def duration_str(self) -> str:
+        """Get formatted duration."""
+        mins, secs = divmod(self.duration, 60)
+        hours, mins = divmod(mins, 60)
+        if hours > 0:
+            return f"{hours}:{mins:02d}:{secs:02d}"
+        return f"{mins}:{secs:02d}"
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "video_id": self.video_id,
+            "title": self.title,
+            "channel": self.channel,
+            "duration": self.duration,
+            "thumbnail_url": self.thumbnail_url,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Track":
+        """Create from dictionary."""
+        return cls(
+            id=data.get("id"),
+            video_id=data["video_id"],
+            title=data["title"],
+            channel=data["channel"],
+            duration=data["duration"],
+            thumbnail_url=data.get("thumbnail_url"),
+        )
+
+
+@dataclass
+class Playlist:
+    """Represents a playlist."""
+
+    name: str
+    description: str = ""
+    tracks: list[Track] = field(default_factory=list)
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    id: Optional[int] = None
+
+    @property
+    def track_count(self) -> int:
+        """Get number of tracks."""
+        return len(self.tracks)
+
+    @property
+    def total_duration(self) -> int:
+        """Get total duration in seconds."""
+        return sum(t.duration for t in self.tracks)
+
+    @property
+    def total_duration_str(self) -> str:
+        """Get formatted total duration."""
+        total = self.total_duration
+        hours, remainder = divmod(total, 3600)
+        mins, secs = divmod(remainder, 60)
+        if hours > 0:
+            return f"{hours}h {mins}m"
+        return f"{mins}m {secs}s"
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "tracks": [t.to_dict() for t in self.tracks],
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Playlist":
+        """Create from dictionary."""
+        return cls(
+            id=data.get("id"),
+            name=data["name"],
+            description=data.get("description", ""),
+            tracks=[Track.from_dict(t) for t in data.get("tracks", [])],
+            created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else None,
+            updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else None,
+        )
+
+
+@dataclass
+class HistoryEntry:
+    """Represents a play history entry."""
+
+    track: Track
+    played_at: datetime
+    play_count: int = 1
+    last_position: int = 0  # seconds, for resume
+    completed: bool = False
+    id: Optional[int] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "track": self.track.to_dict(),
+            "played_at": self.played_at.isoformat(),
+            "play_count": self.play_count,
+            "last_position": self.last_position,
+            "completed": self.completed,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HistoryEntry":
+        """Create from dictionary."""
+        return cls(
+            id=data.get("id"),
+            track=Track.from_dict(data["track"]),
+            played_at=datetime.fromisoformat(data["played_at"]),
+            play_count=data.get("play_count", 1),
+            last_position=data.get("last_position", 0),
+            completed=data.get("completed", False),
+        )

wrkmon/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI package for wrkmon TUI."""
+
+from wrkmon.ui.theme import APP_CSS, THEMES
+
+__all__ = ["APP_CSS", "THEMES"]

wrkmon/ui/components.py

@@ -0,0 +1,211 @@
+"""Reusable TUI components for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static, Input, ProgressBar, Label
+from textual.reactive import reactive
+
+from wrkmon.utils.stealth import get_stealth
+
+
+class HeaderBar(Static):
+    """Header bar showing app name and fake system stats."""
+
+    cpu = reactive(23)
+    mem = reactive(45)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="header"):
+            yield Static("WRKMON v1.0.0", id="header-title")
+            yield Static(self._get_stats_text(), id="header-stats")
+
+    def _get_stats_text(self) -> str:
+        return f"[CPU: {self.cpu}%] [MEM: {self.mem}%]"
+
+    def update_stats(self) -> None:
+        """Update fake system stats."""
+        self.cpu = self._stealth.get_fake_cpu()
+        self.mem = self._stealth.get_fake_memory()
+        stats = self.query_one("#header-stats", Static)
+        stats.update(self._get_stats_text())
+
+
+class SearchBar(Static):
+    """Search input bar."""
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="search-container"):
+            yield Static("> Search: ", classes="search-label")
+            yield Input(placeholder="Enter search query...", id="search-input")
+
+    def focus_input(self) -> None:
+        """Focus the search input."""
+        self.query_one("#search-input", Input).focus()
+
+    def clear_input(self) -> None:
+        """Clear the search input."""
+        self.query_one("#search-input", Input).value = ""
+
+    @property
+    def value(self) -> str:
+        """Get current search value."""
+        return self.query_one("#search-input", Input).value
+
+
+class ResultsHeader(Static):
+    """Header row for results list (styled like ps/top output)."""
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="results-header"):
+            yield Static("#", classes="result-index")
+            yield Static("Process Name", classes="result-title")
+            yield Static("PID", classes="result-pid")
+            yield Static("Status", classes="result-status")
+
+
+class ResultItem(Static):
+    """A single result item styled like a process entry."""
+
+    def __init__(
+        self,
+        index: int,
+        title: str,
+        video_id: str,
+        status: str = "READY",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.index = index
+        self.title = title
+        self.video_id = video_id
+        self.status = status
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        fake_pid = self._stealth.get_fake_pid()
+        process_name = self._stealth.get_fake_process_name(self.title)
+
+        with Horizontal(classes="result-item"):
+            yield Static(f"{self.index}", classes="result-index")
+            yield Static(process_name[:40], classes="result-title")
+            yield Static(str(fake_pid), classes="result-pid")
+            status_class = f"status-{self.status.lower()}"
+            yield Static(self.status, classes=f"result-status {status_class}")
+
+
+class PlayerBar(Static):
+    """Bottom player bar showing current track and controls."""
+
+    title = reactive("No process running")
+    status = reactive("STOPPED")
+    position = reactive(0.0)
+    duration = reactive(0.0)
+    volume = reactive(80)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="player-bar"):
+            # Now playing line
+            with Horizontal(id="now-playing"):
+                yield Static("NOW:", id="now-playing-label")
+                yield Static(self.title, id="now-playing-title")
+                yield Static(self._get_status_icon(), id="now-playing-status")
+
+            # Progress bar
+            with Horizontal(id="progress-container"):
+                yield ProgressBar(total=100, show_percentage=False, id="progress-bar")
+                yield Static(self._get_time_text(), id="progress-time")
+
+            # Volume bar
+            with Horizontal(id="volume-container"):
+                yield Static("VOL:", id="volume-label")
+                yield ProgressBar(total=100, show_percentage=False, id="volume-bar")
+                yield Static(f"{self.volume}%", id="volume-value")
+
+    def _get_status_icon(self) -> str:
+        icons = {
+            "playing": "▶",
+            "paused": "⏸",
+            "stopped": "⏹",
+            "buffering": "⟳",
+        }
+        return icons.get(self.status.lower(), "⏹")
+
+    def _get_time_text(self) -> str:
+        pos = self._stealth.format_duration(self.position)
+        dur = self._stealth.format_duration(self.duration)
+        return f"{pos} / {dur}"
+
+    def update_now_playing(self, title: str, status: str) -> None:
+        """Update the now playing display."""
+        self.title = title
+        self.status = status
+        process_name = self._stealth.get_fake_process_name(title)
+        self.query_one("#now-playing-title", Static).update(f"{process_name}")
+        self.query_one("#now-playing-status", Static).update(self._get_status_icon())
+
+    def update_progress(self, position: float, duration: float) -> None:
+        """Update the progress bar."""
+        self.position = position
+        self.duration = duration
+
+        progress_bar = self.query_one("#progress-bar", ProgressBar)
+        if duration > 0:
+            progress_bar.update(progress=(position / duration) * 100)
+        else:
+            progress_bar.update(progress=0)
+
+        self.query_one("#progress-time", Static).update(self._get_time_text())
+
+    def update_volume(self, volume: int) -> None:
+        """Update the volume display."""
+        self.volume = volume
+        self.query_one("#volume-bar", ProgressBar).update(progress=volume)
+        self.query_one("#volume-value", Static).update(f"{volume}%")
+
+
+class FooterBar(Static):
+    """Footer showing keyboard shortcuts."""
+
+    def __init__(self, hints: list[tuple[str, str]] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.hints = hints or [
+            ("/", "Search"),
+            ("Space", "Play/Pause"),
+            ("+/-", "Volume"),
+            ("n/p", "Next/Prev"),
+            ("q", "Queue"),
+            ("h", "History"),
+            ("Esc", "Back"),
+            ("Ctrl+C", "Quit"),
+        ]
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="footer"):
+            for key, action in self.hints:
+                yield Static(f"[{key}] {action}", classes="key-hint")
+
+
+class LoadingIndicator(Static):
+    """Loading indicator."""
+
+    def compose(self) -> ComposeResult:
+        yield Static("Loading...", classes="loading")
+
+
+class EmptyState(Static):
+    """Empty state message."""
+
+    def __init__(self, message: str = "No data", **kwargs):
+        super().__init__(**kwargs)
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        yield Static(self.message, classes="empty-state")

wrkmon/ui/messages.py

@@ -0,0 +1,89 @@
+"""Custom Textual messages for wrkmon component communication."""
+
+from textual.message import Message
+
+from wrkmon.core.youtube import SearchResult
+
+
+class TrackSelected(Message):
+    """Emitted when a track is selected for playback."""
+
+    def __init__(self, result: SearchResult) -> None:
+        self.result = result
+        super().__init__()
+
+
+class TrackQueued(Message):
+    """Emitted when a track is added to queue."""
+
+    def __init__(self, result: SearchResult) -> None:
+        self.result = result
+        super().__init__()
+
+
+class PlaybackStateChanged(Message):
+    """Emitted when playback state changes."""
+
+    def __init__(
+        self,
+        is_playing: bool,
+        position: float = 0.0,
+        duration: float = 0.0,
+        title: str = "",
+    ) -> None:
+        self.is_playing = is_playing
+        self.position = position
+        self.duration = duration
+        self.title = title
+        super().__init__()
+
+
+class VolumeChanged(Message):
+    """Emitted when volume changes."""
+
+    def __init__(self, volume: int) -> None:
+        self.volume = volume
+        super().__init__()
+
+
+class ViewChanged(Message):
+    """Emitted when the active view should change."""
+
+    def __init__(self, view_name: str) -> None:
+        self.view_name = view_name
+        super().__init__()
+
+
+class SearchStarted(Message):
+    """Emitted when a search begins."""
+
+    def __init__(self, query: str) -> None:
+        self.query = query
+        super().__init__()
+
+
+class SearchCompleted(Message):
+    """Emitted when search results are ready."""
+
+    def __init__(self, results: list[SearchResult], query: str) -> None:
+        self.results = results
+        self.query = query
+        super().__init__()
+
+
+class QueueUpdated(Message):
+    """Emitted when the queue changes."""
+
+    def __init__(self, queue_length: int, current_index: int) -> None:
+        self.queue_length = queue_length
+        self.current_index = current_index
+        super().__init__()
+
+
+class StatusMessage(Message):
+    """Emitted to show a status message to the user."""
+
+    def __init__(self, message: str, level: str = "info") -> None:
+        self.message = message
+        self.level = level  # "info", "success", "warning", "error"
+        super().__init__()

wrkmon/ui/screens/__init__.py

@@ -0,0 +1,8 @@
+"""TUI screens for wrkmon."""
+
+from wrkmon.ui.screens.search import SearchScreen
+from wrkmon.ui.screens.player import PlayerScreen
+from wrkmon.ui.screens.playlist import PlaylistScreen
+from wrkmon.ui.screens.history import HistoryScreen
+
+__all__ = ["SearchScreen", "PlayerScreen", "PlaylistScreen", "HistoryScreen"]