import os
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'SubtoneSelector.settings')
import django
django.setup()
SPOTIPY_REDIRECT_URI = 'http://localhost:8000/logged/'
SPOTIPY_CLIENT_ID = 'c6b73836172b40b2ac90879f9b54271b'
SPOTIPY_CLIENT_SECRET = 'bced1ccc150b4ee5b65f295b98e33b95'
CACHE_PATH = ''
token = ''
username = ''
sp_oauth = spotipy.SpotifyOAuth(SPOTIPY_CLIENT_ID,
SPOTIPY_CLIENT_SECRET,
SPOTIPY_REDIRECT_URI,
scope='playlist-modify-public',
cache_path=CACHE_PATH,
show_dialog=False)
from Recommendation.models import BigArtist, SmallArtist
def getArtistPopularity(artist):
artist = sp.artist(artist)
artist_name = artist['name']
artist_popularity = artist['popularity']
print(artist_name, artist_popularity)
def getArtists(genre):
big_artist = []
def __init__(self, device_name, title, artist, duration_ms, progress_ms, art, is_playing):
self.device_name = device_name
self.title = title
self.artist = artist
self.duration_ms = duration_ms
self.progress_ms = progress_ms
self.art = art
self.is_playing = is_playing
# get the username from terminal
username = sys.argv[1]
# authorize
spotifyObject = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(
"f34308de95354355a1cd0c3565659dd8",
"f883197f63654ba0906f2de7ac31be8d",
"https://google.co.nz/",
scope="user-read-playback-state"
))
def main_loop():
MAX_TITLE_LENGTH = 36
TIME_TO_SLEEP = 0.3
TIME_UNTIL_TIMEOUT = 300
current_time = 0
t0 = time.time()
while current_time < TIME_UNTIL_TIMEOUT:
current_time += TIME_TO_SLEEP
try:
# get track info
track = spotifyObject.current_user_playing_track()
0M7IiBVBquus5YkeV4xEyt YouTube channel with minimal dub, industrial techno, minimal techno. Add your own on www.mirror.fm #mirrorfm
7xbwKyY3vYNFGunL35KtYo YouTube channel with industrial techno. Add your own on www.mirror.fm #mirrorfm
6LFZ6taEfZ0i7VWnZl8u4Z YouTube channel. Add your own on www.mirror.fm #mirrorfm
"""
import boto3
from collections import OrderedDict
from operator import itemgetter
import spotipy
client = boto3.client("dynamodb", region_name='eu-west-1')
dynamodb = boto3.resource("dynamodb", region_name='eu-west-1')
mirrorfm_yt_playlists = dynamodb.Table('mirrorfm_yt_playlists')
sp = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(
scope='playlist-modify-public playlist-modify-private',
username="******"))
# Get all
playlists = mirrorfm_yt_playlists.scan()
print(len(playlists['Items']))
for p in playlists['Items']:
# Get top 3 genres
genres = p.get('genres')
sorted_genres = OrderedDict(
sorted(genres.items(), key=itemgetter(1), reverse=True))
top3_genres = list(sorted_genres)[:3]
# Description
genres_str = ''
tag_list = soup.findAll(
class_='chart-element__information__song text--truncate color--primary')
print('Song List Created')
for tag in tag_list:
song_list.append(tag.text)
# Search Songs and Extract URIs
uri_list = []
scope = "user-library-read"
sp = spotipy.Spotify(
auth_manager=spotipy.SpotifyOAuth(client_id=keys.spotify_client_id,
client_secret=keys.spotify_client_secret,
scope=scope,
redirect_uri=keys.spotify_redirect_uri))
user_id = sp.current_user()['id']
for i in range(10):
search_string = song_list[i]
test = sp.search(q=search_string, type='track')
name = test['tracks']['items'][0]['name']
uri = test['tracks']['items'][0]['uri']
uri_list.append(uri)
print(f'Song \'{name}\' added')
print('All Songs added')
import json
import spotipy
from spotipy.oauth2 import SpotifyClientCredentials
from colour_puller.album import SpotifyAlbum
from colour_puller.database import AlbumDatabase
auth = spotipy.SpotifyOAuth(
redirect_uri='http://localhost:8888/callback', username='******'
)
sp = spotipy.Spotify(auth_manager=auth)
recently_played = sp.current_user_recently_played()
recent_albums = []
for item in recently_played['items'][::-1]:
album = SpotifyAlbum(item['track']['album'])
if album.art_link and not any(prev == album for prev in recent_albums):
recent_albums.append(album)
ad = AlbumDatabase()
ad.add_albums(recent_albums)
# Get counts
queue = ad.count_records(status='queued')
completed = ad.count_records(status='completed')
return None
def sleeping(duration, result, index):
time.sleep(duration)
result[index] = True
sys.exit()
# Scope required for currently playing
scope = "user-read-currently-playing"
# Create our spotifyOAuth object
spotifyOAuth = spotipy.SpotifyOAuth(
client_id=os.environ['SPOTIPY_CLIENT_ID'],
client_secret=os.environ['SPOTIPY_CLIENT_SECRET'],
redirect_uri=os.environ['SPOTIPY_REDIRECT_URI'],
scope=scope)
token = spotifyOAuth.get_access_token()
# print(json.dumps(token, sort_keys=True, indent=4))
# Create our spotifyObject
spotifyObject = spotipy.Spotify(auth=token['access_token'])
# Create out geniusObject
access_token = os.environ['GENIUS_ACCESS_TOKEN']
genius = lg.Genius(access_token)
counter = 1
result = [False]
def prompt_for_user_token_mod(username,
scope=None,
client_id=None,
client_secret=None,
redirect_uri=None,
cache_path=None,
oauth_manager=None,
show_dialog=False):
if not oauth_manager:
if not client_id:
client_id = os.getenv("SPOTIPY_CLIENT_ID")
if not client_secret:
client_secret = os.getenv("SPOTIPY_CLIENT_SECRET")
if not redirect_uri:
redirect_uri = os.getenv("SPOTIPY_REDIRECT_URI")
if not client_id:
print("""
You need to set your Spotify API credentials.
You can do this by setting environment variables like so:
export SPOTIPY_CLIENT_ID='your-spotify-client-id'
export SPOTIPY_CLIENT_SECRET='your-spotify-client-secret'
export SPOTIPY_REDIRECT_URI='your-app-redirect-url'
Get your credentials at
https://developer.spotify.com/my-applications
""")
raise spotipy.SpotifyException(550, -1, "no credentials set")
cache_path = cache_path or ".cache-" + username
sp_oauth = oauth_manager or spotipy.SpotifyOAuth(client_id,
client_secret,
redirect_uri,
scope=scope,
cache_path=cache_path,
show_dialog=show_dialog)
# try to get a valid token for this user, from the cache,
# if not in the cache, the create a new (this will send
# the user to a web page where they can authorize this app)
token_info = sp_oauth.get_cached_token()
if not token_info:
server_address = ('', 8420)
httpd = OAuthHTTPServer(server_address)
import webbrowser
webbrowser.open(sp_oauth.get_authorize_url())
httpd.server.handle_request()
if httpd.server.url:
url = httpd.server.url
code = sp_oauth.parse_response_code(url)
token = sp_oauth.get_access_token(code, as_dict=False)
else:
return token_info["access_token"]
# Auth'ed API request
if token:
return token
else:
return None
username = ''
#Scope to view the playing song
scope = 'user-read-currently-playing'
#Add your client ID from Spotify Dev
client_id = ''
#Add your client secret from Spotify Dev
client_secret = ''
redirect_uri = 'http://localhost:8080/callback'
#script has a bunch of time.sleep, if it seems to take too long try changing these values
#spotify authenticator / manages tokens as well
sp = spotipy.Spotify(
auth_manager=spotipy.SpotifyOAuth(username=username,
client_id=client_id,
client_secret=client_secret,
redirect_uri=redirect_uri,
scope=scope))
def relaunchSpotify():
keyboard = Controller()
#Finds all PIDs with the name Spotify
for proc in psutil.process_iter():
if any(procstr in proc.name() for procstr in ['Spotify']):
try:
#Kills all processes of spotify
proc.kill()
#sometimes the process will already be gone
def get_spotipy_instance(self):
return spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(scope=SCOPE, client_id=self.client_id,
client_secret=self.client_secret,
redirect_uri=REDIRECT_URI))
def main():
spotify = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth())
me = spotify.me()
pprint(me)
import json
import uuid
from django.conf import settings
from django.http import JsonResponse, HttpResponseBadRequest, HttpResponseRedirect, HttpResponseNotAllowed, HttpResponseNotFound
import spotipy
from . import db, mail, patterns, apikeys
SPOTIFY_OAUTH = spotipy.SpotifyOAuth(
settings.SPOTIFY_CLIENT_ID,
settings.SPOTIFY_CLIENT_SECRET,
settings.SPOTIFY_REDIRECT_URI,
scope=settings.SPOTIFY_SCOPE,
username=settings.SPOTIFY_USERNAME,
)
SPOTIFY_MARKET = 'US'
SPOTIFY_CONTENT_TYPES = ['track', 'artist', 'album', 'playlist']
def _enforce_method(request, method):
if not request.method == method:
return HttpResponseNotAllowed([method])
def _get_user(request):
if 'user' not in request.session:
return None
else:
0M7IiBVBquus5YkeV4xEyt YouTube channel with minimal dub, industrial techno, minimal techno. Add your own on www.mirror.fm #mirrorfm
7xbwKyY3vYNFGunL35KtYo YouTube channel with industrial techno. Add your own on www.mirror.fm #mirrorfm
6LFZ6taEfZ0i7VWnZl8u4Z YouTube channel. Add your own on www.mirror.fm #mirrorfm
"""
import boto3
from collections import OrderedDict
from operator import itemgetter
import spotipy
client = boto3.client("dynamodb", region_name='eu-west-1')
dynamodb = boto3.resource("dynamodb", region_name='eu-west-1')
mirrorfm_yt_playlists = dynamodb.Table('mirrorfm_yt_playlists')
sp = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(
scope='playlist-modify-public playlist-modify-private'))
# Get all
playlists = mirrorfm_yt_playlists.scan()
print(len(playlists['Items']))
for p in playlists['Items']:
# Get top 3 genres
genres = p.get('genres')
sorted_genres = OrderedDict(
sorted(genres.items(), key=itemgetter(1), reverse=True))
top3_genres = list(sorted_genres)[:3]
# Description
genres_str = ''
if len(top3_genres) > 0:
import spotipy
from spotipy.oauth2 import SpotifyClientCredentials
import os
scope = "user-read-playback-state,user-modify-playback-state"
spotify = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(),
auth_manager=spotipy.SpotifyOAuth(scope=scope))
def get_device_id():
devices = spotify.devices()
print(devices)
for device in devices["devices"]:
if device["name"] == os.getenv("SPOTIPY_DEVICE_NAME"):
return device["id"]
def play_song(query, source="track"):
device_id = get_device_id()
try:
results = spotify.search(q=query, type=source, limit=1)
if "playlists" in results and len(results["playlists"]["items"]) > 0:
playlist = results["playlists"]["items"][0]["uri"]
spotify.start_playback(device_id=device_id, context_uri=playlist)
return True, "Playing the " + source + results["playlists"][
"items"][0]["name"]
if "tracks" in results and len(results["tracks"]["items"]) > 0:
track = results["tracks"]["items"][0]["uri"]
GRAPH_DIR.mkdir(exist_ok=True)
parser = argparse.ArgumentParser()
parser.add_argument('-config', help='yaml config file')
config_path = parser.parse_args().config
args = yaml.load(Path(config_path).read_text(), Loader=yaml.SafeLoader)
if 'rcParams' in args.keys():
for k, v in args['rcParams'].items():
plt.rcParams[k] = v
if 'style' in args.keys():
plt.style.use(args['style'])
auth = spotipy.SpotifyOAuth(redirect_uri='http://localhost:8888/callback',
username=args['username'])
sp = spotipy.Spotify(auth_manager=auth)
album = tools.get_album(sp, args['album_id'])
all_data = pd.concat(
tools.Track(t).loudness(sp) for t in album['tracks']['items'])
all_data['Centred Time'] = (
all_data['Time'] -
(all_data.groupby('TrackNo')['Time'].transform('max') / 2))
g = sns.FacetGrid(data=all_data,
sharex=True,
sharey=True,
row='Name',
import json
import spotipy
import spotipy.util as util
import sys
import time
scope = 'user-read-private user-read-currently-playing'
if len(sys.argv) > 1:
username = sys.argv[1]
else:
print("Usage: %s username" % (sys.argv[0], ))
sys.exit()
while True:
sp_oauth = spotipy.SpotifyOAuth(scope=scope, username=username)
if sp_oauth:
sp = spotipy.Spotify(oauth_manager=sp_oauth)
for i in range(0, 359):
results = sp.currently_playing()
playing_file = open("playing.txt", "w+", encoding='utf-8')
contents = str(playing_file.read())
if results == None or results['item'] == None or results[
'is_playing'] == False:
if contents != "":
contents = ""
playing_file.write("")
playing_file.close()
print("Paused or nothing's playing on Spotify.",
flush=True)
def sleep_timer(
username: str,
client_id: str,
client_secret: str,
scope: Iterable[str],
redirect_uri: str,
music_stop_time: Union[int, float, datetime, timedelta],
elapced_time_check_interval: Union[int, float] = 1.0,
) -> None:
"""Spotify sleep timer
Args:
username (str): spotify username code
client_id (str): spotify client id code
client_secret (str): spotify client secret code
scope (Iterable[str]): spotify authorization scope
redirect_uri (str): spotify client redirect uri
music_stop_time (int|float|datetime|timedelta): timer setting
elapsed_time_check_interval(int|float, optional): time check interval
Raises:
ValueError: cannot convert from music_stop_time to timedelta object
"""
auth_manager: SpotifyOAuth = spotipy.SpotifyOAuth(
client_id=client_id,
client_secret=client_secret,
redirect_uri=redirect_uri,
scope=" ".join(scope),
username=username,
)
spotify: Spotify = spotipy.Spotify(auth_manager=auth_manager)
if not is_playing(spotify):
print("does not play songs.")
return
stop_time: Optional[timedelta] = None
if isinstance(music_stop_time, (int, float)):
stop_time = timedelta(seconds=music_stop_time)
elif isinstance(music_stop_time, datetime):
stop_time = music_stop_time - datetime.now()
elif isinstance(music_stop_time, timedelta):
stop_time = music_stop_time
else:
raise ValueError("cannot convert stop time.")
if stop_time < timedelta(days=0):
raise ValueError("stopping time is before now.")
print("start sleep timer")
start_time: Final[datetime] = datetime.now()
print("start {} -> {} end.".format(
start_time.strftime("%H:%M:%S"),
(datetime.now() + stop_time).strftime("%H:%M:%S"),
))
with Progress() as progress:
pbar = progress.add_task("will stop playing at...",
total=int(stop_time /
timedelta(microseconds=1)))
while True:
elapsed_time: timedelta = datetime.now() - start_time
progress.update(pbar,
completed=elapsed_time / timedelta(microseconds=1))
if elapsed_time > stop_time:
break
sleep(elapced_time_check_interval)
if is_playing(spotify):
spotify.pause_playback()
print("stop playing")
from telethon.tl.functions.photos import UploadProfilePhotoRequest, DeletePhotosRequest
from telethon.tl.functions.account import UpdateProfileRequest
from telethon import TelegramClient
from datetime import datetime
from termcolor import colored
import urllib.request
import configparser
import spotipy
config = configparser.ConfigParser()
config.read("config.ini")
client = TelegramClient('default', int(config["!USER!"]["tg_api_id"]),
config["!USER!"]["tg_api_hash"])
sp = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(
scope="user-read-currently-playing",
client_id=config["!SPOTIFY!"]["client"],
client_secret=config["!SPOTIFY!"]["secret"],
redirect_uri=config["!SPOTIFY!"]["redirect"])) # Connects to Spotify API
async def main():
""" This function is the main function of the program. """
first_name = config["!SETTINGS!"]["first_name"]
last_name = config["!SETTINGS!"]["last_name"]
profile_photo = config["!SETTINGS!"]["profile_photo"]
bio_act = config["!SETTINGS!"]["bio"]
bio_link = config["!SETTINGS!"]["bio_link"]
market = config["!SPOTIFY!"]["market"]
image = ["", ""]
def temp():
spotify = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(username="******"))
print(spotify.me())
return render_template('home.html')
def prompt_for_user_token(username,
scope=None,
client_id=None,
client_secret=None,
redirect_uri=None,
cache_path=None,
oauth_manager=None,
show_dialog=False):
warnings.warn(
"'prompt_for_user_token' is deprecated."
"Use the following instead: "
" auth_manager=SpotifyOAuth(scope=scope)"
" spotipy.Spotify(auth_manager=auth_manager)", DeprecationWarning)
""" prompts the user to login if necessary and returns
the user token suitable for use with the spotipy.Spotify
constructor
Parameters:
- username - the Spotify username
- scope - the desired scope of the request
- client_id - the client id of your app
- client_secret - the client secret of your app
- redirect_uri - the redirect URI of your app
- cache_path - path to location to save tokens
- oauth_manager - Oauth manager object.
- show_dialog - If true, a login prompt always shows
"""
if not oauth_manager:
if not client_id:
client_id = os.getenv("SPOTIPY_CLIENT_ID")
if not client_secret:
client_secret = os.getenv("SPOTIPY_CLIENT_SECRET")
if not redirect_uri:
redirect_uri = os.getenv("SPOTIPY_REDIRECT_URI")
if not client_id:
LOGGER.warning("""
You need to set your Spotify API credentials.
You can do this by setting environment variables like so:
export SPOTIPY_CLIENT_ID='your-spotify-client-id'
export SPOTIPY_CLIENT_SECRET='your-spotify-client-secret'
export SPOTIPY_REDIRECT_URI='your-app-redirect-url'
Get your credentials at
https://developer.spotify.com/my-applications
""")
raise spotipy.SpotifyException(550, -1, "no credentials set")
cache_path = cache_path or ".cache-" + username
sp_oauth = oauth_manager or spotipy.SpotifyOAuth(client_id,
client_secret,
redirect_uri,
scope=scope,
cache_path=cache_path,
show_dialog=show_dialog)
# try to get a valid token for this user, from the cache,
# if not in the cache, the create a new (this will send
# the user to a web page where they can authorize this app)
token_info = sp_oauth.get_cached_token()
if not token_info:
code = sp_oauth.get_auth_response()
token = sp_oauth.get_access_token(code, as_dict=False)
else:
return token_info["access_token"]
# Auth'ed API request
if token:
return token
else:
return None
async def get_new_token(self):
sp = spotipy.Spotify(auth_manager=spotipy.SpotifyOAuth(
username=config.SPOTIFY_USERNAME, scope=config.SPOTIFY_SCOPE))
token = sp.auth_manager.get_access_token(as_dict=False)
self.headers = {'Authorization': f'Bearer {token}'}
self.sp = sp
