spotapi 0.0.0__tar.gz → 0.2.0__tar.gz

spotapi-0.2.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: spotapi
+Version: 0.2.0
+Summary: A sleek API wrapper for Spotify's private API
+Home-page: UNKNOWN
+Author: Aran
+License: UNKNOWN
+Keywords: Spotify,API,Spotify API,Spotify Private API,Follow,Like,Creator,Music,Music API,Streaming,Music Data,Track,Playlist,Album,Artist,Music Search,Music Metadata,SpotAPI,Python Spotify Wrapper,Music Automation,Web Scraping,Python Music API,Spotify Integration,Spotify Playlist,Spotify Tracks
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# 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**: 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.
+
+## 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"),
+    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, "SOME_PLAYLIST")
+playlist.create_playlist("Spotapi Showcase!")
+
+# Save the session
+instance.save(MongoSaver())
+```
+
+[GPL 3.0](https://choosealicense.com/licenses/gpl-3.0/)
+
+
+

{spotapi-0.0.0 → spotapi-0.2.0}/setup.py

@@ -14,6 +14,9 @@ __install_require__ = [
     "websockets",
 ]
 
+with open("README.md", "r") as f:
+    long_description = f.read()
+
 setup(
     name="spotapi",
     author="Aran",
@@ -47,4 +50,7 @@ setup(
         "Spotify Playlist",
         "Spotify Tracks",
     ],
-)
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    version="0.2.0",
+)

{spotapi-0.0.0 → spotapi-0.2.0}/spotapi/__init__.py

@@ -12,6 +12,10 @@ from spotapi.utils.logger import Logger, NoopLogger
 from spotapi.utils.saver import *
 from spotapi.websocket import WebsocketStreamer
 from spotapi.family import Family, JoinFamily
+from spotapi.http import *
+from spotapi.exceptions import *
+from spotapi.utils import *
+
 
 __author__ = "Aran"
-__license__ = "GPL 3.0"
+__license__ = "GPL 3.0"

spotapi-0.2.0/spotapi/http/__init__.py

@@ -0,0 +1,2 @@
+from spotapi.http.request import TLSClient, StdClient
+from spotapi.http.data import Response, Error

spotapi-0.2.0/spotapi/http/data.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Union
+
+from tls_client.response import Response as TLSResponse
+
+
+# Dataclass needs to be here to avoid circular imports
+@dataclass
+class Response:
+    raw: TLSResponse
+    status_code: int
+    response: Any
+
+    error: Error = field(init=False)
+    success: bool = field(init=False)
+    fail: bool = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.error = Error(
+            self.status_code,
+            self.response,
+            f"Status Code: {self.status_code}, Response: {self.response}",
+        )
+        self.success = self.error.is_success
+        self.fail = not self.success
+
+
+@dataclass
+class Error:
+    status_code: int
+    response: Union[str, dict]
+    string: str
+
+    @property
+    def is_success(self) -> bool:
+        return 200 <= self.status_code <= 302
+
+    @property
+    def is_fail(self) -> bool:
+        return not self.is_success

spotapi-0.2.0/spotapi/http/request.py

@@ -0,0 +1,190 @@
+import atexit
+import json
+from typing import Any, Callable, Type, Union
+
+import requests
+from tls_client import Session
+from tls_client.exceptions import TLSClientExeption
+from tls_client.response import Response as TLSResponse
+
+from spotapi.exceptions import ParentException, RequestError
+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
+    ) -> None:
+        super().__init__()
+        self.auto_retries = auto_retries + 1
+        self.authenticate = auth_rule
+        atexit.register(self.close)
+
+    def __call__(
+        self, method: str, url: str, **kwargs
+    ) -> Union[requests.Response, None]:
+        return self.build_request(method, url, kwargs)
+
+    def build_request(
+        self, method: str, url: str, **kwargs
+    ) -> Union[requests.Response, None]:
+        err = "Unknown"
+        for _ in range(self.auto_retries):
+            try:
+                response = super().request(method.upper(), url, **kwargs)
+            except Exception as err:
+                err = err
+                continue
+            else:
+                return response
+        raise RequestError("Failed to complete request.", error=err)
+
+    def parse_response(self, response: requests.Response) -> Response:
+        body: Union[str, dict, None] = response.text
+        headers = {key.lower(): value for key, value in response.headers.items()}
+
+        if "application/json" in headers.get("content-type", ""):
+            try:
+                body = response.json()
+            except ValueError:
+                pass
+
+        return Response(status_code=response.status_code, response=body, raw=response)
+
+    def request(
+        self, method: str, url: str, *, authenticate: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        if authenticate and self.authenticate:
+            kwargs = self.authenticate(kwargs)
+
+        response = self.build_request(method, url, **kwargs)
+
+        if response is not None:
+            return self.parse_response(response)
+
+    def post(
+        self, url: str, *, authenticate: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        return self.request("POST", url, authenticate=authenticate, **kwargs)
+
+    def get(
+        self, url: str, *, authenticate: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        return self.request("GET", url, authenticate=authenticate, **kwargs)
+
+    def put(
+        self, url: str, *, authenticate: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        return self.request("PUT", url, authenticate=authenticate, **kwargs)
+
+
+class TLSClient(Session):
+    def __init__(
+        self,
+        profile: str,
+        proxy: str,
+        *,
+        auto_retries: int = 0,
+        auth_rule: Callable[[dict[Any, Any]], dict] = None,
+    ) -> None:
+        super().__init__(client_identifier=profile, random_tls_extension_order=True)
+
+        if proxy:
+            self.proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
+
+        self.auto_retries = auto_retries + 1
+        self.authenticate = auth_rule
+        self.fail_exception: Type[ParentException] = None
+        atexit.register(self.close)
+
+    def __call__(self, method: str, url: str, **kwargs) -> Union[TLSResponse, None]:
+        return self.build_request(method, url, kwargs)
+
+    def build_request(
+        self, method: str, url: str, **kwargs
+    ) -> Union[TLSResponse, None]:
+        err = "Unknown"
+        for _ in range(self.auto_retries):
+            try:
+                response = self.execute_request(method.upper(), url, **kwargs)
+            except TLSClientExeption as err:
+                err = err
+                continue
+            else:
+                return response
+
+        raise RequestError("Failed to complete request.", error=err)
+
+    def parse_response(
+        self, response: TLSResponse, method: str, danger: bool
+    ) -> Response:
+        body: Union[str, dict, None] = response.text
+        headers = {key.lower(): value for key, value in response.headers.items()}
+
+        # Spotify doesn't set content-type for some reason?
+        json_encoded = "application/json" in headers.get("content-type", "")
+        is_dict = True
+
+        try:
+            json.loads(body)
+        except json.JSONDecodeError:
+            is_dict = False
+
+        if json_encoded or is_dict:
+            json_formatted = response.json()
+            body = json_formatted if isinstance(json_formatted, dict) else body
+
+        if not body:
+            body = None
+
+        resp = Response(status_code=response.status_code, response=body, raw=response)
+
+        if danger and self.fail_exception and resp.fail:
+            raise self.fail_exception(
+                f"Could not {method} {str(response.url).split('?')[0]}. Status Code: {resp.status_code}",
+                "Request Failed.",
+            )
+
+        return resp
+
+    def get(
+        self, url: str, *, authenticate: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        """Routes a GET Request"""
+        if authenticate:
+            kwargs = self.authenticate(kwargs)
+
+        response = self.build_request("GET", url, allow_redirects=True, **kwargs)
+
+        if response is None:
+            return
+
+        return self.parse_response(response, "GET", True)
+
+    def post(
+        self, url: str, *, authenticate: bool = False, danger: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        """Routes a POST Request"""
+        if authenticate:
+            kwargs = self.authenticate(kwargs)
+
+        response = self.build_request("POST", url, allow_redirects=True, **kwargs)
+
+        if response is None:
+            raise TLSClientExeption("Request kept failing after retries.")
+
+        return self.parse_response(response, "POST", danger)
+
+    def put(
+        self, url: str, *, authenticate: bool = False, danger: bool = False, **kwargs
+    ) -> Union[Response, None]:
+        """Routes a PUT Request"""
+        if authenticate:
+            kwargs = self.authenticate(kwargs)
+
+        response = self.build_request("PUT", url, allow_redirects=True, **kwargs)
+
+        if response is None:
+            raise TLSClientExeption("Request kept failing after retries.")
+
+        return self.parse_response(response, "PUT", danger)

spotapi-0.2.0/spotapi/utils/__init__.py

@@ -0,0 +1,3 @@
+from spotapi.utils.logger import Logger, NoopLogger
+from spotapi.utils.saver import *
+from spotapi.utils.strings import *

spotapi-0.2.0/spotapi/utils/logger.py

@@ -0,0 +1,92 @@
+import os
+import time
+from threading import Lock
+from datetime import datetime
+from colorama import Fore, Style, init
+from spotapi.data import LoggerProtocol
+
+os.system("")
+init(autoreset=True)
+
+# By convention we use the thread lock to ensure that we don't interfere with prints.
+# If there are multiple instances of your program, you may need to use a custom logger implementation that doesn't rely on staticmethods
+LOCK = Lock()
+
+
+class Logger(LoggerProtocol):
+    """
+    A simple Stdout logger that can be used internally.
+    """
+
+    @staticmethod
+    def __fmt_time() -> str:
+        t = datetime.now().strftime("%H:%M:%S")
+        return f"[{Style.BRIGHT}{Fore.LIGHTCYAN_EX}{str(t)}{Style.RESET_ALL}]"
+
+    @staticmethod
+    def error(s: str, **extra) -> None:
+        with LOCK:
+            fields = [
+                f"{Style.BRIGHT}{Fore.LIGHTBLUE_EX}{k}={Fore.LIGHTRED_EX}{v}{Style.RESET_ALL}"
+                for k, v in extra.items()
+            ]
+            print(
+                f"{Logger.__fmt_time()} {Style.BRIGHT}{Style.RESET_ALL}{Fore.LIGHTRED_EX}{s} "
+                + " ".join(fields)
+            )
+
+    @staticmethod
+    def debug(s: str, **extra) -> None:
+        with LOCK:
+            fields = [
+                f"{Style.BRIGHT}{Fore.LIGHTBLUE_EX}{k}={Fore.LIGHTYELLOW_EX}{v}{Style.RESET_ALL}"
+                for k, v in extra.items()
+            ]
+            print(
+                f"{Logger.__fmt_time()} {Style.BRIGHT}{Style.RESET_ALL}{Fore.LIGHTYELLOW_EX}{s} "
+                + " ".join(fields)
+            )
+
+    @staticmethod
+    def info(s: str, **extra) -> None:
+        with LOCK:
+            fields = [
+                f"{Style.BRIGHT}{Fore.LIGHTBLUE_EX}{k}={Fore.LIGHTMAGENTA_EX}{v}{Style.RESET_ALL}"
+                for k, v in extra.items()
+            ]
+            print(
+                f"{Logger.__fmt_time()} {Style.BRIGHT}{Style.RESET_ALL}{Fore.LIGHTMAGENTA_EX}{s} "
+                + " ".join(fields)
+            )
+
+    @staticmethod
+    def fatal(s: str, **extra) -> None:
+        with LOCK:
+            fields = [
+                f"{Style.BRIGHT}{Fore.LIGHTBLUE_EX}{k}={Fore.LIGHTRED_EX}{v}{Style.RESET_ALL}"
+                for k, v in extra.items()
+            ]
+            print(
+                f"{Logger.__fmt_time()} {Style.BRIGHT}{Style.RESET_ALL}{Fore.LIGHTRED_EX}{s} "
+                + " ".join(fields)
+            )
+            time.sleep(5)
+            os._exit(1)
+
+
+class NoopLogger(LoggerProtocol):
+    @staticmethod
+    def error(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def info(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def fatal(s: str, **extra) -> None:
+        ...
+
+    @staticmethod
+    def attempt(s: str, **extra) -> None:
+        ...

spotapi-0.2.0/spotapi/utils/saver.py

@@ -0,0 +1,320 @@
+""" 
+Saver.py contains a few saver implementations using the SaverProtocol interface. 
+These are popular savers that are used for session storing, but if you need a different saver, you can implement it yourself quite easily.
+"""
+
+import atexit
+import json
+import os
+import sqlite3
+from typing import Any, List, Mapping, Optional
+
+import pymongo
+import redis
+from readerwriterlock import rwlock
+
+from spotapi.data.interfaces import SaverProtocol
+from spotapi.exceptions import SaverError
+
+
+class JSONSaver(SaverProtocol):
+    """
+    CRUD methods for JSON files
+    """
+
+    def __init__(self, path: Optional[str] = "sessions.json") -> None:
+        self.path = path
+
+        self.rwlock = rwlock.RWLockFairD()
+        self.rlock = self.rwlock.gen_rlock()
+        self.wlock = self.rwlock.gen_wlock()
+
+    def save(self, data: List[Mapping[str, Any]], **kwargs) -> None:
+        """
+        Save data to a JSON file
+
+        Kwargs
+        -------
+        overwrite (bool, optional): Defaults to False.
+            Overwrites the entire file instead of appending.
+        """
+        with self.wlock:
+            if len(data) == 0:
+                raise ValueError("No data to save")
+
+            if not os.path.exists(self.path):
+                open(self.path, "w").close()
+
+            if kwargs.get("overwrite", False):
+                current = []
+            else:
+                with open(self.path, "r") as f:
+                    file_content = f.read()
+                    current = json.loads(file_content) if file_content.strip() else []
+
+            current.extend(data)
+
+            with open(self.path, "w") as f:
+                json.dump(current, f, indent=4)
+
+    def load(self, query: Mapping[str, Any], **kwargs) -> Mapping[str, Any]:
+        """
+        Load data from a JSON file given a query
+
+        Kwargs
+        -------
+        allow_collisions (bool, optional): Defaults to False.
+            Raises an error if the query returns more than one result.
+        """
+        with self.rlock:
+            if not query:
+                raise ValueError("Query dictionary cannot be empty")
+
+            with open(self.path, "r") as f:
+                data = json.load(f)
+
+            allow_collisions = kwargs.get("allow_collisions", False)
+            matches: List[Mapping[str, Any]] = []
+
+            for item in data:
+                if all(item[key] == query[key] for key in query):
+                    matches.append(item)
+                    # Save time by checking for collisions each iteration
+                    if allow_collisions and len(matches) > 1:
+                        raise SaverError("Collision found")
+
+            if len(matches) >= 1:
+                return matches[0]
+
+            raise SaverError("Item not found")
+
+    def delete(self, query: Mapping[str, Any], **kwargs) -> None:
+        """
+        Delete data from a JSON file given a query
+
+        Kwargs
+        -------
+        all_instances (bool, optional): Defaults to True.
+            Deletes all instances of the query.
+
+        clear_all (bool, optional): Defaults to False.
+            Deletes all data in the file.
+        """
+        with self.wlock:
+            if not query:
+                raise ValueError("Query dictionary cannot be empty")
+
+            delete_all_instances = kwargs.get("all_instances", True)
+            clear_all = kwargs.get("clear_all", False)
+
+            if clear_all:
+                with open(self.path, "w") as f:
+                    return json.dump([], f)
+
+            with open(self.path, "r") as f:
+                data = json.load(f)
+
+            assert isinstance(data, list), "JSON must be an array"
+
+            # Copy the list to avoid modifying the original
+            for item in data.copy():
+                if all(item[key] == query[key] for key in query):
+                    data.remove(item)
+                    if not delete_all_instances:
+                        break
+
+            with open(self.path, "w") as f:
+                json.dump(data, f, indent=4)
+
+
+class SqliteSaver(SaverProtocol):
+    """
+    CRUD methods for SQLite3 files
+    """
+
+    def __init__(self, path: str = "sessions.db") -> None:
+        self.path = path
+        self.conn = sqlite3.connect(self.path, check_same_thread=False)
+        self.cursor = self.conn.cursor()
+
+        # Create table
+        self.cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS sessions (
+                identifier TEXT PRIMARY KEY NOT NULL,
+                password TEXT NOT NULL, 
+                cookies TEXT
+            )
+        """
+        )
+
+        # Cleanup
+        atexit.register(self.cursor.close)
+        atexit.register(self.conn.close)
+
+        # Sqlite may not behave as intended under multi-threaded environments
+        self.rwlock = rwlock.RWLockFairD()
+        self.rlock = self.rwlock.gen_rlock()
+        self.wlock = self.rwlock.gen_wlock()
+
+    def save(self, data: List[Mapping[str, Any]], **kwargs) -> None:
+        """
+        Saves data to a SQLite3 database
+
+        Kwargs
+        -------
+        overwrite (bool, optional): Defaults to False.
+            Overwrites the entire database instead of appending.
+        """
+        with self.wlock:
+            try:
+                if len(data) == 0:
+                    raise ValueError("No data to save")
+
+                if kwargs.get("overwrite", False):
+                    self.cursor.execute("DELETE FROM sessions")
+                    self.conn.commit()
+
+                for item in data:
+                    self.cursor.execute(
+                        "INSERT INTO sessions VALUES (?, ?, ?)",
+                        (
+                            item["identifier"],
+                            item["password"],
+                            json.dumps(item["cookies"]),
+                        ),
+                    )
+
+                self.conn.commit()
+            except Exception as e:
+                self.conn.rollback()
+                raise SaverError(e)
+
+    def load(self, query: Mapping[str, Any], **kwargs) -> Mapping[str, Any]:
+        """
+        Loads data from a SQLite3 database given a query
+        """
+
+        with self.rlock:
+            if not query:
+                raise ValueError("Query dictionary cannot be empty")
+
+            # Turn dictionary into sql query
+            sql = "SELECT * FROM sessions WHERE "
+            params = []
+
+            for key, value in query.items():
+                sql += f"{key} = ? AND "
+                params.append(value)
+
+            self.cursor.execute(sql[:-5], tuple(params))
+            result = self.cursor.fetchall()
+
+            if len(result) == 0:
+                raise SaverError("Item not found")
+
+            return result[0]
+
+    def delete(self, query: Mapping[str, Any], **kwargs) -> None:
+        """
+        Deletes data from a SQLite3 database given a query
+        """
+        with self.wlock:
+            if not query:
+                raise ValueError("Query dictionary cannot be empty")
+
+            # Turn dictionary into sql query
+            sql = "DELETE FROM sessions WHERE "
+            params = []
+
+            for key, value in query.items():
+                sql += f"{key} = ? AND "
+                params.append(value)
+
+            self.cursor.execute(sql[:-5], tuple(params))
+            self.conn.commit()
+
+
+class MongoSaver(SaverProtocol):
+    """
+    CRUD methods for MongoDB
+    """
+
+    def __init__(
+        self,
+        host: Optional[str] = "mongodb://localhost:27017/",
+        database_name: Optional[str] = "spotify",
+        collection: Optional[str] = "sessions",
+    ) -> None:
+        self.conn = pymongo.MongoClient(host)
+        self.database = self.conn[database_name]
+        self.collection = self.database[collection]
+
+        atexit.register(self.conn.close)
+
+    def save(self, data: List[Mapping[str, Any]], **kwargs) -> None:
+        if len(data) == 0:
+            raise ValueError("No data to save")
+
+        self.collection.insert_many(data)
+
+    def load(self, query: Mapping[str, Any], **kwargs) -> Mapping[str, Any]:
+        if not query:
+            raise ValueError("Query dictionary cannot be empty")
+
+        result = self.collection.find_one(query)
+
+        if result is None:
+            raise SaverError("Item not found")
+
+        return result
+
+    def delete(self, query: Mapping[str, Any], **kwargs) -> None:
+        if not query:
+            raise ValueError("Query dictionary cannot be empty")
+
+        self.collection.delete_one(query)
+
+
+class RedisSaver(SaverProtocol):
+    def __init__(
+        self, host: Optional[str] = "localhost", port: int = 6379, db: int = 0
+    ) -> None:
+        self.client = redis.StrictRedis(host=host, port=port, db=db)
+        atexit.register(self.client.close)
+
+    def save(self, data: List[Mapping[str, Any]], **kwargs) -> None:
+        if len(data) == 0:
+            raise ValueError("No data to save")
+
+        for item in data:
+            self.client.set(item["identifier"], json.dumps(item))
+
+    def load(self, query: Mapping[str, Any], **kwargs) -> Mapping[str, Any]:
+        """
+        Loads data from a Redis database given a query.
+
+        Due to the nature of Redis, the query must be a singular identifier.
+        """
+        if not query:
+            raise ValueError("Query dictionary cannot be empty")
+
+        identifier = query.get("identifier")
+        if not identifier:
+            raise ValueError("Identifier is required for Redis lookup")
+
+        result = self.client.get(identifier)
+        if not result:
+            raise SaverError("Item not found")
+
+        return json.loads(result)
+
+    def delete(self, query: Mapping[str, Any], **kwargs) -> None:
+        if not query:
+            raise ValueError("Query dictionary cannot be empty")
+
+        identifier = query.get("identifier")
+        if not identifier:
+            raise ValueError("Identifier is required for Redis lookup")
+
+        self.client.delete(identifier)

spotapi-0.2.0/spotapi/utils/strings.py

@@ -0,0 +1,53 @@
+import string
+import random
+from typing import Optional
+
+
+def parse_json_string(b: str, s: str) -> str:
+    start_index = b.find(f'{s}":"')
+    if start_index == -1:
+        raise ValueError(f'Substring "{s}":" not found in JSON string')
+
+    value_start_index = start_index + len(s) + 3
+    value_end_index = b.find('"', value_start_index)
+    if value_end_index == -1:
+        raise ValueError(f'Closing double quote not found after "{s}":"')
+
+    return b[value_start_index:value_end_index]
+
+
+def random_string(length: int, /, strong: Optional[bool] = False) -> str:
+    letters = string.ascii_letters
+    rnd = "".join(random.choice(letters) for _ in range(length))
+
+    if strong:
+        rnd += random.choice(string.digits)
+        rnd += random.choice("@$%&*!?")
+
+    return rnd
+
+
+def random_domain() -> str:
+    domains = [
+        "gmail.com",
+        "outlook.com",
+        "yahoo.com",
+        "hotmail.com",
+        "aol.com",
+        "comcast.net",
+        "icloud.com",
+        "msn.com",
+        "live.com",
+        "protonmail.com",
+        "yandex.com",
+        "tutanota.com",
+    ]
+    return random.choice(domains)
+
+
+def random_email() -> str:
+    return f"{random_string(10)}@{random_domain()}"
+
+
+def random_dob() -> str:
+    return f"{random.randint(1950, 2000)}-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"

spotapi-0.2.0/spotapi.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: spotapi
+Version: 0.2.0
+Summary: A sleek API wrapper for Spotify's private API
+Home-page: UNKNOWN
+Author: Aran
+License: UNKNOWN
+Keywords: Spotify,API,Spotify API,Spotify Private API,Follow,Like,Creator,Music,Music API,Streaming,Music Data,Track,Playlist,Album,Artist,Music Search,Music Metadata,SpotAPI,Python Spotify Wrapper,Music Automation,Web Scraping,Python Music API,Spotify Integration,Spotify Playlist,Spotify Tracks
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# 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**: 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.
+
+## 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"),
+    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, "SOME_PLAYLIST")
+playlist.create_playlist("Spotapi Showcase!")
+
+# Save the session
+instance.save(MongoSaver())
+```
+
+[GPL 3.0](https://choosealicense.com/licenses/gpl-3.0/)
+
+
+

{spotapi-0.0.0 → spotapi-0.2.0}/spotapi.egg-info/SOURCES.txt

@@ -22,6 +22,13 @@ spotapi/data/data.py
 spotapi/data/interfaces.py
 spotapi/exceptions/__init__.py
 spotapi/exceptions/errors.py
+spotapi/http/__init__.py
+spotapi/http/data.py
+spotapi/http/request.py
 spotapi/solvers/__init__.py
 spotapi/solvers/capmonster.py
-spotapi/solvers/capsolver.py
+spotapi/solvers/capsolver.py
+spotapi/utils/__init__.py
+spotapi/utils/logger.py
+spotapi/utils/saver.py
+spotapi/utils/strings.py

spotapi-0.0.0/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.1
-Name: spotapi
-Version: 0.0.0
-Summary: A sleek API wrapper for Spotify's private API
-Home-page: UNKNOWN
-Author: Aran
-License: UNKNOWN
-Keywords: Spotify,API,Spotify API,Spotify Private API,Follow,Like,Creator,Music,Music API,Streaming,Music Data,Track,Playlist,Album,Artist,Music Search,Music Metadata,SpotAPI,Python Spotify Wrapper,Music Automation,Web Scraping,Python Music API,Spotify Integration,Spotify Playlist,Spotify Tracks
-Platform: UNKNOWN
-License-File: LICENSE
-
-UNKNOWN
-

spotapi-0.0.0/spotapi.egg-info/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.1
-Name: spotapi
-Version: 0.0.0
-Summary: A sleek API wrapper for Spotify's private API
-Home-page: UNKNOWN
-Author: Aran
-License: UNKNOWN
-Keywords: Spotify,API,Spotify API,Spotify Private API,Follow,Like,Creator,Music,Music API,Streaming,Music Data,Track,Playlist,Album,Artist,Music Search,Music Metadata,SpotAPI,Python Spotify Wrapper,Music Automation,Web Scraping,Python Music API,Spotify Integration,Spotify Playlist,Spotify Tracks
-Platform: UNKNOWN
-License-File: LICENSE
-
-UNKNOWN
-