yutipy 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

yutipy/deezer.py

@@ -21,10 +21,10 @@ class Deezer:
 
     def __init__(self) -> None:
         """Initializes the Deezer class and sets up the session."""
-        self._session = requests.Session()
         self.api_url = "https://api.deezer.com"
         self._is_session_closed = False
         self.normalize_non_english = True
+        self.__session = requests.Session()
         self._translation_session = requests.Session()
 
     def __enter__(self) -> "Deezer":
@@ -38,7 +38,7 @@ class Deezer:
     def close_session(self) -> None:
         """Closes the current session."""
         if not self.is_session_closed:
-            self._session.close()
+            self.__session.close()
             self._translation_session.close()
             self._is_session_closed = True
 
@@ -93,7 +93,7 @@ class Deezer:
                     f'Searching music info for `artist="{artist}"` and `song="{song}"`'
                 )
                 logger.debug(f"Query URL: {query_url}")
-                response = self._session.get(query_url, timeout=30)
+                response = self.__session.get(query_url, timeout=30)
                 logger.debug(f"Response status code: {response.status_code}")
                 response.raise_for_status()
             except requests.RequestException as e:
@@ -160,7 +160,7 @@ class Deezer:
         try:
             logger.info(f"Fetching track info for track_id: {track_id}")
             logger.debug(f"Query URL: {query_url}")
-            response = self._session.get(query_url, timeout=30)
+            response = self.__session.get(query_url, timeout=30)
             logger.debug(f"Response status code: {response.status_code}")
             response.raise_for_status()
         except requests.RequestException as e:
@@ -201,7 +201,7 @@ class Deezer:
         try:
             logger.info(f"Fetching album info for album_id: {album_id}")
             logger.debug(f"Query URL: {query_url}")
-            response = self._session.get(query_url, timeout=30)
+            response = self.__session.get(query_url, timeout=30)
             logger.info(f"Response status code: {response.status_code}")
             response.raise_for_status()
         except requests.RequestException as e:

yutipy/itunes.py

@@ -26,11 +26,11 @@ class Itunes:
 
     def __init__(self) -> None:
         """Initializes the iTunes class and sets up the session."""
-        self._session = requests.Session()
+        self.__session = requests.Session()
         self.api_url = "https://itunes.apple.com"
         self._is_session_closed = False
         self.normalize_non_english = True
-        self._translation_session = requests.Session()
+        self.__translation_session = requests.Session()
 
     def __enter__(self) -> "Itunes":
         """Enters the runtime context related to this object."""
@@ -43,8 +43,8 @@ class Itunes:
     def close_session(self) -> None:
         """Closes the current session."""
         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
@@ -96,7 +96,7 @@ class Itunes:
                     f'Searching iTunes for `artist="{artist}"` and `song="{song}"`'
                 )
                 logger.debug(f"Query URL: {query_url}")
-                response = self._session.get(query_url, timeout=30)
+                response = self.__session.get(query_url, timeout=30)
                 logger.debug(f"Response status code: {response.status_code}")
                 response.raise_for_status()
             except requests.RequestException as e:
@@ -148,13 +148,13 @@ class Itunes:
                     result.get("trackName", result["collectionName"]),
                     song,
                     use_translation=self.normalize_non_english,
-                    translation_session=self._translation_session,
+                    translation_session=self.__translation_session,
                 )
                 and are_strings_similar(
                     result["artistName"],
                     artist,
                     use_translation=self.normalize_non_english,
-                    translation_session=self._translation_session,
+                    translation_session=self.__translation_session,
                 )
             ):
                 continue

yutipy/kkbox.py

@@ -2,8 +2,9 @@ __all__ = ["KKBox", "KKBoxException"]
 
 import base64
 import os
-import time
+from dataclasses import asdict
 from pprint import pprint
+from time import time
 from typing import Optional, Union
 
 import requests
@@ -16,9 +17,9 @@ from yutipy.exceptions import (
     KKBoxException,
     NetworkException,
 )
+from yutipy.logger import logger
 from yutipy.models import MusicInfo
 from yutipy.utils.helpers import are_strings_similar, is_valid_string
-from yutipy.logger import logger
 
 load_dotenv()
 
@@ -35,7 +36,7 @@ class KKBox:
     """
 
     def __init__(
-        self, client_id: str = KKBOX_CLIENT_ID, client_secret: str = KKBOX_CLIENT_SECRET
+        self, client_id: str = None, client_secret: str = None, defer_load: bool = False
     ) -> None:
         """
         Initializes the KKBox class and sets up the session.
@@ -46,22 +47,54 @@ class KKBox:
             The Client ID for the KKBOX Open API. Defaults to ``KKBOX_CLIENT_ID`` from .env file.
         client_secret : str, optional
             The Client secret for the KKBOX Open API. Defaults to ``KKBOX_CLIENT_SECRET`` from .env file.
+        defer_load : bool, optional
+            Whether to defer loading the access token during initialization. Default is ``False``.
         """
-        if not client_id or not client_secret:
+        self.client_id = client_id or KKBOX_CLIENT_ID
+        self.client_secret = client_secret or KKBOX_CLIENT_SECRET
+
+        if not self.client_id:
             raise KKBoxException(
-                "Failed to read `KKBOX_CLIENT_ID` and/or `KKBOX_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."
             )
 
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self._session = requests.Session()
-        self.api_url = "https://api.kkbox.com/v1.1"
-        self.__header, self.__expires_in = self.__authenticate()
-        self.__start_time = time.time()
+        if not self.client_secret:
+            raise KKBoxException(
+                "Client Secret was not found. Set it in environment variable or directly pass it when creating object."
+            )
+
+        self.defer_load = defer_load
+
         self._is_session_closed = False
-        self.valid_territories = ["HK", "JP", "MY", "SG", "TW"]
-        self.normalize_non_english = True
-        self._translation_session = requests.Session()
+        self._normalize_non_english = True
+        self._valid_territories = ["HK", "JP", "MY", "SG", "TW"]
+
+        self.api_url = "https://api.kkbox.com/v1.1"
+        self.__access_token = None
+        self.__token_expires_in = None
+        self.__token_requested_at = None
+        self.__session = requests.Session()
+        self.__translation_session = requests.Session()
+
+        if not defer_load:
+            # Attempt to load access token during initialization if not deferred
+            token_info = None
+            try:
+                token_info = self.load_access_token()
+            except NotImplementedError:
+                logger.warning(
+                    "`load_access_token` is not implemented. Falling back to in-memory storage and requesting new access token."
+                )
+            finally:
+                if not token_info:
+                    token_info = self.__get_access_token()
+                self.__access_token = token_info.get("access_token")
+                self.__token_expires_in = token_info.get("expires_in")
+                self.__token_requested_at = token_info.get("requested_at")
+        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."""
@@ -74,8 +107,8 @@ class KKBox:
     def close_session(self) -> None:
         """Closes the current session."""
         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
@@ -83,31 +116,44 @@ class KKBox:
         """Checks if the session is closed."""
         return self._is_session_closed
 
-    def __authenticate(self) -> tuple:
+    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.
+        """
+        token_info = None
+        try:
+            token_info = self.load_access_token()
+        except NotImplementedError:
+            logger.warning(
+                "`load_access_token` is not implemented. Falling back to in-memory storage and requesting new access token."
+            )
+        finally:
+            if not token_info:
+                token_info = self.__get_access_token()
+            self.__access_token = token_info.get("access_token")
+            self.__token_expires_in = token_info.get("expires_in")
+            self.__token_requested_at = token_info.get("requested_at")
+
+    def __authorization_header(self) -> dict:
         """
-        Authenticates with the KKBOX Open API and returns the authorization header.
+        Generates the authorization header for Spotify API requests.
 
         Returns
         -------
         dict
-            The authorization header.
+            A dictionary containing the Bearer token for authentication.
         """
-        try:
-            token, expires_in = self.__get_access_token()
-            return {"Authorization": f"Bearer {token}"}, expires_in
-        except Exception as e:
-            raise AuthenticationException(
-                "Failed to authenticate with KKBOX Open API"
-            ) from e
-
-    def __get_access_token(self) -> tuple:
+        return {"Authorization": f"Bearer {self.__access_token}"}
+
+    def __get_access_token(self) -> dict:
         """
-        Gets the KKBOX Open API token.
+        Gets the KKBOX Open API access token information.
 
         Returns
         -------
         str
-            The KKBOX Open API token.
+            The KKBOX Open API access token, with additional information such as expires in, etc.
         """
         auth_string = f"{self.client_id}:{self.client_secret}"
         auth_base64 = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
@@ -121,7 +167,7 @@ class KKBox:
 
         try:
             logger.info("Authenticating with KKBOX Open 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}")
@@ -130,17 +176,80 @@ class KKBox:
             logger.error(f"Network error during KKBOX authentication: {e}")
             raise NetworkException(f"Network error occurred: {e}")
 
-        try:
+        if response.status_code == 200:
             response_json = response.json()
-            return response_json.get("access_token"), response_json.get("expires_in")
-        except (KeyError, ValueError) as e:
-            raise InvalidResponseException(f"Invalid response received: {e}")
+            response_json["requested_at"] = time()
+            return response_json
+        else:
+            raise InvalidResponseException(
+                f"Invalid response received: {response.json()}"
+            )
 
-    def __refresh_token_if_expired(self):
+    def __refresh_access_token(self):
         """Refreshes the token if it has expired."""
-        if time.time() - self.__start_time >= self.__expires_in:
-            self.__header, self.__expires_in = self.__authenticate()
-            self.__start_time = time.time()
+        if time() - self.__token_requested_at >= self.__token_expires_in:
+            token_info = self.__get_access_token()
+
+            try:
+                self.save_access_token(token_info)
+            except NotImplementedError as e:
+                logger.warning(e)
+
+            self.__access_token = token_info.get("access_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.")
+
+    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., expiration time). If not implemented,
+        the access token will not be saved, and it will be requested each time the
+        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., expiration time) from persistent storage.
+        If not implemented, the access token will not be loaded, and it will be requested
+        each time the 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 search(
         self,
@@ -177,9 +286,9 @@ class KKBox:
                 "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()
+        self.__refresh_access_token()
 
         query = (
             f"?q={artist} - {song}&type=track,album&territory={territory}&limit={limit}"
@@ -190,7 +299,9 @@ class KKBox:
         logger.debug(f"Query URL: {query_url}")
 
         try:
-            response = self._session.get(query_url, headers=self.__header, timeout=30)
+            response = self.__session.get(
+                query_url, headers=self.__authorization_header(), timeout=30
+            )
             logger.debug(f"Parsing response JSON: {response.json()}")
             response.raise_for_status()
         except requests.RequestException as e:
@@ -241,9 +352,9 @@ class KKBox:
                 f"`content_type` must be one of these: {valid_content_types} !"
             )
 
-        if territory not in self.valid_territories:
+        if territory not in self._valid_territories:
             raise InvalidValueException(
-                f"`territory` must be one of these: {self.valid_territories} !"
+                f"`territory` must be one of these: {self._valid_territories} !"
             )
 
         if widget_lang not in valid_widget_langs:
@@ -306,8 +417,6 @@ class KKBox:
             The name of the artist.
         track : dict
             A single track from the search results.
-        artist_ids : list
-            A list of artist IDs.
 
         Returns
         -------
@@ -317,39 +426,39 @@ class KKBox:
         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
 
-        artists_name = track["album"]["artist"]["name"]
+        artists_name = track.get("album", {}).get("artist", {}).get("name")
         matching_artists = (
             artists_name
             if are_strings_similar(
                 artists_name,
                 artist,
-                use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                use_translation=self._normalize_non_english,
+                translation_session=self.__translation_session,
             )
             else None
         )
 
         if matching_artists:
             return MusicInfo(
-                album_art=track["album"]["images"][2]["url"],
-                album_title=track["album"]["name"],
+                album_art=track.get("album", {}).get("images", [])[2]["url"],
+                album_title=track.get("album", {}).get("name"),
                 album_type=None,
                 artists=artists_name,
                 genre=None,
-                id=track["id"],
-                isrc=track["isrc"],
+                id=track.get("id"),
+                isrc=track.get("isrc"),
                 lyrics=None,
-                release_date=track["album"]["release_date"],
+                release_date=track.get("album", {}).get("release_date"),
                 tempo=None,
-                title=track["name"],
+                title=track.get("name"),
                 type="track",
                 upc=None,
-                url=track["url"],
+                url=track.get("url"),
             )
 
         return None
@@ -366,8 +475,6 @@ class KKBox:
             The name of the artist.
         album : dict
             A single album from the search results.
-        artist_ids : list
-            A list of artist IDs.
 
         Returns
         -------
@@ -377,39 +484,39 @@ class KKBox:
         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
 
-        artists_name = album["artist"]["name"]
+        artists_name = album.get("artist", {}).get("name")
         matching_artists = (
             artists_name
             if are_strings_similar(
                 artists_name,
                 artist,
-                use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                use_translation=self._normalize_non_english,
+                translation_session=self.__translation_session,
             )
             else None
         )
 
         if matching_artists:
             return MusicInfo(
-                album_art=album["images"][2]["url"],
-                album_title=album["name"],
+                album_art=album.get("images", [])[2]["url"],
+                album_title=album.get("name"),
                 album_type=None,
                 artists=artists_name,
                 genre=None,
-                id=album["id"],
+                id=album.get("id"),
                 isrc=None,
                 lyrics=None,
-                release_date=album["release_date"],
+                release_date=album.get("release_date"),
                 tempo=None,
-                title=album["name"],
+                title=album.get("name"),
                 type="album",
                 upc=None,
-                url=album["url"],
+                url=album.get("url"),
             )
 
         return None
@@ -417,6 +524,7 @@ class KKBox:
 
 if __name__ == "__main__":
     import logging
+
     from yutipy.logger import enable_logging
 
     enable_logging(level=logging.DEBUG)
@@ -425,6 +533,7 @@ if __name__ == "__main__":
     try:
         artist_name = input("Artist Name: ")
         song_name = input("Song Name: ")
-        pprint(kkbox.search(artist_name, song_name))
+        result = kkbox.search(artist_name, song_name)
+        pprint(asdict(result))
     finally:
         kkbox.close_session()

yutipy/models.py

@@ -66,3 +66,16 @@ class MusicInfos(MusicInfo):
     """
 
     album_art_source: Optional[str] = None
+
+
+@dataclass
+class UserPlaying(MusicInfo):
+    """A data class to store users' currently playing music information.
+
+    Attributes
+    ----------
+    is_playing : Optional[bool]
+        Whether the music is currently playing or paused.
+    """
+
+    is_playing: Optional[bool] = None

yutipy/musicyt.py

@@ -24,7 +24,7 @@ class MusicYT:
         self.ytmusic = YTMusic()
         self._is_session_closed = False
         self.normalize_non_english = True
-        self._translation_session = requests.Session()
+        self.__translation_session = requests.Session()
 
     def __enter__(self) -> "MusicYT":
         """Enters the runtime context related to this object."""
@@ -37,7 +37,7 @@ class MusicYT:
     def close_session(self) -> None:
         """Closes the current session(s)."""
         if not self.is_session_closed:
-            self._translation_session.close()
+            self.__translation_session.close()
             self._is_session_closed = True
 
     @property
@@ -125,13 +125,13 @@ class MusicYT:
                 result.get("title"),
                 song,
                 use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                translation_session=self.__translation_session,
             )
             and are_strings_similar(
                 _artist.get("name"),
                 artist,
                 use_translation=self.normalize_non_english,
-                translation_session=self._translation_session,
+                translation_session=self.__translation_session,
             )
             for _artist in result.get("artists", [])
         )
@@ -199,9 +199,9 @@ class MusicYT:
         MusicInfo
             The extracted music information.
         """
-        title = result["title"]
-        artist_names = ", ".join([artist["name"] for artist in result["artists"]])
-        video_id = result["videoId"]
+        title = result.get("title")
+        artist_names = ", ".join([artist.get("name") for artist in result.get("artists", [])])
+        video_id = result.get("videoId")
         song_url = f"https://music.youtube.com/watch?v={video_id}"
         lyrics_id = self.ytmusic.get_watch_playlist(video_id)
 
@@ -300,8 +300,9 @@ if __name__ == "__main__":
 
     enable_logging(level=logging.DEBUG)
     music_yt = MusicYT()
-
-    artist_name = input("Artist Name: ")
-    song_name = input("Song Name: ")
-
-    pprint(music_yt.search(artist_name, song_name))
+    try:
+        artist_name = input("Artist Name: ")
+        song_name = input("Song Name: ")
+        pprint(music_yt.search(artist_name, song_name))
+    finally:
+        music_yt.close_session()

yutipy/spotify.py

@@ -21,7 +21,7 @@ from yutipy.exceptions import (
     SpotifyException,
 )
 from yutipy.logger import logger
-from yutipy.models import MusicInfo
+from yutipy.models import MusicInfo, UserPlaying
 from yutipy.utils.helpers import (
     are_strings_similar,
     guess_album_type,
@@ -45,9 +45,7 @@ class Spotify:
     """
 
     def __init__(
-        self,
-        client_id: str = None,
-        client_secret: str = None,
+        self, client_id: str = None, client_secret: str = None, defer_load: bool = False
     ) -> None:
         """
         Initializes the Spotify class (using Client Credentials grant type/flow) and sets up the session.
@@ -58,6 +56,8 @@ class Spotify:
             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.
+        defer_load : bool, optional
+            Whether to defer loading the access token during initialization. Default is ``False``.
         """
 
         self.client_id = client_id or SPOTIFY_CLIENT_ID
@@ -73,14 +73,37 @@ class Spotify:
                 "Client Secret was not found. Set it in environment variable or directly pass it when creating object."
             )
 
+        self.defer_load = defer_load
+
         self._is_session_closed = False
         self._normalize_non_english = True
 
         self.__api_url = "https://api.spotify.com/v1"
+        self.__access_token = None
+        self.__token_expires_in = None
+        self.__token_requested_at = None
         self.__session = requests.Session()
         self.__translation_session = requests.Session()
-        self.__start_time = time()
-        self.__header, self.__expires_in = self.__authenticate()
+
+        if not defer_load:
+            # Attempt to load access token during initialization if not deferred
+            token_info = None
+            try:
+                token_info = self.load_access_token()
+            except NotImplementedError:
+                logger.warning(
+                    "`load_access_token` is not implemented. Falling back to in-memory storage and requesting new access token."
+                )
+            finally:
+                if not token_info:
+                    token_info = self.__get_access_token()
+                self.__access_token = token_info.get("access_token")
+                self.__token_expires_in = token_info.get("expires_in")
+                self.__token_requested_at = token_info.get("requested_at")
+        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."""
@@ -102,31 +125,44 @@ class Spotify:
         """Checks if the session is closed."""
         return self._is_session_closed
 
-    def __authenticate(self) -> tuple:
+    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.
         """
-        Authenticates with the Spotify API and returns the authorization header.
+        token_info = None
+        try:
+            token_info = self.load_access_token()
+        except NotImplementedError:
+            logger.warning(
+                "`load_access_token` is not implemented. Falling back to in-memory storage and requesting new access token."
+            )
+        finally:
+            if not token_info:
+                token_info = self.__get_access_token()
+            self.__access_token = token_info.get("access_token")
+            self.__token_expires_in = token_info.get("expires_in")
+            self.__token_requested_at = token_info.get("requested_at")
+
+    def __authorization_header(self) -> dict:
+        """
+        Generates the authorization header for Spotify API requests.
 
         Returns
         -------
         dict
-            The authorization header.
+            A dictionary containing the Bearer token for authentication.
         """
-        try:
-            token, expires_in = self.__get_spotify_token()
-            return {"Authorization": f"Bearer {token}"}, expires_in
-        except Exception as e:
-            raise AuthenticationException(
-                "Failed to authenticate with Spotify API"
-            ) from e
+        return {"Authorization": f"Bearer {self.__access_token}"}
 
-    def __get_spotify_token(self) -> tuple:
+    def __get_access_token(self) -> dict:
         """
-        Gets the Spotify API token.
+        Gets the Spotify API access token information.
 
         Returns
         -------
-        str
-            The Spotify API token.
+        dict
+            The Spotify API access token, with additional information such as expires in, etc.
         """
         auth_string = f"{self.client_id}:{self.client_secret}"
         auth_base64 = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
@@ -139,7 +175,9 @@ class Spotify:
         data = {"grant_type": "client_credentials"}
 
         try:
-            logger.info("Authenticating with Spotify API")
+            logger.info(
+                "Authenticating with Spotify API using Client Credentials grant type."
+            )
             response = self.__session.post(
                 url=url, headers=headers, data=data, timeout=30
             )
@@ -149,17 +187,80 @@ class Spotify:
             logger.error(f"Network error during Spotify authentication: {e}")
             raise NetworkException(f"Network error occurred: {e}")
 
-        try:
+        if response.status_code == 200:
             response_json = response.json()
-            return response_json.get("access_token"), response_json.get("expires_in")
-        except (KeyError, ValueError) as e:
-            raise InvalidResponseException(f"Invalid response received: {e}")
+            response_json["requested_at"] = time()
+            return response_json
+        else:
+            raise InvalidResponseException(
+                f"Invalid response received: {response.json()}"
+            )
 
-    def __refresh_token_if_expired(self):
+    def __refresh_access_token(self):
         """Refreshes the token if it has expired."""
-        if time() - self.__start_time >= self.__expires_in:
-            self.__header, self.__expires_in = self.__authenticate()
-            self.__start_time = time()
+        if time() - self.__token_requested_at >= self.__token_expires_in:
+            token_info = self.__get_access_token()
+
+            try:
+                self.save_access_token(token_info)
+            except NotImplementedError as e:
+                logger.warning(e)
+
+            self.__access_token = token_info.get("access_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.")
+
+    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., expiration time). If not implemented,
+        the access token will not be saved, and it will be requested each time the
+        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., expiration time) from persistent storage.
+        If not implemented, the access token will not be loaded, and it will be requested
+        each time the 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 search(
         self,
@@ -205,7 +306,7 @@ class Spotify:
             if music_info:
                 return music_info
 
-            self.__refresh_token_if_expired()
+            self.__refresh_access_token()
 
             query_url = f"{self.__api_url}/search{query}"
 
@@ -216,7 +317,7 @@ class Spotify:
 
             try:
                 response = self.__session.get(
-                    query_url, headers=self.__header, timeout=30
+                    query_url, headers=self.__authorization_header(), timeout=30
                 )
                 response.raise_for_status()
             except requests.RequestException as e:
@@ -271,7 +372,7 @@ class Spotify:
 
         self._normalize_non_english = normalize_non_english
 
-        self.__refresh_token_if_expired()
+        self.__refresh_access_token()
 
         if isrc:
             query = f"?q={artist} {song} isrc:{isrc}&type=track&limit={limit}"
@@ -282,7 +383,9 @@ class Spotify:
 
         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.__authorization_header(), timeout=30
+            )
             response.raise_for_status()
         except requests.RequestException as e:
             raise NetworkException(f"Network error occurred: {e}")
@@ -314,7 +417,7 @@ class Spotify:
             query_url = f"{self.__api_url}/search?q={name}&type=artist&limit=5"
             try:
                 response = self.__session.get(
-                    query_url, headers=self.__header, timeout=30
+                    query_url, headers=self.__authorization_header(), timeout=30
                 )
                 response.raise_for_status()
             except requests.RequestException as e:
@@ -560,6 +663,7 @@ class SpotifyAuth:
 
         self._is_session_closed = False
 
+        self.__api_url = "https://api.spotify.com/v1/me"
         self.__access_token = None
         self.__refresh_token = None
         self.__token_expires_in = None
@@ -608,7 +712,6 @@ class SpotifyAuth:
         """Closes the current session(s)."""
         if not self.is_session_closed:
             self.__session.close()
-            self.__translation_session.close()
             self._is_session_closed = True
 
     @property
@@ -709,7 +812,7 @@ class SpotifyAuth:
                 f"Invalid response received: {response.json()}"
             )
 
-    def refresh_access_token(self):
+    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)
@@ -717,7 +820,7 @@ class SpotifyAuth:
             try:
                 self.save_access_token(token_info)
             except NotImplementedError as e:
-                print(e)
+                logger.warning(e)
 
             self.__access_token = token_info.get("access_token")
             self.__refresh_token = token_info.get("refresh_token")
@@ -909,11 +1012,12 @@ class SpotifyAuth:
         dict
             A dictionary containing the user's display name and profile images.
         """
-        endpoint_url = "https://api.spotify.com/v1/me"
+        self.__refresh_access_token()
+        query_url = self.__api_url
         header = self.__authorization_header()
 
         try:
-            response = self.__session.get(endpoint_url, headers=header, timeout=30)
+            response = self.__session.get(query_url, headers=header, timeout=30)
             response.raise_for_status()
         except requests.RequestException as e:
             logger.error(f"Failed to fetch user profile: {e}")
@@ -929,6 +1033,72 @@ class SpotifyAuth:
             "images": response_json.get("images", []),
         }
 
+    def get_currently_playing(self) -> Optional[UserPlaying]:
+        """
+        Fetches information about the currently playing track for the authenticated user.
+
+        This method interacts with the Spotify API to retrieve details about the track
+        the user is currently listening to. It includes information such as the track's
+        title, album, artists, release date, and more.
+
+        Returns
+        -------
+        Optional[UserPlaying_]
+            An instance of the ``UserPlaying`` model containing details about the currently
+            playing track if available, or ``None`` if no track is currently playing or an
+            error occurs.
+
+        Notes
+        -----
+        - The user must have granted the necessary permissions (e.g., `user-read-currently-playing` scope) for this method to work.
+        - If the API response does not contain the expected data, the method will return `None`.
+
+        """
+        self.__refresh_access_token()
+        query_url = f"{self.__api_url}/player/currently-playing"
+        header = self.__authorization_header()
+
+        try:
+            response = self.__session.get(query_url, headers=header, timeout=30)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            raise NetworkException(f"Network error occurred: {e}")
+
+        if response.status_code != 200:
+            logger.error(f"Unexpected response: {response.json()}")
+            return None
+
+        response_json = response.json()
+        result = response_json.get("item")
+        if result:
+            guess = guess_album_type(result.get("album", {}).get("total_tracks", 1))
+            guessed_right = are_strings_similar(
+                result.get("album", {}).get("album_type", "x"),
+                guess,
+                use_translation=False,
+            )
+            return UserPlaying(
+                album_art=result.get("album", {}).get("images", [])[0].get("url"),
+                album_title=result.get("album", {}).get("name"),
+                album_type=(
+                    result.get("album", {}).get("album_type")
+                    if guessed_right
+                    else guess
+                ),
+                artists=", ".join([x["name"] for x in result.get("artists", [])]),
+                genre=None,
+                id=result.get("id"),
+                isrc=result.get("external_ids", {}).get("isrc"),
+                is_playing=response_json.get("is_playing"),
+                lyrics=None,
+                release_date=result.get("album", {}).get("release_date"),
+                tempo=None,
+                title=result.get("name"),
+                type=result.get("type"),
+                upc=result.get("external_ids", {}).get("upc"),
+                url=result.get("external_urls", {}).get("spotify"),
+            )
+
 
 if __name__ == "__main__":
     import logging
@@ -949,7 +1119,8 @@ if __name__ == "__main__":
         try:
             artist_name = input("Artist Name: ")
             song_name = input("Song Name: ")
-            pprint(f"\n{asdict(spotify.search(artist_name, song_name))}")
+            result = spotify.search(artist_name, song_name)
+            pprint(asdict(result))
         finally:
             spotify.close_session()
 

yutipy/yutipy_music.py

@@ -1,3 +1,5 @@
+__all__ = ["YutipyMusic"]
+
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pprint import pprint
 from typing import Optional

{yutipy-2.0.0.dist-info → yutipy-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yutipy
-Version: 2.0.0
+Version: 2.1.1
 Summary: A simple package for retrieving music information from various music platforms APIs.
 Author: Cheap Nightbot
 Author-email: Cheap Nightbot <hi@cheapnightbot.slmail.me>

yutipy-2.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+yutipy/__init__.py,sha256=eURfdAFBvA9xF6cuUJUMWLf44LHxRQuXONfIPD-CkIQ,268
+yutipy/deezer.py,sha256=PTTTfeORh1HZ_ta7_Uu4YARouSknUnAxO9AQJPFm4v0,11402
+yutipy/exceptions.py,sha256=fur945x1Ibu7yeIPDRsOcujfVRRa5JHQw27dsOUreK4,1393
+yutipy/itunes.py,sha256=fV7KLsXWvfM_97KwVwn_KfnWM7j0cVGE7RytvnDGlZM,7929
+yutipy/kkbox.py,sha256=MuYpR_UTZQxeitn2rc0UUgiMVikIXcVWmns3eSVjd_g,18847
+yutipy/logger.py,sha256=cHCjpDslVsBOnp7jluqrOOi4ekDIggPhbSfqHeIfT-U,1263
+yutipy/models.py,sha256=_92e54uXXCw53oWZiNLBBai6C0InOZMJL7r8GJ5smbM,2215
+yutipy/musicyt.py,sha256=6Vz8bI8hDNFoDKRh6GK90dGMRbn_d5d6eGPsaYogb_Y,9315
+yutipy/spotify.py,sha256=m9GV3xZ94jRKtajMo34BARuR4l2gP6sUfZ8CKsJQDWo,42135
+yutipy/yutipy_music.py,sha256=cHJ95HxGILweVrnEacj8tTlU0NPxMpuDVMpngdX0mZQ,6558
+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=AZaqvs6AJwnqwJuodbGnHu702WSUqc8plVC16SppOcU,239
+yutipy/utils/helpers.py,sha256=W3g9iqoSygcFFCKCp2sk0NQrZOEG26wI2XuNi9pgAXE,5207
+yutipy-2.1.1.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
+yutipy-2.1.1.dist-info/METADATA,sha256=86Xbqgk9pHIiGIQkZAMzaOKkUu4vmo8sadsoH1hAlQ8,6494
+yutipy-2.1.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+yutipy-2.1.1.dist-info/entry_points.txt,sha256=BrgmanaPjQqKQ3Ip76JLcsPgGANtrBSURf5CNIxl1HA,106
+yutipy-2.1.1.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
+yutipy-2.1.1.dist-info/RECORD,,

yutipy-2.0.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-yutipy/__init__.py,sha256=eURfdAFBvA9xF6cuUJUMWLf44LHxRQuXONfIPD-CkIQ,268
-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=7BG9iv42mQk5CGAd7879fvUwo5ImpQlbFf3yfAzhnQI,34722
-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=AZaqvs6AJwnqwJuodbGnHu702WSUqc8plVC16SppOcU,239
-yutipy/utils/helpers.py,sha256=W3g9iqoSygcFFCKCp2sk0NQrZOEG26wI2XuNi9pgAXE,5207
-yutipy-2.0.0.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
-yutipy-2.0.0.dist-info/METADATA,sha256=3KzURL_aKX4g6PHVo0RYO_cMxTnQ8cCHNeXVZsMxvRE,6494
-yutipy-2.0.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-yutipy-2.0.0.dist-info/entry_points.txt,sha256=BrgmanaPjQqKQ3Ip76JLcsPgGANtrBSURf5CNIxl1HA,106
-yutipy-2.0.0.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
-yutipy-2.0.0.dist-info/RECORD,,