480 lines
18 KiB
Python
480 lines
18 KiB
Python
from typing import Any, Dict, Sequence, List, Optional
|
|
import sys
|
|
import json
|
|
import platform
|
|
import socket
|
|
import re
|
|
import subprocess
|
|
from ._shared import Cmdlet, CmdletArg, parse_cmdlet_args
|
|
from helper.logger import log, debug
|
|
from result_table import ResultTable
|
|
from helper.mpv_ipc import get_ipc_pipe_path, MPVIPCClient
|
|
import pipeline as ctx
|
|
|
|
from helper.local_library import LocalLibrarySearchOptimizer
|
|
from config import get_local_storage_path
|
|
|
|
def _send_ipc_command(command: Dict[str, Any], silent: bool = False) -> Optional[Any]:
|
|
"""Send a command to the MPV IPC pipe and return the response."""
|
|
try:
|
|
ipc_pipe = get_ipc_pipe_path()
|
|
client = MPVIPCClient(socket_path=ipc_pipe)
|
|
|
|
if not client.connect():
|
|
return None # MPV not running
|
|
|
|
response = client.send_command(command)
|
|
client.disconnect()
|
|
return response
|
|
except Exception as e:
|
|
if not silent:
|
|
debug(f"IPC Error: {e}", file=sys.stderr)
|
|
return None
|
|
|
|
def _get_playlist(silent: bool = False) -> Optional[List[Dict[str, Any]]]:
|
|
"""Get the current playlist from MPV. Returns None if MPV is not running."""
|
|
cmd = {"command": ["get_property", "playlist"], "request_id": 100}
|
|
resp = _send_ipc_command(cmd, silent=silent)
|
|
if resp is None:
|
|
return None
|
|
if resp.get("error") == "success":
|
|
return resp.get("data", [])
|
|
return []
|
|
|
|
def _extract_title_from_item(item: Dict[str, Any]) -> str:
|
|
"""Extract a clean title from an MPV playlist item, handling memory:// M3U hacks."""
|
|
title = item.get("title")
|
|
filename = item.get("filename") or ""
|
|
|
|
# Special handling for memory:// M3U playlists (used to pass titles via IPC)
|
|
if "memory://" in filename and "#EXTINF:" in filename:
|
|
try:
|
|
# Extract title from #EXTINF:-1,Title
|
|
# Use regex to find title between #EXTINF:-1, and newline
|
|
match = re.search(r"#EXTINF:-1,(.*?)(?:\n|\r|$)", filename)
|
|
if match:
|
|
extracted_title = match.group(1).strip()
|
|
if not title or title == "memory://":
|
|
title = extracted_title
|
|
|
|
# If we still don't have a title, try to find the URL in the M3U content
|
|
if not title:
|
|
lines = filename.splitlines()
|
|
for line in lines:
|
|
line = line.strip()
|
|
if line and not line.startswith('#') and not line.startswith('memory://'):
|
|
# Found the URL, use it as title
|
|
return line
|
|
except Exception:
|
|
pass
|
|
|
|
return title or filename or "Unknown"
|
|
|
|
def _queue_items(items: List[Any], clear_first: bool = False) -> None:
|
|
"""Queue items to MPV, starting it if necessary.
|
|
|
|
Args:
|
|
items: List of items to queue
|
|
clear_first: If True, the first item will replace the current playlist
|
|
"""
|
|
for i, item in enumerate(items):
|
|
# Extract URL/Path
|
|
target = None
|
|
title = None
|
|
|
|
if isinstance(item, dict):
|
|
target = item.get("target") or item.get("url") or item.get("path") or item.get("filename")
|
|
title = item.get("title") or item.get("name")
|
|
elif hasattr(item, "target"):
|
|
target = item.target
|
|
title = getattr(item, "title", None)
|
|
elif isinstance(item, str):
|
|
target = item
|
|
|
|
if target:
|
|
# Add to MPV playlist
|
|
# We use loadfile with append flag (or replace if clear_first is set)
|
|
|
|
# Use memory:// M3U hack to pass title to MPV
|
|
if title:
|
|
# Sanitize title for M3U (remove newlines)
|
|
safe_title = title.replace('\n', ' ').replace('\r', '')
|
|
m3u_content = f"#EXTM3U\n#EXTINF:-1,{safe_title}\n{target}"
|
|
target_to_send = f"memory://{m3u_content}"
|
|
else:
|
|
target_to_send = target
|
|
|
|
mode = "append"
|
|
if clear_first and i == 0:
|
|
mode = "replace"
|
|
|
|
cmd = {"command": ["loadfile", target_to_send, mode], "request_id": 200}
|
|
resp = _send_ipc_command(cmd)
|
|
|
|
if resp is None:
|
|
# MPV not running (or died)
|
|
# Start MPV with remaining items
|
|
_start_mpv(items[i:])
|
|
return
|
|
elif resp.get("error") == "success":
|
|
# Also set property for good measure
|
|
if title:
|
|
title_cmd = {"command": ["set_property", "force-media-title", title], "request_id": 201}
|
|
_send_ipc_command(title_cmd)
|
|
debug(f"Queued: {title or target}")
|
|
else:
|
|
error_msg = str(resp.get('error'))
|
|
debug(f"Failed to queue item: {error_msg}", file=sys.stderr)
|
|
|
|
def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
|
|
"""Manage and play items in the MPV playlist via IPC."""
|
|
|
|
parsed = parse_cmdlet_args(args, CMDLET)
|
|
|
|
# Handle positional index argument if provided
|
|
index_arg = parsed.get("index")
|
|
|
|
clear_mode = parsed.get("clear")
|
|
list_mode = parsed.get("list")
|
|
play_mode = parsed.get("play")
|
|
pause_mode = parsed.get("pause")
|
|
save_mode = parsed.get("save")
|
|
load_mode = parsed.get("load")
|
|
|
|
# Handle Save Playlist
|
|
if save_mode:
|
|
playlist_name = index_arg or f"Playlist {subprocess.check_output(['date', '/t'], shell=True).decode().strip()}"
|
|
# If index_arg was used for name, clear it so it doesn't trigger index logic
|
|
if index_arg:
|
|
index_arg = None
|
|
|
|
items = _get_playlist()
|
|
if not items:
|
|
debug("Cannot save: MPV playlist is empty or MPV is not running.")
|
|
return 1
|
|
|
|
# Clean up items for saving (remove current flag, etc)
|
|
clean_items = []
|
|
for item in items:
|
|
# If title was extracted from memory://, we should probably save the original filename
|
|
# if it's a URL, or reconstruct a clean object.
|
|
# Actually, _extract_title_from_item handles the display title.
|
|
# But for playback, we need the 'filename' (which might be memory://...)
|
|
# If we save 'memory://...', it will work when loaded back.
|
|
clean_items.append(item)
|
|
|
|
# Use config from context or load it
|
|
config_data = config if config else {}
|
|
|
|
storage_path = get_local_storage_path(config_data)
|
|
if not storage_path:
|
|
debug("Local storage path not configured.")
|
|
return 1
|
|
|
|
with LocalLibrarySearchOptimizer(storage_path) as db:
|
|
if db.save_playlist(playlist_name, clean_items):
|
|
debug(f"Playlist saved as '{playlist_name}'")
|
|
return 0
|
|
else:
|
|
debug(f"Failed to save playlist '{playlist_name}'")
|
|
return 1
|
|
|
|
# Handle Load Playlist
|
|
current_playlist_name = None
|
|
if load_mode:
|
|
# Use config from context or load it
|
|
config_data = config if config else {}
|
|
|
|
storage_path = get_local_storage_path(config_data)
|
|
if not storage_path:
|
|
debug("Local storage path not configured.")
|
|
return 1
|
|
|
|
with LocalLibrarySearchOptimizer(storage_path) as db:
|
|
if index_arg:
|
|
try:
|
|
pl_id = int(index_arg)
|
|
result = db.get_playlist_by_id(pl_id)
|
|
if result is None:
|
|
debug(f"Playlist ID {pl_id} not found.")
|
|
return 1
|
|
|
|
name, items = result
|
|
current_playlist_name = name
|
|
|
|
# Queue items (replacing current playlist)
|
|
if items:
|
|
_queue_items(items, clear_first=True)
|
|
else:
|
|
# Empty playlist, just clear
|
|
_send_ipc_command({"command": ["playlist-clear"]}, silent=True)
|
|
|
|
# Switch to list mode to show the result
|
|
list_mode = True
|
|
index_arg = None
|
|
# Fall through to list logic
|
|
|
|
except ValueError:
|
|
debug(f"Invalid playlist ID: {index_arg}")
|
|
return 1
|
|
else:
|
|
playlists = db.get_playlists()
|
|
|
|
if not playlists:
|
|
debug("No saved playlists found.")
|
|
return 0
|
|
|
|
table = ResultTable("Saved Playlists")
|
|
for i, pl in enumerate(playlists):
|
|
item_count = len(pl.get('items', []))
|
|
row = table.add_row()
|
|
# row.add_column("ID", str(pl['id'])) # Hidden as per user request
|
|
row.add_column("Name", pl['name'])
|
|
row.add_column("Items", str(item_count))
|
|
row.add_column("Updated", pl['updated_at'])
|
|
|
|
# Set the playlist items as the result object for this row
|
|
# When user selects @N, they get the list of items
|
|
# We also set the source command to .pipe -load <ID> so it loads it
|
|
table.set_row_selection_args(i, ["-load", str(pl['id'])])
|
|
|
|
table.set_source_command(".pipe")
|
|
|
|
# Register results
|
|
ctx.set_last_result_table_overlay(table, [p['items'] for p in playlists])
|
|
ctx.set_current_stage_table(table)
|
|
|
|
print(table)
|
|
return 0
|
|
|
|
# Handle Play/Pause commands
|
|
if play_mode:
|
|
cmd = {"command": ["set_property", "pause", False], "request_id": 103}
|
|
resp = _send_ipc_command(cmd)
|
|
if resp and resp.get("error") == "success":
|
|
debug("Resumed playback")
|
|
return 0
|
|
else:
|
|
debug("Failed to resume playback (MPV not running?)", file=sys.stderr)
|
|
return 1
|
|
|
|
if pause_mode:
|
|
cmd = {"command": ["set_property", "pause", True], "request_id": 104}
|
|
resp = _send_ipc_command(cmd)
|
|
if resp and resp.get("error") == "success":
|
|
debug("Paused playback")
|
|
return 0
|
|
else:
|
|
debug("Failed to pause playback (MPV not running?)", file=sys.stderr)
|
|
return 1
|
|
|
|
# Handle Clear All command (no index provided)
|
|
if clear_mode and index_arg is None:
|
|
cmd = {"command": ["playlist-clear"], "request_id": 105}
|
|
resp = _send_ipc_command(cmd)
|
|
if resp and resp.get("error") == "success":
|
|
debug("Playlist cleared")
|
|
return 0
|
|
else:
|
|
debug("Failed to clear playlist (MPV not running?)", file=sys.stderr)
|
|
return 1
|
|
|
|
# Handle piped input (add to playlist)
|
|
if result:
|
|
# If result is a list of items, add them to playlist
|
|
items_to_add = []
|
|
if isinstance(result, list):
|
|
items_to_add = result
|
|
elif isinstance(result, dict):
|
|
items_to_add = [result]
|
|
|
|
_queue_items(items_to_add)
|
|
|
|
if items_to_add:
|
|
# If we added items, we might want to play the first one if nothing is playing?
|
|
# For now, just list the playlist
|
|
pass
|
|
|
|
# Get playlist from MPV
|
|
items = _get_playlist()
|
|
|
|
if items is None:
|
|
debug("MPV is not running. Starting new instance...")
|
|
_start_mpv([])
|
|
return 0
|
|
|
|
if not items:
|
|
debug("MPV playlist is empty.")
|
|
return 0
|
|
|
|
# If index is provided, perform action (Play or Clear)
|
|
if index_arg is not None:
|
|
try:
|
|
# Handle 1-based index
|
|
idx = int(index_arg) - 1
|
|
|
|
if idx < 0 or idx >= len(items):
|
|
debug(f"Index {index_arg} out of range (1-{len(items)}).")
|
|
return 1
|
|
|
|
item = items[idx]
|
|
title = _extract_title_from_item(item)
|
|
|
|
if clear_mode:
|
|
# Remove item
|
|
cmd = {"command": ["playlist-remove", idx], "request_id": 101}
|
|
resp = _send_ipc_command(cmd)
|
|
if resp and resp.get("error") == "success":
|
|
debug(f"Removed: {title}")
|
|
# Refresh items for listing
|
|
items = _get_playlist() or []
|
|
list_mode = True
|
|
index_arg = None
|
|
else:
|
|
debug(f"Failed to remove item: {resp.get('error') if resp else 'No response'}")
|
|
return 1
|
|
else:
|
|
# Play item
|
|
cmd = {"command": ["playlist-play-index", idx], "request_id": 102}
|
|
resp = _send_ipc_command(cmd)
|
|
if resp and resp.get("error") == "success":
|
|
# Ensure playback starts (unpause)
|
|
unpause_cmd = {"command": ["set_property", "pause", False], "request_id": 103}
|
|
_send_ipc_command(unpause_cmd)
|
|
|
|
debug(f"Playing: {title}")
|
|
return 0
|
|
else:
|
|
debug(f"Failed to play item: {resp.get('error') if resp else 'No response'}")
|
|
return 1
|
|
|
|
except ValueError:
|
|
debug(f"Invalid index: {index_arg}")
|
|
return 1
|
|
|
|
# List items (Default action or after clear)
|
|
if list_mode or index_arg is None:
|
|
if not items:
|
|
debug("MPV playlist is empty.")
|
|
return 0
|
|
|
|
# Use the loaded playlist name if available, otherwise default
|
|
# Note: current_playlist_name is defined in the load_mode block if a playlist was loaded
|
|
try:
|
|
table_title = current_playlist_name or "MPV Playlist"
|
|
except NameError:
|
|
table_title = "MPV Playlist"
|
|
|
|
table = ResultTable(table_title)
|
|
|
|
for i, item in enumerate(items):
|
|
is_current = item.get("current", False)
|
|
title = _extract_title_from_item(item)
|
|
|
|
# Truncate if too long
|
|
if len(title) > 80:
|
|
title = title[:77] + "..."
|
|
|
|
row = table.add_row()
|
|
row.add_column("Current", "*" if is_current else "")
|
|
row.add_column("Title", title)
|
|
|
|
table.set_row_selection_args(i, [str(i + 1)])
|
|
|
|
table.set_source_command(".pipe")
|
|
|
|
# Register results with pipeline context so @N selection works
|
|
ctx.set_last_result_table_overlay(table, items)
|
|
ctx.set_current_stage_table(table)
|
|
|
|
print(table)
|
|
|
|
return 0
|
|
|
|
def _start_mpv(items: List[Any]) -> None:
|
|
"""Start MPV with a list of items."""
|
|
ipc_pipe = get_ipc_pipe_path()
|
|
|
|
cmd = ['mpv', f'--input-ipc-server={ipc_pipe}', '--idle', '--force-window']
|
|
cmd.append('--ytdl-format=bestvideo[height<=?1080]+bestaudio/best[height<=?1080]')
|
|
|
|
# Add items
|
|
for item in items:
|
|
target = None
|
|
title = None
|
|
|
|
if isinstance(item, dict):
|
|
target = item.get("target") or item.get("url") or item.get("path") or item.get("filename")
|
|
title = item.get("title") or item.get("name")
|
|
elif hasattr(item, "target"):
|
|
target = item.target
|
|
title = getattr(item, "title", None)
|
|
elif isinstance(item, str):
|
|
target = item
|
|
|
|
if target:
|
|
if title:
|
|
# Use memory:// M3U hack to pass title
|
|
safe_title = title.replace('\n', ' ').replace('\r', '')
|
|
m3u_content = f"#EXTM3U\n#EXTINF:-1,{safe_title}\n{target}"
|
|
cmd.append(f"memory://{m3u_content}")
|
|
else:
|
|
cmd.append(target)
|
|
|
|
try:
|
|
kwargs = {}
|
|
if platform.system() == 'Windows':
|
|
kwargs['creationflags'] = 0x00000008 # DETACHED_PROCESS
|
|
|
|
subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, **kwargs)
|
|
debug(f"Started MPV with {len(items)} items")
|
|
except Exception as e:
|
|
debug(f"Error starting MPV: {e}", file=sys.stderr)
|
|
|
|
CMDLET = Cmdlet(
|
|
name=".pipe",
|
|
aliases=["pipe", "playlist", "queue", "ls-pipe"],
|
|
summary="Manage and play items in the MPV playlist via IPC",
|
|
usage=".pipe [index] [-clear]",
|
|
args=[
|
|
CmdletArg(
|
|
name="index",
|
|
type="int",
|
|
description="Index of item to play or clear",
|
|
required=False
|
|
),
|
|
CmdletArg(
|
|
name="clear",
|
|
type="flag",
|
|
description="Remove the selected item, or clear entire playlist if no index provided"
|
|
),
|
|
CmdletArg(
|
|
name="list",
|
|
type="flag",
|
|
description="List items (default)"
|
|
),
|
|
CmdletArg(
|
|
name="play",
|
|
type="flag",
|
|
description="Resume playback"
|
|
),
|
|
CmdletArg(
|
|
name="pause",
|
|
type="flag",
|
|
description="Pause playback"
|
|
),
|
|
CmdletArg(
|
|
name="save",
|
|
type="flag",
|
|
description="Save current playlist to database"
|
|
),
|
|
CmdletArg(
|
|
name="load",
|
|
type="flag",
|
|
description="List saved playlists"
|
|
),
|
|
],
|
|
exec=_run
|
|
)
|
|
|