spotapi 1.0.0__tar.gz → 1.0.2__tar.gz

{spotapi-1.0.0/spotapi.egg-info → spotapi-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spotapi
-Version: 1.0.0
+Version: 1.0.2
 Summary: A sleek API wrapper for Spotify's private API
 Home-page: UNKNOWN
 Author: Aran
@@ -17,9 +17,19 @@ Welcome to SpotAPI! This Python library is designed to interact with the private
 **Note**: This project is intended solely for educational purposes and should be used responsibly. Accessing private endpoints and scraping data without proper authorization may violate Spotify's terms of service
 
 ## Features
-- **Public API Access**: Fetch and manipulate public Spotify data such as playlists, albums, and tracks.
-- **Private API Access**: Experiment with less commonly used Spotify endpoints.
-- **Browser-like Requests**: Mimics the HTTP requests Spotify makes in the browser perfectly, providing an accurate representation of what you’d see on the web interface.
+- **Public API Access**: Retrieve and manipulate public Spotify data such as playlists, albums, and tracks with ease.
+- **Private API Access**: Explore private Spotify endpoints to tailor your application to your needs.
+- **Ready to Use**: **SpotAPI** is designed for immediate integration, allowing you to accomplish tasks with just a few lines of code.
+- **No API Key Required**: Seamlessly use **SpotAPI** without needing a Spotify API key. It’s straightforward and hassle free!
+- **Browser-like Requests**: Accurately replicate the HTTP requests Spotify makes in the browser, providing a true to web experience while remaining undetected.
+
+Everything you can do with Spotify, **SpotAPI** can do with just a user’s login credentials.
+
+
+## Installation
+```
+pip install spotapi
+```
 
 ## Quick Example
 ```py
@@ -33,7 +43,7 @@ from spotapi import (
 )
 
 cfg = Config(
-    solver=solver_clients.Capsolver("YOUR_API_KEY", proxy="YOUR_PROXY"),
+    solver=solver_clients.Capsolver("YOUR_API_KEY", proxy="YOUR_PROXY"), # Proxy is optional
     logger=NoopLogger(),
     # You can add a proxy by passing a custom TLSClient
 )
@@ -43,14 +53,18 @@ instance = Login(cfg, "YOUR_PASSWORD", email="YOUR_EMAIL")
 instance.login()
 
 # Do whatever you want now
-playlist = PrivatePlaylist(instance, "SOME_PLAYLIST")
-playlist.create_playlist("Spotapi Showcase!")
+playlist = PrivatePlaylist(instance)
+playlist.create_playlist("SpotAPI Showcase!")
 
 # Save the session
 instance.save(MongoSaver())
 ```
 
-[GPL 3.0](https://choosealicense.com/licenses/gpl-3.0/)
+## Contributing
+Contributions are welcome! If you find any issues or have suggestions, please open an issue or submit a pull request.
+
+## License
+This project is licensed under the **GPL 3.0** License. See [LICENSE](https://choosealicense.com/licenses/gpl-3.0/) for details.
 
 
 

spotapi-1.0.2/README.md

@@ -0,0 +1,56 @@
+# SpotAPI
+
+Welcome to SpotAPI! This Python library is designed to interact with the private and public Spotify APIs, emulating the requests typically made through a web browser. This wrapper provides a convenient way to access Spotify’s rich set of features programmatically.
+
+**Note**: This project is intended solely for educational purposes and should be used responsibly. Accessing private endpoints and scraping data without proper authorization may violate Spotify's terms of service
+
+## Features
+- **Public API Access**: Retrieve and manipulate public Spotify data such as playlists, albums, and tracks with ease.
+- **Private API Access**: Explore private Spotify endpoints to tailor your application to your needs.
+- **Ready to Use**: **SpotAPI** is designed for immediate integration, allowing you to accomplish tasks with just a few lines of code.
+- **No API Key Required**: Seamlessly use **SpotAPI** without needing a Spotify API key. It’s straightforward and hassle free!
+- **Browser-like Requests**: Accurately replicate the HTTP requests Spotify makes in the browser, providing a true to web experience while remaining undetected.
+
+Everything you can do with Spotify, **SpotAPI** can do with just a user’s login credentials.
+
+
+## Installation
+```
+pip install spotapi
+```
+
+## Quick Example
+```py
+from spotapi import (
+    Login, 
+    Config, 
+    NoopLogger, 
+    solver_clients, 
+    PrivatePlaylist, 
+    MongoSaver
+)
+
+cfg = Config(
+    solver=solver_clients.Capsolver("YOUR_API_KEY", proxy="YOUR_PROXY"), # Proxy is optional
+    logger=NoopLogger(),
+    # You can add a proxy by passing a custom TLSClient
+)
+
+instance = Login(cfg, "YOUR_PASSWORD", email="YOUR_EMAIL")
+# Now we have a valid Login instance to pass around
+instance.login()
+
+# Do whatever you want now
+playlist = PrivatePlaylist(instance)
+playlist.create_playlist("SpotAPI Showcase!")
+
+# Save the session
+instance.save(MongoSaver())
+```
+
+## Contributing
+Contributions are welcome! If you find any issues or have suggestions, please open an issue or submit a pull request.
+
+## License
+This project is licensed under the **GPL 3.0** License. See [LICENSE](https://choosealicense.com/licenses/gpl-3.0/) for details.
+

{spotapi-1.0.0 → spotapi-1.0.2}/setup.py

@@ -52,5 +52,5 @@ setup(
     ],
     long_description=long_description,
     long_description_content_type="text/markdown",
-    version="1.0.0",
+    version="1.0.2",
 )

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/__init__.py

@@ -7,7 +7,7 @@ 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.types.data import Config
 from spotapi.utils.logger import Logger, NoopLogger
 from spotapi.utils.saver import *
 from spotapi.websocket import WebsocketStreamer

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/artist.py

@@ -10,17 +10,11 @@ from spotapi.login import Login
 from spotapi.client import BaseClient
 
 
-class Artist(BaseClient, Login):
+class Artist:
     """
     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,
@@ -31,7 +25,7 @@ class Artist(BaseClient, Login):
             raise ValueError("Must be logged in")
 
         self._login: bool = bool(login)
-        super().__init__(client=login.client if self._login else client)
+        self.base = BaseClient(client=login.client if (login is not None) else client) # type: ignore
 
     def query_artists(
         self, query: str, /, limit: Optional[int] = 10, *, offset: Optional[int] = 0
@@ -54,14 +48,15 @@ class Artist(BaseClient, Login):
                 {
                     "persistedQuery": {
                         "version": 1,
-                        "sha256Hash": self.part_hash("searchArtists"),
+                        "sha256Hash": self.base.part_hash("searchArtists"),
                     }
                 }
             ),
         }
 
-        resp = self.client.post(url, params=params, authenticate=True)
+        resp = self.base.client.post(url, params=params, authenticate=True)
 
+        
         if resp.fail:
             raise ArtistError("Could not get artists", error=resp.error.string)
 
@@ -120,12 +115,13 @@ class Artist(BaseClient, Login):
             "extensions": {
                 "persistedQuery": {
                     "version": 1,
-                    "sha256Hash": self.part_hash(action),
+                    "sha256Hash": self.base.part_hash(str(action)),
                 },
             },
         }
 
-        resp = self.client.post(url, json=payload, authenticate=True)
+        resp = self.base.client.post(url, json=payload, authenticate=True)
+
 
         if resp.fail:
             raise ArtistError("Could not follow artist", error=resp.error.string)

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/client.py

@@ -11,19 +11,21 @@ class BaseClient:
     """
     A base class that all the Spotify classes extend.
     This base class contains all the common methods used by the Spotify classes.
+    
+    NOTE: Should not be used directly. Use the Spotify classes instead.
     """
 
     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.js_pack: str | None = None
+        self.client_version: str | None = None
+        self.access_token: str | None = None
+        self.client_token: str | None = None
+        self.client_id: str | None = None
+        self.device_id: str | None = None
+        self.raw_hashes: str | None = None
 
         self.browser_version = self.client.client_identifier.split("_")[1]
         self.client.headers.update(
@@ -37,15 +39,16 @@ class BaseClient:
         atexit.register(self.client.close)
 
     def _auth_rule(self, kwargs: dict) -> dict:
-        if not self.client_token:
+        if self.client_token is None:
             self.get_client_token()
 
-        if not self.access_token:
+        if self.access_token is None:
             self.get_session()
 
         if not ("headers" in kwargs):
             kwargs["headers"] = {}
-
+            
+        assert self.access_token is not None, "Access token is None"
         kwargs["headers"].update(
             {
                 "Authorization": "Bearer " + self.access_token,
@@ -64,6 +67,7 @@ class BaseClient:
             },
         )
 
+
         if resp.fail:
             raise BaseClientError("Could not get session", error=resp.error.string)
 
@@ -103,6 +107,7 @@ class BaseClient:
 
         resp = self.client.post(url, json=payload, headers=headers)
 
+
         if resp.fail:
             raise BaseClientError("Could not get client token", error=resp.error.string)
 
@@ -117,8 +122,11 @@ class BaseClient:
         self.client_token = resp.response["granted_token"]["token"]
 
     def part_hash(self, name: str) -> str:
-        if not self.raw_hashes:
+        if self.raw_hashes is None:
             self.get_sha256_hash()
+            
+        if self.raw_hashes is None:
+            raise ValueError("Could not get playlist hashes")
 
         try:
             return self.raw_hashes.split(f'"{name}","query","')[1].split('"')[0]
@@ -126,16 +134,22 @@ class BaseClient:
             return self.raw_hashes.split(f'"{name}","mutation","')[1].split('"')[0]
 
     def get_sha256_hash(self) -> None:
-        if not self.js_pack:
+        if self.js_pack is None:
             self.get_session()
+            
+        if self.js_pack is None:
+            raise ValueError("Could not get playlist hashes")
 
         resp = self.client.get(self.js_pack)
 
+
         if resp.fail:
             raise BaseClientError(
                 "Could not get playlist hashes", error=resp.error.string
             )
 
+        assert isinstance(resp.response, str), "Invalid HTML response"
+        
         self.raw_hashes = resp.response
         self.client_version = resp.response.split('clientVersion:"')[1].split('"')[0]
         # Maybe it's static? Let's not take chances.
@@ -149,6 +163,7 @@ class BaseClient:
             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)
 

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/creator.py

@@ -1,7 +1,7 @@
 import time
 import uuid
 from typing import Optional
-from spotapi.data import Config
+from spotapi.types import Config
 from spotapi.exceptions import GeneratorError
 from spotapi.http.request import TLSClient
 from spotapi.utils.strings import (
@@ -32,15 +32,16 @@ class Creator:
 
     def __get_session(self) -> None:
         url = "https://www.spotify.com/ca-en/signup"
-        request = self.client.get(url)
+        resp = 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")
+        if resp.fail:
+            raise GeneratorError("Could not get session", error=resp.error.string)
+
+        self.api_key = parse_json_string(resp.response, "signupServiceAppKey")
+        self.installation_id = parse_json_string(resp.response, "spT")
+        self.csrf_token = parse_json_string(resp.response, "csrfToken")
+        self.flow_id = parse_json_string(resp.response, "flowId")
 
     def __process_register(self, captcha_token: str) -> None:
         payload = {
@@ -77,19 +78,21 @@ class Creator:
         }
         url = "https://spclient.wg.spotify.com/signup/public/v2/account/create"
 
-        request = self.client.post(url, json=payload)
+        resp = self.client.post(url, json=payload)
+
 
-        if request.fail:
+        if resp.fail:
             raise GeneratorError(
-                "Could not process registration", error=request.error.string
+                "Could not process registration", error=resp.error.string
             )
 
-        if "challenge" in request.response:
+        if "challenge" in resp.response:
             self.cfg.logger.attempt("Encountered Embedded Challenge. Defeating...")
-            AccountChallenge(self.client, request.response, self.cfg).defeat_challenge()
+            AccountChallenge(self.client, resp.response, self.cfg).defeat_challenge()
 
     def register(self) -> None:
         self.__get_session()
+        # Pylance keeps complaining about self keyword. I don't know why.
         captcha_token = self.cfg.solver.solve_captcha(
             "https://www.spotify.com/ca-en/signup",
             "6LfCVLAUAAAAALFwwRnnCJ12DalriUGbj8FW_J39",
@@ -109,14 +112,15 @@ class AccountChallenge:
     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)
+        resp = self.client.post(url, json=payload)
+
 
-        if request.fail:
+        if resp.fail:
             raise GeneratorError(
-                "Could not get challenge session", error=request.error.string
+                "Could not get challenge session", error=resp.error.string
             )
 
-        self.challenge_url = parse_json_string(request.response, "url")
+        self.challenge_url = parse_json_string(resp.response, "url")
 
     def __submit_challenge(self, token: str) -> None:
         session_id = self.challenge_url.split("c/")[1].split("/")[0]
@@ -127,7 +131,7 @@ class AccountChallenge:
             "challenge_id": challenge_id,
             "recaptcha_challenge_v1": {"solve": {"recaptcha_token": token}},
         }
-        request = self.client.post(
+        resp = self.client.post(
             url,
             json=payload,
             headers={
@@ -135,9 +139,10 @@ class AccountChallenge:
             },
         )
 
-        if request.fail:
+
+        if resp.fail:
             raise GeneratorError(
-                "Could not submit challenge", error=request.error.string
+                "Could not submit challenge", error=resp.error.string
             )
 
     def __complete_challenge(self) -> None:
@@ -145,15 +150,16 @@ class AccountChallenge:
             "https://spclient.wg.spotify.com/signup/public/v2/account/complete-creation"
         )
         payload = {"session_id": self.session_id}
-        request = self.client.post(url, json=payload)
+        resp = self.client.post(url, json=payload)
+
 
-        if request.fail:
+        if resp.fail:
             raise GeneratorError(
-                "Could not complete challenge", error=request.error.string
+                "Could not complete challenge", error=resp.error.string
             )
 
-        if not ("success" in request.response):
-            raise GeneratorError("Could not complete challenge", error=request.response)
+        if not ("success" in resp.response):
+            raise GeneratorError("Could not complete challenge", error=resp.response)
 
     def defeat_challenge(self) -> None:
         self.__get_session()

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/family.py

@@ -6,17 +6,13 @@ from spotapi.exceptions.errors import FamilyError
 from spotapi.utils.strings import parse_json_string
 
 
-class JoinFamily(User):
+class JoinFamily:
     """
     Wrapper class for joining a family with a user and a host provided.
     """
 
-    def __new__(cls, user_login: Login, host: "Family", country: str) -> "JoinFamily":
-        instance = super(User, cls).__new__(cls)
-        return instance
-
     def __init__(self, user_login: Login, host: "Family", country: str) -> None:
-        super().__init__(user_login)
+        self.user = User(user_login)
         self.host = host
         self.country = country
         self.client = user_login.client
@@ -31,6 +27,7 @@ class JoinFamily(User):
         url = f"https://www.spotify.com/ca-en/family/join/address/{self.invite_token}/"
         resp = self.client.get(url)
 
+
         if resp.fail:
             raise FamilyError("Could not get session", error=resp.error.string)
 
@@ -45,6 +42,7 @@ class JoinFamily(User):
         }
         resp = self.client.post(url, headers={"X-Csrf-Token": self.csrf}, json=payload)
 
+
         if resp.fail:
             raise FamilyError("Could not get address", error=resp.error.string)
 
@@ -59,6 +57,7 @@ class JoinFamily(User):
         }
         resp = self.client.post(url, headers={"X-Csrf-Token": self.csrf}, json=payload)
 
+
         self.csrf = resp.raw.headers.get("X-Csrf-Token")
         if resp.fail:
             return False
@@ -84,6 +83,7 @@ class JoinFamily(User):
         }
         resp = self.client.post(url, headers={"X-Csrf-Token": self.csrf}, json=payload)
 
+
         if resp.fail:
             raise FamilyError("Could not add to family", error=resp.error.string)
 
@@ -103,11 +103,12 @@ class Family(User):
         if not self.has_premium:
             raise ValueError("Must have premium to use this class")
 
-        self._user_family: Mapping[str, Any] = None
+        self._user_family: Mapping[str, Any] | None = None
 
     def get_family_home(self) -> Mapping[str, Any]:
         url = "https://www.spotify.com/api/family/v1/family/home/"
-        resp = self.client.get(url)
+        resp = self.login.client.get(url)
+
 
         if resp.fail:
             raise FamilyError("Could not get user plan info", error=resp.error.string)
@@ -115,13 +116,12 @@ class Family(User):
         if not isinstance(resp.response, Mapping):
             raise FamilyError("Invalid JSON")
 
-        self._user_family = resp.response
         return resp.response
 
     @property
     def members(self) -> List[Mapping[str, Any]]:
         if self._user_family is None:
-            self.get_family_home()
+            self._user_family = self.get_family_home()
 
         return self._user_family["members"]
 

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/http/data.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Union
 
+from requests import Response as StdResponse
 from tls_client.response import Response as TLSResponse
 
 
 # Dataclass needs to be here to avoid circular imports
 @dataclass
 class Response:
-    raw: TLSResponse
+    raw: TLSResponse | StdResponse
     status_code: int
     response: Any
 

{spotapi-1.0.0 → spotapi-1.0.2}/spotapi/http/request.py

@@ -4,6 +4,7 @@ from typing import Any, Callable, Type, Union
 
 import requests
 from tls_client import Session
+from tls_client.settings import ClientIdentifiers
 from tls_client.exceptions import TLSClientExeption
 from tls_client.response import Response as TLSResponse
 
@@ -13,7 +14,7 @@ from spotapi.http.data import Response
 
 class StdClient(requests.Session):
     def __init__(
-        self, auto_retries: int = 0, auth_rule: Callable[[dict[Any, Any]], dict] = None
+        self, auto_retries: int = 0, auth_rule: Callable[[dict[Any, Any]], dict] | None = None
     ) -> None:
         super().__init__()
         self.auto_retries = auto_retries + 1
@@ -23,7 +24,7 @@ class StdClient(requests.Session):
     def __call__(
         self, method: str, url: str, **kwargs
     ) -> Union[requests.Response, None]:
-        return self.build_request(method, url, kwargs)
+        return self.build_request(method, url, **kwargs)
 
     def build_request(
         self, method: str, url: str, **kwargs
@@ -32,8 +33,8 @@ class StdClient(requests.Session):
         for _ in range(self.auto_retries):
             try:
                 response = super().request(method.upper(), url, **kwargs)
-            except Exception as err:
-                err = err
+            except Exception as e:
+                err = str(e)
                 continue
             else:
                 return response
@@ -81,11 +82,11 @@ class StdClient(requests.Session):
 class TLSClient(Session):
     def __init__(
         self,
-        profile: str,
+        profile: ClientIdentifiers,
         proxy: str,
         *,
         auto_retries: int = 0,
-        auth_rule: Callable[[dict[Any, Any]], dict] = None,
+        auth_rule: Callable[[dict[Any, Any]], dict] | None = None,
     ) -> None:
         super().__init__(client_identifier=profile, random_tls_extension_order=True)
 
@@ -94,11 +95,11 @@ class TLSClient(Session):
 
         self.auto_retries = auto_retries + 1
         self.authenticate = auth_rule
-        self.fail_exception: Type[ParentException] = None
+        self.fail_exception: Type[ParentException] | None = None
         atexit.register(self.close)
 
     def __call__(self, method: str, url: str, **kwargs) -> Union[TLSResponse, None]:
-        return self.build_request(method, url, kwargs)
+        return self.build_request(method, url, **kwargs)
 
     def build_request(
         self, method: str, url: str, **kwargs
@@ -107,8 +108,8 @@ class TLSClient(Session):
         for _ in range(self.auto_retries):
             try:
                 response = self.execute_request(method.upper(), url, **kwargs)
-            except TLSClientExeption as err:
-                err = err
+            except TLSClientExeption as e:
+                err = str(e)
                 continue
             else:
                 return response
@@ -126,7 +127,7 @@ class TLSClient(Session):
         is_dict = True
 
         try:
-            json.loads(body)
+            json.loads(body) # type: ignore
         except json.JSONDecodeError:
             is_dict = False
 
@@ -137,7 +138,10 @@ class TLSClient(Session):
         if not body:
             body = None
 
-        resp = Response(status_code=response.status_code, response=body, raw=response)
+        # Why is status_code a None type...
+        assert response.status_code is not None, "Status Code is None"
+        
+        resp = Response(status_code=int(response.status_code), response=body, raw=response)
 
         if danger and self.fail_exception and resp.fail:
             raise self.fail_exception(
@@ -149,23 +153,23 @@ class TLSClient(Session):
 
     def get(
         self, url: str, *, authenticate: bool = False, **kwargs
-    ) -> Union[Response, None]:
+    ) -> Response:
         """Routes a GET Request"""
-        if authenticate:
+        if authenticate and self.authenticate is not None:
             kwargs = self.authenticate(kwargs)
 
         response = self.build_request("GET", url, allow_redirects=True, **kwargs)
 
         if response is None:
-            return
+            raise TLSClientExeption("Request kept failing after retries.")
 
         return self.parse_response(response, "GET", True)
 
     def post(
         self, url: str, *, authenticate: bool = False, danger: bool = False, **kwargs
-    ) -> Union[Response, None]:
+    ) -> Response:
         """Routes a POST Request"""
-        if authenticate:
+        if authenticate and self.authenticate is not None:
             kwargs = self.authenticate(kwargs)
 
         response = self.build_request("POST", url, allow_redirects=True, **kwargs)
@@ -177,9 +181,9 @@ class TLSClient(Session):
 
     def put(
         self, url: str, *, authenticate: bool = False, danger: bool = False, **kwargs
-    ) -> Union[Response, None]:
+    ) -> Response:
         """Routes a PUT Request"""
-        if authenticate:
+        if authenticate and self.authenticate is not None:
             kwargs = self.authenticate(kwargs)
 
         response = self.build_request("PUT", url, allow_redirects=True, **kwargs)