implement a program

Author: gosha20777

.gitignore

@@ -158,3 +158,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+*.json

core/__init__.py

@@ -0,0 +1,3 @@
+from .yandex import YandexMusicExporter
+from .youtube import YoutubeImoirter
+from .track import Track

core/track.py

@@ -0,0 +1,6 @@
+from typing import NamedTuple
+
+
+class Track(NamedTuple):
+    artist: str
+    name: str

core/yandex.py

@@ -0,0 +1,24 @@
+from yandex_music import Client, Artist
+from typing import List
+from .track import Track
+from tqdm import tqdm
+
+
+class YandexMusicExporter:
+    def __init__(self, token: str):
+        self.client = Client(token).init()
+
+    def export_liked_tracks(self) -> List[Track]:
+        tracks = self.client.users_likes_tracks().tracks
+
+        result = []
+        with tqdm(total=len(tracks), position=0, desc='Export tracks') as pbar:
+            with tqdm(total=0, bar_format='{desc}', position=1) as trank_log:
+                for track in tracks:
+                    track = track.fetch_track()
+                    artist = track.artists_name()[0]
+                    name = track.title
+                    result.append(Track(artist, name))
+                    pbar.update(1)
+                    trank_log.set_description_str(f'{artist} - {name}')
+        return result

core/youtube.py

@@ -0,0 +1,54 @@
+from ytmusicapi import YTMusic, setup_oauth
+from .track import Track
+from typing import List, Tuple
+import os
+from tqdm import tqdm
+
+
+class YoutubeImoirter:
+    def __init__(self, token_path: str):
+        if not os.path.exists(token_path):
+            token = setup_oauth().as_json()
+            with open(token_path, 'w') as f:
+                f.write(token)
+        else:
+            token = open(token_path, 'r').read()
+
+        self.ytmusic = YTMusic(token)
+
+    def import_liked_tracks(self, tracks: List[Track]) -> Tuple[List[Track], List[Track]]:
+        not_found = []
+        errors = []
+        with tqdm(total=len(tracks), position=0, desc='Import tracks') as pbar:
+            with tqdm(total=0, bar_format='{desc}', position=1) as trank_log:
+                for track in tracks:
+                    results = self.ytmusic.search(f'{track.artist} {track.name}')
+                    if len(results) == 0:
+                        not_found.append(track)
+                        continue
+                    
+                    result = self._get_best_result(results, track)
+                    try:
+                        self.ytmusic.rate_song(result['videoId'], 'LIKE')
+                    except Exception as e:
+                        errors.append(track)
+                        pbar.write(f'Error: {track.artist} - {track.name}, {e}')
+                    pbar.update(1)
+                    trank_log.set_description_str(f'{track.artist} - {track.name}')
+
+                return not_found, errors
+    
+    def _get_best_result(self, results: List[dict], track: Track) -> dict:
+        songs = []
+        for result in results:
+            if 'videoId' not in result.keys():
+                continue
+            if result['category'] == 'Top result':
+                return result
+            if result['title'] == track.name:
+                return result
+            songs.append(result)
+        if len(songs) == 0:
+            return results[0]
+        return songs[0]
+        

main.py

@@ -0,0 +1,72 @@
+import argparse
+from core import YandexMusicExporter
+from core import YoutubeImoirter
+import json
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='Train a model')
+    parser.add_argument(
+        '--yandex', type=str, help='Yandex Music token'
+    )
+    parser.add_argument(
+        '--output', type=str, default='tracks.json', help='Output json file'
+    )
+    parser.add_argument(
+        '--youtube', type=str, default='youtube.json', 
+        help='Youtube Music credentials file. If file not exists, it will be created.'
+    )
+    return parser.parse_args()
+
+
+def move_tracks(
+        importer: YandexMusicExporter, exporter: YoutubeImoirter, out_path: str
+    ) -> None:
+    data = {
+        'liked_tracks': [],
+        'not_found': [],
+        'errors': [],
+    }
+    
+    print('Exporting liked tracks from Yandex Music...')
+    tracks = importer.export_liked_tracks()
+    tracks.reverse()
+
+    for track in tracks:
+        data['liked_tracks'].append({
+            'artist': track.artist,
+            'name': track.name
+        })
+
+    print('Importing liked tracks to Youtube Music...')
+    not_found, errors = exporter.import_liked_tracks(tracks)
+
+    for track in not_found:
+        data['not_found'].append({
+            'artist': track.artist,
+            'name': track.name
+        })
+        print(f'{track.artist} - {track.name}')
+    
+    for track in errors:
+        data['errors'].append({
+            'artist': track.artist,
+            'name': track.name
+        })
+    
+    print(f'{len(not_found)} not found tracks, {len(errors)} errors.')
+
+    str_data = json.dumps(data)
+    with open(out_path, 'w', encoding='utf-8') as f:
+        f.write(str_data)
+
+
+def main() -> None:
+    args = parse_args()
+    importer = YandexMusicExporter(args.yandex)
+    exporter = YoutubeImoirter(args.youtube)
+    move_tracks(importer, exporter, args.output)
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,3 @@
+yandex-music>=2.0.0
+ytmusicapi>=1.4.2
+tqdm