разрабатываю скрипт для подсчёта статистики экспорта тг чата.

нужно найти потенциальные ошибки и исправить их. нужно изменить логику мерджа: щас "merge_folder = 'merge_files'" в конфиг файле, но нужно чтобы мерджились все файлы содержащие в названии после result цифры. result1.json, result2.json, result3.json и т.д. сколько пользователь положет, хоть result99.json. нужно по-умолчанию не отображать ссылку открытия пользователей в выдаче (tg://openmessage?user_id=), это должно выбираться в конфиге. также в конфиге должен быть выбор и для json-выдачи, где айди (без ссылки) включён по умолчанию. в конце текстового (но не json) файла выдачи генерируются ссылки, но они должны иметь в начале ⚡️ и на предыдущей и последующей строке как оформление, перед молниями должны быть пустая строка

start.py:
# Скрипт анализа Telegram чата

import json
import datetime
import re
import sys
import os
from collections import Counter, defaultdict
import time

import config  # Импортируем конфигурацию

def is_bot(user_name, bot_identifiers):
    return any(bot_id.lower() in user_name.lower() for bot_id in bot_identifiers)

def merge_json_files(folder_path, output_file):
    merged_data = None
    for filename in os.listdir(folder_path):
        if filename.endswith('.json'):
            file_path = os.path.join(folder_path, filename)
            if not os.path.isfile(file_path):
                continue
            with open(file_path, 'r', encoding='utf-8') as f:
                data = json.load(f)
                if merged_data is None:
                    merged_data = data
                else:
                    merged_data['messages'].extend(data.get('messages', []))
    if merged_data:
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(merged_data, f, ensure_ascii=False)
        print(f"Файлы из папки '{folder_path}' успешно объединены и сохранены в '{output_file}'.")
    else:
        print("Нет данных для объединения.")

def format_number(number):
    if number >= 1000000:
        return '{:,.0f}'.format(number).replace(',', '  ')
    elif number >= 1000:
        return '{:,.0f}'.format(number).replace(',', ' ')
    else:
        return str(int(number))

def main():
    # Ссылки на автора
    author_github_link = 'https://github.com/yourusername'
    author_telegram_channel = 'https://t.me/yourchannel'

    version = "Version 1.0"

    # ASCII-арт один для обоих языков
    ascii_art = "\033[32m" + r"""
 __    __  __    __  __    __  ________  _______
|  \  |  \|  \  |  \|  \  |  \|        \|       \
| $$  | $$| $$  | $$| $$  | $$| $$$$$$$$| $$$$$$$\
| $$  | $$| $$  | $$| $$  | $$| $$__    | $$__/ $$
| $$  | $$| $$  | $$| $$  | $$| $$  \   | $$    $$
| $$  | $$| $$  | $$| $$  | $$| $$$$$   | $$$$$$$\
| $$__/ $$| $$__/ $$| $$__/ $$| $$_____ | $$  | $$
 \$$    $$ \$$    $$ \$$    $$| $$     \| $$  | $$
  \$$$$$$   \$$$$$$   \$$$$$$  \$$$$$$$$ \$$   \$$
""" + "\033[0m"  # Сброс цвета

    # Тексты на двух языках
    texts = {
        'ru': {
            'ascii_art': ascii_art,
            'description': "Этот скрипт анализирует экспорт чата Telegram в формате JSON и предоставляет статистику активности.",
            'menu_options': {
                '0': "Switch to English",
                '1': f"Анализировать файл {config.input_file}",
                '2': f"Объединить файлы из папки и сохранить в {config.input_file}",
                '3': "Анализировать и сохранить результат в текстовый и JSON файлы"
            },
            'prompt_choice': "Введите номер выбора и нажмите Enter (по умолчанию 1): ",
            'start_analysis': "Запуск анализа...",
            'start_analysis_save': "Запуск анализа и сохранение в текстовый и JSON файлы...",
            'file_not_found': "Файл '{0}' не найден.",
            'file_size_warning': "Файл размером {0} МБ, обработка займёт время.",
            'invalid_json': "Ошибка: Неверный формат JSON файла.",
            'no_messages': "Файл не содержит сообщений для анализа.",
            'total_messages': "Общее количество сообщений в чате: {0}",
            'processing_completed': "Анализ завершён за {0:.2f} секунд. Результаты сохранены в файл '{1}'.",
            'unprocessed_messages': "Не удалось обработать {0:.2f}% сообщений.",
            'error_count': "Количество ошибок: {0}. Подробности в '{1}'.",
            'author_links': "\nGitHub: {0}\nTelegram-канал: {1}",
            'select_action': "Выберите действие:",
            'processing': "Обработано {0}/{1} сообщений... {2}",
            'date_range': "за период",
            'non_consecutive': "не подряд",
            'symbols': "Символов",
            'avg_symbols_in_message': "Символов в сообщении",
            'voice_messages': "Голосовых",
            'forwards': "Пересланных",
            'photos': "Фото",
            'videos': "Видео",
            'audios': "Аудио",
            'files': "Файлы",
            'channel_posts': "Репостов из каналов",
            'stickers': "Стикеров",
            'commands': "Команд",
            'emojis': "Смайлов",
            'profanity_messages': "Сообщений с матом",
            'top_participants': "Топ участников",
            'top_words': "Топ слов",
            'times': "раз",
            'activity': "Активность",
            'most_active_days': "Самые активные дни",
            'messages': "сообщений",
            'average_message_length': "средняя длина сообщения"
        },
        'en': {
            'ascii_art': ascii_art,
            'description': "This script analyzes Telegram chat export in JSON format and provides activity statistics.",
            'menu_options': {
                '0': "Переключиться на русский",
                '1': f"Analyze file {config.input_file}",
                '2': f"Merge files from folder and save to {config.input_file}",
                '3': "Analyze and save results to text and JSON files"
            },
            'prompt_choice': "Enter your choice number and press Enter (default is 1): ",
            'start_analysis': "Starting analysis...",
            'start_analysis_save': "Starting analysis and saving to text and JSON files...",
            'file_not_found': "File '{0}' not found.",
            'file_size_warning': "File size is {0} MB, processing may take some time.",
            'invalid_json': "Error: Invalid JSON file format.",
            'no_messages': "The file contains no messages for analysis.",
            'total_messages': "Total messages in chat: {0}",
            'processing_completed': "Analysis completed in {0:.2f} seconds. Results saved to '{1}'.",
            'unprocessed_messages': "Failed to process {0:.2f}% of messages.",
            'error_count': "Number of errors: {0}. Details in '{1}'.",
            'author_links': "\nGitHub: {0}\nTelegram channel: {1}",
            'select_action': "Select an action:",
            'processing': "Processed {0}/{1} messages... {2}",
            'date_range': "for the period",
            'non_consecutive': "not consecutive",
            'symbols': "Symbols",
            'avg_symbols_in_message': "Symbols per message",
            'voice_messages': "Voice messages",
            'forwards': "Forwards",
            'photos': "Photos",
            'videos': "Videos",
            'audios': "Audios",
            'files': "Files",
            'channel_posts': "Channel posts",
            'stickers': "Stickers",
            'commands': "Commands",
            'emojis': "Emojis",
            'profanity_messages': "Messages with profanity",
            'top_participants': "Top participants",
            'top_words': "Top words",
            'times': "times",
            'activity': "Activity",
            'most_active_days': "Most active days",
            'messages': "messages",
            'average_message_length': "average message length"
        }
    }

    language = 'ru'  # По умолчанию русский
    current_texts = texts[language]

    while True:
        # Отображение ASCII-арта и информации
        print(current_texts['ascii_art'])
        print(version)
        print(current_texts['description'])
        if config.show_author_links:
            if language == 'ru':
                print(f"GitHub: {author_github_link}")
                print(f"Telegram-канал: {author_telegram_channel}")
            else:
                print(f"GitHub: {author_github_link}")
                print(f"Telegram channel: {author_telegram_channel}")
        print()

        # Главное меню
        print(current_texts['select_action'])
        for key, value in current_texts['menu_options'].items():
            print(f"{key}. {value}")
        choice = input(current_texts['prompt_choice']).strip()
        if not choice:
            choice = '1'

        if choice == '0':
            # Переключить язык
            language = 'en' if language == 'ru' else 'ru'
            current_texts = texts[language]
            continue  # Показать меню снова на выбранном языке
        elif choice == '2':
            start_time = time.time()
            merge_json_files(config.merge_folder, config.input_file)
            elapsed_time = time.time() - start_time
            if language == 'ru':
                print(f"Объединение завершено за {elapsed_time:.2f} секунд.")
            else:
                print(f"Merging completed in {elapsed_time:.2f} seconds.")
            return
        elif choice == '3':
            save_json = True
            print(current_texts['start_analysis_save'])
            start_time = time.time()
            break  # Выходим из цикла меню и начинаем анализ
        else:
            save_json = False
            print(current_texts['start_analysis'])
            start_time = time.time()
            break  # Выходим из цикла меню и начинаем анализ

    # Проверка наличия файла
    if not os.path.isfile(config.input_file):
        print(current_texts['file_not_found'].format(config.input_file))
        return

    file_size_mb = os.path.getsize(config.input_file) / (1024 * 1024)
    if file_size_mb > 50:
        size_str = format_number(file_size_mb)
        print(current_texts['file_size_warning'].format(size_str))

    try:
        with open(config.input_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
    except json.JSONDecodeError:
        print(current_texts['invalid_json'])
        return

    # Извлечение сообщений
    messages = data.get('messages', [])
    total_messages = len(messages)
    total_messages_formatted = format_number(total_messages)
    print(current_texts['total_messages'].format(total_messages_formatted))

    if total_messages == 0:
        print(current_texts['no_messages'])
        return

    # Инициализация переменных
    user_messages = []
    first_date = None
    last_date = None

    message_counts = {
        'text': 0,
        'sticker': 0,
        'photo': 0,
        'video': 0,
        'gif': 0,
        'voice_message': 0,
        'video_message': 0,
        'audio': 0,
        'file': 0,
        'commands': 0,
        'forwards': 0,
        'channel_posts': 0,
        'emojis': 0,
        'profanity': 0,
        'replies': 0,
    }

    user_counts = Counter()
    user_symbols = Counter()
    chains_counts = Counter()
    chains_symbols = Counter()
    user_ids = {}
    prev_user = None
    prev_time = None
    user_response_times = defaultdict(list)
    words = []
    hours = Counter()
    weekdays = Counter()
    months = Counter()
    years = Counter()
    dates = Counter()
    date_messages = defaultdict(int)
    date_symbols = defaultdict(int)
    emoji_pattern = config.emoji_pattern
    profanity_words = set(config.profanity_words)
    commands_identifiers = set(config.commands_identifiers)
    unprocessed_messages = 0
    error_count = 0

    # Подготовка файла для логирования ошибок
    chat_name = data.get('name', 'Chat Name').replace(' ', '_').replace('/', '_')
    timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
    error_log_filename = f"error_logs_{chat_name}_{timestamp}.txt"
    error_log = open(error_log_filename, 'w', encoding='utf-8')

    # Прогресс-бар
    spinner = ['|', '/', '-', '\\']
    spinner_index = 0

    def print_progress(current, total):
        nonlocal spinner_index
        current_formatted = format_number(current)
        total_formatted = format_number(total)
        progress = current_texts['processing'].format(current_formatted, total_formatted, spinner[spinner_index % len(spinner)])
        spinner_index += 1
        print(progress, end='\r', flush=True)

    total_messages = len(messages)

    for idx, message in enumerate(messages):
        try:
            if 'from' not in message:
                unprocessed_messages += 1
                continue
            user = message.get('from', 'Unknown')
            from_id = message.get('from_id', '')
            if from_id.startswith('user'):
                user_id = from_id.replace('user', '')
            elif from_id.startswith('channel'):
                user_id = from_id.replace('channel', '')
            else:
                user_id = ''
            user_ids[user] = user_id

            if config.exclude_bots and is_bot(user, config.bot_identifiers):
                continue
            text = message.get('text', '')
            if isinstance(text, list):
                text_pieces = []
                for t_piece in text:
                    if isinstance(t_piece, dict):
                        text_pieces.append(t_piece.get('text', ''))
                    elif isinstance(t_piece, str):
                        text_pieces.append(t_piece)
                text = ''.join(text_pieces)
            elif text is None:
                text = ''
            symbols = len(text)
            message_type = message.get('type', '')

            if message_type == 'message':
                user_messages.append(message)
                user_counts[user] += 1
                user_symbols[user] += symbols

                if prev_user != user:
                    chains_counts[user] += 1
                    chains_symbols[user] += symbols

                    # Вычисление времени ответа между сообщениями разных пользователей
                    message_date = message.get('date')
                    if message_date:
                        try:
                            current_time = datetime.datetime.fromisoformat(message_date)
                            if prev_time:
                                delta = current_time - prev_time
                                if delta.total_seconds() > 0:
                                    user_response_times[user].append(delta.total_seconds())
                            prev_time = current_time
                        except (ValueError, TypeError) as e:
                            error_count += 1
                            error_log.write(f"Ошибка при обработке даты в сообщении id {message.get('id')}: {e}\n")
                    else:
                        prev_time = None
                else:
                    chains_symbols[user] += symbols

                prev_user = user

                # Сбор слов
                if text:
                    text_clean = re.sub(r'[^\w\s]', '', text.lower())
                    words.extend([word for word in text_clean.split() if word not in config.stop_words and word.isalpha()])

                    # Проверка на команды
                    if text.strip().startswith(tuple(commands_identifiers)):
                        message_counts['commands'] += 1

                    # Проверка на эмодзи
                    if emoji_pattern.search(text):
                        message_counts['emojis'] += 1

                    # Проверка на мат
                    if profanity_words.intersection(set(text_clean.split())):
                        message_counts['profanity'] += 1

                # Проверка на пересланные сообщения
                if 'forwarded_from' in message:
                    message_counts['forwards'] += 1
                    if message['forwarded_from'].startswith('channel'):
                        message_counts['channel_posts'] += 1

                # Проверка на ответы
                if 'reply_to_message_id' in message:
                    message_counts['replies'] += 1

                # Подсчет типов медиа
                if 'media_type' in message:
                    media_type = message['media_type']
                    if media_type == 'sticker':
                        message_counts['sticker'] += 1
                    elif media_type == 'photo':
                        message_counts['photo'] += 1
                    elif media_type == 'video_file':
                        file_name = message.get('file', '') or message.get('file_name', '')
                        if 'gif' in file_name.lower():
                            message_counts['gif'] += 1
                        else:
                            message_counts['video'] += 1
                    elif media_type == 'voice_message':
                        message_counts['voice_message'] += 1
                    elif media_type == 'video_message':
                        message_counts['video_message'] += 1
                    elif media_type == 'audio_file':
                        message_counts['audio'] += 1
                    elif media_type == 'document':
                        message_counts['file'] += 1
                else:
                    message_counts['text'] += 1

                # Активность по времени
                message_date = message.get('date')
                if message_date:
                    try:
                        date_time = datetime.datetime.fromisoformat(message_date)
                        if first_date is None or date_time < first_date:
                            first_date = date_time
                        if last_date is None or date_time > last_date:
                            last_date = date_time

                        hours[date_time.hour] += 1
                        weekday_index = date_time.weekday()
                        weekday_name = config.day_names[language][weekday_index]
                        weekdays[weekday_name] += 1
                        month_name = f"{config.month_names[language][date_time.month -1]} {date_time.year}"
                        months[month_name] +=1
                        years[date_time.year] +=1
                        date_only = date_time.date()
                        dates[date_only] += 1
                        date_messages[date_only] += 1
                        date_symbols[date_only] += symbols
                    except (ValueError, KeyError) as e:
                        error_count +=1
                        error_log.write(f"Ошибка при обработке даты в сообщении id {message.get('id')}: {e}\n")

            else:
                unprocessed_messages += 1
                continue

            # Обновление прогресса
            if total_messages > 0 and idx % 1000 == 0:
                print_progress(idx, total_messages)

        except Exception as e:
            unprocessed_messages += 1
            error_count += 1
            msg_id = message.get('id', 'Unknown')
            error_log.write(f"Ошибка при обработке сообщения id {msg_id}: {e}\n")

    error_log.close()

    # Завершаем прогресс
    print_progress(total_messages, total_messages)
    print('\n')

    total_msgs = len(user_messages)
    total_symbols = sum(user_symbols.values())
    avg_message_length = total_symbols / total_msgs if total_msgs else 0
    common_words = Counter(words).most_common(config.top_words_count)
    activity = {
        'hours': hours.most_common(3) if hours else [],
        'weekdays': weekdays.most_common(3) if weekdays else [],
        'months': months.most_common(3) if months else [],
        'years': years.most_common(3) if years else [],
    }
    avg_response = {}
    for user, times in user_response_times.items():
        if times:
            avg_response[user] = sum(times) / len(times)
        else:
            avg_response[user] = 0

    # Топ самые активные дни
    top_days = dates.most_common(config.top_days_count)

    # Вычисление процента не обработанных сообщений
    unprocessed_percentage = (unprocessed_messages / total_messages) * 100 if total_messages else 0

    # Форматирование имени выходного файла
    output_filename = config.output_filename_pattern.replace('<chat_name>', chat_name).replace('<timestamp>', timestamp)

    # Запись результатов в выходной файл
    with open(output_filename, 'w', encoding='utf-8') as f:
        # Заголовок
        date_range = ''
        if first_date and last_date:
            date_range = f"{current_texts['date_range']}: {first_date.strftime('%d.%m.%Y')} - {last_date.strftime('%d.%m.%Y')}"
        f.write(f"{data.get('name', 'Chat Name')} {date_range}\n\n")
        f.write(f"{config.emojis.get('messages','')} {current_texts['total_messages'].format(format_number(total_msgs))} ({format_number(sum(chains_counts.values()))} {current_texts.get('non_consecutive', 'not consecutive')})\n")
        f.write(f"{config.emojis.get('symbols','')} {current_texts.get('symbols', 'Symbols')}: {format_number(total_symbols)} ({format_number(sum(chains_symbols.values()))} {current_texts.get('non_consecutive', 'not consecutive')})\n")
        f.write(f"{config.emojis.get('avg_symbols','')} {current_texts.get('avg_symbols_in_message', 'Symbols per message')}: {avg_message_length:.0f}\n\n")

        f.write(f"{config.emojis.get('voice','')} {current_texts.get('voice_messages', 'Voice messages')}: {format_number(message_counts['voice_message'])}\n")
        f.write(f"{config.emojis.get('forwarded','')} {current_texts.get('forwards', 'Forwards')}: {format_number(message_counts['forwards'])}\n")
        f.write(f"{config.emojis.get('photo','')} {current_texts.get('photos', 'Photos')}: {format_number(message_counts['photo'])}\n")
        f.write(f"{config.emojis.get('video','')} {current_texts.get('videos', 'Videos')}: {format_number(message_counts['video'])}\n")
        f.write(f"{config.emojis.get('gif','')} GIF: {format_number(message_counts['gif'])}\n")
        f.write(f"{config.emojis.get('audio','')} {current_texts.get('audios', 'Audios')}: {format_number(message_counts['audio'])}\n")
        f.write(f"{config.emojis.get('file','')} {current_texts.get('files', 'Files')}: {format_number(message_counts['file'])}\n")
        f.write(f"{config.emojis.get('channel_post','')} {current_texts.get('channel_posts', 'Channel posts')}: {format_number(message_counts['channel_posts'])}\n")
        f.write(f"{config.emojis.get('sticker','')} {current_texts.get('stickers', 'Stickers')}: {format_number(message_counts['sticker'])}\n")
        f.write(f"{config.emojis.get('command','')} {current_texts.get('commands', 'Commands')}: {format_number(message_counts['commands'])}\n")
        f.write(f"{config.emojis.get('emoji','')} {current_texts.get('emojis', 'Emojis')}: {format_number(message_counts['emojis'])}\n")
        f.write(f"{config.emojis.get('profanity','')} {current_texts.get('profanity_messages', 'Messages with profanity')}: {format_number(message_counts['profanity'])}\n\n")

        # Топ участников
        f.write(f"{config.emojis.get('participant', '')} {current_texts.get('top_participants', 'Top participants')}:\n")
        sorted_users = user_counts.most_common(config.top_participants_count)
        rank = 1
        for user, count in sorted_users:
            chain_count = chains_counts[user]
            symbols = user_symbols[user]
            chain_symbols = chains_symbols[user]
            user_id = user_ids.get(user, '')
            user_link = f"tg://openmessage?user_id={user_id}" if user_id else ''
            f.write(f"{rank}. {user} ({user_link}): {format_number(count)} ({format_number(chain_count)}) · {format_number(symbols)} ({format_number(chain_symbols)})\n")
            rank += 1
        f.write("\n")

        # Топ слов
        f.write(f"{config.emojis.get('word', '')} {current_texts.get('top_words', 'Top words')}:\n")
        rank = 1
        for word, freq in common_words:
            f.write(f"{rank}. {word}: {format_number(freq)} {current_texts.get('times', 'times')}\n")
            rank += 1
        f.write("\n")

        # Активность
        f.write(f"{config.emojis.get('activity', '')} {current_texts.get('activity', 'Activity')}:\n")
        # Топ часов
        hours_list = ', '.join([f"{config.emojis.get('list_item', '')} {hour}:00–{hour}:59" for hour, _ in activity['hours']])
        f.write(f"{hours_list}\n")
        # Топ дней недели
        weekdays_list = ', '.join([f"{config.emojis.get('list_item', '')} {weekday}" for weekday, _ in activity['weekdays']])
        f.write(f"{weekdays_list}\n")
        # Топ месяцев
        months_list = ', '.join([f"{config.emojis.get('list_item', '')} {month.capitalize()}" for month, _ in activity['months']])
        f.write(f"{months_list}\n")
        # Топ лет
        years_list = ', '.join([f"{config.emojis.get('list_item', '')} {year}" for year, _ in activity['years']])
        f.write(f"{years_list}\n\n")

        # Самые активные дни
        f.write(f"{config.emojis.get('activity', '')} {current_texts.get('most_active_days', 'Most active days')}:\n")
        rank = 1
        for date, msg_count in top_days:
            symbol_count = date_symbols[date]
            avg_length = symbol_count / msg_count if msg_count else 0
            date_str = date.strftime('%d.%m.%Y')
            f.write(f"{rank}. {date_str}: {format_number(msg_count)} {current_texts.get('messages', 'messages')}, {format_number(symbol_count)} {current_texts.get('symbols', 'symbols')}, {current_texts.get('average_message_length', 'average message length')} {avg_length:.1f} {current_texts.get('symbols', 'symbols')}\n")
            rank += 1
        f.write("\n")

        # Ссылки на автора в конце файла
        if config.show_author_links:
            f.write(current_texts['author_links'].format(author_github_link, author_telegram_channel))

    # Сохранение статистики в JSON-файл, если выбрано
    if save_json:
        json_output_filename = output_filename.replace('.txt', '.json')
        with open(json_output_filename, 'w', encoding='utf-8') as jf:
            json.dump({
                'chat_name': data.get('name', 'Chat Name'),
                'date_range': date_range,
                'message_counts': message_counts,
                'user_counts': user_counts,
                'common_words': common_words,
                'activity': activity,
                'top_days': [(date.strftime('%d.%m.%Y'), msg_count) for date, msg_count in top_days],
            }, jf, ensure_ascii=False, indent=4)

    elapsed_time = time.time() - start_time
    print(current_texts['processing_completed'].format(elapsed_time, output_filename))

    if unprocessed_messages > 0:
        unprocessed_percentage = (unprocessed_messages / total_messages) * 100
        print(current_texts['unprocessed_messages'].format(unprocessed_percentage))
        print(current_texts['error_count'].format(error_count, error_log_filename))

    if config.show_author_links:
        print(current_texts['author_links'].format(author_github_link, author_telegram_channel))

if __name__ == "__main__":
    main()


config.py:
# Файл конфигурации для скрипта start.py

# -------------------------
# Основные настройки
# -------------------------

# Основной файл для анализа
input_file = 'result.json'  # Имя основного файла для анализа

# Путь к папке с файлами для слияния
merge_folder = 'merge_files'  # Папка, содержащая файлы JSON для слияния

# Шаблон имени выходного файла
output_filename_pattern = '<chat_name>_<timestamp>.txt'  # Имя выходного отчёта; <chat_name> будет заменено на название чата

# Список стоп-слов для исключения из анализа часто используемых слов
stop_words = ['и', 'в', 'не', 'на', 'с', 'что', 'а', 'как', 'это', 'по', 'но', 'из', 'у', 'за', 'о', 'же', 'то', 'к', 'для', 'до', 'вы', 'мы', 'они', 'он', 'она', 'оно', 'так', 'было', 'только', 'бы', 'когда', 'уже']

# Количество топ участников и слов для отображения в отчёте
top_participants_count = None  # Установите None, чтобы отобразить всех участников
top_words_count = 50  # Количество топ слов для отображения

# Эмодзи для использования в отчёте
emojis = {
    'title': '💬',
    'participant': '👥',
    'word': '🔠',
    'activity': '📊',
    'list_item': '➡️',
    'messages': '✉️',
    'symbols': '🔣',
    'avg_symbols': '💬',
    'voice': '🎵',
    'forwarded': '📩',
    'photo': '📷',
    'video': '📹',
    'gif': '🎬',
    'audio': '🎧',
    'file': '📑',
    'channel_post': '📣',
    'sticker': '💌',
    'command': '❗',
    'emoji': '🤣',
    'profanity': '👺',
    'reply': '💬',
}

# Количество топ дней для отображения
top_days_count = 10  # Количество самых активных дней для отображения

# Настройки для исключения ботов
exclude_bots = True  # Исключать ли ботов из анализа
bot_identifiers = ['Bot']  # Строки для идентификации ботов

# Названия дней недели и месяцев на русском и английском языках
day_names = {
    'ru': ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'],
    'en': ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
}
month_names = {
    'ru': ['январь', 'февраль', 'март', 'апрель', 'май', 'июнь', 'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь'],
    'en': ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
}

# Слова для определения сообщений с матом
profanity_words = ['слово1', 'слово2', 'слово3']  # Замените на реальные нецензурные слова

# Начало команд (например, '/')
commands_identifiers = ['/']

# Регулярное выражение для поиска эмодзи
import re
emoji_pattern = re.compile("["
                           u"\U0001F600-\U0001F64F"  # эмотиконы
                           u"\U0001F300-\U0001F5FF"  # символы и пиктограммы
                           u"\U0001F680-\U0001F6FF"  # транспорт и символы карт
                           u"\U0001F1E0-\U0001F1FF"  # флаги (iOS)
                           "]+", flags=re.UNICODE)

show_author_links = True  # False чтобы отключить отображение ссылок меня. @Teslak @TesNot

# -------------------------
# Конец настроек
# -------------------------