# Online Python compiler (interpreter) to run Python online.
# Write Python 3 code in this online editor and run it.
from collections import defaultdict

class Eclat:
    def __init__(self, min_support=0.5):
        self.min_support = min_support

    def fit(self, transactions):
        self.transactions = transactions
        self.items = self._get_unique_items(transactions)
        self.itemsets = self._get_frequent_itemsets(transactions)

    def _get_unique_items(self, transactions):
        items = set()
        for transaction in transactions:
            items.update(transaction)
        return items

    def _get_frequent_itemsets(self, transactions):
        itemsets = defaultdict(int)
        for transaction in transactions:
            for item in self.items:
                if item in transaction:
                    itemsets[frozenset([item])] += 1

        num_transactions = len(transactions)
        frequent_itemsets = {}
        for itemset, support in itemsets.items():
            if support / num_transactions >= self.min_support:
                frequent_itemsets[itemset] = support

        return frequent_itemsets

    def _join_itemsets(self, itemset1, itemset2):
        return itemset1.union(itemset2)

    def _get_candidate_itemsets(self, frequent_itemsets):
        candidate_itemsets = {}
        for itemset1 in frequent_itemsets:
            for itemset2 in frequent_itemsets:
                if len(itemset1.union(itemset2)) == len(itemset1) + 1:
                    candidate_itemset = self._join_itemsets(itemset1, itemset2)
                    if candidate_itemset not in candidate_itemsets:
                        candidate_itemsets[candidate_itemset] = 0
        return candidate_itemsets

    def _count_support(self, candidate_itemsets):
        itemsets = defaultdict(int)
        for transaction in self.transactions:
            for itemset in candidate_itemsets:
                if itemset.issubset(transaction):
                    itemsets[itemset] += 1
        return itemsets

    def _prune_itemsets(self, candidate_itemsets, min_support):
        pruned_itemsets = {}
        num_transactions = len(self.transactions)
        for itemset, support in candidate_itemsets.items():
            if support / num_transactions >= min_support:
                pruned_itemsets[itemset] = support
        return pruned_itemsets

    def _generate_association_rules(self, frequent_itemsets):
        association_rules = []
        for itemset in frequent_itemsets:
            if len(itemset) > 1:
                for i in range(1, len(itemset)):
                    for subset in itertools.combinations(itemset, i):
                        antecedent = set(subset)
                        consequent = itemset.difference(antecedent)
                        support_itemset = frequent_itemsets[itemset]
                        support_antecedent = frequent_itemsets[frozenset(antecedent)]
                        confidence = support_itemset / support_antecedent
                        association_rules.append((antecedent, consequent, confidence))
        return association_rules

    def print_frequent_itemsets(self):
        for itemset, support in self.itemsets.items():
            print(f"Itemset: {list(itemset)}, Support: {support}")

    def print_association_rules(self):
        association_rules = self._generate_association_rules(self.itemsets)
        for antecedent, consequent, confidence in association_rules:
            print(f"Rule: {list(antecedent)} => {list(consequent)}, Confidence: {confidence}")

# Example usage:
transactions = [
    {'milk', 'bread', 'butter'},
    {'milk', 'bread'},
    {'milk', 'butter'},
    {'bread', 'butter'},
    {'milk', 'bread', 'butter'},
    {'tea', 'coffee'},
    {'coffee', 'sugar'},
    {'tea', 'sugar'},
    {'tea', 'coffee', 'sugar'}
]

eclat = Eclat(min_support=0.5)
eclat.fit(transactions)
eclat.print_frequent_itemsets()