tunewrangler 1.0.0__py3-none-any.whl

tunewrangler/__init__.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+from platformdirs import user_data_dir
+
+APP_NAME = "TuneWrangler"
+APP_AUTHOR = "Alexandre Chabot-Leclerc"
+
+SPOTIFY_USERNAME = "example-spotify-user"
+LASTFM_USERNAME = "example-lastfm-user"
+
+HERE_DIR = Path(__file__).parent.absolute()
+DATA_DIR = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+TRACK_PLAYLISTS = {
+    2021: "YOUR_PLAYLIST_01_ID",
+    2022: "YOUR_PLAYLIST_02_ID",
+    2023: "YOUR_PLAYLIST_03_ID",
+    2024: "YOUR_PLAYLIST_04_ID",
+    2025: "YOUR_PLAYLIST_05_ID",
+}
+ALBUM_PLAYLIST = {
+    2021: "YOUR_PLAYLIST_06_ID",
+    2022: "YOUR_PLAYLIST_07_ID",
+    2023: "YOUR_PLAYLIST_08_ID",
+    2024: "YOUR_PLAYLIST_09_ID",
+    2025: "YOUR_PLAYLIST_10_ID",
+}
+RELEASE_RADAR_PLAYLIST = "YOUR_PLAYLIST_11_ID"
+RELEASE_SINGLES_PLAYLIST = "YOUR_PLAYLIST_12_ID"
+RELEASE_ALBUMS_PLAYLIST = "YOUR_PLAYLIST_13_ID"

tunewrangler/__main__.py

@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

tunewrangler/cli.py

@@ -0,0 +1,415 @@
+"""
+Automation to save tracks or albums in Spotify.
+"""
+
+import logging
+import shutil
+import subprocess
+from datetime import datetime
+from functools import wraps
+from getpass import getpass
+
+import click
+import keyring
+
+from tunewrangler import HERE_DIR
+from tunewrangler.tidal_api import TidalRateLimitError, TidalUnsupportedFeatureError
+from tunewrangler.tidal_client import TidalClient
+from tunewrangler.spotify_client import SpotifyClient
+from tunewrangler.errors import (
+    AlbumIsSingleError,
+    PlaylistExistsError,
+    NotPlayingError,
+    TrackNotFoundError,
+)
+from tunewrangler.last_fm_client import LastFmClient
+
+logger = logging.getLogger(__name__)
+
+
+def handle_tidal_rate_limit(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except TidalRateLimitError as error:
+            raise click.ClickException(str(error)) from error
+        except TrackNotFoundError as error:
+            raise click.ClickException(str(error)) from error
+        except TidalUnsupportedFeatureError as error:
+            raise click.ClickException(str(error)) from error
+
+    return wrapper
+
+
+def notify(title, message, subtitle=""):
+    notificator_path = (
+        HERE_DIR.parent
+        / "TuneWranglerNotificator.app"
+        / "Contents"
+        / "Resources"
+        / "Scripts"
+        / "notificator"
+    )
+    if not shutil.which(notificator_path):
+        logger.error("Notification script not found.")
+        return
+
+    cmd = [
+        notificator_path,
+        "--title",
+        title,
+        "--subtitle",
+        subtitle,
+        "--message",
+        message,
+    ]
+    subprocess.run(cmd)
+
+
+class Client:
+    def __init__(self, music_client, lastfm_client):
+        self.music_client = music_client
+        self.lastfm_client = lastfm_client
+
+    def save_current_track(self):
+        track_info = self.music_client.save_current_track()
+        if track_info is None:
+            notify("Oops!", "Something went wrong. Nothing is playing.")
+        else:
+            artist_name, track_name, track_id = track_info
+        self.music_client.save_track_to_weekly_playlist(track_id)
+        self.lastfm_client.save_track(artist_name, track_name)
+
+        # Success, don't notify
+        # notify("🎶 Saved Track", f"Saved track {artist_name} - {track_name}")
+
+    def save_current_album(self):
+        artist_name, album_name = self.music_client.save_current_album()
+        # success, don't notify
+        # notify("💿 Saved Album", f"Saved album {artist_name} - {album_name}")
+
+    def favorite_current_track(self):
+        self.music_client.favorite_current_track()
+
+    def favorite_current_album(self):
+        self.music_client.favorite_current_album()
+
+    def save_album_of_current_track_in_new_playlist(self):
+        try:
+            (
+                artist_name,
+                album_name,
+            ) = self.music_client.save_album_of_current_track_in_new_playlist()
+        except NotPlayingError:
+            notify("Nothing Playing", "⛔️🎵")
+            notify(
+                "❌ Album is a Single",
+                f"This album wasn't saved because it's a single.",
+            )
+        except PlaylistExistsError:
+            notify(
+                "❌ Album already exists", f"There's already a playlist with that name."
+            )
+        except TrackNotFoundError:
+            notify("❌ Track Not Found", f"Could not find a matching track in Tidal.")
+        else:
+            # Success, don't notify
+            # notify(
+            #     "✅ Saved New Playlist",
+            #     f"Saved new playlist {artist_name} - {album_name}.",
+            # )
+            pass
+
+
+@click.group()
+@click.option(
+    "-s",
+    "--service",
+    type=click.Choice(["tidal", "spotify"], case_sensitive=False),
+    default="tidal",
+    help="Music provider. Default is Tidal.",
+)
+@click.option("-v", "--verbose", count=True, help="Increase verbosity.")
+@click.option("-d", "--debug", is_flag=True, help="Start debugger on exceptions.")
+@click.pass_context
+def cli(ctx, service, verbose, debug):
+    logging_level = logging.WARN - 10 * verbose
+    logging.basicConfig(level=logging_level)
+    ctx.ensure_object(dict)
+    ctx.obj["DEBUG"] = debug
+    if service == "tidal":
+        ctx.obj["MUSIC_CLIENT"] = TidalClient()
+    elif service == "spotify":
+        ctx.obj["MUSIC_CLIENT"] = SpotifyClient()
+    ctx.obj["LASTFM_CLIENT"] = LastFmClient()
+
+
+@cli.group(name="save")
+def save_group():
+    """Save current playback items to your music services."""
+
+
+@save_group.command(name="track")
+@click.pass_context
+@handle_tidal_rate_limit
+def save_track(ctx):
+    """Save current track to library, weekly playlist, and Last.fm."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+    ctx.obj["LASTFM_CLIENT"].authenticate()
+
+    client = Client(ctx.obj["MUSIC_CLIENT"], ctx.obj["LASTFM_CLIENT"])
+    client.save_current_track()
+
+
+@save_group.command(name="album")
+@click.pass_context
+@handle_tidal_rate_limit
+def save_album(ctx):
+    """Save current album to your music library."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    client = Client(ctx.obj["MUSIC_CLIENT"], None)
+    client.save_current_album()
+
+
+@cli.group(name="collect")
+def collect_group():
+    """Collect current playback items for later listening."""
+
+
+@collect_group.command(name="album")
+@click.pass_context
+@handle_tidal_rate_limit
+def collect_album(ctx):
+    """Create a playlist from the current album."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    client = Client(ctx.obj["MUSIC_CLIENT"], None)
+    client.save_album_of_current_track_in_new_playlist()
+
+
+@cli.group(name="favorite")
+def favorite_group():
+    """Favorite current playback items and file them by year."""
+
+
+@favorite_group.command(name="track")
+@click.pass_context
+@handle_tidal_rate_limit
+def favorite_track(ctx):
+    """Save current track to library and this year's playlist."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    client = Client(ctx.obj["MUSIC_CLIENT"], None)
+    client.favorite_current_track()
+
+
+@favorite_group.command(name="album")
+@click.pass_context
+@handle_tidal_rate_limit
+def favorite_album(ctx):
+    """Save current album to library and this year's albums playlist."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    client = Client(ctx.obj["MUSIC_CLIENT"], None)
+    client.favorite_current_album()
+
+
+@cli.group(name="list")
+def list_group():
+    """List music service resources."""
+
+
+@list_group.command(name="playlists")
+@click.pass_context
+@handle_tidal_rate_limit
+def list_playlists(ctx):
+    """List all playlists."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    for name in music_client.list_playlist_names():
+        click.echo(name)
+
+
+@cli.group(name="refresh")
+def refresh_group():
+    """Refresh locally cached music service data."""
+
+
+@refresh_group.command(name="playlists")
+@click.pass_context
+@handle_tidal_rate_limit
+def refresh_playlists(ctx):
+    """Refresh playlist cache where supported."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    music_client.update_playlist_cache()
+
+
+@cli.group(name="url")
+def url_group():
+    """Print URLs for current playback items."""
+
+
+@url_group.command(name="track")
+@click.pass_context
+@handle_tidal_rate_limit
+def track_url(ctx):
+    """Print URL of current track."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    click.echo(music_client.get_url_of_current_track())
+
+
+@url_group.command(name="album")
+@click.pass_context
+@handle_tidal_rate_limit
+def album_url(ctx):
+    """Print URL of current album."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    click.echo(music_client.get_url_of_current_album())
+
+
+@url_group.command(name="weekly")
+@click.pass_context
+@handle_tidal_rate_limit
+def weekly_playlist_url(ctx):
+    """Print this week's playlist URL."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    url = music_client.get_weekly_playlist_url()
+    click.echo(url)
+
+
+@cli.group(name="link")
+def link_group():
+    """Print formatted links for current playback items."""
+
+
+@link_group.command(name="track")
+@click.pass_context
+@handle_tidal_rate_limit
+def track_link(ctx):
+    """Print Markdown link for current track."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    info = music_client.get_current_track_info()
+    url = music_client.get_url_of_current_track()
+    click.echo(f"[{info['artist']} - {info['title']}]({url})")
+
+
+@link_group.command(name="album")
+@click.pass_context
+@handle_tidal_rate_limit
+def album_link(ctx):
+    """Print Markdown link for current album."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    info = music_client.get_current_track_info()
+    url = music_client.get_url_of_current_album()
+    click.echo(f"[{info['artist']} - {info['album']}]({url})")
+
+
+@link_group.command(name="weekly")
+@click.pass_context
+@handle_tidal_rate_limit
+def weekly_link(ctx):
+    """Print Markdown link for this week's playlist."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    url = music_client.get_weekly_playlist_url()
+    click.echo(f"[{datetime.now().strftime('%Y-W%V')}]({url})")
+
+
+@cli.group(name="split")
+def split_group():
+    """Split music service resources."""
+
+
+@split_group.command(name="releases")
+@click.pass_context
+@handle_tidal_rate_limit
+def split_releases(ctx):
+    """Split new release singles and albums."""
+    ctx.obj["MUSIC_CLIENT"].authenticate()
+
+    music_client = ctx.obj["MUSIC_CLIENT"]
+    music_client.split_new_release_singles_and_albums()
+
+
+@cli.group(name="auth")
+def auth_group():
+    """Manage service credentials."""
+
+
+@auth_group.command(name="set")
+@click.option(
+    "--service",
+    type=click.Choice(["spotify", "lastfm", "tidal"]),
+    help="Specify service for setting keys",
+)
+@click.pass_context
+def keys_set(ctx, service):
+    """Set API keys for Spotify, LastFM, or TIDAL."""
+    if service == "spotify":
+        client_id = getpass("Enter your Spotify client-id: ")
+        client_secret = getpass("Enter your Spotify client-secret: ")
+        keyring.set_password(
+            "tunewrangler-spotify-client-id",
+            "tunewrangler-spotify-client-id",
+            client_id,
+        )
+        keyring.set_password(
+            "tunewrangler-spotify-client-secret",
+            "tunewrangler-spotify-client-secret",
+            client_secret,
+        )
+        click.echo("Spotify keys set successfully.")
+    elif service == "lastfm":
+        api_key = getpass("Enter your LastFM api-key: ")
+        shared_secret = getpass("Enter your LastFM shared-secret: ")
+        password = getpass("Enter your LastFM password: ")
+        keyring.set_password(
+            "tunewrangler-last-fm-api-key", "tunewrangler-last-fm-api-key", api_key
+        )
+        keyring.set_password(
+            "tunewrangler-last-fm-shared-secret",
+            "tunewrangler-last-fm-shared-secret",
+            shared_secret,
+        )
+        keyring.set_password(
+            "tunewrangler-last-fm-password",
+            "tunewrangler-last-fm-password",
+            password,
+        )
+        click.echo("LastFM keys set successfully.")
+    elif service == "tidal":
+        client_id = getpass("Enter your TIDAL client-id: ")
+        redirect_uri = getpass("Enter your TIDAL redirect URI: ")
+        keyring.set_password(
+            "tunewrangler-tidal-client-id",
+            "tunewrangler-tidal-client-id",
+            client_id,
+        )
+        keyring.set_password(
+            "tunewrangler-tidal-redirect-uri",
+            "tunewrangler-tidal-redirect-uri",
+            redirect_uri,
+        )
+        click.echo("TIDAL keys set successfully.")
+    else:
+        click.echo("Please specify a service: --service [spotify|lastfm|tidal]")
+
+
+if __name__ == "__main__":
+    cli(obj={})

tunewrangler/errors.py

@@ -0,0 +1,22 @@
+class SpotifyControlError(BaseException):
+    pass
+
+
+class AlbumIsSingleError(SpotifyControlError):
+    pass
+
+
+class PlaylistExistsError(SpotifyControlError):
+    pass
+
+
+class AuthenticationError(SpotifyControlError):
+    pass
+
+
+class NotPlayingError(SpotifyControlError):
+    pass
+
+
+class TrackNotFoundError(SpotifyControlError):
+    pass

tunewrangler/last_fm_client.py

@@ -0,0 +1,68 @@
+from tunewrangler import LASTFM_USERNAME
+from tunewrangler.errors import AuthenticationError
+
+import keyring
+import pylast
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def missing_key_message(key_name):
+    return (
+        f"Cannot find {key_name!r} in the keychain. "
+        "Have you set your keys with `tunewrangler auth set`?"
+    )
+
+
+class LastFmClient:
+    def __init__(self):
+        self.username = LASTFM_USERNAME
+        self.lastfm = None
+
+    def authenticate(self):
+        try:
+            logging.info("Logging in to LastFM")
+            api_key = keyring.get_password(
+                "tunewrangler-last-fm-api-key", "tunewrangler-last-fm-api-key"
+            )
+            if api_key is None:
+                raise AuthenticationError(
+                    missing_key_message("tunewrangler-last-fm-api-key")
+                )
+
+            api_secret = keyring.get_password(
+                "tunewrangler-last-fm-shared-secret",
+                "tunewrangler-last-fm-shared-secret",
+            )
+            if api_secret is None:
+                raise AuthenticationError(
+                    missing_key_message("tunewrangler-last-fm-shared-secret")
+                )
+
+            password = keyring.get_password(
+                "tunewrangler-last-fm-password", "tunewrangler-last-fm-password"
+            )
+            if password is None:
+                raise AuthenticationError(
+                    missing_key_message("tunewrangler-last-fm-password")
+                )
+
+            self.lastfm = pylast.LastFMNetwork(
+                api_key=api_key,
+                api_secret=api_secret,
+                username=self.username,
+                password_hash=pylast.md5(password),
+            )
+        except Exception as e:
+            logger.error("Authentication failed: %s", e)
+            raise AuthenticationError("Can't authenticate to LastFM.")
+
+    def save_track(self, artist_name, track_name):
+        logging.info(
+            f"LastFmClient: getting current track: {artist_name} - {track_name}"
+        )
+        track = self.lastfm.get_track(artist_name, track_name)
+        logging.debug(f"Found track: {track}, {vars(track)}")
+        track.love()
+        logger.info(f"LastFM loved track: {track.artist.name} - {track.title}")