spotapi 0.0.0__py3-none-any.whl

spotapi/__init__.py

@@ -0,0 +1,17 @@
+from spotapi.artist import Artist
+from spotapi.client import BaseClient
+from spotapi.login import Login
+from spotapi.playlist import PrivatePlaylist, PublicPlaylist
+from spotapi.song import Song
+from spotapi.user import User
+from spotapi.creator import Creator
+from spotapi.password import Password
+from spotapi.solvers import solver_clients, solver_clients_str
+from spotapi.data.data import Config
+from spotapi.utils.logger import Logger, NoopLogger
+from spotapi.utils.saver import *
+from spotapi.websocket import WebsocketStreamer
+from spotapi.family import Family, JoinFamily
+
+__author__ = "Aran"
+__license__ = "GPL 3.0"

spotapi/artist.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Generator, Literal, Mapping, Optional
+
+from spotapi.client import BaseClient
+from spotapi.exceptions import ArtistError
+from spotapi.http.request import TLSClient
+from spotapi.login import Login
+from spotapi.client import BaseClient
+
+
+class Artist(BaseClient, Login):
+    """
+    A class that represents an artist in the Spotify catalog.
+    """
+
+    def __new__(cls, login: Optional[Login] = None) -> Artist:
+        instance = super(Artist, cls).__new__(cls)
+        if login:
+            instance.__dict__.update(login.__dict__)
+        return instance
+
+    def __init__(
+        self,
+        login: Optional[Login] = None,
+        *,
+        client: Optional[TLSClient] = TLSClient("chrome_120", "", auto_retries=3),
+    ) -> None:
+        if login and not login.logged_in:
+            raise ValueError("Must be logged in")
+
+        self._login: bool = bool(login)
+        super().__init__(client=login.client if self._login else client)
+
+    def query_artists(
+        self, query: str, /, limit: Optional[int] = 10, *, offset: Optional[int] = 0
+    ) -> Mapping[str, Any]:
+        """Searches for an artist in the Spotify catalog"""
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        params = {
+            "operationName": "searchArtists",
+            "variables": json.dumps(
+                {
+                    "searchTerm": query,
+                    "offset": offset,
+                    "limit": limit,
+                    "numberOfTopResults": 5,
+                    "includeAudiobooks": True,
+                    "includePreReleases": False,
+                }
+            ),
+            "extensions": json.dumps(
+                {
+                    "persistedQuery": {
+                        "version": 1,
+                        "sha256Hash": self.part_hash("searchArtists"),
+                    }
+                }
+            ),
+        }
+
+        resp = self.client.post(url, params=params, authenticate=True)
+
+        if resp.fail:
+            raise ArtistError("Could not get artists", error=resp.error.string)
+
+        if not isinstance(resp.response, Mapping):
+            raise ArtistError("Invalid JSON")
+
+        return resp.response
+
+    def paginate_artists(
+        self, query: str, /
+    ) -> Generator[Mapping[str, Any], None, None]:
+        """
+        Generator that fetches artists in chunks
+
+        Note: If total_tracks <= 100, then there is no need to paginate
+        """
+        UPPER_LIMIT: int = 100
+
+        # We need to get the total artists first
+        artists = self.query_artists(query, limit=UPPER_LIMIT)
+        total_count: int = artists["data"]["searchV2"]["artists"]["totalCount"]
+
+        yield artists["data"]["searchV2"]["artists"]["items"]
+
+        if total_count <= UPPER_LIMIT:
+            return
+
+        offset = UPPER_LIMIT
+        while offset < total_count:
+            yield self.query_artists(query, limit=UPPER_LIMIT, offset=offset)["data"][
+                "searchV2"
+            ]["artists"]["items"]
+            offset += UPPER_LIMIT
+
+    def __do_follow(
+        self,
+        artist_id: str,
+        /,
+        *,
+        action: Optional[Literal["addToLibrary", "removeFromLibrary"]] = "addToLibrary",
+    ) -> None:
+        if not self._login:
+            raise ValueError("Must be logged in")
+
+        if "artist:" in artist_id:
+            artist_id = artist_id.split("artist:")[1]
+
+        url = "https://api-partner.spotify.com/pathfinder/v1/query"
+        payload = {
+            "variables": {
+                "uris": [
+                    f"spotify:artist:{artist_id}",
+                ],
+            },
+            "operationName": action,
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": self.part_hash(action),
+                },
+            },
+        }
+
+        resp = self.client.post(url, json=payload, authenticate=True)
+
+        if resp.fail:
+            raise ArtistError("Could not follow artist", error=resp.error.string)
+
+    def follow(self, artist_id: str, /) -> None:
+        """Follow an artist"""
+        return self.__do_follow(artist_id)
+
+    def unfollow(self, artist_id: str, /) -> None:
+        """Unfollow an artist"""
+        return self.__do_follow(artist_id, action="removeFromLibrary")

spotapi/client.py

@@ -0,0 +1,158 @@
+import re
+import atexit
+from typing import Mapping
+
+from spotapi.exceptions import BaseClientError
+from spotapi.http.request import TLSClient
+from spotapi.utils.strings import parse_json_string
+
+
+class BaseClient:
+    """
+    A base class that all the Spotify classes extend.
+    This base class contains all the common methods used by the Spotify classes.
+    """
+
+    def __init__(self, client: TLSClient) -> None:
+        self.client = client
+        self.client.authenticate = lambda kwargs: self._auth_rule(kwargs)
+
+        self.js_pack: str = None
+        self.client_version: str = None
+        self.access_token: str = None
+        self.client_token: str = None
+        self.client_id: str = None
+        self.device_id: str = None
+        self.raw_hashes: str = None
+
+        self.browser_version = self.client.client_identifier.split("_")[1]
+        self.client.headers.update(
+            {
+                "Content-Type": "application/json;charset=UTF-8",
+                "User-Agent": f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{self.browser_version}.0.0.0 Safari/537.36",
+                "Sec-Ch-Ua": f'"Chromium";v="{self.browser_version}", "Not(A:Brand";v="24", "Google Chrome";v="{self.browser_version}"',
+            }
+        )
+
+        atexit.register(self.client.close)
+
+    def _auth_rule(self, kwargs: dict) -> dict:
+        if not self.client_token:
+            self.get_client_token()
+
+        if not self.access_token:
+            self.get_session()
+
+        if not ("headers" in kwargs):
+            kwargs["headers"] = {}
+
+        kwargs["headers"].update(
+            {
+                "Authorization": "Bearer " + self.access_token,
+                "Client-Token": self.client_token,
+                "Spotify-App-Version": self.client_version,
+            }
+        )
+
+        return kwargs
+
+    def get_session(self) -> None:
+        resp = self.client.get(
+            "https://open.spotify.com",
+            headers={
+                "User-Agent": f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{self.browser_version}.0.0.0 Safari/537.36"
+            },
+        )
+
+        if resp.fail:
+            raise BaseClientError("Could not get session", error=resp.error.string)
+
+        pattern = r"https:\/\/open\.spotifycdn\.com\/cdn\/build\/web-player\/web-player.*?\.js"
+        self.js_pack = re.findall(pattern, resp.response)[1]
+        self.access_token = parse_json_string(resp.response, "accessToken")
+        self.client_id = parse_json_string(resp.response, "clientId")
+        self.device_id = parse_json_string(resp.response, "correlationId")
+
+    def get_client_token(self) -> None:
+        if not (self.client_id and self.device_id):
+            self.get_session()
+
+        if not self.client_version:
+            self.get_sha256_hash()
+
+        url = "https://clienttoken.spotify.com/v1/clienttoken"
+        payload = {
+            "client_data": {
+                "client_version": self.client_version,
+                "client_id": self.client_id,
+                "js_sdk_data": {
+                    "device_brand": "unknown",
+                    "device_model": "unknown",
+                    "os": "windows",
+                    "os_version": "NT 10.0",
+                    "device_id": self.device_id,
+                    "device_type": "computer",
+                },
+            }
+        }
+        headers = {
+            "Authority": "clienttoken.spotify.com",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        resp = self.client.post(url, json=payload, headers=headers)
+
+        if resp.fail:
+            raise BaseClientError("Could not get client token", error=resp.error.string)
+
+        if resp.response.get("response_type") != "RESPONSE_GRANTED_TOKEN_RESPONSE":
+            raise BaseClientError(
+                "Could not get client token", error=resp.response.get("response_type")
+            )
+
+        if not isinstance(resp.response, Mapping):
+            raise BaseClientError("Invalid JSON")
+
+        self.client_token = resp.response["granted_token"]["token"]
+
+    def part_hash(self, name: str) -> str:
+        if not self.raw_hashes:
+            self.get_sha256_hash()
+
+        try:
+            return self.raw_hashes.split(f'"{name}","query","')[1].split('"')[0]
+        except IndexError:
+            return self.raw_hashes.split(f'"{name}","mutation","')[1].split('"')[0]
+
+    def get_sha256_hash(self) -> None:
+        if not self.js_pack:
+            self.get_session()
+
+        resp = self.client.get(self.js_pack)
+
+        if resp.fail:
+            raise BaseClientError(
+                "Could not get playlist hashes", error=resp.error.string
+            )
+
+        self.raw_hashes = resp.response
+        self.client_version = resp.response.split('clientVersion:"')[1].split('"')[0]
+        # Maybe it's static? Let's not take chances.
+        self.xpui_route_num = resp.response.split(':"xpui-routes-search"')[0].split(
+            ","
+        )[-1]
+        pattern = rf'{self.xpui_route_num}:"([^"]*)"'
+        self.xpui_route = re.findall(pattern, resp.response)[-1]
+
+        resp = self.client.get(
+            f"https://open.spotifycdn.com/cdn/build/web-player/xpui-routes-search.{self.xpui_route}.js"
+        )
+
+        if resp.fail:
+            raise BaseClientError("Could not get xpui hashes", error=resp.error.string)
+
+        self.raw_hashes += resp.response
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(...)"

spotapi/creator.py

@@ -0,0 +1,168 @@
+import time
+import uuid
+from typing import Optional
+from spotapi.data import Config
+from spotapi.exceptions import GeneratorError
+from spotapi.http.request import TLSClient
+from spotapi.utils.strings import (
+    random_email,
+    random_string,
+    parse_json_string,
+    random_dob,
+)
+
+
+class Creator:
+    """
+    Creates a new Spotify account.
+    """
+
+    def __init__(
+        self,
+        cfg: Config,
+        email: Optional[str] = random_email(),
+        password: Optional[str] = random_string(10, True),
+    ) -> None:
+        self.email = email
+        self.password = password
+        self.cfg = cfg
+
+        self.client = self.cfg.client
+        self.submission_id = str(uuid.uuid4())
+
+    def __get_session(self) -> None:
+        url = "https://www.spotify.com/ca-en/signup"
+        request = self.client.get(url)
+
+        if request.fail:
+            raise GeneratorError("Could not get session", error=request.error.string)
+
+        self.api_key = parse_json_string(request.response, "signupServiceAppKey")
+        self.installation_id = parse_json_string(request.response, "spT")
+        self.csrf_token = parse_json_string(request.response, "csrfToken")
+        self.flow_id = parse_json_string(request.response, "flowId")
+
+    def __process_register(self, captcha_token: str) -> None:
+        payload = {
+            "account_details": {
+                "birthdate": random_dob(),
+                "consent_flags": {
+                    "eula_agreed": True,
+                    "send_email": True,
+                    "third_party_email": False,
+                },
+                "display_name": "Aran",
+                "email_and_password_identifier": {
+                    "email": self.email,
+                    "password": self.password,
+                },
+                "gender": 1,
+            },
+            "callback_uri": f"https://www.spotify.com/signup/challenge?flow_ctx={self.flow_id}%{int(time.time())}&locale=ca-en",
+            "client_info": {
+                "api_key": self.api_key,
+                "app_version": "v2",
+                "capabilities": [1],
+                "installation_id": self.installation_id,
+                "platform": "www",
+            },
+            "tracking": {
+                "creation_flow": "",
+                "creation_point": "spotify.com",
+                "referrer": "",
+            },
+            "recaptcha_token": captcha_token,
+            "submission_id": self.submission_id,
+            "flow_id": self.flow_id,
+        }
+        url = "https://spclient.wg.spotify.com/signup/public/v2/account/create"
+
+        request = self.client.post(url, json=payload)
+
+        if request.fail:
+            raise GeneratorError(
+                "Could not process registration", error=request.error.string
+            )
+
+        if "challenge" in request.response:
+            self.cfg.logger.attempt("Encountered Embedded Challenge. Defeating...")
+            AccountChallenge(self.client, request.response, self.cfg).defeat_challenge()
+
+    def register(self) -> None:
+        self.__get_session()
+        captcha_token = self.cfg.solver.solve_captcha(
+            "https://www.spotify.com/ca-en/signup",
+            "6LfCVLAUAAAAALFwwRnnCJ12DalriUGbj8FW_J39",
+            "website/signup/submit_email",
+            "v3",
+        )
+        self.__process_register(captcha_token)
+
+
+class AccountChallenge:
+    def __init__(self, client: TLSClient, raw_response: str, cfg: Config) -> None:
+        self.client = client
+        self.raw = raw_response
+        self.session_id = parse_json_string(raw_response, "session_id")
+        self.cfg = cfg
+
+    def __get_session(self) -> None:
+        url = "https://challenge.spotify.com/api/v1/get-session"
+        payload = {"session_id": self.session_id}
+        request = self.client.post(url, json=payload)
+
+        if request.fail:
+            raise GeneratorError(
+                "Could not get challenge session", error=request.error.string
+            )
+
+        self.challenge_url = parse_json_string(request.response, "url")
+
+    def __submit_challenge(self, token: str) -> None:
+        session_id = self.challenge_url.split("c/")[1].split("/")[0]
+        challenge_id = self.challenge_url.split(session_id + "/")[1].split("/")[0]
+        url = "https://challenge.spotify.com/api/v1/invoke-challenge-command"
+        payload = {
+            "session_id": session_id,
+            "challenge_id": challenge_id,
+            "recaptcha_challenge_v1": {"solve": {"recaptcha_token": token}},
+        }
+        request = self.client.post(
+            url,
+            json=payload,
+            headers={
+                "X-Cloud-Trace-Context": "000000000000000004ec7cfe60aa92b5/8088460714428896449;o=1"
+            },
+        )
+
+        if request.fail:
+            raise GeneratorError(
+                "Could not submit challenge", error=request.error.string
+            )
+
+    def __complete_challenge(self) -> None:
+        url = (
+            "https://spclient.wg.spotify.com/signup/public/v2/account/complete-creation"
+        )
+        payload = {"session_id": self.session_id}
+        request = self.client.post(url, json=payload)
+
+        if request.fail:
+            raise GeneratorError(
+                "Could not complete challenge", error=request.error.string
+            )
+
+        if not ("success" in request.response):
+            raise GeneratorError("Could not complete challenge", error=request.response)
+
+    def defeat_challenge(self) -> None:
+        self.__get_session()
+        token = self.cfg.solver.solve_captcha(
+            self.challenge_url,
+            "6LeO36obAAAAALSBZrY6RYM1hcAY7RLvpDDcJLy3",
+            "challenge",
+            "v2",
+        )
+        self.__submit_challenge(token)
+        self.__complete_challenge()
+        self.cfg.logger.info("Successfully defeated challenge. Account created.")

spotapi/data/__init__.py

@@ -0,0 +1,2 @@
+from .data import Config
+from .interfaces import CaptchaProtocol, LoggerProtocol, SaverProtocol

spotapi/data/data.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from typing import Type
+from spotapi.data.interfaces import CaptchaProtocol, LoggerProtocol
+from spotapi.http.request import TLSClient
+
+
+@dataclass
+class Config:
+    solver: Type[CaptchaProtocol]
+    logger: Type[LoggerProtocol]
+    client: TLSClient = field(default=TLSClient("chrome_120", "", auto_retries=3))
+
+
+@dataclass
+class SolverConfig:
+    api_key: str
+    captcha_service: str
+    retries: int = field(default=120)

spotapi/data/interfaces.py

@@ -0,0 +1,59 @@
+from typing import Any, List, Literal, Mapping, Optional, Protocol
+from typing_extensions import runtime_checkable
+from spotapi.http.request import StdClient
+
+
+@runtime_checkable
+class CaptchaProtocol(Protocol):
+    def __init__(
+        self,
+        api_key: str,
+        client: Optional[StdClient] = StdClient(3),
+        *,
+        proxy: Optional[str] = None,
+        retries: Optional[int] = 120,
+    ) -> None:
+        ...
+
+    def get_balance(self) -> float | None:
+        ...
+
+    def solve_captcha(
+        self,
+        url: str,
+        site_key: str,
+        action: str,
+        task: Literal["v2", "v3"],
+    ) -> str:
+        ...
+
+
+@runtime_checkable
+class LoggerProtocol(Protocol):
+    @staticmethod
+    def info(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def attempt(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def error(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def fatal(s: str, **extra) -> None:
+        ...
+
+
+@runtime_checkable
+class SaverProtocol(Protocol):
+    def save(self, data: List[Mapping[str, Any]], **kwargs) -> None:
+        ...
+
+    def load(self, query: Mapping[str, Any], **kwargs) -> Mapping[str, Any]:
+        ...
+
+    def delete(self, query: Mapping[str, Any], **kwargs) -> None:
+        ...

spotapi/exceptions/__init__.py

@@ -0,0 +1,15 @@
+from .errors import (
+    ArtistError,
+    BaseClientError,
+    CaptchaException,
+    LoginError,
+    ParentException,
+    PlaylistError,
+    RequestError,
+    SaverError,
+    SolverError,
+    SongError,
+    UserError,
+    GeneratorError,
+    PasswordError,
+)

spotapi/exceptions/errors.py

@@ -0,0 +1,68 @@
+class ParentException(Exception):
+    def __init__(self, message: str, error: str = str) -> None:
+        super().__init__(message)
+        self.error = error
+
+
+# Runtime exceptions (API errors)
+class CaptchaException(ParentException):
+    pass
+
+
+# Final exceptions
+class SolverError(ParentException):
+    pass
+
+
+# Login.py exceptions
+class LoginError(ParentException):
+    pass
+
+
+# User.py exceptions
+class UserError(ParentException):
+    pass
+
+
+# Playlist.py exceptions
+class PlaylistError(ParentException):
+    pass
+
+
+# Saver.py exceptions
+class SaverError(ParentException):
+    pass
+
+
+# Song.py exceptions
+class SongError(ParentException):
+    pass
+
+
+# Artist.py exceptions
+class ArtistError(ParentException):
+    pass
+
+
+# client.py exceptions
+class BaseClientError(ParentException):
+    pass
+
+
+# request.py exceptions
+class RequestError(ParentException):
+    pass
+
+
+# generator.py exceptions
+class GeneratorError(ParentException):
+    pass
+
+
+# password.py exceptions
+class PasswordError(ParentException):
+    pass
+
+
+class FamilyError(ParentException):
+    pass