yutipy 1.4.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

yutipy/__init__.py

@@ -1,17 +1,17 @@
 from .deezer import Deezer
 from .itunes import Itunes
 from .kkbox import KKBox
-from .models import MusicInfo
 from .musicyt import MusicYT
 from .spotify import Spotify
 from .yutipy_music import YutipyMusic
+from . import exceptions
 
 __all__ = [
     "Deezer",
     "Itunes",
     "KKBox",
-    "MusicInfo",
     "MusicYT",
     "Spotify",
     "YutipyMusic",
+    "exceptions"
 ]

yutipy/cli/config.py

@@ -0,0 +1,86 @@
+import os
+import webbrowser
+from dotenv import load_dotenv, set_key
+
+
+def run_config_wizard():
+    """Interactive configuration wizard for setting up API keys."""
+    print("Welcome to the yutipy Configuration Wizard!")
+    print("This wizard will help you set up your API keys for various services.\n")
+
+    # Load existing .env file if it exists
+    env_file = ".env"
+    load_dotenv(env_file)
+
+    # List of required environment variables and their instructions
+    required_vars = {
+        "SPOTIFY_CLIENT_ID": {
+            "description": "Spotify Client ID",
+            "url": "https://developer.spotify.com/dashboard",
+            "instructions": """
+1. Go to your Spotify Developer Dashboard: https://developer.spotify.com/dashboard
+2. Create a new app and fill in the required details.
+3. Copy the "Client ID" and "Client Secret" from the app's settings.
+4. Paste them here when prompted.
+            """,
+        },
+        "SPOTIFY_CLIENT_SECRET": {
+            "description": "Spotify Client Secret",
+            "url": "https://developer.spotify.com/dashboard",
+            "instructions": "See the steps above for Spotify Client ID.",
+        },
+        "KKBOX_CLIENT_ID": {
+            "description": "KKBox Client ID",
+            "url": "https://developer.kkbox.com/",
+            "instructions": """
+1. Go to the KKBOX Developer Portal: https://developer.kkbox.com/
+2. Log in and create a new application.
+3. Copy the "Client ID" and "Client Secret" from the app's settings.
+4. Paste them here when prompted.
+            """,
+        },
+        "KKBOX_CLIENT_SECRET": {
+            "description": "KKBox Client Secret",
+            "url": "https://developer.kkbox.com/",
+            "instructions": "See the steps above for KKBox Client ID.",
+        },
+    }
+
+    # Track whether the browser has already been opened for a service
+    browser_opened = set()
+
+    # Prompt the user for each variable
+    for var, details in required_vars.items():
+        current_value = os.getenv(var)
+        if current_value:
+            print(f"{details['description']} is already set.")
+            continue
+
+        print(f"\n{details['description']} is missing.")
+        print(details["instructions"])
+
+        # Check if the browser has already been opened for this service
+        if details["url"] not in browser_opened:
+            open_browser = (
+                input(
+                    f"Do you want to open the website to get your {details['description']}? (y/N): "
+                )
+                .strip()
+                .lower()
+            )
+            if open_browser == "y":
+                webbrowser.open(details["url"])
+                print(f"The website has been opened in your browser: {details['url']}")
+                browser_opened.add(details["url"])  # Mark this URL as opened
+
+        # Prompt the user to enter the value
+        new_value = input(f"Enter your {details['description']}: ").strip()
+        if new_value:
+            set_key(env_file, var, new_value)
+            print(f"{details['description']} has been saved to the .env file.")
+
+    print("\nConfiguration complete! Your API keys have been saved to the .env file.")
+
+
+if __name__ == "__main__":
+    run_config_wizard()

yutipy/cli/search.py

@@ -0,0 +1,104 @@
+import argparse
+from dataclasses import asdict
+from pprint import pprint
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("yutipy")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from yutipy.deezer import Deezer
+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.yutipy_music import YutipyMusic
+
+
+def main():
+    disable_logging()
+
+    # Create the argument parser
+    parser = argparse.ArgumentParser(
+        description="Search for music information across multiple platforms using yutipy."
+    )
+    parser.add_argument("artist", type=str, help="The name of the artist.")
+    parser.add_argument("song", type=str, help="The title of the song.")
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=5,
+        help="The number of results to retrieve (default: 5).",
+    )
+    parser.add_argument(
+        "--normalize",
+        action="store_true",
+        help="Normalize non-English characters.",
+        default=False,
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable logging in terminal",
+        default=False,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"yutipy v{__version__}",
+        help="Show the version of the yutipy and exit.",
+    )
+    parser.add_argument(
+        "--service",
+        type=str,
+        choices=["deezer", "itunes", "kkbox", "spotify", "ytmusic"],
+        help="Specify a single service to search (e.g., deezer, itunes, kkbox, spotify, ytmusic).",
+    )
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    if args.verbose:
+        enable_logging()
+
+    # Use the specified service or default to YutipyMusic
+    try:
+        if args.service:
+            service_map = {
+                "deezer": Deezer,
+                "itunes": Itunes,
+                "kkbox": KKBox,
+                "spotify": Spotify,
+                "ytmusic": MusicYT,
+            }
+            service_class = service_map[args.service]
+            with service_class() as service:
+                result = service.search(
+                    artist=args.artist,
+                    song=args.song,
+                    limit=args.limit,
+                    normalize_non_english=args.normalize,
+                )
+        else:
+            with YutipyMusic() as yutipy_music:
+                result = yutipy_music.search(
+                    artist=args.artist,
+                    song=args.song,
+                    limit=args.limit,
+                    normalize_non_english=args.normalize,
+                )
+
+        if result:
+            print("\nSEARCH RESULTS:\n")
+            pprint(asdict(result))
+        else:
+            print("No results found.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+if __name__ == "__main__":
+    main()

yutipy/deezer.py

@@ -10,7 +10,8 @@ from yutipy.exceptions import (
     NetworkException,
 )
 from yutipy.models import MusicInfo
-from yutipy.utils.cheap_utils import are_strings_similar, is_valid_string
+from yutipy.utils.helpers import are_strings_similar, is_valid_string
+from yutipy.utils.logger import logger
 
 
 class Deezer:
@@ -86,22 +87,34 @@ class Deezer:
             query_url = endpoint + query
 
             try:
+                logger.info(
+                    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)
+                logger.debug(f"Response status code: {response.status_code}")
                 response.raise_for_status()
             except requests.RequestException as e:
+                logger.error(f"Network error while fetching music info: {e}")
                 raise NetworkException(f"Network error occurred: {e}")
             except Exception as e:
+                logger.exception(f"Unexpected error while searching Deezer: {e}")
                 raise DeezerException(f"An error occurred while searching Deezer: {e}")
 
             try:
+                logger.debug(f"Parsing response JSON: {response.json()}")
                 result = response.json()["data"]
             except (IndexError, KeyError, ValueError) as e:
+                logger.error(f"Invalid response structure from Deezer: {e}")
                 raise InvalidResponseException(f"Invalid response received: {e}")
 
             music_info = self._parse_results(artist, song, result)
             if music_info:
                 return music_info
 
+        logger.warning(
+            f"No matching results found for artist='{artist}' and song='{song}'"
+        )
         return None
 
     def _get_upc_isrc(self, music_id: int, music_type: str) -> Optional[Dict]:
@@ -127,7 +140,7 @@ class Deezer:
         else:
             raise DeezerException(f"Invalid music type: {music_type}")
 
-    def _get_track_info(self, music_id: int) -> Optional[Dict]:
+    def _get_track_info(self, track_id: int) -> Optional[Dict]:
         """
         Retrieves track information for a given track ID.
 
@@ -141,18 +154,25 @@ class Deezer:
         Optional[Dict]
             A dictionary containing track information.
         """
-        query_url = f"{self.api_url}/track/{music_id}"
+        query_url = f"{self.api_url}/track/{track_id}"
         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)
+            logger.debug(f"Response status code: {response.status_code}")
             response.raise_for_status()
         except requests.RequestException as e:
+            logger.error(f"Error fetching track info: {e}")
             raise NetworkException(f"Network error occurred: {e}")
         except Exception as e:
+            logger.error(f"Error fetching track info: {e}")
             raise DeezerException(f"An error occurred while fetching track info: {e}")
 
         try:
+            logger.debug(f"Response JSON: {response.json()}")
             result = response.json()
         except ValueError as e:
+            logger.error(f"Invalid response received from Deezer: {e}")
             raise InvalidResponseException(f"Invalid response received: {e}")
 
         return {
@@ -161,7 +181,7 @@ class Deezer:
             "tempo": result.get("bpm"),
         }
 
-    def _get_album_info(self, music_id: int) -> Optional[Dict]:
+    def _get_album_info(self, album_id: int) -> Optional[Dict]:
         """
         Retrieves album information for a given album ID.
 
@@ -175,18 +195,25 @@ class Deezer:
         Optional[Dict]
             A dictionary containing album information.
         """
-        query_url = f"{self.api_url}/album/{music_id}"
+        query_url = f"{self.api_url}/album/{album_id}"
         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)
+            logger.info(f"Response status code: {response.status_code}")
             response.raise_for_status()
         except requests.RequestException as e:
+            logger.error(f"Error fetching album info: {e}")
             raise NetworkException(f"Network error occurred: {e}")
         except Exception as e:
+            logger.error(f"Error fetching album info: {e}")
             raise DeezerException(f"An error occurred while fetching album info: {e}")
 
         try:
+            logger.debug(f"Response JSON: {response.json()}")
             result = response.json()
         except ValueError as e:
+            logger.error(f"Invalid response received from Deezer: {e}")
             raise InvalidResponseException(f"Invalid response received: {e}")
 
         return {
@@ -293,6 +320,10 @@ class Deezer:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     deezer = Deezer()
     try:
         artist_name = input("Artist Name: ")

yutipy/itunes.py

@@ -11,11 +11,12 @@ from yutipy.exceptions import (
     NetworkException,
 )
 from yutipy.models import MusicInfo
-from yutipy.utils.cheap_utils import (
+from yutipy.utils.helpers import (
     are_strings_similar,
     guess_album_type,
     is_valid_string,
 )
+from yutipy.utils.logger import logger
 
 
 class Itunes:
@@ -89,22 +90,34 @@ class Itunes:
             query_url = endpoint + query
 
             try:
+                logger.info(
+                    f'Searching iTunes for `artist="{artist}"` and `song="{song}"`'
+                )
+                logger.debug(f"Query URL: {query_url}")
                 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:
+                logger.error(f"Network error while searching iTunes: {e}")
                 raise NetworkException(f"Network error occurred: {e}")
             except Exception as e:
+                logger.exception(f"Unexpected error while searching iTunes: {e}")
                 raise ItunesException(f"An error occurred while searching iTunes: {e}")
 
             try:
+                logger.debug(f"Parsing response JSON: {response.json()}")
                 result = response.json()["results"]
             except (IndexError, KeyError, ValueError) as e:
+                logger.error(f"Invalid response structure from iTunes: {e}")
                 raise InvalidResponseException(f"Invalid response received: {e}")
 
             music_info = self._parse_result(artist, song, result)
             if music_info:
                 return music_info
 
+        logger.warning(
+            f"No matching results found for artist='{artist}' and song='{song}'"
+        )
         return None
 
     def _parse_result(
@@ -212,6 +225,10 @@ class Itunes:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     itunes = Itunes()
 
     try:

yutipy/kkbox.py

@@ -15,7 +15,8 @@ from yutipy.exceptions import (
     NetworkException,
 )
 from yutipy.models import MusicInfo
-from yutipy.utils.cheap_utils import are_strings_similar, is_valid_string
+from yutipy.utils.helpers import are_strings_similar, is_valid_string
+from yutipy.utils.logger import logger
 
 load_dotenv()
 
@@ -117,11 +118,14 @@ class KKBox:
         data = {"grant_type": "client_credentials"}
 
         try:
+            logger.info("Authenticating with KKBOX Open API")
             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 KKBOX authentication: {e}")
             raise NetworkException(f"Network error occurred: {e}")
 
         try:
@@ -180,8 +184,12 @@ class KKBox:
         )
         query_url = f"{self.api_url}/search{query}"
 
+        logger.info(f"Searching KKBOX for `artist='{artist}'` and `song='{song}'`")
+        logger.debug(f"Query URL: {query_url}")
+
         try:
             response = self._session.get(query_url, headers=self.__header, timeout=30)
+            logger.debug(f"Parsing response JSON: {response.json()}")
             response.raise_for_status()
         except requests.RequestException as e:
             raise NetworkException(f"Network error occurred: {e}")
@@ -279,6 +287,9 @@ class KKBox:
         except KeyError:
             pass
 
+        logger.warning(
+            f"No matching results found for artist='{artist}' and song='{song}'"
+        )
         return None
 
     def _find_track(self, song: str, artist: str, track: dict) -> Optional[MusicInfo]:
@@ -403,6 +414,10 @@ class KKBox:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     kkbox = KKBox(KKBOX_CLIENT_ID, KKBOX_CLIENT_SECRET)
 
     try:

yutipy/logging.py

@@ -0,0 +1,3 @@
+from .utils.logger import enable_logging, disable_logging
+
+__all__ = ["enable_logging", "disable_logging"]

yutipy/models.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Union
+from typing import Dict, Optional, Union
 
 
 @dataclass

yutipy/musicyt.py

@@ -11,7 +11,8 @@ from yutipy.exceptions import (
     NetworkException,
 )
 from yutipy.models import MusicInfo
-from yutipy.utils.cheap_utils import are_strings_similar, is_valid_string
+from yutipy.utils.helpers import are_strings_similar, is_valid_string
+from yutipy.utils.logger import logger
 
 
 class MusicYT:
@@ -24,6 +25,14 @@ class MusicYT:
         self.normalize_non_english = True
         self._translation_session = requests.Session()
 
+    def __enter__(self) -> "MusicYT":
+        """Enters the runtime context related to this object."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
+        """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:
@@ -70,15 +79,23 @@ class MusicYT:
 
         query = f"{artist} - {song}"
 
+        logger.info(
+            f"Searching YouTube Music for `artist='{artist}'` and `song='{song}'`"
+        )
+
         try:
             results = self.ytmusic.search(query=query, limit=limit)
         except exceptions.YTMusicServerError as e:
+            logger.error(f"Network error while searching YouTube Music: {e}")
             raise NetworkException(f"Network error occurred: {e}")
 
         for result in results:
             if self._is_relevant_result(artist, song, result):
                 return self._process_result(result)
 
+        logger.warning(
+            f"No matching results found for artist='{artist}' and song='{song}'"
+        )
         return None
 
     def _is_relevant_result(self, artist: str, song: str, result: dict) -> bool:
@@ -276,6 +293,10 @@ class MusicYT:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     music_yt = MusicYT()
 
     artist_name = input("Artist Name: ")

yutipy/spotify.py

@@ -15,12 +15,13 @@ from yutipy.exceptions import (
     SpotifyException,
 )
 from yutipy.models import MusicInfo
-from yutipy.utils.cheap_utils import (
+from yutipy.utils.helpers import (
     are_strings_similar,
     guess_album_type,
     is_valid_string,
     separate_artists,
 )
+from yutipy.utils.logger import logger
 
 load_dotenv()
 
@@ -123,11 +124,14 @@ class Spotify:
         data = {"grant_type": "client_credentials"}
 
         try:
+            logger.info("Authenticating with Spotify API")
             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}")
 
         try:
@@ -190,6 +194,11 @@ class Spotify:
 
             query_url = f"{self.api_url}/search{query}"
 
+            logger.info(
+                f"Searching Spotify for `artist='{artist}'` and `song='{song}'`"
+            )
+            logger.debug(f"Query URL: {query_url}")
+
             try:
                 response = self._session.get(
                     query_url, headers=self.__header, timeout=30
@@ -342,6 +351,9 @@ class Spotify:
         except KeyError:
             pass
 
+        logger.warning(
+            f"No matching results found for artist='{artist}' and song='{song}'"
+        )
         return None
 
     def _find_track(
@@ -477,6 +489,10 @@ class Spotify:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     spotify = Spotify(SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET)
 
     try:

yutipy/utils/__init__.py

@@ -1,4 +1,4 @@
-from .cheap_utils import (
+from .helpers import (
     guess_album_type,
     are_strings_similar,
     is_valid_string,

yutipy/utils/{cheap_utils.py → helpers.py}

@@ -139,7 +139,3 @@ def guess_album_type(total_tracks: int):
         return "ep"
     if total_tracks >= 7:
         return "album"
-
-
-if __name__ == "__main__":
-    separate_artists("Artist A ft. Artist B")

yutipy/utils/logger.py

@@ -1,4 +1,39 @@
 import logging
 
-logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
-logger = logging.getLogger(__name__)
+# Create a logger for the library
+logger = logging.getLogger("yutipy")
+logger.setLevel(logging.WARNING)
+
+
+def enable_logging(level=logging.INFO, handler=None):
+    """Enable logging for the library.
+
+    Parameters
+    ----------
+    level : int, optional
+        The logging level to set, by default logging.INFO.
+    handler : logging.Handler, optional
+        A custom logging handler to add, by default None (uses console handler).
+    """
+    logger.setLevel(level)
+
+    # If no handler is provided, use the default console handler
+    if handler is None:
+        console_handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "[%(asctime)s] | %(name)s | [%(levelname)s] → %(module)s : line %(lineno)d : %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S %Z",
+        )
+        console_handler.setFormatter(formatter)
+        handler = console_handler
+
+    # Add the handler if not already added
+    if not any(isinstance(h, type(handler)) for h in logger.handlers):
+        logger.addHandler(handler)
+
+
+def disable_logging():
+    """Disable logging for the library."""
+    logger.setLevel(logging.CRITICAL)
+    for handler in logger.handlers[:]:  # Remove all handlers
+        logger.removeHandler(handler)

yutipy/yutipy_music.py

@@ -2,8 +2,6 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from pprint import pprint
 from typing import Optional
 
-import requests
-
 from yutipy.deezer import Deezer
 from yutipy.exceptions import InvalidValueException, KKBoxException, SpotifyException
 from yutipy.itunes import Itunes
@@ -11,7 +9,7 @@ from yutipy.kkbox import KKBox
 from yutipy.models import MusicInfo, MusicInfos
 from yutipy.musicyt import MusicYT
 from yutipy.spotify import Spotify
-from yutipy.utils.cheap_utils import is_valid_string
+from yutipy.utils.helpers import is_valid_string
 from yutipy.utils.logger import logger
 
 
@@ -25,6 +23,7 @@ class YutipyMusic:
     def __init__(self) -> None:
         """Initializes the YutipyMusic class."""
         self.music_info = MusicInfos()
+        self.normalize_non_english = True
         self.album_art_priority = ["deezer", "ytmusic", "itunes"]
         self.services = {
             "deezer": Deezer(),
@@ -34,7 +33,7 @@ class YutipyMusic:
 
         try:
             self.services["kkbox"] = KKBox()
-        except KKBoxException as e:
+        except (KKBoxException, Exception) as e:
             logger.warning(
                 f"{self.__class__.__name__}: Skipping KKBox due to KKBoxException: {e}"
             )
@@ -44,20 +43,13 @@ class YutipyMusic:
 
         try:
             self.services["spotify"] = Spotify()
-        except SpotifyException as e:
+        except (SpotifyException, Exception) as e:
             logger.warning(
                 f"{self.__class__.__name__}: Skipping Spotify due to SpotifyException: {e}"
             )
         else:
             idx = self.album_art_priority.index("ytmusic")
             self.album_art_priority.insert(idx, "spotify")
-        self.normalize_non_english = True
-        self._translation_session = requests.Session()
-
-        # Assign the translation session to each service
-        for service in self.services.values():
-            if hasattr(service, "_translation_session"):
-                service._translation_session = self._translation_session
 
     def __enter__(self) -> "YutipyMusic":
         return self
@@ -98,19 +90,9 @@ class YutipyMusic:
 
         self.normalize_non_english = normalize_non_english
 
-        attributes = [
-            "album_title",
-            "album_type",
-            "artists",
-            "genre",
-            "isrc",
-            "lyrics",
-            "release_date",
-            "tempo",
-            "title",
-            "type",
-            "upc",
-        ]
+        logger.info(
+            f"Searching all platforms for `artist='{artist}'` and `song='{song}'`"
+        )
 
         with ThreadPoolExecutor() as executor:
             futures = {
@@ -126,17 +108,23 @@ class YutipyMusic:
 
             for future in as_completed(futures):
                 service_name = futures[future]
-                result = future.result()
-                self._combine_results(result, service_name, attributes)
+                try:
+                    result = future.result()
+                    self._combine_results(result, service_name)
+                except Exception as e:
+                    logger.error(
+                        f"Error occurred while searching with {service_name}: {e}"
+                    )
 
         if len(self.music_info.url) == 0:
+            logger.warning(
+                f"No matching results found across all platforms for artist='{artist}' and song='{song}'"
+            )
             return None
 
         return self.music_info
 
-    def _combine_results(
-        self, result: Optional[MusicInfo], service_name: str, attributes: list
-    ) -> None:
+    def _combine_results(self, result: Optional[MusicInfo], service_name: str) -> None:
         """
         Combines the results from different services.
 
@@ -150,16 +138,26 @@ class YutipyMusic:
         if not result:
             return
 
+        attributes = [
+            "album_title",
+            "album_type",
+            "artists",
+            "genre",
+            "isrc",
+            "lyrics",
+            "release_date",
+            "tempo",
+            "title",
+            "type",
+            "upc",
+        ]
+
         for attr in attributes:
             if getattr(result, attr) and (
                 not getattr(self.music_info, attr)
                 or (attr in ["genre", "album_type"] and service_name == "itunes")
             ):
-                setattr(
-                    self.music_info,
-                    attr,
-                    getattr(result, attributes.pop(attributes.index(attr))),
-                )
+                setattr(self.music_info, attr, getattr(result, attr))
 
         if result.album_art:
             current_priority = self.album_art_priority.index(service_name)
@@ -183,8 +181,14 @@ class YutipyMusic:
 
 
 if __name__ == "__main__":
+    import logging
+    from yutipy.utils.logger import enable_logging
+
+    enable_logging(level=logging.DEBUG)
     yutipy_music = YutipyMusic()
+
     artist_name = input("Artist Name: ")
     song_name = input("Song Name: ")
+
     pprint(yutipy_music.search(artist_name, song_name))
     yutipy_music.close_sessions()

{yutipy-1.4.2.dist-info → yutipy-1.5.0.dist-info}/METADATA

@@ -1,39 +1,18 @@
 Metadata-Version: 2.4
 Name: yutipy
-Version: 1.4.2
+Version: 1.5.0
 Summary: A simple package for retrieving music information from various music platforms APIs.
 Author: Cheap Nightbot
 Author-email: Cheap Nightbot <hi@cheapnightbot.slmail.me>
 Maintainer-email: Cheap Nightbot <hi@cheapnightbot.slmail.me>
-License: MIT License
-        
-        Copyright (c) 2025 Cheap Nightbot
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/CheapNightbot/yutipy
 Project-URL: Documentation, https://yutipy.readthedocs.io/
 Project-URL: Repository, https://github.com/CheapNightbot/yutipy.git
 Project-URL: Issues, https://github.com/CheapNightbot/yutipy/issues
 Project-URL: Changelog, https://github.com/CheapNightbot/yutipy/blob/master/CHANGELOG.md
 Project-URL: funding, https://ko-fi.com/cheapnightbot
-Keywords: music,API,Deezer,iTunes,Spotify,YouTube Music,search,retrieve,information,yutify,KKBox
+Keywords: music,API,Deezer,iTunes,KKBox,Spotify,YouTube Music,search,retrieve,information,yutify
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
@@ -43,11 +22,11 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: pykakasi==2.3.0
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: rapidfuzz==3.12.1
 Requires-Dist: requests==2.32.3
@@ -89,6 +68,10 @@ A _**simple**_ Python package for searching and retrieving music information fro
     - [Available Music Platforms](#available-music-platforms)
 - [Installation](#installation)
 - [Usage Example](#usage-example)
+- [Command-Line Interface (CLI)](#command-line-interface-cli)
+    - [Search for Music](#search-for-music)
+        - [Options](#options)
+    - [Configuration Wizard](#configuration-wizard)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -120,9 +103,7 @@ pip install -U yutipy
 
 ## Usage Example
 
-Here's a quick example of how to use the `yutipy` package to search for a song:
-
-### Deezer
+Here's a quick example of how to use the `yutipy` package to search for a song on **Deezer**:
 
 ```python
 from yutipy.deezer import Deezer
@@ -134,6 +115,36 @@ with Deezer() as deezer:
 
 For more usage examples, see the [Usage Examples](https://yutipy.readthedocs.io/en/latest/usage_examples.html) page in docs.
 
+## Command-Line Interface (CLI)
+
+The `yutipy` package includes a CLI tool that allows you to search for music directly from the command line and configure API keys interactively.
+
+### Search for Music
+
+You can use the CLI tool to search for music across multiple platforms:
+
+```bash
+yutipy-cli "Rick Astley" "Never Gonna Give You Up" --limit 3 --normalize
+```
+
+#### Options:
+- `artist` (required): The name of the artist.
+- `song` (required): The title of the song.
+- `--limit`: The number of results to retrieve (default: 5).
+- `--normalize`: Normalize non-English characters for comparison.
+- `--verbose`: Enable logging in the terminal.
+- `--service`: Specify a single service to search (e.g., `deezer`, `spotify`, `itunes`).
+
+### Configuration Wizard
+
+To set up your API keys interactively, use the configuration wizard:
+
+```bash
+yutipy-config
+```
+
+The wizard will guide you through obtaining and setting up API keys for supported services like Spotify and KKBOX. If the required environment variables are already set, the wizard will skip those steps.
+
 ## Contributing
 
 Contributions are welcome! Please follow these steps:

yutipy-1.5.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+yutipy/__init__.py,sha256=wCSrxrAzsRZ0qElyyws5P6x-1FQnc9PeyPVjvy2I9rk,322
+yutipy/deezer.py,sha256=nPw4aUhr4RSgbholsvV_oVYvGyK5SXQF4pKixwweIfg,11368
+yutipy/exceptions.py,sha256=4L0Oe1PwFP34LoFTy-Fruipk7uB-JkaackRmkjlaZJU,1138
+yutipy/itunes.py,sha256=sG-qXi8FDahG2NDdGdkwa3dsgwWUzbuEbRZ8wzzzsO0,7893
+yutipy/kkbox.py,sha256=ueIrske7yfmcNX_VFNK7v7OQJk6UGBfPNpQRYMZdGu4,14157
+yutipy/logging.py,sha256=CcnaAZGClTUgfYqRXuVfFEhfMhlXF86di4r3O7aSHDA,107
+yutipy/models.py,sha256=vvWIA3MwCOOM2CBHSabqmFXz4NdVHaQtObU6zhGpJOM,1931
+yutipy/musicyt.py,sha256=iel4-iYpo24-BcknwgO7hb_nu0E016pa_NsgFL2BybI,9181
+yutipy/spotify.py,sha256=OUYDSEYMAqg1a9XSAyrE2eTJRRhq_KorAL2Cd_nbGkw,16280
+yutipy/yutipy_music.py,sha256=2MInRKG5HkbLcVafua6Vkg9u66XvBctV2dnRdS3jX7M,6565
+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=S28uLH8-WlytWHNabgeLNHx1emZVryBz0BDwF5wgum4,228
+yutipy/utils/helpers.py,sha256=W3g9iqoSygcFFCKCp2sk0NQrZOEG26wI2XuNi9pgAXE,5207
+yutipy/utils/logger.py,sha256=cHCjpDslVsBOnp7jluqrOOi4ekDIggPhbSfqHeIfT-U,1263
+yutipy-1.5.0.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
+yutipy-1.5.0.dist-info/METADATA,sha256=JYM-LSbrHsmVetyNWf8rzW-hDBmNnGZeVX2XVM2VWy0,6498
+yutipy-1.5.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+yutipy-1.5.0.dist-info/entry_points.txt,sha256=BrgmanaPjQqKQ3Ip76JLcsPgGANtrBSURf5CNIxl1HA,106
+yutipy-1.5.0.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
+yutipy-1.5.0.dist-info/RECORD,,

yutipy-1.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+yutipy-cli = yutipy.cli.search:main
+yutipy-config = yutipy.cli.config:run_config_wizard

yutipy-1.4.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-yutipy/__init__.py,sha256=ucXbhRgNpLo-G0TeDGCaKyCK9Ftc13hUqB8POWdUY1c,327
-yutipy/deezer.py,sha256=cTQpnOgS81mUw_EJ0b2Z1r9CG9ircHCxl9vL-oAJ9Lg,9622
-yutipy/exceptions.py,sha256=4L0Oe1PwFP34LoFTy-Fruipk7uB-JkaackRmkjlaZJU,1138
-yutipy/itunes.py,sha256=SZOCShlIyutIWQ2KI9WLqxc4gN4Cu2gilqxYwuXugUU,7059
-yutipy/kkbox.py,sha256=V-A7nFa1oNrTBOEu7DFzMHAHFZ5cPz55GInEuYfTSfg,13466
-yutipy/models.py,sha256=si_qgaApAYDfSyE8cl_Yg4IfWOtxk1I5JCT8bZsmV4U,1931
-yutipy/musicyt.py,sha256=igqz99bJYGtUGyZAmEJoQbdGIF-1YFmeaV5HmlhwqkA,8441
-yutipy/spotify.py,sha256=P-MCOny1ZXK75_jdQKRI_jgUrK7B9xbBFOvRu6NOjxk,15620
-yutipy/yutipy_music.py,sha256=I4581MvcTTclSwVtAfMEsOujxmhZzqKyG7eX8zuEsEY,6424
-yutipy/utils/__init__.py,sha256=o6lk01FHwhFmNHV0HjGG0qe2azTaQT_eviiLgNV5fHw,232
-yutipy/utils/cheap_utils.py,sha256=ttNu566ybTQ3BzQ2trBgpvpNthB6Da-KnkBbFiK3pw4,5282
-yutipy/utils/logger.py,sha256=2_b2FlDwUVpdPdqiwweR8Xr2tZOq0qGUGcekC5lXq2M,130
-yutipy-1.4.2.dist-info/licenses/LICENSE,sha256=_89JsS2QnBG8tAb5-VWbJDj_uJ002zPJAYBJJdh3DPY,1071
-yutipy-1.4.2.dist-info/METADATA,sha256=nxBwtRJFWpM7gsgH9-RZIP239hna-PirfWJ2WIBxXB4,6495
-yutipy-1.4.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-yutipy-1.4.2.dist-info/top_level.txt,sha256=t2A5V2_mUcfnHkbCy6tAQlb3909jDYU5GQgXtA4756I,7
-yutipy-1.4.2.dist-info/RECORD,,