spotapi 0.0.0__py3-none-any.whl

spotapi/song.py

@@ -0,0 +1,234 @@
+import json
+from typing import Any, Generator, List, Mapping, Optional, Tuple
+
+from spotapi.exceptions import SongError
+from spotapi.http.request import TLSClient
+from spotapi.client import BaseClient
+from spotapi.playlist import PrivatePlaylist, PublicPlaylist
+
+
+class Song(BaseClient):
+    """
+    Extends the PrivatePlaylist class with methods that can only be used while logged in.
+    These methods interact with songs and tend to be used in the context of a playlist.
+    """
+
+    def __init__(
+        self,
+        playlist: Optional[PrivatePlaylist] = None,
+        *,
+        client: Optional[TLSClient] = TLSClient("chrome_120", "", auto_retries=3),
+    ) -> None:
+        self.playlist = playlist
+        super().__init__(client=playlist.client if playlist else client)
+
+    def query_songs(
+        self, query: str, /, limit: Optional[int] = 10, *, offset: Optional[int] = 0
+    ) -> Mapping[str, Any]:
+        """
+        Searches for songs in the Spotify catalog.
+        """
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        params = {
+            "operationName": "searchDesktop",
+            "variables": json.dumps(
+                {
+                    "searchTerm": query,
+                    "offset": offset,
+                    "limit": limit,
+                    "numberOfTopResults": 5,
+                    "includeAudiobooks": True,
+                    "includeArtistHasConcertsField": False,
+                    "includePreReleases": True,
+                    "includeLocalConcertsField": False,
+                }
+            ),
+            "extensions": json.dumps(
+                {
+                    "persistedQuery": {
+                        "version": 1,
+                        "sha256Hash": self.part_hash("searchDesktop"),
+                    }
+                }
+            ),
+        }
+
+        resp = self.client.post(url, params=params, authenticate=True)
+
+        if resp.fail:
+            raise SongError("Could not get songs", error=resp.error.string)
+
+        if not isinstance(resp.response, Mapping):
+            raise SongError("Invalid JSON")
+
+        return resp.response
+
+    def paginate_songs(self, query: str, /) -> Generator[Mapping[str, Any], None, None]:
+        """
+        Generator that fetches songs in chunks
+
+        Note: If total_tracks <= 100, then there is no need to paginate
+        """
+        UPPER_LIMIT: int = 100
+        # We need to get the total songs first
+        songs = self.query_songs(query, limit=UPPER_LIMIT)
+        total_count: int = songs["data"]["searchV2"]["tracksV2"]["totalCount"]
+
+        yield songs["data"]["searchV2"]["tracksV2"]["items"]
+
+        if total_count <= UPPER_LIMIT:
+            return
+
+        offset = UPPER_LIMIT
+        while offset < total_count:
+            yield self.query_songs(query, limit=UPPER_LIMIT, offset=offset)["data"][
+                "searchV2"
+            ]["tracksV2"]["items"]
+            offset += UPPER_LIMIT
+
+    def add_song_to_playlist(self, song_id: str, /) -> None:
+        """Adds a song to the playlist"""
+        if not self.playlist or not hasattr(self.playlist, "playlist_id"):
+            raise ValueError("Playlist not set")
+
+        if "track" in song_id:
+            song_id = song_id.split("track/")[1]
+
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        payload = {
+            "variables": {
+                "uris": [f"spotify:track:{song_id}"],
+                "playlistUri": f"spotify:playlist:{self.playlist.playlist_id}",
+                "newPosition": {"moveType": "BOTTOM_OF_PLAYLIST", "fromUid": None},
+            },
+            "operationName": "addToPlaylist",
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": self.part_hash("addToPlaylist"),
+                }
+            },
+        }
+        resp = self.client.post(url, json=payload, authenticate=True)
+
+        if resp.fail:
+            raise SongError("Could not add song to playlist", error=resp.error.string)
+
+    def __stage_remove_song(self, uids: List[str]) -> None:
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        payload = {
+            "variables": {
+                "playlistUri": f"spotify:playlist:{self.playlist.playlist_id}",
+                "uids": uids,
+            },
+            "operationName": "removeFromPlaylist",
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": self.part_hash("removeFromPlaylist"),
+                }
+            },
+        }
+
+        resp = self.client.post(url, json=payload, authenticate=True)
+
+        if resp.fail:
+            raise SongError(
+                "Could not remove song from playlist", error=resp.error.string
+            )
+
+    def __parse_playlist_items(
+        self,
+        items: List[Mapping[str, Any]],
+        song_id: Optional[str] = None,
+        song_name: Optional[str] = None,
+        all_instances: Optional[bool] = False,
+    ) -> Tuple[List[str], bool]:
+        uids: List[str] = []
+        for item in items:
+            is_song_id = song_id and song_id in item["itemV2"]["data"]["uri"]
+            is_song_name = (
+                song_name
+                and song_name.lower() in str(item["itemV2"]["data"]["name"]).lower()
+            )
+
+            if is_song_id or is_song_name:
+                uids.append(item["uid"])
+
+                if all_instances:
+                    return uids, True
+
+        return uids, False
+
+    def remove_song_from_playlist(
+        self,
+        *,
+        uid: Optional[str] = None,
+        song_id: Optional[str] = None,
+        song_name: Optional[str] = None,
+        all_instances: Optional[bool] = False,
+    ) -> None:
+        """
+        Removes a song from the playlist.
+        If all_instances is True, only song_name can be used.
+        """
+        if song_id and "track" in song_id:
+            song_id = song_id.split("track:")[1]
+
+        if not (song_id or song_name or uid):
+            raise ValueError("Must provide either song_id or song_name or uid")
+
+        if all_instances and song_id:
+            raise ValueError("Cannot provide both song_id and all_instances")
+
+        if not self.playlist or not hasattr(self.playlist, "playlist_id"):
+            raise ValueError("Playlist not set")
+
+        playlist = PublicPlaylist(self.playlist.playlist_id).paginate_playlist()
+
+        uids: List[str] = []
+        if not uid:
+            for playlist_chunk in playlist:
+                items = playlist_chunk["items"]
+                extended_uids, stop = self.__parse_playlist_items(
+                    items,
+                    song_id=song_id,
+                    song_name=song_name,
+                    all_instances=all_instances,
+                )
+                uids.extend(extended_uids)
+
+                if stop:
+                    playlist.close()
+                    break
+        else:
+            uids.append(uid)
+
+        if len(uids) == 0:
+            raise SongError("Song not found in playlist")
+
+        self.__stage_remove_song(uids)
+
+    def like_song(self, song_id: str, /) -> None:
+        if not self.playlist or not hasattr(self.playlist, "playlist_id"):
+            raise ValueError("Playlist not set")
+
+        if song_id and "track" in song_id:
+            song_id = song_id.split("track:")[1]
+
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        payload = {
+            "variables": {"uris": [f"spotify:track:{song_id}"]},
+            "operationName": "addToLibrary",
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": self.part_hash("addToLibrary"),
+                }
+            },
+        }
+
+        resp = self.client.post(url, json=payload, authenticate=True)
+
+        if resp.fail:
+            raise SongError("Could not like song", error=resp.error.string)

spotapi/user.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from spotapi.exceptions import UserError
+from spotapi.login import Login
+
+
+class User(Login):
+    """
+    Represents a Spotify user.
+    """
+
+    def __new__(cls, login: Login) -> User:
+        instance = super(User, cls).__new__(cls)
+        instance.__dict__.update(login.__dict__)
+        return instance
+
+    def __init__(self, login: Login) -> None:
+        if not login.logged_in:
+            raise ValueError("Must be logged in")
+
+        self._user_plan: Mapping[str, Any] = None
+        self._user_info: Mapping[str, Any] = None
+
+    @property
+    def has_premium(self) -> bool:
+        if self._user_plan is None:
+            self.get_plan_info()
+
+        return self._user_plan["plan"]["name"] != "Spotify Free"
+
+    @property
+    def username(self) -> str:
+        if self._user_info is None:
+            self._user_info = self.get_user_info()
+
+        return self._user_info["profile"]["username"]
+
+    def get_plan_info(self) -> Mapping[str, Any]:
+        """Gets user plan info."""
+        url = "https://www.spotify.com/ca-en/api/account/v2/plan/"
+        resp = self.client.get(url)
+
+        if resp.fail:
+            raise UserError("Could not get user plan info", error=resp.error.string)
+
+        if not isinstance(resp.response, Mapping):
+            raise UserError("Invalid JSON")
+
+        self._user_plan = resp.response
+        return resp.response
+
+    def verify_login(self) -> bool:
+        try:
+            self.get_plan_info()
+        except Exception as e:
+            if "401" in str(e):
+                return False
+        else:
+            return True
+
+    def get_user_info(self) -> Mapping[str, Any]:
+        """Gets accounts user info."""
+        url = "https://www.spotify.com/api/account-settings/v1/profile"
+        resp = self.client.get(url)
+
+        if resp.fail:
+            raise UserError("Could not get user info", error=resp.error.string)
+
+        if not isinstance(resp.response, Mapping):
+            raise UserError("Invalid JSON")
+
+        self.csrf_token = resp.raw.headers.get("X-Csrf-Token")
+        return resp.response
+
+    def edit_user_info(self, dump: Mapping[str, Any]) -> None:
+        """
+        Edits account user account info.
+        For this function to work, dump must be the entire profile dump.
+        You can get this dump from get_user_info, then change the fields you want.
+        """
+        captcha_response = self.solver.solve_captcha(
+            "https://www.spotify.com",
+            "6LfCVLAUAAAAALFwwRnnCJ12DalriUGbj8FW_J39",
+            "account_settings/profile_update",
+            "v3",
+        )
+
+        if not captcha_response:
+            raise UserError("Could not solve captcha")
+
+        profile_dump = dump["profile"]
+        dump = {
+            "profile": {
+                "email": profile_dump["email"],
+                "gender": profile_dump["gender"],
+                "birthdate": profile_dump["birthdate"],
+                "country": profile_dump["country"],
+            },
+            "recaptcha_token": captcha_response,
+        }
+
+        url = "https://www.spotify.com/api/account-settings/v1/profile"
+
+        headers = {
+            "Content-Type": "application/json",
+            "X-Csrf-Token": self.csrf_token,
+        }
+
+        resp = self.client.put(url, json=dump, headers=headers)
+
+        if resp.fail:
+            raise UserError("Could not edit user info", error=resp.error.string)

spotapi/websocket.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from websockets.sync.client import connect
+from spotapi.login import Login
+from spotapi.client import BaseClient
+from typing import Optional
+import threading
+import atexit
+import json
+import time
+
+
+class WebsocketStreamer(BaseClient, Login):
+    """
+    Standard streamer to connect to spotify's websocket API.
+    """
+
+    def __new__(cls, login: Login) -> WebsocketStreamer:
+        instance = super().__new__(cls)
+        instance.__dict__.update(login.__dict__)
+        return instance
+
+    def __init__(self, login: Login, ignore_init_packet: Optional[bool] = True):
+        if not login.logged_in:
+            raise ValueError("Must be logged in")
+
+        super().__init__(client=login.client)
+
+        self.get_session()
+        self.get_client_token()
+
+        uri = f"wss://gue1-dealer2.spotify.com/?access_token={self.access_token}"
+        self.ws = connect(
+            uri,
+            user_agent_header="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        )
+
+        self.rlock = threading.Lock()
+        self.ws_dump: dict = None
+
+        if ignore_init_packet:
+            self.get_init_packet()
+
+        threading.Thread(target=self.keep_alive, daemon=True).start()
+        atexit.register(self.ws.close)
+
+    def keep_alive(self) -> None:
+        while True:
+            # We need to make sure the ws doesn't read the PONG
+            with self.rlock:
+                self.ws.send('{"type":"ping"}')
+                self.ws.recv()
+
+            time.sleep(60)
+
+    def get_packet(self) -> dict:
+        with self.rlock:
+            self.ws_dump = dict(json.loads(self.ws.recv()))
+            return self.ws_dump
+
+    def get_main_packet(self) -> dict:
+        """Eqivalent to get_packet() just asserts that the init packet has been consumed"""
+        with self.rlock:
+            self.ws_dump = dict(json.loads(self.ws.recv()))
+
+            is_not_init_packet: bool = (self.ws_dump.get("headers") is None) or (
+                dict(self.ws_dump["headers"]).get("Spotify-Connection-Id") is None
+            )
+            assert (
+                not is_not_init_packet
+            ), "Init packet has not been consumed yet, restart the streamer."
+
+            return self.ws_dump
+
+    def get_init_packet(self) -> str:
+        """Gets the Spotify Connection ID in the init packet"""
+        packet = self.get_packet()
+
+        if (
+            packet.get("headers") is None
+            or dict(packet["headers"]).get("Spotify-Connection-Id") is None
+        ):
+            raise ValueError("Invalid init packet")
+
+        return packet["headers"]["Spotify-Connection-Id"]
+
+    def get_player_state(self) -> dict:
+        self.get_main_packet()
+        payload = self.ws_dump["payload"][0]
+        return payload["cluster"]["player_state"]