def check_storage():
"""
Verifica se o pacote de armazenamento existe
:return: None
"""
try:
if not os.path.exists(get_path('../storage')):
os.mkdir('../storage')
except Exception as e:
from functions import get_error
get_error(e)
def get_playlists(user_id, token) -> dict or None:
"""
Consulta as playlists do usuário
:param user_id: ID do usuário no Spotify
:param token: Código de acesso à conta do usuário
:return:
"""
try:
playlists = {} # Variável de retorno da função
current = 0 # Contagem da quantidade de músicas encontradas
offset = 0 # Offset da consulta para buscar todos os dados
total = 1 # Total de músicas retornadas da consulta
# Enquanto não consultar todas as playlists, não interrompe a consulta
while current <= total:
funded_something_playlist = False
# Configurando a URL
url = "https://api.spotify.com/v1/users/{0}/playlists?limit=10&offset={1}".format(
user_id, offset)
# Realizando a consulta
response = made_request(url, token)
# Convertendo o resultado de json pra dicionário
data = response.json()
if 'error' in data:
print(data['error']['message'])
return []
# Verificando se existe a informação da quantidade de músicas encontradas na consulta
if 'total' in data:
total = data['total']
# Verificando se retornou alguma música da consulta
if 'items' in data:
# Percorrendo as músicas retornadas
for item in data['items']:
funded_something_playlist = True
current += 1
offset += 1
# Console
functions.clear_terminal()
print("{0} playlists encontradas".format(current))
# Atribuindo os valores no dicionário
playlists[item['id']] = Playlist(item['id'], item['name'])
else:
# Se não retornou nada, interrompe a consulta não manter um loop infinito na execução
break
# Verifica se a quantidade de músicas teve alteração, se não, interrompe a consulta para impedir loop infinito
if not funded_something_playlist:
break
# Retorno das playlists encontradas
return playlists
except Exception as e:
return functions.get_error(e)
def connect():
try:
import MySQLdb
return MySQLdb.connect(user=data_access['user'],
passwd=data_access['passwd'],
host=data_access['host'],
db=data_access['db'])
except Exception as e:
return get_error(e)
def execute_script(script: str,
param: tuple = None,
returning_id: bool = False) -> bool or None:
try:
database = connect()
cursor = database.cursor()
cursor.execute(script, param)
database.commit()
database.close()
return cursor.lastrowid if returning_id else True
except Exception as e:
return get_error(e)
def select(script, param=None, featchone=False, featchmany=None):
try:
database = connect()
cursor = database.cursor()
cursor.execute(script, param)
if featchone:
response = cursor.fetchone()
elif featchmany is not None:
response = cursor.fetchmany(int(featchmany))
else:
response = cursor.fetchall()
database.close()
return response
except Exception as e:
return get_error(e)
def delete_data(user_id) -> bool or None:
"""
Apaga os arquivos exportados de um usuário
:param user_id: ID do usuário (mesmo ID do spotify)
:return: bool verdadeiro em caso de sucesso ou None em caso de erro
"""
try:
# Verifica se o usuário possui arquivos exportados
if os.path.exists(get_path(f"./storage/{user_id}")):
# Caso possua, exclui todos os arquivos exportados dele
shutil.rmtree(get_path(f"./storage/{user_id}"))
# Tendo ou não arquivos exportados, retorna True como forma de indicar que o usuário não possui mais nada armazenado
return True
except Exception as e:
from functions import get_error
return get_error(e)
def get_tracks_by_playlist(playlist_id, token) -> dict or None:
"""
Consulta as músicsa de uma determinada playlist
:param playlist_id: ID da playlist no Spotify
:param token: Código de acesso à conta do usuário
:return:
"""
try:
tracks = {} # Variável de retorno da função
# Configurando a URL
url = "https://api.spotify.com/v1/playlists/" + playlist_id
# Configurando o cabeçalho
headers = get_header(token)
# Realizando a consulta
response = requests.get(url, headers=headers)
# Convertendo o resultado de json pra dicionário
data = response.json()
if 'error' in data:
print(data['error']['message'])
return []
# Verificando se retornou alguma música da consulta
if 'tracks' in data:
if 'items' in data['tracks']:
# Percorrendo as músicas retornadas
for item in data['tracks']['items']:
if 'track' in item:
# Atribuindo os valores no dicionário
tracks[item['track']['id']] = item['track']['name']
# Retorna a playlist modificada
return tracks
except Exception as e:
return functions.get_error(e)
def delete(table: str, where: str) -> bool or None:
try:
return execute_script(f"DELETE FROM {table} WHERE {where}")
except Exception as e:
return get_error(e)
def update(table: str, columns: str, where: str, param: tuple) -> bool or None:
try:
return execute_script(f"UPDATE {table} SET {columns} WHERE {where}",
param)
except Exception as e:
return get_error(e)
def insert(script: str, param: tuple) -> int or bool or None:
try:
return execute_script(script, param)
except Exception as e:
return get_error(e)
def get_tracks(token) -> dict or None:
"""
Consulta as músicsa de um determinado usuário
:param token: Código de acesso à conta do usuário
:return:
"""
try:
tracks = {} # Variável de retorno da função
current = 0 # Contagem da quantidade de músicas encontradas
offset = 0 # Offset da consulta para buscar todos os dados
total = 1 # Total de músicas retornadas da consulta
# Enquanto não consultar todas as músicas, não interrompe a consulta
while current <= total:
funded_something_track = False
# Configurando a URL
url = "https://api.spotify.com/v1/me/tracks?offset={0}".format(
offset)
# Realizando a consulta
response = made_request(url, token)
# Convertendo o resultado de json pra dicionário
data = response.json()
if 'error' in data:
print(data['error']['message'])
return []
# Verificando se existe a informação da quantidade de músicas encontradas na consulta
if 'total' in data:
total = data['total']
# Verificando se retornou alguma música da consulta
if 'items' in data:
# Percorrendo as músicas retornadas
for item in data['items']:
funded_something_track = True
current += 1
offset += 1
# Console
functions.clear_terminal()
print("{0} músicas encontradas na sua biblioteca".format(
current))
# Consultando os artistas que participam da música
artists = ""
for artist in item['track']['artists']:
artists += artist[
'name'] if artists == "" else ", " + artist['name']
# Atribuindo os valores no dicionário
tracks[item['track']['id']] = Track(
item['track']['id'], item['track']['name'], artists,
item['track']['album']['name'])
else:
# Se não retornou nada, interrompe a consulta não manter um loop infinito na execução
break
# Verifica se a quantidade de músicas teve alteração, se não, interrompe a consulta para impedir loop infinito
if not funded_something_track:
break
# Retornando as músicas encontradas
return tracks
except Exception as e:
return functions.get_error(e)
# print 'predicting...'
# make predictions
train_predictions = predict_y(train_x, w)
test_predictions = predict_y(test_x, w)
# apply sigmoid
train_predictions = sigmoid(train_predictions)
test_predictions = sigmoid(test_predictions)
# stabilize predictions
train_predictions = stabilize(train_predictions)
test_predictions = stabilize(test_predictions)
# calculate error
error_rate = get_error(train_predictions, train_y)
print 'Train - Error Rate:', error_rate
error_rate = get_error(test_predictions, test_y)
print 'Test - Error Rate:', error_rate
# -------------------------------------------------- #
# ------------- Transformed Features --------------- #
# -------------------------------------------------- #
print 'Logistic Regression with Transformed Features:'
# print 'refreshing dataset...'
# parse train and test text files
train_x = get_features('spam_train.txt')
