Initial commit

Author: brentc

.gitignore

@@ -0,0 +1,3 @@
+.gmusic.credentials
+.cache-*
+*.pyc

README.md

@@ -0,0 +1,88 @@
+# TuneZinc
+
+Synchronize your Google Music Playlists with Spotify
+
+## Installation
+
+1. git clone [email protected]:brentc/tunezinc.git
+1. mkvirtualenv TuneZinc
+1. pip install requirements.txt
+
+## Configuration 
+
+Set the following environment variables:
+
+* `GMUSIC_USERNAME` Your google username
+* `GMUSIC_PASSWORD` Your google password
+* `GMUSIC_PLAYLISTS` a '`;`' separated list of playlist names you want to sync
+
+You will need to register a Spotify application to authenticate with spotify. Go to 
+[My Applications](https://developer.spotify.com/my-applications/#!/applications) and "Create An 
+App":
+    
+* Application Name: TuneZinc
+* Description: _Some Description_
+* Redirect URIs: `http://example.com/tunezinc/`
+
+Save the app and configure the following environment variables:
+    
+* `SPOTIFY_USERNAME` Your spotify username
+* `SPOTIFY_CLIENT_ID` Your new app's Client ID
+* `SPOTIFY_CLIENT_SECRET` Your new app's Client Secret
+
+## Usage
+
+```bash
+python tunezinc.py
+```
+
+The first time you run it, it will prompt you to oAuth authenticate with Spotify by open a browser,
+granting access and pasting the redirected URL back to the console.
+
+You may also need to do a similar process with Google Music if it needs to get details from any 
+tracks you uploaded via All Access (even though you must still provide your username and password as
+an environment variable)
+
+## TODO
+
+See [docs/TODO](docs/TODO.md) for thoughts on what's missing/needed. 
+
+## Contributing
+
+1. Fork it!
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Submit a pull request :D
+
+## History
+
+* Feb 7, 2016 - First working version
+
+## Credits
+
+Brent Charbonneau
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2016 Brent Charbonneau
+
+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.

app/__init__.py

@@ -0,0 +1,83 @@
+import logging
+from datetime import datetime, time
+import os
+
+import pytz
+from cached_property import cached_property
+from gmusicapi import Mobileclient, Musicmanager
+
+logger = logging.getLogger(__name__)
+
+
+class Gmusic(object):
+    _client = Mobileclient()
+    _manager = Musicmanager()
+
+    def __init__(self, username, password, playlists_to_sync, credentials_storage_location):
+        self.username = username
+        self.password = password
+        self.playlists_to_sync = playlists_to_sync
+        self.credentials_storage_location = credentials_storage_location
+
+    def client_login(self):
+        if not self._client.login(self.username, self.password, Mobileclient.FROM_MAC_ADDRESS):
+            logger.error(u"Gmusic mobile client authentication failed")
+            return False
+
+        logger.info(u"Gmusic mobile client authentication succeeded.")
+        return True
+
+    def manager_login(self):
+        credentials = self.credentials_storage_location
+
+        if not os.path.isfile(credentials):
+            credentials = self._manager.perform_oauth(
+                storage_filepath=self.credentials_storage_location,
+                open_browser=True
+            )
+
+        if not self._manager.login(
+                oauth_credentials=credentials,
+        ):
+            logger.error(u"Gmusic music manager authentication failed")
+            return False
+
+        logger.info(u"Gmusic music manager authentication succeeded.")
+        return True
+
+    @property
+    def client(self):
+        if not self._client.is_authenticated():
+            self.client_login()
+        return self._client
+
+    @property
+    def manager(self):
+        if not self._manager.is_authenticated():
+            self.manager_login()
+        return self._manager
+
+    @cached_property
+    def uploaded_songs(self):
+        return {song['id']: song for song in self.manager.get_uploaded_songs()}
+
+    @property
+    def _playlists(self):
+        playlists = self.client.get_all_user_playlist_contents()
+        logger.debug(u"Loaded {} playlists".format(len(playlists)))
+        return playlists
+
+    @cached_property
+    def playlists(self):
+        playlists_to_sync = []
+        for playlist in self._playlists:
+            if playlist['name'] in self.playlists_to_sync:
+                playlists_to_sync.append(playlist)
+        return playlists_to_sync
+
+    def get_latest_addition_date(self, playlist):
+        lastModified = playlist.get('lastModifiedTimestamp')
+        if lastModified:
+            return datetime.fromtimestamp(int(lastModified) / 10 ** 6).replace(tzinfo=pytz.utc)
+
+        return None

app/gmusic.py

@@ -0,0 +1,143 @@
+import logging
+import urllib
+from datetime import datetime
+
+import dateutil
+import spotipy
+from spotipy import util as spotipy_util
+
+logger = logging.getLogger(__name__)
+
+
+class Spotify(object):
+    _client = None
+    _playlists = None
+    SCOPES = ' '.join([
+        'playlist-read-private',
+        'playlist-modify-public',
+        'playlist-modify-private',
+        'user-read-private'
+    ])
+
+    def __init__(self, username, client_id, client_secret, create_public=False):
+        self.username = username
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.create_public = create_public
+
+    def _get_auth(self):
+        return spotipy_util.prompt_for_user_token(
+            username=self.username,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            redirect_uri='http://example.com/tunezinc/',
+            scope=self.SCOPES,
+        )
+
+    @property
+    def client(self):
+        if not self._client:
+            self._client = spotipy.Spotify(auth=self._get_auth())
+        return self._client
+
+    def search(self, q, market=None, limit=10, offset=0, type='track'):
+        """
+        Spotipy 2.0 doesn't support the market parameter for search results, but
+        we can add it ourselves
+        """
+        if not market:
+            return self.client.search(q, limit, offset, type)
+
+        return self.client._get('search', q=q, market=market, limit=limit, offset=offset, type=type)
+
+    def _fetch_playlists(self):
+        playlists = {}
+        for playlist in self.client.user_playlists(self.username)['items']:
+            if playlist['owner']['id'] != self.username:
+                logger.debug(u"Skipping playlist owned by a different user, {} ".format(playlist['name']))
+                continue
+
+            name = playlist['name']
+            if playlists.get(name):
+                raise Exception("Duplicate playlist named '{}' found.".format(playlist['name']))
+            playlists[name] = playlist
+
+        logger.debug(u"Loaded {} playlists".format(len(playlists)))
+        return playlists
+
+    @property
+    def playlists(self):
+        if not self._playlists:
+            self._playlists = self._fetch_playlists()
+        return self._playlists
+
+    def _create_playlist(self, name):
+        playlist = self.client.user_playlist_create(self.username, name)
+        logger.info(u"Playlist named '{}' created.".format(name))
+        self._playlists[name] = playlist
+        return playlist
+
+    def get_playlist(self, name):
+        return self.playlists[name]
+
+    def get_playlist_tracks(self, playlist_uri):
+        return self.client.user_playlist_tracks(self.username, playlist_uri)
+
+    def get_latest_addition_date(self, playlist_tracks):
+        max_added_at = None
+        items = playlist_tracks.get('items')
+        if not items:
+            return None
+
+        for item in items:
+            added_at = item.get('added_at')
+            if not added_at:
+                continue
+            if max_added_at < added_at:
+                max_added_at = added_at
+
+        if max_added_at:
+            return dateutil.parser.parse(max_added_at)
+        return None
+
+    def get_or_create_playlist(self, name):
+        try:
+            return self.get_playlist(name)
+        except KeyError:
+            logger.info(u"Playlist named '{}' doesn't exist".format(name))
+            return self._create_playlist(name)
+
+    def find_track(self, track):
+        logger.debug(u"Searching for spotify track matching: {}".format(track))
+        parts = [
+            u'track:"{}"'.format(track.search_title),
+            u'artist:"{}"'.format(track.artist),
+            u'album:"{}"'.format(track.search_album),
+        ]
+
+        results = self.search(
+            q=u' '.join(parts),
+            type='track',
+            market='from_token'
+        )
+
+        items = results.get('tracks', {}).get('items')
+        if not items:
+            logger.info(u"No match found for {}".format(track))
+            return None
+
+        for track_info in items:
+            if track.matches_spotify_track_info(track_info):
+                track.spotify_uri = track_info.get('uri')
+                logger.debug(u"Match found: {}, {}".format(track, track_info))
+                return track
+
+    def add_tracks_to_playlist(self, playlist, tracks):
+        if not tracks:
+            return 0
+
+        result = self.client.user_playlist_add_tracks(
+            self.username,
+            playlist['uri'],
+            [track.spotify_uri for track in tracks],
+        )