def comparison_pie_plot(path, data, txt):
    """
    Plots a pie chart comparison of the # of times each AD found
    the highest best/average final solution for all simulations
    """
    # The slices will be ordered and plotted counter-clockwise.

    unzipped_data = list(zip(*data))
    num_sims = len(unzipped_data)
    sizes = [0] * len(data)
    for simulation_data in unzipped_data:
        m = max(simulation_data)
        max_indexes = [i for i, j in enumerate(simulation_data) if j == m]
        for i in max_indexes:
            sizes[i] += 1

    # percentages
    for i in range(len(sizes)):
        sizes[i] = round((sizes[i] / num_sims) * 100)

    # "explode" all slices
    explode = [0.1] * len(data)

    plt.figure()
    plt.title("Comparison of the # of times each AD found the highest " + txt + " final solution for all simulations")

    plt.pie(sizes, explode=tuple(explode), labels=AD_labels, colors=AD_color, autopct='%1.1f%%', shadow=True)

    plt.axis('equal')  # Set aspect ratio to be equal so that pie is drawn as a circle.
    plt.savefig(path + "/pie_" + txt + ".png", bbox_inches='tight')
    plt.close()

    return

    def display_channel_efficiency(self):

        size = 0

        start_time = self.pcap_file[0].time
        end_time = self.pcap_file[len(self.pcap_file) - 1].time

        duration = (end_time - start_time)/1000

        for i in range(len(self.pcap_file) - 1):
            size += len(self.pcap_file[i])
        ans = (((size * 8) / duration) / BW_STANDARD_WIFI) * 100
        ans = float("%.2f" % ans)
        labels = ['utilized', 'unutilized']
        sizes = [ans, 100.0 - ans]
        colors = ['g', 'r']

        # Make a pie graph
        plt.clf()
        plt.figure(num=1, figsize=(8, 6))
        plt.axes(aspect=1)
        plt.suptitle('Channel efficiency', fontsize=14, fontweight='bold')
        plt.title("Bits/s: " + str(float("%.2f" % ((size*8)/duration))),fontsize = 12)
        plt.rcParams.update({'font.size': 17})
        plt.pie(sizes, labels=labels, autopct='%.2f%%', startangle=60, colors=colors, pctdistance=0.7, labeldistance=1.2)

        plt.show()

def plot_percent_mentions(tweets, gop = False, save_to = None):
  '''
  Plots the percent mentions of each candidate (filtered for party)
  Used for Task 3.
  ''' 

  percents = tweets.get_percent_mentions(gop)

  candidates = [] 
  mentions = [] 
  for c, ment in percents:
    if c == "other": 
      other_v = ment 
    else:   
      candidates.append(CANDIDATE_NAMES[c[:-1]])
      mentions.append(ment)
  candidates.append("other")
  mentions.append(other_v)

  fig = plt.figure(figsize = (FIGWIDTH, FIGHEIGHT)) 

  plt.pie(mentions, labels = candidates, autopct='%1.1f%%')
  if gop: 
    plt.title("Percent of Mentions per GOP candidate")
  else: 
    plt.title("Percent of Mentions per candidate")
 
  plt.show() 
  if save_to: 
    fig.savefig(save_to)

    def plotPieChart(self, title=None, cmap_name='Pastel2'):
        if sys.hexversion >= 0x02700000:
            self.fig.set_tight_layout(True)

        # Generate plot data
        labels, ydata = self._getPlotData()
        totalobjects = float(np.sum(ydata))
        fracs = [ynum / totalobjects for ynum in ydata]

        explode = np.zeros(len(fracs))  # non zero makes the slices come out of the pie

        # plot pie chart
        cmap = plt.cm.get_cmap(cmap_name)
        colors = cmap(np.linspace(0., 0.9, len(fracs)))
        plt.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=False, startangle=90,
                colors=colors)

        # generate plot / axis labels
        for axis in self.ax.get_xticklabels():
            axis.set_fontsize(self.xticksize)

        if self.unit is None:  # NOTE this is hacked in so it only works with DataPerParameterClass
            self.unit = self._getParLabelAndUnit(self._planetProperty)[1]  # use the default unit defined in this class
        self._yaxis_unit = self.unit

        if title is None:
            title = 'Planet {0} Bins'.format(self._gen_label(self._planetProperty, self.unit))  # NOTE not always planet

        plt.title(title)
        plt.xlim(-1.5, 1.5)

def analyzeData(db):
    # Total calls, incoming, outgoing (and percents). Times to/from liz and percentage.
    cursor = db.cursor()
    
    numCalls = cursor.execute('''SELECT Count(*) FROM calls''').fetchone()[0]
    print numCalls, "calls from May to July 2014."
    
    numIncoming = cursor.execute('''SELECT Count(*) FROM calls WHERE incoming=1''').fetchone()[0]
    print numIncoming, "incoming calls. (" + str((numIncoming*100.0)/numCalls) + "%)"
    numOutgoing = cursor.execute('''SELECT Count(*) FROM calls WHERE incoming=0''').fetchone()[0]
    print numOutgoing, "outgoing calls. (" + str((numOutgoing*100.0)/numCalls) + "%)"
    # Display the info in a pie chart
    labels = 'Incoming Calls', 'Outgoing Calls'
    values = [numIncoming, numOutgoing]
    colors = ['orange', 'seagreen']
    plt.pie(values, labels=labels, colors=colors, autopct='%1.1f%%')
    plt.axis('equal')
    plt.show()
    
    numLiz = cursor.execute('''SELECT Count(*) FROM calls WHERE phone_number='630-380-4152';
            ''').fetchone()[0]
    percentLiz = (numLiz*100.0)/numCalls
    print numLiz, "calls to/from Liz. (" + str(percentLiz) + "%)"
    # Display the info in a pie chart
    labels = 'Liz', 'Others'
    sizes = [int(percentLiz), 100 - int(percentLiz)]
    colors = ['turquoise', 'gold']
    plt.pie(sizes, colors=colors, labels=labels, autopct='%1.1f%%')
    plt.axis('equal')
    plt.show()

    return

def plot_NA_ratio_features(dataset, feature_names, missing_value_string='nan'):

	y, x = dataset.shape
	ind = np.zeros((x, 1)).reshape(1, x)

	for j in range(y):
		for i in range(x):
			# print str(dataset[j, i])
			if missing_value_string == str(dataset[j, i]):
				ind[0, i] += 1

	ind = (ind/y*100)


	labels = 'NA', ''
	colors = ['yellowgreen', 'lightcoral']
	explode = (0, 0)
	plt.rcParams.update({'font.size': 8})
	plt.suptitle("NA ration", fontsize=16)

	for i in range(x):
		ax = plt.subplot(5, 5, i+1)
		ax.set_title(feature_names[i])
		sizes = [ind[0, i], 100-ind[0, i]]
		plt.pie(sizes, explode=explode, labels=labels, colors=colors, autopct='%1.1f%%')
		# autopct permits to add the value of the part in chart
		plt.axis('equal')

	plt.show()

def create_pie_chart(data, title, filename, cutoff=0.01, verbose=False):
    """Create a pie chart from the given data

    Params:
    data- a collections.Counter where the keys should be the labels to
        the graph

    """
    total = float(sum(data.values()))
    frac_labels = []
    other_count = 0
    # compute the fraction for each label
    for cnt in data.keys():
        fraction = float(data[cnt]) / total
        if verbose:
            print "{}: {}".format(cnt, fraction)
        # if this slice is too small, just add it to other small
        # totals and display them together
        if fraction < cutoff:
            other_count += data[cnt]
            continue
        frac_labels.append((fraction, cnt))
    if other_count > 0:
        frac_labels.append((float(other_count) / total, "Other"))
    frac_labels.sort(key=lambda entry: entry[1])
    fractions, labels = zip(*frac_labels)
    plt.figure()
    plt.pie(fractions, labels=labels, autopct='%1.1f%%',
            colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'))
    plt.title(title)
    plt.savefig(filename, fmt='pdf')

def pie_graph(conn, query, output, title='', lower=0, log=False):
	labels = []
	sizes = []

	res = query_db(conn, query)
	# Sort so the graph doesn't look like complete shit.
	res = sorted(res, key=lambda tup: tup[1])
	for row in res:
		if row[1] > lower:
			labels.append(row[0])
			if log:
				sizes.append(math.log(row[1]))
			else:
				sizes.append(row[1])
	# Normalize.
	norm = [float(i)/sum(sizes) for i in sizes]

	plt.pie(norm,
			labels=labels,
			shadow=True,
			startangle=90,
	)
	plt.figtext(.1,.03,'{}\n{} UTC'.format(site,generation_time))
	plt.axis('equal')
	plt.legend()
	plt.title(title)
	plt.savefig(output)
	plt.close()

def pieplot(data, total, min, stitle): #Create a pie plot... mmm, pie
	import matplotlib.pyplot as plt
	labels=[]
	sizes=[]
	other=0
	if total is None: #Calc total if not given
		total=0
		for cat in data:
			total+=cat[0]
	for cat in data: #Convert values to a percentage of total, separate smaller categories
		cat[0]=cat[0]/total*100
		if cat[0]>min:
			labels.append(cat[1])
			sizes.append(cat[0])
		else:
			other+=cat[0]
	if other>0.1: #Include the rest if it's significant
		sizes.append(other)
		labels.append("Other")
	# The slices will be ordered and plotted counter-clockwise.
	colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
	#explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice # But I don't wanna explode...
	plt.pie(sizes, labels=labels, #colors=colors,
			autopct='%1.1f%%', shadow=True, startangle=90)
	plt.axis('equal') # Set aspect ratio to be equal so that pie is drawn as a circle.
	plt.title(stitle)
	plt.show()

def plotResults(red_wins, black_wins, tie):

    # Adjusting the plot results to not show 0%`s
    def make_autopct(values):
        def my_autopct(pct):
            if pct == 0:
                return ""
            else:
                return '{p:.1f}% '.format(p=pct)

        return my_autopct

    # Setting up plot variables
    labels = ['Red Wins', 'Black Wins', 'Ties']
    sizes = [red_wins, black_wins, tie]
    colors = ['yellowgreen', 'gold', 'lightskyblue']
    explode = (0.1, 0, 0)

    plt.pie(sizes, colors=colors, explode=explode, labels=labels, autopct=make_autopct(sizes), shadow=True,
            startangle=70)
    plt.axis('equal')
    plt.tight_layout()
    plt.show()
    print "number of red wins ", red_wins
    print "number of black wins ", black_wins
    print "number of ties ", tie

    def plot_single_piechart(self, cluster_no, labels, pdf):
       cluster_label_dict = {}

       for label in labels:
           if label not in cluster_label_dict:
               cluster_label_dict[label] = 1
           else:
               cluster_label_dict[label] += 1
       distinct_labels = []
       label_counts = []
       colors = []
       cmap = self.get_cmap(30)
       i = 0
       for label,value in cluster_label_dict.iteritems():
           colors.append(cmap(i))
           distinct_labels.append(label)
           label_counts.append(value)
           i = i+1
       matplotlib.rcParams['font.size'] = 5

       plt.figure(figsize=(8,8))
       plt.pie(label_counts, explode=None, labels=distinct_labels, colors=colors,
       autopct='%1.1f%%', shadow=True, startangle=90)
       # Set aspect ratio to be equal so that pie is drawn as a circle.
       plt.axis('equal')
       plt.suptitle("Cluster no " + str(cluster_no) + "\nNumber of docs in cluster: " + str(len(labels)),fontsize=10)
       pdf.savefig()
       plt.close()

def drawing_pie(start_date, end_date):
    p_count=0
    n_count=0
    neu_count=0
    sentiment = get_sentiment_dates(start_date,end_date)
    for semt in sentiment[0].values():
        p_count+=semt
    for semt in sentiment[1].values():
        n_count+=semt
    for semt in sentiment[2].values():
        neu_count+=semt

    print p_count
    print n_count
    print neu_count
    labels = 'Positive','Negative','Neutral'
    sizes = [p_count,n_count,neu_count]
    colors = ['green', 'red', 'yellow']
    explode = (0, 0.1, 0) # only "explode" the 2nd slice

    plt.pie(sizes, explode=explode, labels=labels, colors=colors,
            autopct='%1.1f%%', shadow=True, startangle=90)
    plt.axis('equal')
    plt.title('Sentiment is Positive')

    plt.show()
    return

def makePieChart(bigList):
    streetNameList = []
    bikeSpaceList = []
    x = 0
    ##bigList = readBikeData.GatherData('rows.json')
    for i in range(len(bigList)):
        streetName = bigList[i][10].lower()
        bikeSpaceInt = int(bigList[i][12])
        if streetName in streetNameList:
            ndx = streetNameList.index(streetName)
            bikeSpaceList[ndx] += bikeSpaceInt
        else:
            streetNameList.append(streetName)
            bikeSpaceList.append(bikeSpaceInt)
    bikeSpaceSum = sum(bikeSpaceList)

    ##I omited any area that was less then 1% of the total bike space to get a cleaner pie chart
    while x < len(bikeSpaceList):
        if(bikeSpaceList[x] < (bikeSpaceSum * .01) and x >= 0):
            del bikeSpaceList[x]
            del streetNameList[x]
            x-=1

        else:
            x+=1

    plt.axis("equal")
    plt.pie(bikeSpaceList, labels = streetNameList, autopct = "%1.1f%%", shadow = False)
    plt.title("Bike Space to Street Name Distribution")
    plt.show()

    def pieplot(self, variable):
        """ Plot pie plot for gender or usertype in certain period """
        variable_type = self.data[variable].unique()
        variable_size = []
        if variable == 'gender':
            for i in np.sort(variable_type):
                variable_size.append(round((sum(self.data[variable] == i) / self.data.shape[0] * 100), 2))    # calculate distirbution
            # Gender (Zero=unknown; 1=male; 2=female)
            labels = 'Unknown', 'Male', 'Female'
            sizes = variable_size
            colors = ['lightyellow','lightskyblue', 'lightcoral']
            explode = (0, 0.1, 0.1)  # "explode" the distribution of male and female

            plt.pie(sizes, explode=explode, labels=labels, colors=colors,
                    autopct='%1.1f%%', shadow=True, startangle=90)
            # Set aspect ratio to be equal so that pie is drawn as a circle.
            plt.axis('equal')
            plt.title('Gender Distribution in {}-{}'.format(self.year, self.month), fontsize = 12,y = 1,x=0.12,bbox={'facecolor':'0.8', 'pad':5})
            plt.show()

        elif variable == 'usertype':
            # usertype (Zero=Customer, 1=Subscriber)
            for i in range(2): # change to 0, 1
                variable_size.append(round((sum(self.data[variable] == i) / self.data.shape[0] * 100), 2))    # calculate distribution
            labels = 'Subscriber', 'Customer'
            sizes = variable_size
            colors = ['lightcoral','lightskyblue']
            explode = (0, 0.1)  # only "explode" the subscriber

            plt.pie(sizes, explode=explode, labels=labels, colors=colors,
                    autopct='%1.1f%%', shadow=True, startangle=90)
            # Set aspect ratio to be equal so that pie is drawn as a circle.
            plt.axis('equal')
            plt.title('User Type Distribution in {}-{}'.format(self.year, self.month), fontsize = 12,y = 1,x=0.12,bbox={'facecolor':'0.8', 'pad':5})
            plt.show()

def make_chart_pie_chart():

    plt.pie([0.95, 0.05], labels=["Uses pie charts", "Knows better"])

    # make sure pie is a circle and not an oval
    plt.axis("equal")
    plt.show()

def plot_pie(df, name):
    """ plot a pie chart showing composition of different restaurants, return 1 if succeed """
    # Get restaurant count group by description in descending order
    ranking = df.groupby('DESCRIPTION').count().sort('CAMIS', ascending=False)
    n = ranking.sum()[0] - ranking.ix['Other'][0]
    # Get top 10 descriptions and their corresponding counts
    other = n - ranking[:10].sum()[0]
    labels = list(ranking.index[:10])
    try:
        labels.remove('Other')
    except ValueError:
        pass
    sizes = []
    for label in labels:
        sizes.append(ranking.ix[label][0])
    labels = [x.decode('utf8').encode('ascii', 'replace') for x in labels]
    labels.append('Other')
    sizes.append(other)
        
    cm = plt.get_cmap('gist_rainbow')
    colors = [cm(x) for x in np.arange(0, 1, 1./len(labels))]

    plt.figure()
    plt.pie(sizes, labels=labels, colors = colors, autopct='%1.1f%%', shadow=True, startangle=90)
    plt.title('Percentage of Different Restaurants ({})'.format(name))
    plt.axis('equal')
    plt.savefig('rest_pie_{}.png'.format(name))
    return 1

def plot_visit_duration_dist(page_info, course, style='pie',
                             include_subpages=True):
    dict_to_plot = visit_duration_dist(page_info, course, include_subpages)
    y = []
    my_labels = []
    for num, key in enumerate(sorted(dict_to_plot.keys())):
        # disregard entries below 1%
        if float(dict_to_plot[key]) / sum(dict_to_plot.values()) < 0.01:
            continue
        y.append(dict_to_plot[key])
        if 'pie' == style:
            my_labels.append(key.replace(
                '_', '') + ' [' + str(int(y[num] / 60 / 60)) + 'h ' + str(
                int(100 * round(float(dict_to_plot[key]) / sum(
                    dict_to_plot.values()), 2))) + '%]')
        elif 'bar' == style:
            my_labels.append(key.replace(
                'December_', 'Dec').replace(
                'April_', 'Apr').replace(
                '20', '') + '\n' + str(
                int(100 * round(float(dict_to_plot[key]) / sum(
                    dict_to_plot.values()), 2))) + '%')
    y = np.asarray(y)
    if 'pie' == style:
        plt.pie(y, labels=my_labels, startangle=90)
    elif 'bar' == style:
        plt.bar(range(len(y)), y / 60 / 60, align='center',
                color=create_RGB_list(len(y)))
        plt.gca().set_xticks(range(len(y)))
        plt.gca().set_xticklabels(my_labels)
        plt.ylabel('Total pageview time in hours')
    plt.title(course + ' - Total pageview time per exam')

def plotTime():
	#Time levels
	pp = PdfPages('time.pdf')
	lev1 = 0
	lev2 = 0
	lev3 = 0
	lev4 = 0
	lev5 = 0
	lev6 = 0
	for time in userTime.keys():
		if len(time) > 0:
			intTime = int(time)
			if intTime < 10:
				lev1 += 1 * userTime[time]
			elif intTime >=10 and intTime < 20:
				lev2 += 1 * userTime[time]
			elif intTime >= 20 and intTime < 30:		
				lev3 += 1 * userTime[time]
			elif intTime >=30 and intTime < 40:		
				lev4 += 1 * userTime[time]
			elif intTime >=40 and intTime < 50:		
				lev5 += 1 * userTime[time]
			else:
				lev6 += 1 * userTime[time]
	labels = '10-', '10-20', '20-30', '30-40', '40-50', '50+'
	sizes = [lev1, lev2, lev3, lev4, lev5, lev6] 		
	colors = ['yellowgreen', 'gold', 'lightskyblue', 'blue', 'lightcoral', 'red']
	plt.figure()
	plt.clf()
	plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', shadow=True)
	plt.axis('equal')
	pp.savefig()
	pp.close()

def plot_educationLevel(df):
    """
    Function takes dataframe as input,
    plot a pie of

    Argument
    ========
    DataFrame

    """

    degree=degreeDict(df)
    bach=degree['Bachelor']
    master=degree['Master']
    others=degree['High School or others non-degree']
    labels = 'At least \n a Bachelor degree', 'At least\n   A Master \n degree','Others:\nHigh school \nDiploma or \nSome experiences '
    fracs = [bach, master, others]
    plt.figure(figsize=(12,8))
    explode = (0.05, 0.05, 0.05)
    colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
    plt.pie(fracs,explode=explode, colors=colors, autopct='%1.1f%%', shadow=True, startangle=90)
    plt.axis('equal')
    plt.legend(labels,loc="lower right")
    plt.title('Minimum Degree Requirement', fontsize=20)
    plt.show()

def generate_piechart(TPdata, key, dictionary):
    """generates a pie chart about a key in the dataset using translation dictionary"""

    counts = defaultdict(int)  # empty dictionary

    for TP in TPdata:
        counts[TP[key]] += 1

    logging.debug("extracted counts: [%s]", str(counts) )

    fig1 = plt.figure(figsize=(8,8)) ## makes sure that there is no squeezing of the round pie
    plt.axis('equal')

    values = [value for key, value in counts.items()]
    labels = counts.keys()

    if dictionary:
        labels = translate_labels(labels, dictionary)

    labels = add_sum_to_labels(values, labels)

    plt.pie(values, explode=None, \
                labels=labels, colors=None, autopct=None, pctdistance=0, \
                shadow=False, labeldistance=1.1, hold=None)

    plt.show()