Comment utiliser DiscordChatExporter et Python pour analyser les données de votre serveur Discord

pip install matplotlib plotly

python discord_analyzer.py

import os
import csv
import logging
from collections import Counter
from datetime import datetime
import matplotlib.pyplot as plt
import plotly.express as px

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

def normalize_date(date_str):
    try:
        # Remove the timezone offset and milliseconds if present
        date_str = date_str.split('+')[0]
        date_str = date_str.split('.')[0]
        return datetime.fromisoformat(date_str)
    except ValueError:
        logging.warning(f"Invalid date format: {date_str}")
        return None

def process_csv_files(directory):
    word_count = Counter()
    messages_by_author = Counter()
    messages_by_month = Counter()
    attachment_count = Counter()
    reaction_count = Counter()
    message_lengths = []

    # Get a list of all authors to exclude their names from word count
    authors = set()

    for filename in os.listdir(directory):
        if filename.endswith('.csv'):
            filepath = os.path.join(directory, filename)
            with open(filepath, 'r', encoding='utf-8') as csvfile:
                reader = csv.DictReader(csvfile)
                for row in reader:
                    # Add author to the set of authors
                    authors.add(row['Author'])

    for filename in os.listdir(directory):
        if filename.endswith('.csv'):
            filepath = os.path.join(directory, filename)
            with open(filepath, 'r', encoding='utf-8') as csvfile:
                reader = csv.DictReader(csvfile)
                for row in reader:
                    # Count words in Content, excluding words that are part of author names
                    words = row['Content'].split()
                    for word in words:
                        # Check if the word is not part of any author's name
                        if not any(word.lower() in author.lower() for author in authors):
                            word_count[word.lower()] += 1
                    message_lengths.append(len(words))

                    # Count messages by Author
                    messages_by_author[row['Author']] += 1

                    # Count messages by month
                    date = normalize_date(row['Date'])
                    if date:
                        month = date.strftime('%Y-%m')
                        messages_by_month[month] += 1

                    # Count attachments
                    if row['Attachments']:
                        attachment_count[row['Author']] += 1

                    # Count reactions
                    if row['Reactions']:
                        reactions = row['Reactions'].split(',')
                        reaction_count.update(reactions)

    avg_message_length = sum(message_lengths) / len(message_lengths) if message_lengths else 0

    return {
        'word_count': word_count,
        'messages_by_author': dict(sorted(messages_by_author.items(), key=lambda x: x[0])),
        'messages_by_month': dict(sorted(messages_by_month.items())),
        'attachment_count': dict(sorted(attachment_count.items(), key=lambda x: x[0])),
        'reaction_count': dict(sorted(reaction_count.items(), key=lambda x: x[0])),
        'avg_message_length': avg_message_length,
    }

def print_statistics(stats, max_words, sort_by='name'):
    """
    Print statistics, with options to sort authors by name or message count.
    
    :param stats: Dictionary containing statistics.
    :param max_words: Maximum number of words to display in word count.
    :param sort_by: Sort authors by 'name' (alphabetically) or 'count' (by message count).
    """
    print("Word Count:")
    for word, count in stats['word_count'].most_common(max_words):
        print(f"  {word}: {count}")

    print("\nMessages by Author:")
    if sort_by == 'count':
        # Sort authors by message count (descending)
        sorted_authors = sorted(stats['messages_by_author'].items(), key=lambda x: x[1], reverse=True)
    else:
        # Sort authors alphabetically (default)
        sorted_authors = sorted(stats['messages_by_author'].items(), key=lambda x: x[0])

    for author, count in sorted_authors:
        print(f"  {author}: {count}")

    print("\nMessages by Month:")
    for month, count in stats['messages_by_month'].items():
        print(f"  {month}: {count}")

    print("\nAttachments by Author:")
    for author, count in stats['attachment_count'].items():
        print(f"  {author}: {count}")

    print("\nReactions:")
    for reaction, count in stats['reaction_count'].items():
        print(f"  {reaction}: {count}")

    print(f"\nAverage Message Length: {stats['avg_message_length']:.2f} words")

def plot_data(stats, output_dir, max_words, max_authors=None, export_graphs=False):

    if output_dir:
        os.makedirs(output_dir, exist_ok=True)

    # Sort authors by message count (descending)
    sorted_authors = sorted(stats['messages_by_author'].items(), key=lambda x: x[1], reverse=True)
    
    # Limit the number of authors to display
    if max_authors:
        sorted_authors = sorted_authors[:max_authors]
    
    authors, author_counts = zip(*sorted_authors)

    # Plot messages by author (sorted by count)
    plt.figure(figsize=(20, 10))
    plt.bar(authors, author_counts, color='skyblue')
    plt.title(f'Top {len(authors)} Authors by Message Count')
    plt.xlabel('Author')
    plt.ylabel('Number of Messages')
    plt.xticks(rotation=45)
    plt.tight_layout()
    if export_graphs:
        plt.savefig(os.path.join(output_dir, 'messages_by_author_sorted_by_count.png'))
    plt.show()

    # Plot messages by month
    months, month_counts = zip(*stats['messages_by_month'].items())
    plt.figure(figsize=(20, 10))
    plt.plot(months, month_counts, marker='o', color='green')
    plt.title('Messages by Month')
    plt.xlabel('Month')
    plt.ylabel('Number of Messages')
    plt.xticks(rotation=45)
    plt.tight_layout()
    if export_graphs:
        plt.savefig(os.path.join(output_dir, 'messages_by_month.png'))
    plt.show()

    # Plot word frequency
    words, word_counts = zip(*stats['word_count'].most_common(max_words))
    plt.figure(figsize=(20, 10))
    plt.bar(words, word_counts, color='orange')
    plt.title(f'Top {max_words} Words')
    plt.xlabel('Word')
    plt.ylabel('Frequency')
    plt.xticks(rotation=45)
    plt.tight_layout()
    if export_graphs:
        plt.savefig(os.path.join(output_dir, f'top_{max_words}_words.png'))
    plt.show()

    fig = px.bar(x=words, y=word_counts, labels={'x': 'Word', 'y': 'Frequency'}, title=f'Top {max_words} Words')
    fig.show()

def main():
    directory = input("Enter the directory containing the CSV files (default: ./data): ") or "./data"
    max_words = int(input("Enter the maximum number of words to display in word count (default: 10): ") or 10)
    max_authors = input("Enter the maximum number of authors to display (leave blank for all): ").strip()
    max_authors = int(max_authors) if max_authors else None
    sort_by = input("Sort authors by 'name' or 'count'? (default: name): ").strip().lower() or "name"
    
    try:
        stats = process_csv_files(directory)
        print_statistics(stats, max_words, sort_by=sort_by)

        see_graph_choice = input("Would you like to see graphs of the data? (yes/no): ").strip().lower()
        if see_graph_choice == 'yes':
            export_graph_choice = input("Would you like to export graphs of the data? (yes/no): ").strip().lower()
            output_dir = directory if export_graph_choice == 'yes' else None
            if export_graph_choice == 'yes':
                output_dir = input("Enter the directory to save the graphs (default: ./graphs): ") or "./graphs"
            plot_data(stats, output_dir, max_words, max_authors=max_authors, export_graphs=export_graph_choice == 'yes')
    except Exception as e:
        logging.error(f"An error occurred: {e}")

if __name__ == '__main__':
    main()