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')