lysn 0.1.4__tar.gz

lysn-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wattox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lysn-0.1.4/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: lysn
+Version: 0.1.4
+Summary: TUI music player
+Author: Wattox00
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=0.50.0
+Requires-Dist: python-vlc
+Requires-Dist: yt-dlp
+Dynamic: license-file
+
+# Lysn - cli_music_player
+A Cli music player mainly for Linux

lysn-0.1.4/README.md

@@ -0,0 +1,2 @@
+# Lysn - cli_music_player
+A Cli music player mainly for Linux

lysn-0.1.4/lysn/browse/soundcloud.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+import time
+import logging
+from pathlib import Path
+from yt_dlp import YoutubeDL
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+BASE_DIR = Path.home() / "Music"
+
+def load_set(path: Path):
+    if path.exists():
+        with path.open() as f:
+            return set(x.strip() for x in f if x.strip())
+    return set()
+
+def append_lines(path: Path, lines):
+    with path.open("a") as f:
+        for line in lines:
+            f.write(line + "\n")
+
+def extract_entries(url):
+    ydl_opts = {
+        "quiet": True,
+        "extract_flat": True,
+        "skip_download": True,
+    }
+
+    with YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=False)
+
+    entries = info.get("entries", [])
+    urls = []
+
+    for e in entries:
+        if not e:
+            continue
+        webpage_url = e.get("url") or e.get("webpage_url")
+        if webpage_url:
+            urls.append(webpage_url)
+
+    return urls
+
+def likes_url(username: str) -> str:
+    return f"https://soundcloud.com/{username}/likes"
+
+def playlist_url(username: str, set_name: str, is_user_playlist: bool = False) -> str:
+    return f"https://soundcloud.com/{username}/sets/{set_name}"
+
+def extract_likes(username: str):
+    return extract_entries(likes_url(username))
+
+def extract_playlist(username: str, set_name: str, is_user_playlist: bool = False):
+    return extract_entries(playlist_url(username, set_name, is_user_playlist))
+
+def get_folder_name(username: str, is_likes: bool, set_name: str = None):
+    if is_likes:
+        return f"{username}-likes"
+    return set_name
+
+def download_urls(urls, folder_name: str):
+    target_dir = BASE_DIR / folder_name
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    downloaded_file = target_dir / "downloaded.txt"
+    ignored_file = target_dir / "ignored.txt"
+    errors_file = target_dir / "errors.txt"
+
+    downloaded = load_set(downloaded_file)
+    ignored = load_set(ignored_file)
+    seen = downloaded | ignored
+
+    urls = [u for u in urls if u not in seen]
+
+    if not urls:
+        logger.info("No new tracks")
+        return
+
+    ydl_opts = {
+        "outtmpl": str(target_dir / "%(uploader)s - %(title)s"),
+        "format": "bestaudio/best",
+        "quiet": True,
+        "noplaylist": True,
+    }
+
+    success = []
+    failed = []
+
+    with YoutubeDL(ydl_opts) as ydl:
+        for i, url in enumerate(urls, 1):
+            logger.info(f"{i}/{len(urls)} downloading")
+            try:
+                ydl.download([url])
+                success.append(url)
+            except Exception as e:
+                failed.append((url, str(e)))
+            time.sleep(1)
+
+    append_lines(downloaded_file, success)
+
+    if failed:
+        with errors_file.open("a") as f:
+            f.write(f"\n\nRun @ {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            for url, err in failed:
+                f.write(f"{url}\n{err}\n\n")
+
+
+def run_likes(username: str):
+    logger.info(f"Fetching likes for: {username}")
+    urls = extract_likes(username)
+    folder = get_folder_name(username, is_likes=True)
+    download_urls(urls, folder)
+
+def run_playlist(username: str, set_name: str, is_user_playlist: bool = False):
+    logger.info(f"Fetching playlist: {username} / {set_name}")
+    urls = extract_playlist(username, set_name, is_user_playlist)
+    folder = get_folder_name(username, is_likes=False, set_name=set_name)
+    download_urls(urls, folder)

lysn-0.1.4/lysn/main.py

@@ -0,0 +1,458 @@
+import vlc
+import random
+from pathlib import Path
+
+from textual.binding import Binding
+from textual.app import App, ComposeResult
+from textual.containers import Container, VerticalScroll
+from textual.widgets import (
+    Header,
+    Static,
+    TabbedContent,
+    TabPane,
+    ListView,
+    ListItem,
+    Label,
+)
+
+from browse.soundcloud import run_likes, run_playlist
+
+MUSIC_DIR = Path.home() / "Music"
+
+
+def song_playing(song):
+    return vlc.MediaPlayer(str(song))
+
+
+class Lysn(App):
+    """Lysn"""
+
+    CSS = """
+    Screen {
+        layout: vertical;
+        background: #0b0f14;
+        color: #d0d7de;
+    }
+
+    #main {
+        height: 1fr;
+    }
+
+    TabbedContent {
+        height: 1fr;
+    }
+
+    .tab-box {
+        border: round #30363d;
+        padding: 1 2;
+    }
+
+    .tab-box, .list-view {
+        background: #0b0f14;
+        color: #d0d7de;
+    }
+    
+    .list-view {
+        height: 1fr;
+    }
+
+    #player_bar {
+        height: 4;
+        border-top: solid #30363d;
+        padding: 0 1;
+        background: #0b0f14;
+        color: #c9d1d9;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("enter", "open_item", "Open"),
+        Binding("backspace", "go_back", "Back"),
+        # Playback controls
+        Binding("space", "pausesong", "Pause Song"),
+        Binding("s", "stopsong", "Stop Song"),
+        Binding("r", "restartsong", "Restart Song"),
+        Binding("n", "next_song", "Next Song"),
+        Binding("b", "prev_song", "Previous Song"),
+        # Seeking
+        Binding("d", "forwardsong", "Seek 10 sec"),
+        Binding("a", "backwardsong", "Go back 10 sec"),
+        # Volume
+        Binding("w", "volumeup", "Volume Up"),
+        Binding("x", "volumedown", "Volume Down"),
+        Binding("m", "volumemute", "Mute"),
+        # Album action
+        Binding("p", "play_album", "Play Album"),
+        Binding("z", "shuffle_album", "Shuffle Album"),
+
+        Binding("down", "focus_tab_content", "Enter Tab"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+        with Container(id="main"):
+            with TabbedContent(id="tabs"):
+                with TabPane("Albums", id="albums_tab"):
+                    self.album_list = ListView(classes="tab-box")
+                    yield self.album_list
+
+                with TabPane("Browse", id="browse_tab"):
+                    self.browser_list = ListView(classes="tab-box")
+                    yield self.browser_list
+
+                with TabPane("Help"):
+                    with VerticalScroll():
+                        yield Static(
+            """
+NAVIGATION
+----------
+[↑ / ↓]        Move selection
+[Enter]        Open item / Confirm
+[Backspace]    Go back
+
+PLAYBACK CONTROLS
+-----------------
+[Space]        Pause / Resume
+[S]            Stop
+[R]            Restart song
+[N]            Next song
+[B]            Previous song
+
+SEEKING
+-------
+[D]            Forward 10 seconds
+[A]            Backward 10 seconds
+
+VOLUME
+------
+[W]            Volume up
+[X]            Volume down
+[M]            Mute toggle
+
+ALBUM ACTIONS
+-------------
+[P]            Play album
+[Z]            Shuffle album
+
+QUIT
+----
+[Q]            Exit application
+
+FOR MORE CHECK OUT THE FULL DOCUMENTATION ON:
+https://github.com/wattox00/lysn
+            """,
+                            classes="tab-box",
+                            markup=False,
+                        )
+
+        self.player_text = Static("No song playing", id="player_bar")
+        yield self.player_text
+
+    def on_mount(self) -> None:
+        self.current_path = MUSIC_DIR
+        self.history = []
+        self.browser_mode = "root"
+        self.refresh_list()
+        self.refresh_browser()
+        self.set_interval(1, self.check_song_end)
+        self.set_interval(1, self.update_player_bar)
+        self.muted = False
+        self.sc_user = "your_username"
+        self.sc_set = "your_playlist"
+        self.input_mode = None
+        self.input_buffer = ""
+        self.pending_action = None
+
+    def get_active_tab(self):
+        tabs = self.query_one("#tabs", TabbedContent)
+        return tabs.active
+
+    #Player
+    def check_song_end(self):
+        if hasattr(self, "player") and hasattr(self, "playlist"):
+            if self.player.get_state() == vlc.State.Ended:
+                self.action_next_song()
+
+    def play_song_list(self, songs):
+        if not songs:
+            return
+
+        self.playlist = songs
+        self.current_index = 0
+        self.play_current_song()
+
+    def play_current_song(self):
+        if not hasattr(self, "playlist") or not self.playlist:
+            return
+
+        song = self.playlist[self.current_index]
+
+        if hasattr(self, "player"):
+            self.player.stop()
+
+        self.player = song_playing(song)
+        self.volume = getattr(self, "volume", 50)
+        self.player.audio_set_volume(self.volume)
+        self.player.play()
+        self.player_text.update(f"Playing: {song.name}")
+
+    # Album Nav
+    def refresh_list(self):
+        self.album_list.clear()
+        items = sorted(self.current_path.iterdir(), key=lambda x: (x.is_file(), x.name.lower()))
+
+        for item in items:
+            label = f"[DIR] {item.name}" if item.is_dir() else item.name
+            self.album_list.append(ListItem(Label(label)))
+
+    def open_album_item(self):
+        if self.album_list.index is None:
+            return
+
+        items = sorted(self.current_path.iterdir(), key=lambda x: (x.is_file(), x.name.lower()))
+        selected = items[self.album_list.index]
+
+        if selected.is_dir():
+            self.history.append(self.current_path)
+            self.current_path = selected
+            self.refresh_list()
+
+    def action_go_back(self) -> None:
+        if self.get_active_tab() == "albums_tab":
+            if self.history:
+                self.current_path = self.history.pop()
+                self.refresh_list()
+
+        elif self.get_active_tab() == "browse_tab":
+            if self.browser_mode == "soundcloud_menu":
+                self.browser_mode = "root"
+                self.refresh_browser()
+
+    def get_album_songs(self):
+        return [f for f in self.current_path.iterdir() if f.is_file()]
+
+    def action_play_album(self) -> None:
+        if self.current_path == MUSIC_DIR:
+            return
+
+        songs = sorted(self.get_album_songs())
+        self.play_song_list(songs)
+
+    def action_shuffle_album(self) -> None:
+        if self.current_path == MUSIC_DIR:
+            return
+
+        songs = self.get_album_songs()
+        random.shuffle(songs)
+        self.play_song_list(songs)
+
+    def action_focus_tab_content(self):
+        if self.get_active_tab() == "albums_tab":
+            self.album_list.focus()
+        elif self.get_active_tab() == "browse_tab":
+            self.browser_list.focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        if event.list_view is self.album_list:
+            self.open_album_item()
+        elif event.list_view is self.browser_list:
+            self.open_browser_item()
+
+    # Browse
+    def refresh_browser(self):
+        self.browser_list.clear()
+
+        if self.browser_mode == "root":
+            options = ["SoundCloud", "Spotify"]
+        elif self.browser_mode == "soundcloud_menu":
+            options = ["Likes", "Albums", "Playlists"]
+        else:
+            options = []
+
+        for opt in options:
+            item = ListItem(Label(opt))
+            item.data = opt
+            self.browser_list.append(item)
+
+    def open_browser_item(self):
+        if self.browser_list.index is None:
+            return
+
+        item = self.browser_list.children[self.browser_list.index]
+        label = item.data
+
+        if self.browser_mode == "root":
+            if label == "SoundCloud":
+                self.browser_mode = "soundcloud_menu"
+                self.refresh_browser()
+
+        elif self.browser_mode == "soundcloud_menu":
+            if label == "Likes":
+                self.input_mode = "username"
+                self.pending_action = "likes"
+                self.input_buffer = ""
+                self.player_text.update("Enter username:")
+
+            elif label == "Albums":
+                self.input_mode = "username"
+                self.pending_action = "album"
+                self.input_buffer = ""
+                self.player_text.update("Enter username:")
+
+            elif label == "Playlists":
+                self.input_mode = "username"
+                self.pending_action = "playlist"
+                self.input_buffer = ""
+                self.player_text.update("Enter username:")
+
+    def action_open_item(self) -> None:
+        if self.get_active_tab() == "albums_tab":
+            self.open_album_item()
+        elif self.get_active_tab() == "browse_tab":
+            self.open_browser_item()
+
+    # Player bar
+    def update_player_bar(self):
+        if not hasattr(self, "player"):
+            return
+
+        state = self.player.get_state()
+
+        icon = {
+            vlc.State.Playing: "›",
+            vlc.State.Paused: "‖",
+        }.get(state, "·")
+
+        current = max(0, self.player.get_time() // 1000)
+        total = max(1, self.player.get_length() // 1000)
+
+        progress = current / total
+        bar_len = 30
+        filled = int(progress * bar_len)
+
+        bar = "─" * filled + " " * (bar_len - filled)
+
+        def fmt(t):
+            return f"{t//60:02}:{t%60:02}"
+
+        time_str = f"{fmt(current)} / {fmt(total)}"
+
+        vol = getattr(self, "volume", 0)
+        muted = getattr(self, "muted", False)
+        vol_str = "MUTE" if muted else f"VOL {vol:02}"
+
+        song = "No song"
+        if hasattr(self, "playlist"):
+            song = self.playlist[self.current_index].name
+
+        line1 = f"{icon} {song[:40]}"
+
+        line2 = f"[{bar}] {time_str}   {vol_str}"
+
+        self.player_text.update(f"{line1}\n{line2}")
+
+    def action_playsong(self) -> None:
+        self.play_current_song()
+
+    def action_stopsong(self) -> None:
+        if hasattr(self, "player"):
+            self.player.stop()
+
+    def action_pausesong(self) -> None:
+        if hasattr(self, "player"):
+            self.player.pause()
+
+    def action_restartsong(self) -> None:
+        if hasattr(self, "player"):
+            self.player.set_time(0)
+
+    def action_forwardsong(self) -> None:
+        if hasattr(self, "player"):
+            self.player.set_time(self.player.get_time() + 10000)
+
+    def action_backwardsong(self) -> None:
+        if hasattr(self, "player"):
+            self.player.set_time(self.player.get_time() - 10000)
+
+    def action_volumeup(self) -> None:
+        if hasattr(self, "player"):
+            self.volume = min(self.volume + 5, 100)
+            self.player.audio_set_volume(self.volume)
+
+    def action_volumedown(self) -> None:
+        if hasattr(self, "player"):
+            self.volume = max(self.volume - 5, 0)
+            self.player.audio_set_volume(self.volume)
+
+    def action_volumemute(self) -> None:
+        if hasattr(self, "player"):
+            self.muted = not self.muted
+            self.player.audio_set_mute(self.muted)
+
+    def action_next_song(self) -> None:
+        if not hasattr(self, "playlist") or not self.playlist:
+            return
+
+        self.current_index += 1
+        if self.current_index >= len(self.playlist):
+            self.current_index = 0
+
+        self.play_current_song()
+
+    def action_prev_song(self) -> None:
+        if not hasattr(self, "playlist") or not self.playlist:
+            return
+
+        self.current_index -= 1
+        if self.current_index < 0:
+            self.current_index = len(self.playlist) - 1
+
+        self.play_current_song()
+
+    # prompt typing
+    def on_key(self, event):
+        if not self.input_mode:
+            return
+
+        if event.key == "enter":
+            if self.input_mode == "username":
+                self.temp_username = self.input_buffer
+                self.input_buffer = ""
+
+                if self.pending_action == "likes":
+                    self.player_text.update("Downloading likes...")
+                    run_likes(self.temp_username)
+                    self.player_text.update(f"Done: {self.temp_username}")
+                    self.input_mode = None
+
+                else:
+                    self.input_mode = "setname"
+                    self.player_text.update("Enter name:")
+
+            elif self.input_mode == "setname":
+                setname = self.input_buffer
+                self.input_buffer = ""
+
+                self.player_text.update("Downloading...")
+                run_playlist(
+                    self.temp_username,
+                    setname,
+                    self.pending_action == "playlist"
+                )
+                self.player_text.update(f"Done: {setname}")
+
+                self.input_mode = None
+
+        elif event.key == "backspace":
+            self.input_buffer = self.input_buffer[:-1]
+
+        elif event.character:
+            self.input_buffer += event.character
+
+        self.player_text.update(f"> {self.input_buffer}")
+
+if __name__ == "__main__":
+    app = Lysn()
+    app.run()

lysn-0.1.4/lysn.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: lysn
+Version: 0.1.4
+Summary: TUI music player
+Author: Wattox00
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=0.50.0
+Requires-Dist: python-vlc
+Requires-Dist: yt-dlp
+Dynamic: license-file
+
+# Lysn - cli_music_player
+A Cli music player mainly for Linux

lysn-0.1.4/lysn.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+lysn/main.py
+lysn.egg-info/PKG-INFO
+lysn.egg-info/SOURCES.txt
+lysn.egg-info/dependency_links.txt
+lysn.egg-info/entry_points.txt
+lysn.egg-info/requires.txt
+lysn.egg-info/top_level.txt
+lysn/browse/__init__.py
+lysn/browse/soundcloud.py

lysn-0.1.4/lysn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lysn-0.1.4/lysn.egg-info/entry_points.txt

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

lysn-0.1.4/lysn.egg-info/requires.txt

@@ -0,0 +1,3 @@
+textual>=0.50.0
+python-vlc
+yt-dlp

lysn-0.1.4/lysn.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+lysn

lysn-0.1.4/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lysn"
+version = "0.1.4"
+description = "TUI music player"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+
+authors = [
+  { name = "Wattox00" }
+]
+
+dependencies = [
+  "textual>=0.50.0",
+  "python-vlc",
+  "yt-dlp",
+]
+
+[project.scripts]
+lysn = "lysn.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

lysn-0.1.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+