url = r'https://raw.githubusercontent.com/QuanNguyenIU/Dataset/main/Online%20Retail.xlsx'
df = pd.read_excel(url)
# Remove non-transactions (dumps/refunds)
df = df[df.UnitPrice > 0]
df = df[df.Quantity > 0]
# Remove transactions with NULL Description
df = df[df.Description.notnull()]
# Remove transactions with non-purchase stock codes
df = df[~df.StockCode.isin(['B', 'C2', 'D', 'm', 'M', 'S', 'DOT', 'POST'])]
df = df[~df.StockCode.isin(['AMAZONFEE', 'BANK CHARGES', 'CRUK', 'PADS'])]
df = df[~df.StockCode.apply(str).str.contains("gift")]
# Remove Punctuations
PUNCT = string.punctuation
def remove_punctuation(text):
      return text.translate(str.maketrans('', '', PUNCT))
col = df['Description']
col = col.astype(str)
col = col.str.lower()
col = col.apply(lambda text: remove_punctuation(text))
df['Description'] = col
# Re-enumerate indexes due to deleted transactions
df.reset_index(drop = True, inplace = True)
df

# Include extra attributes, for further analysis
def extra_fields(dataframe):
    dataframe['TotalAmount'] = dataframe['Quantity'] * dataframe['UnitPrice']
    dataframe['InvoiceYear'] = dataframe['InvoiceDate'].dt.year
    dataframe['InvoiceMonth'] = dataframe['InvoiceDate'].dt.month

# Sort and group the DataFrame, with specifed attributes
def sort_dataframe(dataframe, group, fsort):
    df_group = dataframe.groupby(group)
    result = df_group[fsort].agg(np.sum).sort_values(ascending = False)
    return result

def sort_unique_dataframe(dataframe, group, fsort):
    df_group = dataframe.groupby(group)
    uniques = df_group[fsort].unique()
    result = uniques.agg(np.size).sort_values(ascending = False)
    return result

# Bar plot the DataFrame specified field
def plot_bar(dataframe, head, df_title):
    dataframe.head(head).plot(kind = 'bar', title = df_title)
    plt.show()

def general_info(dataframe):
    print('Transaction Count: ',
          len(dataframe['InvoiceNo'].unique()))
    print('Anonymous Transaction Count: ',
          len(dataframe[dataframe['CustomerID'].isnull()]['InvoiceNo'
                                                          ].unique()))
    print('Customer Count: ', len(dataframe['CustomerID'].unique()) - 1)
    print('Total Profit: ', round(sum(dataframe['TotalAmount']), 2))
    top_customers = sort_dataframe(dataframe, 'CustomerID', 'TotalAmount')
    plot_bar(top_customers, 10, 'Top Customers by Total Amount')
    sort_quantity = sort_dataframe(dataframe, 'Description', 'Quantity')
    plot_bar(sort_quantity, 10, 'Frequent Items by Quantity')
    sort_amount = sort_dataframe(dataframe, 'Description', 'TotalAmount')
    plot_bar(sort_amount, 10, 'Frequent Items by Total Amount')
    
def explore_month(dataframe):
    df_month = dataframe.sort_values('InvoiceDate').groupby(['InvoiceYear',
                                                             'InvoiceMonth'])
    month_invoice = df_month['InvoiceNo'].unique().agg(np.size)
    plot_bar(month_invoice, 12, 'Invoice Count by Month')
    month_amount = df_month['TotalAmount'].agg(np.sum)
    plot_bar(month_amount, 12, 'Total Amount by Month')

def explore_country(dataframe):
    sort_amount = sort_dataframe(dataframe, 'Country', 'TotalAmount')
    plot_bar(sort_amount, 10, 'Countries by Total Amount')
    sort_invoice = sort_unique_dataframe(dataframe, 'Country', 'InvoiceNo')
    plot_bar(sort_invoice, 10, 'Countries by Invoice Count')
    sort_customer = sort_unique_dataframe(dataframe, 'Country', 'CustomerID')
    plot_bar(sort_customer, 10, 'Countries by Customer Count')

def brief_summary(dataframe):
    df_brief = dataframe
    extra_fields(df_brief)
    general_info(df_brief)
    explore_month(df_brief)
    explore_country(df_brief)

brief_summary(df)

# Convert DataFrame to Standard Form
def transform_data(df_original):
    invoice = ''
    transactions = []
    for index, value in enumerate(df_original['InvoiceNo']):
        if invoice != value:
            invoice = value
            transactions.append([df_original['Description'][index]])
            continue
        transactions[-1].append(df_original['Description'][index])
    df_transform = pd.DataFrame(transactions)
    df_transform.fillna(value = pd.np.nan, inplace = True)
    return df_transform

# Find All Unique Items
def unique_items(dataframe):
    squeeze = dataframe.values.ravel()
    nan_items = pd.unique(squeeze)
    items = [x for x in nan_items if str(x) != 'nan']
    return items

# One Hot Encoding
def one_hot_encoding(dataframe, items):
    itemset = set(items)
    envals = []
    for idx, row in dataframe.iterrows():
          rowset = set(row)
          labels = {}
          uncomms = list(itemset - rowset)
          commons = list(itemset.intersection(rowset))
          for uc in uncomms: labels[uc] = 0
          for cm in commons: labels[cm] = 1
          envals.append(labels)
    return envals

# Apriori & Association Rules
def ap_as_plot(envals):
    ohedt = pd.DataFrame(envals)
    
    fitems = apriori(ohedt, min_support = 0.01, use_colnames = True)
    fitems.sort_values('support', ascending = 0, inplace = True)
    fitems.reset_index(drop = True, inplace = True)
    fitems.head(10)
    rules = association_rules(fitems, metric = "confidence", 
                              min_threshold = 0.02)
    rules.sort_values('support', ascending = 0, inplace = True)
    rules.head(10)
    # Plotting Results
    plt.scatter(rules['support'], rules['confidence'], 
                alpha = 0.5, marker = "*")
    plt.xlabel('support')
    plt.ylabel('confidence')
    plt.title('Support vs Confidence - Apriori from \'mlxtend\'')
    plt.show()
    return rules

# Drawing Directed Graph from 10 Top Rules
def draw_graph(rules, rules_to_show):
    G1 = nx.DiGraph()
    color_map = []
    N = 50
    colors = np.random.rand(N)    
    strs=['R0', 'R1', 'R2', 'R3', 'R4', 'R5', 
          'R6', 'R7', 'R8', 'R9', 'R10', 'R11']
    for i in range(rules_to_show):      
        G1.add_nodes_from(['R' + str(i)])
        for a in rules.iloc[i]['antecedents']:             
            G1.add_nodes_from([a])
            G1.add_edge(a, 'R' + str(i), color = colors[i] , weight = 1)
        for c in rules.iloc[i]['consequents']:
            G1.add_nodes_from([c])
            G1.add_edge('R' + str(i), c, color = colors[i],  weight = 1)
    for node in G1:
        found_a_string = False
        for item in strs: 
           if node == item: found_a_string = True
        if found_a_string: color_map.append('yellow')
        else: color_map.append('cyan')       
    edgelist = G1.edges()
    edge_color = [G1[u][v]['color'] for u, v in edgelist]
    weights = [G1[u][v]['weight'] for u, v in edgelist]
    pos = nx.spring_layout(G1, k = 16, scale = 1)
    nx.draw(G1, pos, edgelist = edgelist, node_color = color_map,
            edge_color = edge_color, width = weights, font_size = 10,
            with_labels = True)
    plt.show()

def ap_as(dataframe):
    df_transform = transform_data(dataframe)
    items = unique_items(df_transform)
    envals = one_hot_encoding(df_transform, items)
    rules = ap_as_plot(envals)
    draw_graph(rules, 10)

ap_as(df)