import os

import sys

import glob

import string

import time

import datetime

import operator

import math

import sys

import numpy as np

from Artistdata import *

import hdf5_getters

import nb

import pickle

import random

try:

import sqlite3 as db

except ImportError:

print 'please install sqlite3 to use this'

sys.exit(0)

"""

for d in data: # datapoint d, data as a list of Datapoint

for feature in d: # feature is feature name as string / key in dict

# do stuff with the feature/value pair

# d[feature] is value as float

"""

def die_with_usage():

sys.exit(0)

def get_stuff():

return result

def get_artist_details(artist_ids):

return result

def get_artists(year_min, year_max, limit, order_by = None):

return ['unexpected end of function']

def get_songs(artist_id, year_min, year_max, limit):

return ['unexpected end of function']

def get_mbtag_freq(n, tags):

return ['unexpected end of function']

def parse_aggregate_songs(file_name,file_name2,artist_map):

#return artist_map

def compute_avg(lst):

return lst_sum / not_none_total

#global variables that will be used to scale features

artist_longitude_min=artist_latitude_min=duration_min=end_of_fade_in_min=loudness_min=start_of_fade_out_min=tempo_min = sys.float_info.max

artist_longitude_max=artist_latitude_max=duration_max=end_of_fade_in_max=loudness_max=start_of_fade_out_max=tempo_max= sys.float_info.min

def parse_artist_map(artist_map, term_freq):

return artist_list

def scale(old_val,old_min,old_max):

return new_val

def bin_data(val):

return round(math.floor(val/bin_size)*bin_size,1)

def bin_year(yr):

return (math.floor((yr-min_year)/bin_size)*bin_size+min_year)

def scale_and_convert_maps(artist_maps):

return data_points

def generate_data():

return data

if __name__ == '__main__':

"""

table_res = get_stuff()

print table_res

"""

#TODO: SCALE ALL VALUES THAT ARENT ALREADY BETWEEN 0-1 to be between 0.0-1.0 depending on max and min value for those features

#TODO: Number of tracks as a feature

#TODO: MAKE KEY 0-11 FEATURES WITH VALUE OF COUNT/NUMSONGS that ARENT 0

#WHEN AVGING, MAKE SURE TO ONLY INCLUDE ONES THAT ARENT NONE

#print os.path.isfile('MillionSongSubset\\data\\A\\M\\B\\TRAMBNF128F426FBB6.h5')

#h5 = hdf5_getters.open_h5_file_read('MillionSongSubset\\data\\A\\P\\X\\TRAPXOE128F92FAB15.h5')

#a = np.array(hdf5_getters.get_artist_terms(h5))

#print a

#artist_info = get_artists(1900, 2020, 1000000)

#print artist_info[1079]

"""

#Gets the most popular artist tags

res = get_mbtag_freq(100, False) #use top 100 results for genres [eco name:0/1] in feature map

freq_map = {}

for pair in res:

freq_map[pair[0]] = pair[1]

"""

"""

#can compare unicode to normal string

#TODO: LOOK UP GMAP API TO CONVERT LOCATION TO LONG/LAT

#If no location, find way to look up artist location to fill in

#TODO: when parsing map pass in the term freq map too to get top terms to use as features

#TODO: Should time signature be binary? look up max and min of time signature!

#map nan log/lat to None

#math.isnan(#)

#make key binary 0-11

#for confidences either ignore or wieght it by that

#keep DB id as field

"""

"""

NOTE: term frequency is directly proportional to how often that term

is used to describe that artist. Term weight is a measure of how

important that term is in describing the artist. As an example of the

difference, the term 'rock' may be the most frequently applied term for

The Beatles. However, 'rock' is not very descriptive since many bands

have 'rock' as the most frequent term. However, the most highly

weighted terms for The Beatles are 'merseybeat' and 'british invasion',

which give you a better idea of what The Beatles are all about than 'rock' does. We don't publish the details of our algorithms, but I can tell you that frequency is related to the simple counting of appearance of a term, whereas weight is related to TF-IDF

"""

"""

#Takes an aggregated song file (created from create_summary_file.py) and parses it

artist_map = parse_aggregate_songs('agg_all_songs.h5')

#flattens the artist map into a list

artist_list = parse_artist_map(artist_map, freq_map)

#normalize the list and make it a list of Datapoints

data = scale_and_convert_maps(artist_list)

#data holds a list of Datapoints (aka maps)

"""

data = generate_data()

#pickle stuff

#output = open('data_nobucket.pkl','wb')

output = open('data.pkl','wb')

pickle.dump(data,output)

output.close()

"""

hott_fam_list = []

plus1 = 0

names = set()

for d in data:

if d.label == 1:

#print d.artist_name,d.familiarity,d.hotttnesss

plus1 += 1

names.add(d.artist_name)

hott_fam_list.append((d.familiarity,d.hotttnesss))

print names

"""

"""

n_d = []

c = 40

HOT_THRESH = 0.425

FAM_THRESH = 0.6

for d in not_data:

label = 1 if d['artist_hotttnesss'] >= HOT_THRESH and d['artist_familiarity'] <= FAM_THRESH else -1

if label==1:

n_d.append(d)

elif c>0:

n_d.append(d)

c-=1

print n_d

"""

"""

print data2[15]

print data2[15].hotttnesss

print data2[15].familiarity

print data2[15].artist_name

print data2[15].artist_id

print data2[15].artist_location==""

print data2[15].track_ids[0]

"""

print ""

print str(len(data))

print data[17]

print data[17].years

print data[17].hotttnesss

print data[17].familiarity

print data[17].artist_name

print data[17].artist_id

print data[17].artist_location==""

print data[17].track_ids[0]

print 'Done parsing and flattening song file'