yutipy 2.0.0__tar.gz → 2.1.1__tar.gz

{yutipy-2.0.0 → yutipy-2.1.1}/PKG-INFO

@@ -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.0.0 → yutipy-2.1.1}/docs/api_reference.rst

@@ -82,6 +82,14 @@ MusicInfos
     :noindex:
     :exclude-members: album_art, album_art_source, album_title, album_type, artists, genre, id, isrc, lyrics, release_date, tempo, title, type, upc, url
 
+UserPlaying
+-----------
+
+.. autoclass:: yutipy.models.UserPlaying
+    :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, is_playing
+
 Exceptions
 =============
 

yutipy-2.1.1/tests/test_deezer.py

@@ -0,0 +1,132 @@
+import pytest
+
+from yutipy.deezer import Deezer
+from yutipy.models import MusicInfo
+
+
+@pytest.fixture
+def deezer():
+    return Deezer()
+
+
+class MockSearchResponse:
+    status_code = 200
+
+    @staticmethod
+    def raise_for_status():
+        pass
+
+    @staticmethod
+    def json():
+        return {
+            "data": [
+                {
+                    "id": "1234567",
+                    "title": "Test Track",
+                    "link": "https://www.deezer.com/track/1234567",
+                    "type": "track",
+                    "artist": {"id": "1", "name": "Artist X"},
+                    "album": {
+                        "id": "110678",
+                        "title": "Test Album",
+                        "cover_xl": "https://example.com/image/1234567",
+                        "type": "album",
+                    },
+                },
+                {
+                    "id": "789253",
+                    "title": "Test Album",
+                    "link": "https://www.deezer.com/track/789253",
+                    "type": "album",
+                    "cover_xl": "https://example.com/image/789253",
+                    "record_type": "album",
+                    "artist": {"id": "2", "name": "Artist Y"},
+                },
+            ]
+        }
+
+
+class MockResponse:
+    status_code = 200
+
+    @staticmethod
+    def raise_for_status():
+        pass
+
+    @staticmethod
+    def json():
+        return {
+            "id": "1234567",
+            "isrc": "ISRC",
+            "upc": "UPC",
+            "release_date": "2001-03-12",
+            "bpm": 0,
+            "genres": {
+                "data": [
+                    {
+                        "id": 113,
+                        "name": "Dance",
+                        "type": "genre",
+                    }
+                ]
+            },
+        }
+
+
+@pytest.fixture
+def mock_response(deezer, monkeypatch):
+    def mock_get(*args, **kwargs):
+        return MockSearchResponse()
+
+    monkeypatch.setattr(deezer._Deezer__session, "get", mock_get)
+
+
+def test_search_valid(deezer, mock_response):
+    result = deezer.search("Artist X", "Test Track", normalize_non_english=False)
+    assert result is not None
+    assert isinstance(result, MusicInfo)
+    assert result.title == "Test Track"
+
+
+def test_search_invalid(deezer, mock_response):
+    result = deezer.search(
+        "Nonexistent Artist", "Nonexistent Song", normalize_non_english=False
+    )
+    assert result is None
+
+
+def test_get_upc_isrc_track(deezer, monkeypatch):
+    def mock_get(*args, **kwargs):
+        return MockResponse()
+
+    monkeypatch.setattr(deezer._Deezer__session, "get", mock_get)
+
+    track_id = 1234567
+    result = deezer._get_upc_isrc(track_id, "track")
+    assert result is not None
+    assert "isrc" in result
+    assert "release_date" in result
+
+
+def test_get_upc_isrc_album(deezer, monkeypatch):
+
+    def mock_get(*args, **kwargs):
+        return MockResponse()
+
+    monkeypatch.setattr(deezer._Deezer__session, "get", mock_get)
+
+    album_id = 1234567
+    result = deezer._get_upc_isrc(album_id, "album")
+    assert result is not None
+    assert "upc" in result
+    assert "release_date" in result
+
+
+def test_search_no_results(deezer, mock_response):
+    result = deezer.search("Adele", "Nonexistent Song", normalize_non_english=False)
+    assert result is None
+
+
+def test_close_session(deezer):
+    deezer.close_session()
+    assert deezer.is_session_closed

yutipy-2.1.1/tests/test_itunes.py

@@ -0,0 +1,87 @@
+import pytest
+from pytest import raises
+
+from yutipy.itunes import Itunes
+from yutipy.models import MusicInfo
+from yutipy.exceptions import InvalidValueException
+
+
+@pytest.fixture
+def itunes():
+    return Itunes()
+
+
+class MockResponse:
+    status_code = 200
+
+    @staticmethod
+    def raise_for_status():
+        pass
+
+    @staticmethod
+    def json():
+        return {
+            "results": [
+                {
+                    "wrapperType": "track",
+                    "kind": "song",
+                    "collectionId": 12345678,
+                    "trackId": 91011123,
+                    "artistName": "Artist X",
+                    "collectionName": "Test Album",
+                    "trackName": "Test Track",
+                    "collectionViewUrl": "https://itunes.apple.com/12345678",
+                    "trackViewUrl": "https://itunes.apple.com/91011123",
+                    "artworkUrl100": "https://example.com/image/12345678",
+                    "trackCount": 14,
+                    "releaseDate": "2016-08-11T12:00:00Z",
+                    "primaryGenreName": "Rock",
+                }
+            ]
+        }
+
+
+@pytest.fixture
+def mock_response(itunes, monkeypatch):
+    def mock_get(*args, **kwargs):
+        return MockResponse()
+
+    monkeypatch.setattr(itunes._Itunes__session, "get", mock_get)
+
+
+def test_search_valid(itunes, mock_response):
+    artist = "Artist X"
+    song = "Test Track"
+    result = itunes.search(artist, song, normalize_non_english=False)
+    assert result is not None
+    assert isinstance(result, MusicInfo)
+    assert result.artists == artist
+    assert result.title == song
+
+
+def test_search_invalid(itunes, mock_response):
+    artist = "Nonexistent Artist"
+    song = "Nonexistent Song"
+    result = itunes.search(artist, song, normalize_non_english=False)
+    assert result is None
+
+
+def test_search_empty_artist(itunes, mock_response):
+    artist = ""
+    song = "Test Track"
+
+    with raises(InvalidValueException):
+        itunes.search(artist, song)
+
+
+def test_search_empty_song(itunes, mock_response):
+    artist = "Artist X"
+    song = ""
+
+    with raises(InvalidValueException):
+        itunes.search(artist, song)
+
+
+def test_close_session(itunes):
+    itunes.close_session()
+    assert itunes.is_session_closed

yutipy-2.1.1/tests/test_kkbox.py

@@ -0,0 +1,104 @@
+import pytest
+from pytest import raises
+
+from yutipy.exceptions import InvalidValueException
+from yutipy.models import MusicInfo
+from yutipy.kkbox import KKBox
+
+
+@pytest.fixture(scope="module")
+def kkbox():
+    def mock_get_access_token():
+        return {
+            "access_token": "test_access_token",
+            "expires_in": 3600,
+            "requested_at": 1234567890,
+        }
+
+    kkbox_instance = KKBox(
+        client_id="test_client_id", client_secret="test_client_secret", defer_load=True
+    )
+
+    kkbox_instance._KKBox__get_access_token = mock_get_access_token
+    kkbox_instance.load_token_after_init()
+    return kkbox_instance
+
+
+class MockResponse:
+    status_code = 200
+
+    @staticmethod
+    def raise_for_status():
+        pass
+
+    @staticmethod
+    def json():
+        return {
+            "tracks": {
+                "data": [
+                    {
+                        "id": "123456",
+                        "name": "Test Track",
+                        "isrc": "ISRC",
+                        "url": "https://kkbox.com/track/123456",
+                        "album": {
+                            "id": "78910",
+                            "name": "Test Album",
+                            "url": "https://kkbox.com/album/78910",
+                            "release_date": "2001-10-12",
+                            "images": [
+                                {"url": "https://example.com/image/78910_128"},
+                                {"url": "https://example.com/image/78910_512"},
+                                {"url": "https://example.com/image/78910_1000"},
+                            ],
+                            "artist": {
+                                "id": "65791",
+                                "name": "Artist X",
+                            },
+                        },
+                    }
+                ]
+            }
+        }
+
+
+@pytest.fixture
+def mock_response(kkbox, monkeypatch):
+    def mock_get(*args, **kwargs):
+        return MockResponse()
+
+    monkeypatch.setattr(kkbox._KKBox__session, "get", mock_get)
+
+
+def test_search(kkbox, mock_response):
+    artist = "Artist X"
+    song = "Test Track"
+    result = kkbox.search(artist, song, normalize_non_english=False)
+    assert result is not None
+    assert isinstance(result, MusicInfo)
+    assert result.title == song
+    assert artist in result.artists
+
+
+def test_get_html_widget(kkbox):
+    html_widget = kkbox.get_html_widget(id="8rceGrek59bDS0HmQH", content_type="song")
+    assert html_widget is not None
+    assert isinstance(html_widget, str)
+
+    with raises(InvalidValueException):
+        kkbox.get_html_widget(id="8rceGrek59bDS0HmQH", content_type="track")
+
+    with raises(InvalidValueException):
+        kkbox.get_html_widget(
+            id="8rceGrek59bDS0HmQH", content_type="song", territory="US"
+        )
+
+    with raises(InvalidValueException):
+        kkbox.get_html_widget(
+            id="8rceGrek59bDS0HmQH", content_type="song", widget_lang="JP"
+        )
+
+
+def test_close_session(kkbox):
+    kkbox.close_session()
+    assert kkbox.is_session_closed

yutipy-2.1.1/tests/test_musicyt.py

@@ -0,0 +1,88 @@
+import pytest
+from pytest import raises
+from yutipy.musicyt import MusicYT
+from yutipy.models import MusicInfo
+from yutipy.exceptions import InvalidValueException
+
+
+@pytest.fixture
+def music_yt():
+    return MusicYT()
+
+
+@pytest.fixture
+def mock_ytmusic_search(music_yt, monkeypatch):
+    def mock_search(*args, **kwargs):
+        return [
+            {
+                "category": "Songs",
+                "resultType": "song",
+                "videoId": "ZrOKjDZOtkA",
+                "title": "Test Song",
+                "artists": [{"name": "Test Artist", "id": "ADlkasoiuUUer34ldb"}],
+                "album": {"name": "Test Album", "id": "MIekd34_934"},
+                "microformat": {
+                    "microformatDataRenderer": {"uploadDate": "1969-12-31"}
+                },
+                "thumbnails": [{"url": "https://example.com/image/ZrOKjDZOtkA"}],
+            }
+        ]
+
+    def mock_get_watch_playlist(*args, **kwargs):
+        return {"lyrics": "MPLYt_HNNclO0Ddoc-17"}
+
+    def mock_get_lyrics(*args, **kwargs):
+        return {"lyrics": "Never Gonna Give You Up!"}
+
+    # Patch the `search` and other methods of the `YTMusic` class
+    monkeypatch.setattr("ytmusicapi.YTMusic.search", mock_search)
+    monkeypatch.setattr(
+        "ytmusicapi.YTMusic.get_watch_playlist", mock_get_watch_playlist
+    )
+    monkeypatch.setattr("ytmusicapi.YTMusic.get_lyrics", mock_get_lyrics)
+
+
+def test_search_valid(music_yt, mock_ytmusic_search):
+    artist = "Test Artist"
+    song = "Test Song"
+    result = music_yt.search(artist, song, normalize_non_english=False)
+    assert result is not None
+    assert isinstance(result, MusicInfo)
+    assert artist in result.artists
+    assert result.title == song
+
+
+def test_search_invalid(music_yt, mock_ytmusic_search):
+    artist = ";laksjdflkajsdfj;asdjf"
+    song = "jaksjd;fljkas;dfkjasldkjf"
+    result = music_yt.search(artist, song)
+    assert result is None
+
+
+def test_search_partial_match(music_yt, mock_ytmusic_search):
+    artist = "Test"
+    song = "Test"
+    result = music_yt.search(artist, song, normalize_non_english=False)
+    assert result is not None
+    assert song in result.title
+
+
+def test_search_empty_artist(music_yt, mock_ytmusic_search):
+    artist = ""
+    song = "Song"
+
+    with raises(InvalidValueException):
+        music_yt.search(artist, song, normalize_non_english=False)
+
+
+def test_search_empty_song(music_yt, mock_ytmusic_search):
+    artist = "Artist"
+    song = ""
+
+    with raises(InvalidValueException):
+        music_yt.search(artist, song, normalize_non_english=False)
+
+
+def test_close_session(music_yt):
+    music_yt.close_session()
+    assert music_yt.is_session_closed