yutipy 1.5.2__py3-none-any.whl → 1.6.12__py3-none-any.whl

yutipy/cli/search.py

@@ -14,7 +14,7 @@ from yutipy.itunes import Itunes
 from yutipy.kkbox import KKBox
 from yutipy.musicyt import MusicYT
 from yutipy.spotify import Spotify
-from yutipy.utils.logger import disable_logging, enable_logging
+from yutipy.logger import disable_logging, enable_logging
 from yutipy.yutipy_music import YutipyMusic
 
 

yutipy/deezer.py

@@ -13,7 +13,7 @@ from yutipy.exceptions import (
 )
 from yutipy.models import MusicInfo
 from yutipy.utils.helpers import are_strings_similar, is_valid_string
-from yutipy.utils.logger import logger
+from yutipy.logger import logger
 
 
 class Deezer:
@@ -323,7 +323,7 @@ class Deezer:
 
 if __name__ == "__main__":
     import logging
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
     deezer = Deezer()

yutipy/exceptions.py

@@ -11,60 +11,44 @@ __all__ = [
 class YutipyException(Exception):
     """Base class for exceptions in the Yutipy package."""
 
-    pass
+
+# Generic Exceptions
+class AuthenticationException(YutipyException):
+    """Exception raised for authentication errors."""
+
+
+class InvalidResponseException(YutipyException):
+    """Exception raised for invalid responses from APIs."""
+
+
+class InvalidValueException(YutipyException):
+    """Exception raised for invalid values."""
+
+
+class NetworkException(YutipyException):
+    """Exception raised for network-related errors."""
 
 
 # Service Exceptions
 class DeezerException(YutipyException):
     """Exception raised for errors related to the Deezer API."""
 
-    pass
-
 
 class ItunesException(YutipyException):
     """Exception raised for errors related to the iTunes API."""
 
-    pass
-
 
 class KKBoxException(YutipyException):
     """Exception raised for erros related to the KKBOX Open API."""
 
-    pass
-
 
 class MusicYTException(YutipyException):
     """Exception raised for errors related to the YouTube Music API."""
 
-    pass
-
 
 class SpotifyException(YutipyException):
     """Exception raised for errors related to the Spotify API."""
 
-    pass
-
-
-# Generic Exceptions
-class AuthenticationException(YutipyException):
-    """Exception raised for authentication errors."""
-
-    pass
-
-
-class InvalidResponseException(YutipyException):
-    """Exception raised for invalid responses from APIs."""
-
-    pass
-
-
-class InvalidValueException(YutipyException):
-    """Exception raised for invalid values."""
-
-    pass
-
-
-class NetworkException(YutipyException):
-    """Exception raised for network-related errors."""
 
-    pass
+class SpotifyAuthException(AuthenticationException):
+    """Exception raised for Spotify authorization code grant type / flow"""

yutipy/itunes.py

@@ -18,7 +18,7 @@ from yutipy.utils.helpers import (
     guess_album_type,
     is_valid_string,
 )
-from yutipy.utils.logger import logger
+from yutipy.logger import logger
 
 
 class Itunes:
@@ -228,7 +228,7 @@ class Itunes:
 
 if __name__ == "__main__":
     import logging
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
     itunes = Itunes()

yutipy/kkbox.py

@@ -18,7 +18,7 @@ from yutipy.exceptions import (
 )
 from yutipy.models import MusicInfo
 from yutipy.utils.helpers import are_strings_similar, is_valid_string
-from yutipy.utils.logger import logger
+from yutipy.logger import logger
 
 load_dotenv()
 
@@ -417,7 +417,7 @@ class KKBox:
 
 if __name__ == "__main__":
     import logging
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
     kkbox = KKBox(KKBOX_CLIENT_ID, KKBOX_CLIENT_SECRET)

yutipy/musicyt.py

@@ -13,7 +13,7 @@ from yutipy.exceptions import (
 )
 from yutipy.models import MusicInfo
 from yutipy.utils.helpers import are_strings_similar, is_valid_string
-from yutipy.utils.logger import logger
+from yutipy.logger import logger
 
 
 class MusicYT:
@@ -296,7 +296,7 @@ class MusicYT:
 if __name__ == "__main__":
     import logging
 
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
     music_yt = MusicYT()

yutipy/spotify.py

@@ -1,10 +1,13 @@
-__all__ = ["Spotify", "SpotifyException"]
+__all__ = ["Spotify", "SpotifyException", "SpotifyAuthException"]
 
 import base64
 import os
-import time
+import secrets
+import webbrowser
 from pprint import pprint
+from time import time
 from typing import Optional, Union
+from urllib.parse import urlencode
 
 import requests
 from dotenv import load_dotenv
@@ -14,8 +17,10 @@ from yutipy.exceptions import (
     InvalidResponseException,
     InvalidValueException,
     NetworkException,
+    SpotifyAuthException,
     SpotifyException,
 )
+from yutipy.logger import logger
 from yutipy.models import MusicInfo
 from yutipy.utils.helpers import (
     are_strings_similar,
@@ -23,12 +28,12 @@ from yutipy.utils.helpers import (
     is_valid_string,
     separate_artists,
 )
-from yutipy.utils.logger import logger
 
 load_dotenv()
 
 SPOTIFY_CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")
 SPOTIFY_CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")
+SPOTIFY_REDIRECT_URI = os.getenv("SPOTIFY_REDIRECT_URI")
 
 
 class Spotify:
@@ -41,8 +46,8 @@ class Spotify:
 
     def __init__(
         self,
-        client_id: str = SPOTIFY_CLIENT_ID,
-        client_secret: str = SPOTIFY_CLIENT_SECRET,
+        client_id: str = None,
+        client_secret: str = None,
     ) -> None:
         """
         Initializes the Spotify class (using Client Credentials grant type/flow) and sets up the session.
@@ -54,20 +59,28 @@ class Spotify:
         client_secret : str, optional
             The Client secret for the Spotify API. Defaults to ``SPOTIFY_CLIENT_SECRET`` from environment variable or the ``.env`` file.
         """
-        if not client_id or not client_secret:
+
+        self.client_id = client_id or SPOTIFY_CLIENT_ID
+        self.client_secret = client_secret or SPOTIFY_CLIENT_SECRET
+
+        if not self.client_id:
             raise SpotifyException(
-                "Failed to read `SPOTIFY_CLIENT_ID` and/or `SPOTIFY_CLIENT_SECRET` from environment variables. Client ID and Client Secret must be provided."
+                "Client ID was not found. Set it in environment variable or directly pass it when creating object."
+            )
+
+        if not self.client_secret:
+            raise SpotifyException(
+                "Client Secret was not found. Set it in environment variable or directly pass it when creating object."
             )
 
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self._session = requests.Session()
-        self.api_url = "https://api.spotify.com/v1"
-        self.__header, self.__expires_in = self.__authenticate()
-        self.__start_time = time.time()
         self._is_session_closed = False
-        self.normalize_non_english = True
-        self._translation_session = requests.Session()
+        self._normalize_non_english = True
+
+        self.__api_url = "https://api.spotify.com/v1"
+        self.__session = requests.Session()
+        self.__translation_session = requests.Session()
+        self.__start_time = time()
+        self.__header, self.__expires_in = self.__authenticate()
 
     def __enter__(self):
         """Enters the runtime context related to this object."""
@@ -80,8 +93,8 @@ class Spotify:
     def close_session(self) -> None:
         """Closes the current session(s)."""
         if not self.is_session_closed:
-            self._session.close()
-            self._translation_session.close()
+            self.__session.close()
+            self.__translation_session.close()
             self._is_session_closed = True
 
     @property
@@ -127,7 +140,7 @@ class Spotify:
 
         try:
             logger.info("Authenticating with Spotify API")
-            response = self._session.post(
+            response = self.__session.post(
                 url=url, headers=headers, data=data, timeout=30
             )
             logger.debug(f"Authentication response status code: {response.status_code}")
@@ -144,9 +157,9 @@ class Spotify:
 
     def __refresh_token_if_expired(self):
         """Refreshes the token if it has expired."""
-        if time.time() - self.__start_time >= self.__expires_in:
+        if time() - self.__start_time >= self.__expires_in:
             self.__header, self.__expires_in = self.__authenticate()
-            self.__start_time = time.time()
+            self.__start_time = time()
 
     def search(
         self,
@@ -179,7 +192,7 @@ class Spotify:
                 "Artist and song names must be valid strings and can't be empty."
             )
 
-        self.normalize_non_english = normalize_non_english
+        self._normalize_non_english = normalize_non_english
 
         music_info = None
         artist_ids = None
@@ -194,7 +207,7 @@ class Spotify:
 
             self.__refresh_token_if_expired()
 
-            query_url = f"{self.api_url}/search{query}"
+            query_url = f"{self.__api_url}/search{query}"
 
             logger.info(
                 f"Searching Spotify for `artist='{artist}'` and `song='{song}'`"
@@ -202,7 +215,7 @@ class Spotify:
             logger.debug(f"Query URL: {query_url}")
 
             try:
-                response = self._session.get(
+                response = self.__session.get(
                     query_url, headers=self.__header, timeout=30
                 )
                 response.raise_for_status()
@@ -256,7 +269,7 @@ class Spotify:
                 "Artist and song names must be valid strings and can't be empty."
             )
 
-        self.normalize_non_english = normalize_non_english
+        self._normalize_non_english = normalize_non_english
 
         self.__refresh_token_if_expired()
 
@@ -267,9 +280,9 @@ class Spotify:
         else:
             raise InvalidValueException("ISRC or UPC must be provided.")
 
-        query_url = f"{self.api_url}/search{query}"
+        query_url = f"{self.__api_url}/search{query}"
         try:
-            response = self._session.get(query_url, headers=self.__header, timeout=30)
+            response = self.__session.get(query_url, headers=self.__header, timeout=30)
             response.raise_for_status()
         except requests.RequestException as e:
             raise NetworkException(f"Network error occurred: {e}")
@@ -298,9 +311,9 @@ class Spotify:
         """
         artist_ids = []
         for name in separate_artists(artist):
-            query_url = f"{self.api_url}/search?q={name}&type=artist&limit=5"
+            query_url = f"{self.__api_url}/search?q={name}&type=artist&limit=5"
             try:
-                response = self._session.get(
+                response = self.__session.get(
                     query_url, headers=self.__header, timeout=30
                 )
                 response.raise_for_status()
@@ -383,8 +396,8 @@ class Spotify:
         if not are_strings_similar(
             track["name"],
             song,
-            use_translation=self.normalize_non_english,
-            translation_session=self._translation_session,
+            use_translation=self._normalize_non_english,
+            translation_session=self.__translation_session,
         ):
             return None
 
@@ -395,8 +408,8 @@ class Spotify:
             if are_strings_similar(
                 x["name"],
                 artist,
-                use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                use_translation=self._normalize_non_english,
+                translation_session=self.__translation_session,
             )
             or x["id"] in artist_ids
         ]
@@ -446,8 +459,8 @@ class Spotify:
         if not are_strings_similar(
             album["name"],
             song,
-            use_translation=self.normalize_non_english,
-            translation_session=self._translation_session,
+            use_translation=self._normalize_non_english,
+            translation_session=self.__translation_session,
         ):
             return None
 
@@ -458,8 +471,8 @@ class Spotify:
             if are_strings_similar(
                 x["name"],
                 artist,
-                use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                use_translation=self._normalize_non_english,
+                translation_session=self.__translation_session,
             )
             or x["id"] in artist_ids
         ]
@@ -490,17 +503,479 @@ class Spotify:
         return None
 
 
+class SpotifyAuth:
+    """
+    A class to interact with the Spotify API. It uses "Authorization Code" grant type (or flow).
+
+    This class reads the ``SPOTIFY_CLIENT_ID``, ``SPOTIFY_CLIENT_SECRET`` and ``SPOTIFY_REDIRECT_URI``
+    from environment variables or the ``.env`` file by default.
+    Alternatively, you can manually provide these values when creating an object.
+    """
+
+    def __init__(
+        self,
+        client_id: str = None,
+        client_secret: str = None,
+        redirect_uri: str = None,
+        scopes: list[str] = None,
+        defer_load: bool = False,
+    ):
+        """
+        Initializes the SpotifyAuth class (using Authorization Code grant type/flow) and sets up the session.
+
+        Parameters
+        ----------
+        client_id : str, optional
+            The Client ID for the Spotify API. Defaults to ``SPOTIFY_CLIENT_ID`` from environment variable or the ``.env`` file.
+        client_secret : str, optional
+            The Client secret for the Spotify API. Defaults to ``SPOTIFY_CLIENT_SECRET`` from environment variable or the ``.env`` file.
+        redirect_uri : str, optional
+            The Redirect URI for the Spotify API. Defaults to ``SPOTIFY_REDIRECT_URI`` from environment variable or the ``.env`` file.
+        scopes : list[str], optional
+            A list of scopes for the Spotify API. For example: `['user-read-email', 'user-read-private']`.
+        defer_load : bool, optional
+            Whether to defer loading the access token during initialization. Default is ``False``.
+        """
+        self.client_id = client_id or os.getenv("SPOTIFY_CLIENT_ID")
+        self.client_secret = client_secret or os.getenv("SPOTIFY_CLIENT_SECRET")
+        self.redirect_uri = redirect_uri or os.getenv("SPOTIFY_REDIRECT_URI")
+
+        if not self.client_id:
+            raise SpotifyAuthException(
+                "Client ID was not found. Set it in environment variable or directly pass it when creating object."
+            )
+
+        if not self.client_secret:
+            raise SpotifyAuthException(
+                "Client Secret was not found. Set it in environment variable or directly pass it when creating object."
+            )
+
+        if not self.redirect_uri:
+            raise SpotifyAuthException(
+                "No redirect URI was provided! Set it in environment variable or directly pass it when creating object."
+            )
+
+        self.scope = scopes
+        self.defer_load = defer_load
+
+        self._is_session_closed = False
+
+        self.__access_token = None
+        self.__refresh_token = None
+        self.__token_expires_in = None
+        self.__token_requested_at = None
+        self.__session = requests.Session()
+
+        if not scopes:
+            logger.warning(
+                "No scopes were provided. Authorization will only grant access to publicly available information."
+            )
+            self.scope = None
+        else:
+            self.scope = " ".join(scopes)
+
+        if not defer_load:
+            # Attempt to load access token during initialization if not deferred
+            try:
+                token_info = self.load_access_token()
+                if token_info:
+                    self.__access_token = token_info.get("access_token")
+                    self.__refresh_token = token_info.get("refresh_token")
+                    self.__token_expires_in = token_info.get("expires_in")
+                    self.__token_requested_at = token_info.get("requested_at")
+                else:
+                    logger.warning(
+                        "No access token found during initialization. You must authenticate to obtain a new token."
+                    )
+            except NotImplementedError:
+                logger.warning(
+                    "`load_access_token` is not implemented. Falling back to in-memory storage."
+                )
+        else:
+            logger.warning(
+                "`defer_load` is set to `True`. Make sure to call `load_token_after_init()`."
+            )
+
+    def __enter__(self):
+        """Enters the runtime context related to this object."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        """Exits the runtime context related to this object."""
+        self.close_session()
+
+    def close_session(self) -> None:
+        """Closes the current session(s)."""
+        if not self.is_session_closed:
+            self.__session.close()
+            self.__translation_session.close()
+            self._is_session_closed = True
+
+    @property
+    def is_session_closed(self) -> bool:
+        """Checks if the session is closed."""
+        return self._is_session_closed
+
+    def load_token_after_init(self):
+        """
+        Explicitly load the access token after initialization.
+        This is useful when ``defer_load`` is set to ``True`` during initialization.
+        """
+        try:
+            token_info = self.load_access_token()
+            if token_info:
+                self.__access_token = token_info.get("access_token")
+                self.__refresh_token = token_info.get("refresh_token")
+                self.__token_expires_in = token_info.get("expires_in")
+                self.__token_requested_at = token_info.get("requested_at")
+            else:
+                logger.warning(
+                    "No access token found. You must authenticate to obtain a new token."
+                )
+        except NotImplementedError:
+            logger.warning(
+                "`load_access_token` is not implemented. Falling back to in-memory storage."
+            )
+
+    def __authorization_header(self) -> dict:
+        """
+        Generates the authorization header for Spotify API requests.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the Bearer token for authentication.
+        """
+        return {"Authorization": f"Bearer {self.__access_token}"}
+
+    def __get_access_token(
+        self,
+        authorization_code: str = None,
+        refresh_token: str = None,
+    ) -> dict:
+        """
+        Gets the Spotify API access token information.
+
+        If ``authorization_code`` provided, it will try to get a new access token from Spotify.
+        Otherwise, if `refresh_token` is provided, it will refresh the access token using it
+        and return new access token information.
+
+        Returns
+        -------
+        dict
+            The Spotify API access token, with additional information such as expires in, refresh token, etc.
+        """
+        auth_string = f"{self.client_id}:{self.client_secret}"
+        auth_base64 = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
+
+        url = "https://accounts.spotify.com/api/token"
+        headers = {
+            "Authorization": f"Basic {auth_base64}",
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        if authorization_code:
+            data = {
+                "grant_type": "authorization_code",
+                "code": authorization_code,
+                "redirect_uri": self.redirect_uri,
+            }
+
+        if refresh_token:
+            data = {
+                "grant_type": "refresh_token",
+                "refresh_token": self.__refresh_token,
+            }
+
+        try:
+            logger.info(
+                "Authenticating with Spotify API using Authorization Code grant type."
+            )
+            response = self.__session.post(
+                url=url, headers=headers, data=data, timeout=30
+            )
+            logger.debug(f"Authentication response status code: {response.status_code}")
+            response.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Network error during Spotify authentication: {e}")
+            raise NetworkException(f"Network error occurred: {e}")
+
+        if response.status_code == 200:
+            response_json = response.json()
+            response_json["requested_at"] = time()
+            return response_json
+        else:
+            raise InvalidResponseException(
+                f"Invalid response received: {response.json()}"
+            )
+
+    def refresh_access_token(self):
+        """Refreshes the token if it has expired."""
+        if time() - self.__token_requested_at >= self.__token_expires_in:
+            token_info = self.__get_access_token(refresh_token=self.__refresh_token)
+
+            try:
+                self.save_access_token(token_info)
+            except NotImplementedError as e:
+                print(e)
+
+            self.__access_token = token_info.get("access_token")
+            self.__refresh_token = token_info.get("refresh_token")
+            self.__token_expires_in = token_info.get("expires_in")
+            self.__token_requested_at = token_info.get("requested_at")
+
+        logger.info("The access token is still valid, no need to refresh.")
+
+    @staticmethod
+    def generate_state() -> str:
+        """
+        Generates a random state string for use in OAuth 2.0 authorization.
+
+        This method creates a cryptographically secure, URL-safe string that can be used
+        to prevent cross-site request forgery (CSRF) attacks during the authorization process.
+
+        Returns
+        -------
+        str
+            A random URL-safe string to be used as the state parameter in OAuth 2.0.
+        """
+        return secrets.token_urlsafe(16)
+
+    def get_authorization_url(self, state: str = None):
+        """
+        Constructs the Spotify authorization URL for user authentication.
+
+        This method generates a URL that can be used to redirect users to Spotify's
+        authorization page for user authentication.
+
+        Parameters
+        ----------
+        state : str, optional
+            A random string to maintain state between the request and callback.
+            If not provided, no state parameter is included.
+
+            You may use :meth:`SpotifyAuth.generate_state` method to generate one.
+
+        Returns
+        -------
+        str
+            The full authorization URL to redirect users for Spotify authentication.
+        """
+        auth_endpoint = "https://accounts.spotify.com/authorize"
+        payload = {
+            "response_type": "code",
+            "client_id": self.client_id,
+            "redirect_uri": self.redirect_uri,
+        }
+
+        if self.scope:
+            payload["scope"] = self.scope
+
+        if state:
+            payload["state"] = state
+
+        return f"{auth_endpoint}?{urlencode(payload)}"
+
+    def save_access_token(self, token_info: dict) -> None:
+        """
+        Saves the access token and related information.
+
+        This method must be overridden in a subclass to persist the access token and other
+        related information (e.g., refresh token, expiration time). If not implemented,
+        the access token will not be saved, and users will need to re-authenticate after
+        application restarts.
+
+        Parameters
+        ----------
+        token_info : dict
+            A dictionary containing the access token and related information, such as
+            refresh token, expiration time, etc.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not overridden in a subclass.
+        """
+        raise NotImplementedError(
+            "The `save_access_token` method must be overridden in a subclass to save the access token and related information. "
+            "If not implemented, access token information will not be persisted, and users will need to re-authenticate after application restarts."
+        )
+
+    def load_access_token(self) -> Union[dict, None]:
+        """
+        Loads the access token and related information.
+
+        This method must be overridden in a subclass to retrieve the access token and other
+        related information (e.g., refresh token, expiration time) from persistent storage.
+        If not implemented, the access token will not be loaded, and users will need to
+        re-authenticate after application restarts.
+
+        Returns
+        -------
+        dict | None
+            A dictionary containing the access token and related information, such as
+            refresh token, expiration time, etc., or None if no token is found.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not overridden in a subclass.
+        """
+        raise NotImplementedError(
+            "The `load_access_token` method must be overridden in a subclass to load access token and related information. "
+            "If not implemented, access token information will not be loaded, and users will need to re-authenticate after application restarts."
+        )
+
+    def callback_handler(self, code, state, expected_state):
+        """
+        Handles the callback phase of the OAuth 2.0 authorization process.
+
+        This method processes the authorization code and state returned by Spotify after the user
+        has granted permission. It validates the state to prevent CSRF attacks, exchanges the
+        authorization code for an access token, and saves the token for future use.
+
+        Parameters
+        ----------
+        code : str
+            The authorization code returned by Spotify after user authorization.
+        state : str
+            The state parameter returned by Spotify to ensure the request's integrity.
+        expected_state : str
+            The original state parameter sent during the authorization request, used to validate the response.
+
+        Raises
+        ------
+        SpotifyAuthException
+            If the returned state does not match the expected state.
+
+        Notes
+        -----
+        - This method can be used in a web application (e.g., Flask) in the `/callback` route to handle
+          successful authorization.
+        - Ensure that the ``save_access_token`` and ``load_access_token`` methods are implemented in a subclass
+          if token persistence is required.
+
+        Example
+        -------
+        In a Flask application, you can use this method in the ``/callback`` route:
+
+        .. code-block:: python
+
+            @app.route('/callback')
+            def callback():
+                code = request.args.get('code')
+                state = request.args.get('state')
+                expected_state = session['state']  # Retrieve the state stored during authorization URL generation
+
+                try:
+                    spotify_auth.callback_handler(code, state, expected_state)
+                    return "Authorization successful!"
+                except SpotifyAuthException as e:
+                    return f"Authorization failed: {e}", 400
+        """
+        if state != expected_state:
+            raise SpotifyAuthException("state does not match!")
+
+        try:
+            token_info = self.load_access_token()
+        except NotImplementedError as e:
+            logger.warning(e)
+            token_info = self.__get_access_token(authorization_code=code)
+
+        self.__access_token = token_info.get("access_token")
+        self.__refresh_token = token_info.get("refresh_token")
+        self.__token_expires_in = token_info.get("expires_in")
+        self.__token_requested_at = token_info.get("requested_at")
+
+        try:
+            self.save_access_token(token_info)
+        except NotImplementedError as e:
+            logger.warning(e)
+
+    def get_user_profile(self):
+        """
+        Fetches the user's display name and profile images.
+
+        Notes
+        -----
+        - ``user-read-email`` and ``user-read-private`` scopes are required to access user profile information.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the user's display name and profile images.
+        """
+        endpoint_url = "https://api.spotify.com/v1/me"
+        header = self.__authorization_header()
+
+        try:
+            response = self.__session.get(endpoint_url, headers=header, timeout=30)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Failed to fetch user profile: {e}")
+            return None
+
+        if response.status_code != 200:
+            logger.error(f"Unexpected response: {response.json()}")
+            return None
+
+        response_json = response.json()
+        return {
+            "display_name": response_json.get("display_name"),
+            "images": response_json.get("images", []),
+        }
+
+
 if __name__ == "__main__":
     import logging
+    from dataclasses import asdict
 
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
-    spotify = Spotify(SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET)
-
-    try:
-        artist_name = input("Artist Name: ")
-        song_name = input("Song Name: ")
-        pprint(spotify.search(artist_name, song_name))
-    finally:
-        spotify.close_session()
+
+    print("\nChoose Spotify Grant Type/Flow:")
+    print("1. Client Credentials (Spotify)")
+    print("2. Authorization Code (SpotifyAuth)")
+    choice = input("\nEnter your choice (1 or 2): ")
+
+    if choice == "1":
+        spotify = Spotify(SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET)
+
+        try:
+            artist_name = input("Artist Name: ")
+            song_name = input("Song Name: ")
+            pprint(f"\n{asdict(spotify.search(artist_name, song_name))}")
+        finally:
+            spotify.close_session()
+
+    elif choice == "2":
+        redirect_uri = input("Enter Redirect URI: ")
+        scopes = ["user-read-email", "user-read-private"]
+
+        spotify_auth = SpotifyAuth(
+            client_id=SPOTIFY_CLIENT_ID,
+            client_secret=SPOTIFY_CLIENT_SECRET,
+            redirect_uri=redirect_uri,
+            scopes=scopes,
+        )
+
+        try:
+            state = spotify_auth.generate_state()
+            auth_url = spotify_auth.get_authorization_url(state=state)
+            print(f"Opening the following URL in your browser: {auth_url}")
+            webbrowser.open(auth_url)
+
+            code = input("Enter the authorization code: ")
+            spotify_auth.callback_handler(code, state, state)
+
+            user_profile = spotify_auth.get_user_profile()
+            if user_profile:
+                print(f"Successfully authenticated \"{user_profile['display_name']}\".")
+            else:
+                print("Authentication successful, but failed to fetch user profile.")
+        finally:
+            spotify_auth.close_session()
+
+    else:
+        print("Invalid choice. Exiting.")

yutipy/utils/__init__.py

@@ -4,7 +4,7 @@ from .helpers import (
     is_valid_string,
     separate_artists,
 )
-from .logger import disable_logging, enable_logging
+from ..logger import disable_logging, enable_logging
 
 __all__ = [
     "guess_album_type",

yutipy/yutipy_music.py

@@ -10,7 +10,7 @@ from yutipy.models import MusicInfo, MusicInfos
 from yutipy.musicyt import MusicYT
 from yutipy.spotify import Spotify
 from yutipy.utils.helpers import is_valid_string
-from yutipy.utils.logger import logger
+from yutipy.logger import logger
 
 
 class YutipyMusic:
@@ -182,7 +182,7 @@ class YutipyMusic:
 
 if __name__ == "__main__":
     import logging
-    from yutipy.utils.logger import enable_logging
+    from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
     yutipy_music = YutipyMusic()

{yutipy-1.5.2.dist-info → yutipy-1.6.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yutipy
-Version: 1.5.2
+Version: 1.6.12
 Summary: A simple package for retrieving music information from various music platforms APIs.
 Author: Cheap Nightbot
 Author-email: Cheap Nightbot <hi@cheapnightbot.slmail.me>
@@ -81,6 +81,7 @@ A _**simple**_ Python package for searching and retrieving music information fro
 - Search for music by artist and song title across multiple platforms.
 - It uses `RapidFuzz` to compare & return the best match so that you can be sure you got what you asked for without having to worry and doing all that work by yourself.
 - Retrieve detailed music information, including album art, release dates, lyrics, ISRC, and UPC codes.
+- Authorize and access user resources easily.
 
 ### Available Music Platforms
 

yutipy-1.6.12.dist-info/RECORD

@@ -0,0 +1,21 @@
+yutipy/__init__.py,sha256=qcQS17OJL9NNnQuT_gW5t6ygHawjHhqwz2hmjjDF__M,376
+yutipy/deezer.py,sha256=YZs2ilHL3pwc3AB9CmctKlyZ4GfD6qcMjZ6dgjYVxXo,11397
+yutipy/exceptions.py,sha256=fur945x1Ibu7yeIPDRsOcujfVRRa5JHQw27dsOUreK4,1393
+yutipy/itunes.py,sha256=hXMybI_lVWgAZ6QE4q_F1jOmWqIBShYQnn9nZUa8XW8,7922
+yutipy/kkbox.py,sha256=tS5LqIMlExvW1tUxMEhFXs9d9t5iFMxPp1mgaf9l7uk,14184
+yutipy/logger.py,sha256=cHCjpDslVsBOnp7jluqrOOi4ekDIggPhbSfqHeIfT-U,1263
+yutipy/models.py,sha256=vvWIA3MwCOOM2CBHSabqmFXz4NdVHaQtObU6zhGpJOM,1931
+yutipy/musicyt.py,sha256=6BvHM6SK8kSdFlGlWZIXThljIVhpwqEGUYZ7LMmXqbE,9226
+yutipy/spotify.py,sha256=9bE-qRS_Tz7F5J3T-6tSUWtimbjwczmuL-liOAOLyX8,34667
+yutipy/yutipy_music.py,sha256=3ry1KHukTInWV7xxzigYB-zWsAupBUXiAoL0F61Bmis,6531
+yutipy/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yutipy/cli/config.py,sha256=6p69ZlT3ebUH5wzhd0iisLYKOnYX6xTSzoyrdBwGNo0,3230
+yutipy/cli/search.py,sha256=8SQw0bjRzRqAg-FuVz9aWjB2KBZqmCf38SyKAQ3rx5E,3025
+yutipy/utils/__init__.py,sha256=AY1L9yFznlBzuDquyz7AnWB7t9BfFhnXJewc20hMSK4,325
+yutipy/utils/helpers.py,sha256=W3g9iqoSygcFFCKCp2sk0NQrZOEG26wI2XuNi9pgAXE,5207
+yutipy-1.6.12.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
+yutipy-1.6.12.dist-info/METADATA,sha256=X3qFVrJRJsoiBYc_s6Kax5lDQltQixUASipVKnFrfhM,6545
+yutipy-1.6.12.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+yutipy-1.6.12.dist-info/entry_points.txt,sha256=BrgmanaPjQqKQ3Ip76JLcsPgGANtrBSURf5CNIxl1HA,106
+yutipy-1.6.12.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
+yutipy-1.6.12.dist-info/RECORD,,

{yutipy-1.5.2.dist-info → yutipy-1.6.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

yutipy-1.5.2.dist-info/RECORD

@@ -1,21 +0,0 @@
-yutipy/__init__.py,sha256=qcQS17OJL9NNnQuT_gW5t6ygHawjHhqwz2hmjjDF__M,376
-yutipy/deezer.py,sha256=_-UtSq32FYqmMpmM4Y3S8KYjsxSC1tuU0jLyWZo7bBs,11409
-yutipy/exceptions.py,sha256=LdVYtmQLpX5is9iMsbjECxZYoBUdbtWR3nFN4SBVJOM,1362
-yutipy/itunes.py,sha256=IfJmAhd1OF-LOPYz4jsYOYrWqGV2hhBq8Y-ynOnohas,7934
-yutipy/kkbox.py,sha256=v21qcFzfH2Kg_dYGoEwtaBrWS3JejqpZdddeOqm2F_4,14196
-yutipy/models.py,sha256=vvWIA3MwCOOM2CBHSabqmFXz4NdVHaQtObU6zhGpJOM,1931
-yutipy/musicyt.py,sha256=gPbmhAaFa4PZ7xNNJkKnzcwnkqieOsTUcXgIenp41OM,9238
-yutipy/spotify.py,sha256=BOPa-Gc_CZbZVf-soDxCPbEOUlRc3nIVBfvf5hluCUg,16482
-yutipy/yutipy_music.py,sha256=ec_a5QcygaSISV7OeOeYkMpwzE5YBeJjfobnQ4cb-Cw,6543
-yutipy/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-yutipy/cli/config.py,sha256=6p69ZlT3ebUH5wzhd0iisLYKOnYX6xTSzoyrdBwGNo0,3230
-yutipy/cli/search.py,sha256=i2GkiKYnBewjJNu0WCqSfF7IVd0JtKwglUNk2tCLv2w,3031
-yutipy/utils/__init__.py,sha256=ehnqYct_hA5K5jXsHg3A9RNWFQLCTud86-WRhAbWOcQ,324
-yutipy/utils/helpers.py,sha256=W3g9iqoSygcFFCKCp2sk0NQrZOEG26wI2XuNi9pgAXE,5207
-yutipy/utils/logger.py,sha256=cHCjpDslVsBOnp7jluqrOOi4ekDIggPhbSfqHeIfT-U,1263
-yutipy-1.5.2.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
-yutipy-1.5.2.dist-info/METADATA,sha256=vA7sievHdgl8izs_0UeniMImIfNkUIf1_QrHZsi2az8,6498
-yutipy-1.5.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-yutipy-1.5.2.dist-info/entry_points.txt,sha256=BrgmanaPjQqKQ3Ip76JLcsPgGANtrBSURf5CNIxl1HA,106
-yutipy-1.5.2.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
-yutipy-1.5.2.dist-info/RECORD,,