yutipy 1.2.1__tar.gz → 1.3.0__tar.gz

{yutipy-1.2.1 → yutipy-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yutipy
-Version: 1.2.1
+Version: 1.3.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>

{yutipy-1.2.1 → yutipy-1.3.0}/docs/api_reference.rst

@@ -49,6 +49,14 @@ YouTube Music
     :inherited-members:
     :noindex:
 
+Yutipy Music
+------------
+
+.. autoclass:: yutipy.yutipy_music.YutipyMusic
+    :members:
+    :inherited-members:
+    :noindex:
+
 Data Classes
 =============
 
@@ -60,6 +68,14 @@ MusicInfo
     :noindex:
     :exclude-members: album_art, album_title, album_type, artists, genre, id, isrc, lyrics, release_date, tempo, title, type, upc, url
 
+MusicInfos
+----------
+
+.. autoclass:: yutipy.models.MusicInfos
+    :members:
+    :noindex:
+    :exclude-members: album_art, album_art_source, album_title, album_type, artists, genre, id, isrc, lyrics, release_date, tempo, title, type, upc, url
+
 Exceptions
 =============
 

{yutipy-1.2.1 → yutipy-1.3.0}/docs/usage_examples.rst

@@ -5,7 +5,7 @@ Usage Examples
 Here's a quick example of how to use the **yutipy** package to search for a song:
 
 .. important::
-    All examples here—except for the `YouTube Music`_—use the ``with`` context manager to initialize an instance of the respective class,
+    All examples here—except for the `YouTube Music`_ & `Yutipy Music`_—use the ``with`` context manager to initialize an instance of the respective class,
     as those classes internally use ``requests.Session()`` for making requests to APIs.
     This approach ensures that the session is automatically closed once you exit the context. Although using ``with`` is not mandatory,
     if you instantiate an object without it, you are responsible for closing the session after use by calling the ``close_session()`` method on that object.
@@ -110,3 +110,14 @@ YouTube Music
     music_yt = MusicYT()
     result = music_yt.search("Artist Name", "Song Title")
     print(result)
+
+Yutipy Music
+------------
+
+.. code-block:: python
+
+    from yutipy.yutify_music import YutipyMusic
+
+    yutipy_music = YutipyMusic()
+    result = yutify_music.search("Artist Name", "Song Title")
+    print(result)

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy/__init__.py

@@ -3,6 +3,7 @@ from .itunes import Itunes
 from .models import MusicInfo
 from .musicyt import MusicYT
 from .spotify import Spotify
+from .yutipy_music import YutipyMusic
 
 __all__ = [
     "Deezer",
@@ -10,4 +11,5 @@ __all__ = [
     "MusicInfo",
     "MusicYT",
     "Spotify",
+    "YutipyMusic",
 ]

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy/deezer.py

@@ -238,7 +238,7 @@ class Deezer:
             album_title=(
                 result["album"]["title"] if music_type == "track" else result["title"]
             ),
-            album_type=result.get("record_type", music_type),
+            album_type=result.get("record_type", music_type.replace("track", "single")),
             artists=result["artist"]["name"],
             genre=None,
             id=result["id"],
@@ -273,4 +273,4 @@ if __name__ == "__main__":
         song_name = input("Song Name: ")
         pprint(deezer.search(artist_name, song_name))
     finally:
-        deezer._close_session()
+        deezer.close_session()

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy/itunes.py

@@ -186,4 +186,4 @@ if __name__ == "__main__":
         song_name = input("Song Name: ")
         pprint(itunes.search(artist_name, song_name))
     finally:
-        itunes._close_session()
+        itunes.close_session()

yutipy-1.3.0/yutipy/models.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Union
+
+
+@dataclass
+class MusicInfo:
+    """
+    A data class to store music information.
+
+    Attributes
+    ----------
+    album_art : Optional[str]
+        URL to the album art.
+    album_title : Optional[str]
+        Title of the album.
+    album_type : Optional[str]
+        Type of the album (e.g., album, single).
+    artists : str
+        Name(s) of the artist(s).
+    genre : Optional[str]
+        Genre of the music.
+    id : Union[int, str, Dict[str, str]]
+        Unique identifier(s) for the music from different platforms.
+    isrc : Optional[str]
+        International Standard Recording Code.
+    lyrics : Optional[str]
+        Lyrics of the song.
+    release_date : Optional[str]
+        Release date of the music.
+    tempo : Optional[float]
+        Tempo of the music in BPM.
+    title : str
+        Title of the music.
+    type : Optional[str]
+        Type of the music (e.g., track, album).
+    upc : Optional[str]
+        Universal Product Code.
+    url : Union[str, Dict[str, str]]
+        URL(s) to the music on different platforms.
+    """
+
+    album_art: Optional[str] = None
+    album_title: Optional[str] = None
+    album_type: Optional[str] = None
+    artists: str = ""
+    genre: Optional[str] = None
+    id: Union[int, str, Dict[str, int]] = field(default_factory=dict)
+    isrc: Optional[str] = None
+    lyrics: Optional[str] = None
+    release_date: Optional[str] = None
+    tempo: Optional[float] = None
+    title: str = ""
+    type: Optional[str] = None
+    upc: Optional[str] = None
+    url: Union[str, Dict[str, str]] = field(default_factory=dict)
+
+
+@dataclass
+class MusicInfos(MusicInfo):
+    """A data class to store music information from different services.
+
+    Attributes
+    ----------
+    album_art_source : Optional[str]
+        The source of the album art.
+    """
+
+    album_art_source: Optional[str] = None

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy/utils/cheap_utils.py

@@ -1,3 +1,45 @@
+import requests
+from rapidfuzz import fuzz
+from rapidfuzz.utils import default_process
+
+
+def translate_text(
+    text: str,
+    sl: str = None,
+    dl: str = "en",
+) -> dict:
+    """
+    Translate text from one language to another.
+
+    Args:
+        text (str): The text to be translated.
+        sl (str, optional): The source language code (e.g., 'en' for English, 'es' for Spanish). If not provided, the API will attempt to detect the source language.
+        dl (str, optional): The destination language code (default is 'en' for English).
+
+
+     Returns:
+        dict: A dictionary containing the following keys:
+            - 'source-text': The original text.
+            - 'source-language': The detected or provided source language code.
+            - 'destination-text': The translated text.
+            - 'destination-language': The destination language code.
+    """
+    if sl:
+        url = f"https://ftapi.pythonanywhere.com/translate?sl={sl}&dl={dl}&text={text}"
+    else:
+        url = f"https://ftapi.pythonanywhere.com/translate?dl={dl}&text={text}"
+
+    response = requests.get(url)
+    response_json = response.json()
+    result = {
+        "source-text": response_json["source-text"],
+        "source-language": response_json["source-language"],
+        "destination-text": response_json["destination-text"],
+        "destination-language": response_json["destination-language"],
+    }
+    return result
+
+
 def are_strings_similar(str1: str, str2: str, threshold: int = 80) -> bool:
     """
     Determine if two strings are similar based on a given threshold.
@@ -10,8 +52,8 @@ def are_strings_similar(str1: str, str2: str, threshold: int = 80) -> bool:
     Returns:
         bool: True if the strings are similar, otherwise False.
     """
-    from rapidfuzz import fuzz
-    from rapidfuzz.utils import default_process
+    str1 = translate_text(str1)["destination-text"]
+    str2 = translate_text(str2)["destination-text"]
 
     similarity_score = fuzz.WRatio(str1, str2, processor=default_process)
     return similarity_score > threshold

yutipy-1.3.0/yutipy/yutipy_music.py

@@ -0,0 +1,122 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pprint import pprint
+from typing import Optional
+
+from yutipy.deezer import Deezer
+from yutipy.exceptions import InvalidValueException
+from yutipy.itunes import Itunes
+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
+
+
+class YutipyMusic:
+    """A class that can be used to retrieve music information from all music platforms available in ``yutipy``.
+
+    This is useful when you want to get music information (especially streaming link) from all available platforms.
+    Instead of calling each service separately, you can use this class to get the information from all services at once.
+    """
+
+    def __init__(self) -> None:
+        """Initializes the YutipyMusic class."""
+        self.music_info = MusicInfos()
+        self.album_art_priority = ["deezer", "kkbox", "spotify", "musicyt", "itunes"]
+
+    def search(self, artist: str, song: str) -> Optional[MusicInfos]:
+        """
+        Searches for a song by artist and title.
+
+        Parameters
+        ----------
+        artist : str
+            The name of the artist.
+        song : str
+            The title of the song.
+
+        Returns
+        -------
+        Optional[MusicInfos_]
+            The music information if found, otherwise None.
+        """
+        if not is_valid_string(artist) or not is_valid_string(song):
+            raise InvalidValueException(
+                "Artist and song names must be valid strings and can't be empty."
+            )
+
+        services = [
+            (Deezer, "deezer"),
+            (Itunes, "itunes"),
+            (KKBox, "kkbox"),
+            (MusicYT, "musicyt"),
+            (Spotify, "spotify"),
+        ]
+
+        with ThreadPoolExecutor() as executor:
+            futures = {
+                executor.submit(service().search, artist, song): name
+                for service, name in services
+            }
+
+            for future in as_completed(futures):
+                service_name = futures[future]
+                result = future.result()
+                self._combine_results(result, service_name)
+
+        return self.music_info if self.music_info else None
+
+    def _combine_results(self, result: Optional[MusicInfo], service_name: str) -> None:
+        """
+        Combines the results from different services.
+
+        Parameters
+        ----------
+        result : Optional[MusicInfo]
+            The music information from a service.
+        service_name : str
+            The name of the streaming service.
+        """
+        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 service_name == "spotify"
+            ):
+                setattr(self.music_info, attr, getattr(result, attr))
+
+        if result.album_art:
+            current_priority = self.album_art_priority.index(service_name)
+            existing_priority = (
+                self.album_art_priority.index(self.music_info.album_art_source)
+                if self.music_info.album_art_source
+                else len(self.album_art_priority)
+            )
+            if current_priority < existing_priority:
+                self.music_info.album_art = result.album_art
+                self.music_info.album_art_source = service_name
+
+        self.music_info.id[service_name] = result.id
+        self.music_info.url[service_name] = result.url
+
+
+if __name__ == "__main__":
+    yutipy_music = YutipyMusic()
+    artist_name = input("Artist Name: ")
+    song_name = input("Song Name: ")
+    pprint(yutipy_music.search(artist_name, song_name))

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yutipy
-Version: 1.2.1
+Version: 1.3.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>

{yutipy-1.2.1 → yutipy-1.3.0}/yutipy.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ yutipy/kkbox.py
 yutipy/models.py
 yutipy/musicyt.py
 yutipy/spotify.py
+yutipy/yutipy_music.py
 yutipy.egg-info/PKG-INFO
 yutipy.egg-info/SOURCES.txt
 yutipy.egg-info/dependency_links.txt

yutipy-1.2.1/yutipy/models.py

@@ -1,55 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass
-class MusicInfo:
-    """
-    A data class to store music information.
-
-    Attributes
-    ----------
-    album_art : Optional[str]
-        URL to the album art.
-    album_title : Optional[str]
-        Title of the album.
-    album_type : Optional[str]
-        Type of the album (e.g., album, single).
-    artists : str
-        Name(s) of the artist(s).
-    genre : Optional[str]
-        Genre of the music.
-    id : str
-        Unique identifier for the music.
-    isrc : Optional[str]
-        International Standard Recording Code.
-    lyrics : Optional[str]
-        Lyrics of the song.
-    release_date : Optional[str]
-        Release date of the music.
-    tempo : Optional[float]
-        Tempo of the music in BPM.
-    title : str
-        Title of the music.
-    type : Optional[str]
-        Type of the music (e.g., track, album).
-    upc : Optional[str]
-        Universal Product Code.
-    url : str
-        URL to the music on the platform.
-    """
-
-    album_art: Optional[str]
-    album_title: Optional[str]
-    album_type: Optional[str]
-    artists: str
-    genre: Optional[str]
-    id: str
-    isrc: Optional[str]
-    lyrics: Optional[str]
-    release_date: Optional[str]
-    tempo: Optional[float]
-    title: str
-    type: Optional[str]
-    upc: Optional[str]
-    url: str