flow-twinx 0.1.0__py3-none-any.whl

flow_twinx/Offline/__init__.py

@@ -0,0 +1,5 @@
+# ¯\_(ツ)_/¯  Just some crickets here ! 
+
+# Just joking it is here to make py recognise this is a real module :)
+
+# Don't check online's init.py

flow_twinx/Offline/commands.py

@@ -0,0 +1,207 @@
+import random
+from .. import config
+from ..config import merge_flags
+from . import file as lib
+from . import player
+from ..tui import print as tprint
+
+try:
+    import readline
+    _HAS_READLINE = True
+except ImportError:
+    _HAS_READLINE = False
+
+_last_results = []
+_last_played = None
+
+COMMANDS = {
+    "play":    "Play song(s) from local library",
+    "search":  "Search local music library",
+    "list":    "List local music library",
+    "like":    "Like the currently playing song",
+    "switch":  "Switch to Online mode (checks connection)",
+    "help":    "Show this help message",
+    "exit":    "Exit Flow",
+}
+
+m = tprint(color="grey", border="none")
+e = tprint(color="red", border="none")
+i = tprint(color="theme", border="none")
+
+
+class _Completer:
+    def __init__(self):
+        self.matches = []
+
+    def complete(self, text, state):
+        if state == 0:
+            line = readline.get_line_buffer()
+            parts = line.split()
+            if len(parts) <= 1:
+                options = [c for c in COMMANDS if c.startswith(text)]
+            elif parts[0] == "play":
+                songs = lib.get_song_names()
+                albums = lib.get_album_names()
+                all_names = songs + albums
+                options = sorted(set(
+                    n for n in all_names
+                    if n.lower().startswith(text.lower())
+                ))
+            else:
+                options = []
+            self.matches = options
+        try:
+            return self.matches[state]
+        except IndexError:
+            return None
+
+
+def _setup_completion():
+    if not _HAS_READLINE:
+        return
+    readline.set_completer(_Completer().complete)
+    readline.parse_and_bind("tab: complete")
+    readline.set_completer_delims(' \t\n;')
+
+
+def run(cmd: str, extra: list[str], args):
+    _setup_completion()
+    extra, args = merge_flags(extra, args)
+    if cmd == "play":
+        play(extra, args)
+    elif cmd == "search":
+        search(" ".join(extra) if extra else "")
+    elif cmd == "list":
+        list_library()
+    elif cmd == "like":
+        like_track()
+    elif cmd == "switch":
+        switch_mode()
+    elif cmd == "help":
+        show_help()
+    else:
+        e(f"Unknown command: {cmd}")
+
+
+def play(extra: list[str], args):
+    global _last_results, _last_played
+    arg = " ".join(extra) if extra else None
+    if not arg:
+        e("No song specified")
+        return
+
+    if arg == "liked":
+        _play_liked(args)
+        return
+
+    if arg in lib.get_album_names():
+        _play_album(arg, args)
+        return
+
+    if arg.isdigit():
+        idx = int(arg) - 1
+        if idx < 0 or idx >= len(_last_results):
+            e("Index out of range")
+            return
+        song_path = _last_results[idx]
+    else:
+        results = lib.find_songs(arg)
+        if not results:
+            e(f"No songs found matching '{arg}'")
+            return
+        if len(results) == 1:
+            song_path = results[0]
+        else:
+            _last_results = results
+            m("Multiple matches:")
+            for i, p in enumerate(results, 1):
+                m(f"  {i}. {p.stem}")
+            return
+
+    _last_played = song_path
+    player.play_file(song_path, song_path.stem, args)
+
+
+def _play_liked(args):
+    liked = lib.get_liked_songs()
+    if not liked:
+        e("No liked songs yet")
+        return
+    if getattr(args, "s", False):
+        random.shuffle(liked)
+    for song in liked:
+        _last_played = song
+        player.play_file(song, song.stem, args)
+
+
+def _play_album(album: str, args):
+    songs = lib.get_album_songs(album)
+    if not songs:
+        e(f"No songs found in album '{album}'")
+        return
+    if getattr(args, "s", False):
+        random.shuffle(songs)
+    for song in songs:
+        _last_played = song
+        player.play_file(song, song.stem, args)
+
+
+def like_track():
+    global _last_played
+    if not _last_played:
+        e("No song currently playing")
+        return
+    dest = lib.like_song(_last_played)
+    if dest:
+        i(f"Liked: {_last_played.stem}")
+    else:
+        m(f"{_last_played.stem} is already liked")
+
+
+def search(query: str):
+    global _last_results
+    if not query:
+        e("Search query required")
+        return
+    results = lib.find_songs(query)
+    if not results:
+        e("No results found")
+        return
+    _last_results = results
+    for i, p in enumerate(results, 1):
+        m(f"  {i}. {p.stem}")
+
+
+def list_library():
+    songs = lib.get_songs()
+    albums = lib.get_albums()
+    liked = lib.get_liked_songs()
+
+    if songs:
+        i("\nSongs:")
+        for p in songs:
+            m(f"  {p.stem}")
+    if albums:
+        i("\nAlbums:")
+        for a in albums:
+            m(f"  {a}/")
+    if liked:
+        i("\nLiked Songs:")
+        for p in liked:
+            m(f"  {p.stem}")
+    if not songs and not albums and not liked:
+        e("No music in library")
+
+
+def switch_mode():
+    from ..ping import is_connected
+    if is_connected():
+        i("Switched to Online mode")
+    else:
+        e("No internet connection")
+
+
+def show_help():
+    i("Offline Commands:")
+    for cmd, desc in COMMANDS.items():
+        m(f"  {cmd:12s} {desc}")

flow_twinx/Offline/file.py

@@ -0,0 +1,77 @@
+import pathlib
+import shutil
+from .. import config
+
+AUDIO_EXTENSIONS = {".mp3", ".flac", ".wav", ".m4a", ".ogg", ".opus", ".wma", ".aac",".webm"}
+LIKED_DIR_NAME = "liked songs"
+
+
+def _liked_dir() -> pathlib.Path:
+    return config.DOWNLOAD_DIR / LIKED_DIR_NAME
+
+
+def get_all_songs() -> list[pathlib.Path]:
+    if not config.DOWNLOAD_DIR.exists():
+        return []
+    return sorted([
+        p for p in config.DOWNLOAD_DIR.rglob("*")
+        if p.suffix.lower() in AUDIO_EXTENSIONS
+    ])
+
+
+def get_songs() -> list[pathlib.Path]:
+    liked = _liked_dir()
+    return [s for s in get_all_songs() if liked not in s.parents]
+
+
+def get_albums() -> list[str]:
+    if not config.DOWNLOAD_DIR.exists():
+        return []
+    liked = _liked_dir()
+    return sorted([
+        d.name for d in config.DOWNLOAD_DIR.iterdir()
+        if d.is_dir() and d != liked
+    ])
+
+
+def get_album_songs(album: str) -> list[pathlib.Path]:
+    album_dir = config.DOWNLOAD_DIR / album
+    if not album_dir.exists() or not album_dir.is_dir():
+        return []
+    return sorted([
+        p for p in album_dir.iterdir()
+        if p.suffix.lower() in AUDIO_EXTENSIONS
+    ])
+
+
+def get_liked_songs() -> list[pathlib.Path]:
+    liked = _liked_dir()
+    if not liked.exists():
+        return []
+    return sorted([
+        p for p in liked.iterdir()
+        if p.suffix.lower() in AUDIO_EXTENSIONS
+    ])
+
+
+def like_song(song_path: pathlib.Path) -> pathlib.Path | None:
+    liked = _liked_dir()
+    liked.mkdir(parents=True, exist_ok=True)
+    dest = liked / song_path.name
+    if dest.exists():
+        return None
+    shutil.copy2(song_path, dest)
+    return dest
+
+
+def find_songs(query: str) -> list[pathlib.Path]:
+    q = query.lower()
+    return [s for s in get_songs() if q in s.stem.lower()]
+
+
+def get_song_names() -> list[str]:
+    return sorted(set(s.stem for s in get_songs()))
+
+
+def get_album_names() -> list[str]:
+    return get_albums()

flow_twinx/Offline/player.py

@@ -0,0 +1,64 @@
+import sys
+import time
+import vlc
+from ..tui import print as tprint
+
+m = tprint(color="grey", border="none")
+e = tprint(color="red", border="none")
+i = tprint(color="theme", border="none")
+
+BAR_WIDTH = 40
+
+
+def _progress_bar(elapsed, total):
+    if total <= 0:
+        return ""
+    fraction = min(elapsed / total, 1.0)
+    filled = int(fraction * BAR_WIDTH)
+    bar = "/" * filled + " " * (BAR_WIDTH - filled)
+    pct = int(fraction * 100)
+    return f"  [{bar}] {pct}%"
+
+
+def play_file(filepath, title, args=None):
+    repeat = args and getattr(args, "r", False)
+    shuffle = args and getattr(args, "s", False)
+
+    while True:
+        instance = vlc.Instance("--no-video --quiet")
+        player = instance.media_player_new()
+        media = instance.media_new(str(filepath))
+        player.set_media(media)
+        player.play()
+
+        duration = 0
+        for _ in range(50):
+            duration = player.get_length() / 1000
+            if duration > 0:
+                break
+            time.sleep(0.1)
+        if duration <= 0:
+            duration = 0
+        dur_min, dur_sec = divmod(int(duration), 60)
+        i(f"\nPlaying : {title}")
+        m(f"    {dur_min}:{dur_sec:02d} | repeat:{repeat} | shuffle:{shuffle}")
+
+        start = time.time()
+        try:
+            while player.get_state() not in (vlc.State.Ended, vlc.State.Error):
+                elapsed = time.time() - start
+                bar = _progress_bar(elapsed, duration)
+                sys.stdout.write(f"\r\x1b[35m{bar}\x1b[0m")
+                sys.stdout.flush()
+                time.sleep(0.5)
+        except KeyboardInterrupt:
+            player.stop()
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+            break
+
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+        if not repeat:
+            break

flow_twinx/Online/__init__.py

@@ -0,0 +1,5 @@
+# ¯\_(ツ)_/¯  Just some crickets here ! 
+
+# Just joking it is here to make py recognise this is a real module :)
+
+# Don't check offline's init.py

flow_twinx/Online/commands.py

@@ -0,0 +1,205 @@
+import random
+import sys
+import threading
+import time
+from .. import config
+from ..config import merge_flags
+from . import youtube
+from . import player
+from ..tui import print as tprint
+
+_last_results = []
+_last_played = None
+
+COMMANDS = {
+    "play":  "Play a song from YouTube",
+    "search": "Search YouTube for tracks",
+    "like":  "Like a song",
+    "download": "Download audio from YouTube",
+    "switch": "Switch to Offline mode",
+    "help":  "Show this help message",
+    "exit":  "Exit Flow",
+}
+
+m = tprint(color="grey", border="none")
+e = tprint(color="red", border="none")
+i = tprint(color="theme", border="none")
+
+def run(cmd: str, extra: list[str], args):
+    extra, args = merge_flags(extra, args)
+    if cmd == "play":
+        play(extra, args)
+    elif cmd == "search":
+        search(" ".join(extra) if extra else "")
+    elif cmd == "like":
+        like_track()
+    elif cmd == "download":
+        download(extra)
+    elif cmd == "switch":
+        switch_mode()
+    elif cmd == "help":
+        show_help()
+    else:
+        print(f"Unknown command: {cmd}")
+
+
+def _spinner(stop):
+    chars = "|/-\\"
+    i = 0
+    while not stop():
+        sys.stdout.write(f"\r\x1b[36mSearching... {chars[i]}\x1b[0m")
+        sys.stdout.flush()
+        time.sleep(0.1)
+        i = (i + 1) % len(chars)
+    sys.stdout.write("\r" + " " * 40 + "\r")
+    sys.stdout.flush()
+
+
+def _do_search(query):
+    global _last_results
+    stop = False
+    t = threading.Thread(target=_spinner, args=(lambda: stop,), daemon=True)
+    t.start()
+    _last_results = youtube.search(query)
+    stop = True
+    t.join()
+
+
+def play(extra: list[str], args):
+    global _last_results, _last_played
+    arg = " ".join(extra) if extra else None
+    if not arg:
+        print("No song specified")
+        return
+
+    if arg == "liked":
+        _play_liked(args)
+        return
+
+    if arg.isdigit():
+        idx = int(arg) - 1
+        if idx < 0 or idx >= len(_last_results):
+            print("Index out of range")
+            return
+        entry, title, _ = _last_results[idx]
+    else:
+        _do_search(arg)
+        if not _last_results:
+            print("No results found")
+            return
+        entry, title, _ = _last_results[0]
+
+    _last_played = (entry, title)
+    filepath = None
+    if getattr(args, "d", False):
+        url = entry.get("webpage_url") or entry.get("original_url")
+        if not url:
+            print("No URL found for this entry")
+            return
+        m(f"   \n Downloading {title}...")
+        filepath = youtube.download_url(url, config.DOWNLOAD_DIR)
+        m(f"    Downloaded to {filepath}")
+
+    player.play_entry(entry, title, args, filepath)
+
+
+def _play_liked(args):
+    if not config.liked_music.exists():
+        e("     No liked songs yet")
+        return
+    liked = config.liked_music.read_text().strip().splitlines()
+    if not liked:
+        e("     No liked songs yet")
+        return
+    if getattr(args, "s", False):
+        random.shuffle(liked)
+    for line in liked:
+        if "|" not in line:
+            continue
+        title, url = line.split("|", 1)
+        _do_search(title)
+        if not _last_results:
+            m(f"    Skipping {title} (not found)")
+            continue
+        entry, _, _ = _last_results[0]
+        _last_played = (entry, title)
+        player.play_entry(entry, title, args)
+
+def like_track():
+    global _last_played
+    if not _last_played:
+        e("     No song currently playing")
+        return
+    entry, title = _last_played
+    url = entry.get("webpage_url") or entry.get("original_url")
+    if not url:
+        e("     No URL for current song")
+        return
+    config.liked_music.parent.mkdir(parents=True, exist_ok=True)
+    existing = config.liked_music.read_text().strip().splitlines() if config.liked_music.exists() else []
+    if any(title in line for line in existing):
+        m(f"    {title} already liked")
+        return
+    with open(config.liked_music, "a") as f:
+        f.write(f"{title}|{url}\n")
+    i(f"    Liked: {title}")
+
+
+def search(query: str):
+    global _last_results
+    if not query:
+        print("Search query required")
+        return
+    _do_search(query)
+    if not _last_results:
+        print("No results found")
+        return
+    for i, (_, title, dur) in enumerate(_last_results, 1):
+        mins, secs = divmod(int(dur), 60)
+        m(f"  {i}. {title}  ({mins}:{secs:02d})")
+
+def download(extra: list[str]):
+    global _last_results
+    arg = " ".join(extra) if extra else None
+    if not arg:
+        e("No song specified")
+        return
+
+    if arg.isdigit():
+        idx = int(arg) - 1
+        if idx < 0 or idx >= len(_last_results):
+            e("     Index out of range")
+            return
+        entry, _, _ = _last_results[idx]
+        url = entry.get("webpage_url") or entry.get("original_url")
+        if not url:
+            e("     No URL found for this entry")
+            return
+        title = entry.get("title", "Unknown")
+        filepath = youtube.download_url(url, config.DOWNLOAD_DIR)
+        i(f"    Downloaded: {title} -> {filepath}")
+    else:
+        _do_search(arg)
+        if not _last_results:
+            e("     No results found")
+            return
+        entry, _, _ = _last_results[0]
+        url = entry.get("webpage_url") or entry.get("original_url")
+        if not url:
+            e("     No URL found for this entry")
+            return
+        title = entry.get("title", "Unknown")
+        filepath = youtube.download_url(url, config.DOWNLOAD_DIR)
+        i(f"    Downloaded: {title} -> {filepath}")
+
+
+def switch_mode():
+    config.Mode = "Offline"
+    config.THEME = config.OFFLINE_THEME
+    m("Switched to Offline mode")
+
+
+def show_help():
+    print(f"{config.THEMES[config.THEME]['theme']}Online Commands:{chr(27)}[0m")
+    for cmd, desc in COMMANDS.items():
+        print(f"  {cmd:12s} {desc}")

flow_twinx/Online/player.py

@@ -0,0 +1,69 @@
+import sys
+import time
+import vlc
+from ..tui import print as tprint
+
+m = tprint(color="grey", border="none")
+e = tprint(color="red", border="none")
+i = tprint(color="theme", border="none")
+
+BAR_WIDTH = 40
+
+
+def _progress_bar(elapsed, total):
+    if total <= 0:
+        return ""
+    fraction = min(elapsed / total, 1.0)
+    filled = int(fraction * BAR_WIDTH)
+    bar = "/" * filled + " " * (BAR_WIDTH - filled)
+    pct = int(fraction * 100)
+    return f"  [{bar}] {pct}%"
+
+
+def play_entry(entry, title, args=None, filepath=None):
+    repeat = args and getattr(args, "r", False)
+
+    while True:
+        instance = vlc.Instance("--no-video --quiet")
+        player = instance.media_player_new()
+
+        if filepath:
+            media = instance.media_new(filepath)
+        else:
+            stream_url = None
+            for fmt in reversed(entry.get("formats", [])):
+                if fmt.get("acodec") != "none":
+                    stream_url = fmt["url"]
+                    break
+            if not stream_url:
+                e("     No playable stream found")
+                return
+            media = instance.media_new(stream_url)
+
+        player.set_media(media)
+        player.play()
+
+        duration = entry.get("duration", 0)
+        dur_min, dur_sec = divmod(int(duration), 60)
+        i(f"\nPlaying : {title}")
+        m(f"    {dur_min}:{dur_sec:02d} | repeat:{args.r} | shuffle:{args.s}")
+
+        start = time.time()
+        try:
+            while player.get_state() not in (vlc.State.Ended, vlc.State.Error):
+                elapsed = time.time() - start
+                bar = _progress_bar(elapsed, duration)
+                sys.stdout.write(f"\r\x1b[36m{bar}\x1b[0m")
+                sys.stdout.flush()
+                time.sleep(0.5)
+        except KeyboardInterrupt:
+            player.stop()
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+            break
+
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+        if not repeat:
+            break

flow_twinx/Online/youtube.py

@@ -0,0 +1,31 @@
+import yt_dlp
+
+ydl_opts = {
+    "quiet": True, "no_warnings": True, "noprogress": True,
+    "noplaylist": True, "format": "bestaudio/best",
+    "default_search": "ytsearch1", "skip_download": True,
+}
+
+ydl_opts_dwn = {
+    "quiet": True, "no_warnings": True, "noprogress": True,
+    "noplaylist": True, "format": "bestaudio/best",
+    "outtmpl": "downloads/%(title)s.%(ext)s",
+}
+
+def search(query, limit=5):
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(f"ytsearch{limit}:{query}", download=False)
+        if not info.get("entries"):
+            return []
+        results = []
+        for entry in info["entries"]:
+            title = entry.get("title", "Unknown")
+            dur = entry.get("duration", 0)
+            results.append((entry, title, dur))
+    return results
+
+def download_url(url, outdir):
+    opts = {**ydl_opts_dwn, "outtmpl": f"{outdir}/%(title)s.%(ext)s"}
+    with yt_dlp.YoutubeDL(opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        return ydl.prepare_filename(info)

flow_twinx/config.py

@@ -0,0 +1,36 @@
+import pathlib
+
+def merge_flags(extra: list[str], args) -> tuple[list[str], object]:
+    mapping = {"-r": "r", "-s": "s", "-d": "d"}
+    rest = []
+    for item in extra:
+        if item in mapping:
+            setattr(args, mapping[item], True)
+        elif item.startswith("-"):
+            print(f"Unknown flag: {item}")
+        else:
+            rest.append(item)
+    return rest, args
+
+
+ONLINE_THEME = "cyan"
+OFFLINE_THEME = "magenta"
+
+THEMES = {
+    "blue":     {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[34m"},
+    "green":    {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[32m"},
+    "red":      {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[31m"},
+    "yellow":   {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[33m"},
+    "magenta":  {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[35m"},
+    "cyan":     {"white": "\033[37m", "grey": "\033[90m", "theme": "\033[36m"},
+}
+
+DOWNLOAD_DIR = pathlib.Path.home() / ".flow/downloads"
+
+VERSION = 0.1
+
+Mode = "Online"
+
+THEME = ONLINE_THEME
+
+liked_music = pathlib.Path.home() / ".flow/liked.txt"

flow_twinx/main.py

@@ -0,0 +1,79 @@
+import argparse
+import importlib
+import sys
+import threading
+import time
+from . import config
+from .tui import show_banner, input as tui_input, print as tui_print
+from .ping import is_connected
+
+
+def _spinner(stop):
+    chars = "|/-\\"
+    i = 0
+    while not stop():
+        sys.stdout.write(f"\r\x1b[36mChecking connection... {chars[i]}\x1b[0m")
+        sys.stdout.flush()
+        time.sleep(0.1)
+        i = (i + 1) % len(chars)
+    sys.stdout.write("\r" + " " * 40 + "\r")
+    sys.stdout.flush()
+
+
+def _load_commands():
+    return importlib.import_module(f".{config.Mode}.commands", package=__package__)
+
+
+def main():
+    stop = False
+    t = threading.Thread(target=_spinner, args=(lambda: stop,), daemon=True)
+    t.start()
+    try:
+        is_connected()
+    finally:
+        stop = True
+        t.join()
+
+    parser = argparse.ArgumentParser(description="Flow Music Player")
+    parser.add_argument("-r", action="store_true", help="repeat mode")
+    parser.add_argument("-s", action="store_true", help="shuffle")
+    parser.add_argument("-d", action="store_true", help="download mode")
+    parser.add_argument("command", nargs="?", default=None, help="subcommand (play, search, list, ...)")
+
+    args, unknown = parser.parse_known_args()
+
+    commands = _load_commands()
+
+    show_banner()
+
+    if args.command:
+        commands.run(args.command, unknown, args)
+    elif unknown:
+        tui_print(color="white", border="double")(f"Unknown argument: {' '.join(unknown)}")
+    else:
+        while True:
+            try:
+                parts = tui_input().strip().split()
+                if not parts:
+                    continue
+                cmd = parts[0].lower()
+                extra = parts[1:]
+                if cmd in ("exit", "quit", "q"):
+                    tui_print(color="grey", border="none")("Goodbye!")
+                    break
+                cmd_args = argparse.Namespace(**vars(args))
+                for flag in ("r", "s", "d"):
+                    setattr(cmd_args, flag, False)
+                commands.run(cmd, extra, cmd_args)
+                if cmd == "switch":
+                    mode = config.Mode
+                    commands = _load_commands()
+                    show_banner()
+                    tui_print(color="grey", border="none")(f"Mode changed to {mode}")
+            except (EOFError, KeyboardInterrupt):
+                tui_print(color="grey", border="none")("\nGoodbye!")
+                break
+
+
+if __name__ == "__main__":
+    main()

flow_twinx/ping.py

@@ -0,0 +1,38 @@
+import socket
+import urllib.request
+from . import config
+
+
+def is_connected(timeout: int = 2, hosts: list[str] | None = None) -> bool:
+    if hosts is None:
+        hosts = ["1.1.1.1"]
+
+    socket.setdefaulttimeout(timeout)
+
+    for host in hosts:
+        try:
+            with urllib.request.urlopen(f"https://{host}", timeout=timeout):
+                pass
+            config.Mode = "Online"
+            config.THEME = config.ONLINE_THEME
+            return True
+        except Exception:
+            pass
+
+        try:
+            socket.create_connection((host, 80), timeout=timeout).close()
+            config.Mode = "Online"
+            config.THEME = config.ONLINE_THEME
+            return True
+        except Exception:
+            continue
+
+    config.Mode = "Offline"
+    config.THEME = config.OFFLINE_THEME
+    return False
+
+
+# if __name__ == "__main__":
+#     connected = is_connected()
+#     print(f"Status : {config.Mode}")
+#     print(f"Returns: {connected}")

flow_twinx/tui.py

@@ -0,0 +1,69 @@
+import builtins
+from . import config
+
+RESET = "\033[0m"
+
+BORDER_CHARS = {
+    "none":   None,
+    "single": ("-", "|", "+"),
+    "double": ("=", "|", "+"),
+    "dashed": ("- ", "!", "+"),
+}
+
+
+def _color_map():
+    colors = config.THEMES.get(config.THEME, config.THEMES["cyan"])
+    return {
+        "white": colors["white"],
+        "grey": colors["grey"],
+        "theme": colors["theme"],
+    }
+
+
+def print(color: str = "white", border: str = "none"):
+    def styled_print(text: str):
+        cm = _color_map()
+        color_code = cm.get(color.lower(), cm["white"])
+        border_style = BORDER_CHARS.get(border.lower())
+
+        if border_style is None:
+            print_line = f"{color_code}{text}{RESET}"
+            builtins.print(print_line)
+        else:
+            h_char, v_char, corner_char = border_style
+            lines = text.split("\n")
+            max_w = max(len(l) for l in lines)
+            width = max_w + 2
+            top_bottom = corner_char + h_char * width + corner_char
+            builtins.print(f"{color_code}{top_bottom}{RESET}")
+            for line in lines:
+                padded = line.ljust(max_w)
+                builtins.print(f"{color_code}{v_char} {padded} {v_char}{RESET}")
+            builtins.print(f"{color_code}{top_bottom}{RESET}")
+
+    return styled_print
+
+
+BANNER = r"""
+███████╗██╗      ██████╗ ██╗    ██╗
+██╔════╝██║     ██╔═══██╗██║    ██║
+█████╗  ██║     ██║   ██║██║ █╗ ██║
+██╔══╝  ██║     ██║   ██║██║███╗██║
+██║     ███████╗╚██████╔╝╚███╔███╔╝
+╚═╝     ╚══════╝ ╚═════╝  ╚══╝╚══╝
+"""
+
+
+def show_banner():
+    p = print(color="theme", border="none")
+    p(BANNER)
+    p = print(color="grey", border="none")
+    p(f"         Flow Music Player v{config.VERSION}")
+    p = print(color="theme", border="none")
+    p(f"         Mode : {config.Mode}")
+    builtins.print()
+
+
+def input(prompt: str = "") -> str:
+    cm = _color_map()
+    return builtins.input(f"{cm['theme']}{prompt}$ {RESET}")

flow_twinx-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: flow-twinx
+Version: 0.1.0
+Summary: A terminal music player with online and offline modes
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: python-vlc
+Requires-Dist: yt_dlp
+
+# Flow
+
+A terminal-based music player with online streaming and offline library modes.
+
+## Features
+
+- **Dual-mode operation** — Automatically detects internet and switches between online streaming and offline playback
+- **Online mode** — Search and stream audio from YouTube via `yt-dlp` and `python-vlc`
+- **Offline mode** — Play local audio files with album support, search, and a liked-songs collection
+- **Download** — Save tracks from YouTube to your local library with the `-d` flag
+- **Repeat & shuffle** — Loop tracks or play in random order
+- **Like/unlike** — Save favorites to a dedicated playlist
+- **Tab completion** — Auto-complete commands and song names in offline mode
+- **Colored TUI** — Cyan theme for online, magenta for offline, with borders and banners
+
+## Requirements
+
+- Python 3
+- [VLC](https://www.videolan.org/vlc/) media player (for `python-vlc` bindings)
+
+## Installation
+
+```bash
+git clone https://github.com/yourusername/flow.git
+cd flow
+python -m venv .venv
+.venv\Scripts\pip install -r requirements.txt
+```
+
+Or use the installer script:
+
+```bash
+bash install.sh
+```
+
+## Usage
+
+```bash
+python main.py [-r] [-s] [-d]
+```
+
+Or direct if you have used install.sh
+
+```bash
+flow <command> <flag>
+```
+
+| Flag | Description                                    |
+| ---- | ---------------------------------------------- |
+| `-r` | Repeat mode (loop current track)               |
+| `-s` | Shuffle mode (random order)                    |
+| `-d` | Download mode (save streamed audio to library) |
+
+### Commands
+
+| Command                | Description                                  |
+| ---------------------- | -------------------------------------------- |
+| `play <name or #>`     | Play a song by name or search result number  |
+| `search <query>`       | Search YouTube (online) or library (offline) |
+| `list`                 | Show all songs, albums, or liked tracks      |
+| `like <name or #>`     | Add a song to your liked collection          |
+| `download <name or #>` | Save a streamed song to the local library    |
+| `switch`               | Toggle between online and offline mode       |
+| `help`                 | Show available commands                      |
+
+## Configuration
+
+- Downloads and library are stored in `~/.flow/downloads/`
+- Liked songs (online) are saved to `~/.flow/liked.txt`
+- Liked songs (offline) are copied to `~/.flow/downloads/liked songs/`
+
+## Project Structure
+
+```
+Flow/
+├── config.py          # Configuration and theme settings
+├── main.py            # Entry point and REPL loop
+├── ping.py            # Internet connectivity check
+├── tui.py             # Terminal UI helpers
+├── requirements.txt   # Python dependencies
+├── install.sh         # Installer script
+├── Online/
+│   ├── commands.py    # Online mode commands
+│   ├── player.py      # VLC streaming player
+│   └── youtube.py     # YouTube search and download
+└── Offline/
+    ├── commands.py    # Offline mode commands
+    ├── file.py        # Library scanner and search
+    └── player.py      # Local file player
+```
+
+## License
+
+MIT

flow_twinx-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+flow_twinx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flow_twinx/config.py,sha256=bCdqtwnnhUL0CBuHyq-KlJ5JqvZJA1DQlaGWh3omf_I,1097
+flow_twinx/main.py,sha256=glmm02sT-N_ANkyzJx_5BAn_kKXvxHDwamVh27KD69k,2488
+flow_twinx/ping.py,sha256=HUbgIt74pQa4Rdho4AI9ETl42jEQiwchyStt3FkDJog,974
+flow_twinx/tui.py,sha256=p4CGCxPIRMBQ6LlGi4L3CbpglsyBx2f66dJxaQExqqk,2255
+flow_twinx/Offline/__init__.py,sha256=lbrqtHeIo65UEFVJ9AXqRGey8zqd4i1PtY5EFx_zu3U,151
+flow_twinx/Offline/commands.py,sha256=N9ZSrakpUM8sZ6zyKUuSEKmF9sGcgbz9T2vyfwKOeYI,5191
+flow_twinx/Offline/file.py,sha256=Thna6vgLY0pAtvvOrhoq-vCVYoDSEzaUnCfsAE_TEDQ,1919
+flow_twinx/Offline/player.py,sha256=WTuzdGMgoY1484mCuJ-3ASB41D236mcaJsGgsJQBxwA,1826
+flow_twinx/Offline/youtube.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flow_twinx/Online/__init__.py,sha256=7VmsUqVyQP7Dhf-tnpi_K0aLs2ZoO0HLWyRvhumF06M,152
+flow_twinx/Online/commands.py,sha256=W7YrbMR5LNNuBWjifQt0FMp-KObZXfkzIUq3GboNJYk,5865
+flow_twinx/Online/player.py,sha256=dJDUD_tDgcFlWM18EdWOYWw8YfXAZ0YSnosBGfL4i0E,2002
+flow_twinx/Online/youtube.py,sha256=wl37V02f6yIkbU4QfhzVY7hbThOXPT8qlYfuOPpb0lo,1069
+flow_twinx-0.1.0.dist-info/METADATA,sha256=3mGOlfS0ZcTLjUbpE8mBAnZXkuvwb0CLxmbF6zVQsTw,3502
+flow_twinx-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+flow_twinx-0.1.0.dist-info/entry_points.txt,sha256=LtE-zIBzzSCt-MCRHoGtyCZ7bpNRd5F5fx-WNmqEWSk,46
+flow_twinx-0.1.0.dist-info/top_level.txt,sha256=d--FYiR1hjT5uDgDi0yb7SDWAFUhpcNq5ndZ4yPpAXw,11
+flow_twinx-0.1.0.dist-info/RECORD,,

flow_twinx-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flow_twinx-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flow = flow_twinx.main:main

flow_twinx-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flow_twinx