Загрузка...

Python
Telegram username checker

Thread in Your projects created by форумник Jan 26, 2026. (bumped Feb 23, 2026) 401 view

  1. форумник
    форумник Topic starter Jan 26, 2026 форумник 314 Oct 7, 2025
    Пару месяцев назад делал приватный чекер для автоматической проверки и создания канала под определённый юзернейм. В итоге только сегодня его опять увидел и решил выложить

    1. Проверять юзернеймы на свободность
    2. Автоматичкески создовать канал с юзернеймом который ты выбрал
    3. Ии для создания юзов
    4. Настройки
    5. Менять интерфейс под себя
    6. История юзов
    7. Сохранять юзы которые вы искали
    8. Другие полезные функции



    Первый файл(main.py):

    Python
    import subprocess
    

    
import sys
    

    
def install_module(module_name):
    

    
    try:
    

    
        subprocess.check_call([sys.executable, '-m', 'pip', 'install', module_name, '--quiet'])
    

    
        return True
    

    
    except Exception:
    

    
        try:
    

    
            subprocess.check_call([sys.executable, '-m', 'pip', 'install', module_name])
    

    
            return True
    

    
        except:
    

    
            return False
    

    
def check_module(module_name):
    

    
    try:
    

    
        if module_name == 'python-telegram-bot':
    

    
            __import__('telegram')
    

    
        else:
    

    
            __import__(module_name)
    

    
        return True
    

    
    except ImportError:
    

    
        return False
    

    
def setup_all_modules():
    

    
    MAIN_MODULES = [
    

    
        'telethon',
    

    
        'asyncio',
    

    
        'datetime',
    

    
        'os',
    

    
        'shutil',
    

    
        'glob',
    

    
        'json',
    

    
        'subprocess',
    

    
        'sys',
    

    
        'random',
    

    
        'string'
    

    
    ]
    

    
    
    

    
    BOT_MODULES = [
    

    
        'python-telegram-bot',
    

    
        'sqlite3'
    

    
    ]
    

    
    
    

    
    ALL_MODULES = MAIN_MODULES + BOT_MODULES
    

    
    
    

    
    missing_modules = [mod for mod in ALL_MODULES if not check_module(mod)]
    

    
    
    

    
    if missing_modules:
    

    
        print(" Проверка модулей...")
    

    
        print(" Обнаружены отсутствующие модули:")
    

    
        for module in missing_modules:
    

    
            print(f"   - {module}")
    

    
        
    

    
        print("\n Начинаю автоматическую установку...")
    

    
        
    

    
        success_count = 0
    

    
        for module in missing_modules:
    

    
            print(f" Устанавливаю {module}...", end=" ")
    

    
            if install_module(module):
    

    
                print(" Успешно")
    

    
                success_count += 1
    

    
            else:
    

    
                print(" Ошибка")
    

    
        
    

    
        if success_count == len(missing_modules):
    

    
            print(f"\n Все модули успешно установлены!")
    

    
        else:
    

    
            print(f"\n  Установлено {success_count}/{len(missing_modules)} модулей")
    

    
        
    

    
        print()
    

    
setup_all_modules()
    

    
from telethon import TelegramClient
    

    
from telethon.errors import SessionPasswordNeededError, PhoneCodeInvalidError
    

    
from telethon.sessions import StringSession
    

    
from telethon.tl.functions.channels import CreateChannelRequest, UpdateUsernameRequest
    

    
import asyncio
    

    
import datetime
    

    
import os
    

    
import shutil
    

    
import glob
    

    
import json
    

    
import subprocess
    

    
import sys
    

    
import random
    

    
import string
    

    
SETTINGS_FILE = 'checker_settings.json'
    

    
API_FILE = 'api_config.json'
    

    
SESSION_FILE = 'telegram_session.session'
    

    
COLOR_PRESETS = {
    

    
    '1': {'name': ' Красный', 'code': '91'},
    

    
    '2': {'name': ' Зеленый', 'code': '92'},
    

    
    '3': {'name': ' Желтый', 'code': '93'},
    

    
    '4': {'name': ' Синий', 'code': '94'},
    

    
    '5': {'name': ' Фиолетовый', 'code': '95'},
    

    
    '6': {'name': ' Голубой', 'code': '96'},
    

    
    '7': {'name': ' Белый', 'code': '97'},
    

    
    '8': {'name': ' Оранжевый', 'code': '33'},
    

    
    '9': {'name': ' Розовый', 'code': '35'},
    

    
    '10': {'name': ' Бирюзовый', 'code': '36'},
    

    
    '11': {'name': ' Салатовый', 'code': '32'},
    

    
    '12': {'name': ' Темно-фиолетовый', 'code': '35'},
    

    
    '13': {'name': ' Серый', 'code': '37'},
    

    
    '14': {'name': ' Черный', 'code': '30'},
    

    
    '15': {'name': ' Ярко-оранжевый', 'code': '31'}
    

    
}
    

    
DEFAULT_SETTINGS = {
    

    
    'check_speed': 1,
    

    
    'color_primary': '91',
    

    
    'color_text': '97'
    

    
}
    

    
def load_settings():
    

    
    if os.path.exists(SETTINGS_FILE):
    

    
        try:
    

    
            with open(SETTINGS_FILE, 'r', encoding='utf-8') as f:
    

    
                return json.load(f)
    

    
        except:
    

    
            return DEFAULT_SETTINGS.copy()
    

    
    return DEFAULT_SETTINGS.copy()
    

    
def save_settings(settings):
    

    
    with open(SETTINGS_FILE, 'w', encoding='utf-8') as f:
    

    
        json.dump(settings, f, ensure_ascii=False, indent=2)
    

    
def load_api_config():
    

    
    if os.path.exists(API_FILE):
    

    
        try:
    

    
            with open(API_FILE, 'r', encoding='utf-8') as f:
    

    
                config = json.load(f)
    

    
                if 'api_id' in config and 'api_hash' in config:
    

    
                    return config['api_id'], config['api_hash']
    

    
        except:
    

    
            pass
    

    
    return None, None
    

    
def save_api_config(api_id, api_hash):
    

    
    config = {
    

    
        'api_id': api_id,
    

    
        'api_hash': api_hash
    

    
    }
    

    
    with open(API_FILE, 'w', encoding='utf-8') as f:
    

    
        json.dump(config, f, ensure_ascii=False, indent=2)
    

    
def load_session():
    

    
    if os.path.exists(SESSION_FILE):
    

    
        try:
    

    
            with open(SESSION_FILE, 'r') as f:
    

    
                return f.read().strip()
    

    
        except:
    

    
            pass
    

    
    return None
    

    
def save_session(session_string):
    

    
    with open(SESSION_FILE, 'w') as f:
    

    
        f.write(session_string)
    

    
def clear_session():
    

    
    if os.path.exists(SESSION_FILE):
    

    
        os.remove(SESSION_FILE)
    

    
settings = load_settings()
    

    
api_id, api_hash = load_api_config()
    

    
def get_center_position(text):
    

    
    try:
    

    
        terminal_size = shutil.get_terminal_size()
    

    
        return (terminal_size.columns - len(text)) // 2
    

    
    except:
    

    
        return 0
    

    
def print_centered(text, color_code=None):
    

    
    if color_code is None:
    

    
        color_code = settings['color_text']
    

    
    centered_text = " " * get_center_position(text) + text
    

    
    print(f"\033[{color_code}m{centered_text}\033[0m")
    

    
def print_centered_multiline(lines, color_code=None):
    

    
    if color_code is None:
    

    
        color_code = settings['color_text']
    

    
    
    

    
    max_length = 0
    

    
    for line in lines:
    

    
        clean_line = line.replace(f'\033[{settings["color_primary"]}m', '').replace(f'\033[{settings["color_text"]}m', '').replace('\033[0m', '')
    

    
        max_length = max(max_length, len(clean_line))
    

    
    
    

    
    try:
    

    
        center_pos = (shutil.get_terminal_size().columns - max_length) // 2
    

    
    except:
    

    
        center_pos = 0
    

    
    
    

    
    for line in lines:
    

    
        centered_line = " " * center_pos + line
    

    
        print(f"\033[{color_code}m{centered_line}\033[0m")
    

    
def print_centered_line(length=50):
    

    
    try:
    

    
        terminal_size = shutil.get_terminal_size()
    

    
        line = "=" * length
    

    
        center_pos = (terminal_size.columns - length) // 2
    

    
        centered_line = " " * center_pos + line
    

    
        print(f"\033[{settings['color_primary']}m{centered_line}\033[0m")
    

    
    except:
    

    
        print(f"\033[{settings['color_primary']}m{'=' * length}\033[0m")
    

    
def clear_console():
    

    
    os.system('cls' if os.name == 'nt' else 'clear')
    

    
def print_banner():
    

    
    banner_lines = [
    

    
        "░*****╗░**╗░░**╗*******╗**╗░░**╗*******╗******╗░",
    

    
        "**╔══**╗**║░░**║**╔════╝**║░**╔╝**╔════╝**╔══**╗",
    

    
        "**║░░╚═╝*******║*****╗░░*****═╝░*****╗░░******╔╝",
    

    
        "**║░░**╗**╔══**║**╔══╝░░**╔═**╗░**╔══╝░░**╔══**╗",
    

    
        "╚*****╔╝**║░░**║*******╗**║░╚**╗*******╗**║░░**║",
    

    
        "░╚════╝░╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝"
    

    
    ]
    

    
    
    

    
    for line in banner_lines:
    

    
        print_centered(line, settings['color_primary'])
    

    
def setup_api_config():
    

    
    global api_id, api_hash
    

    
    
    

    
    clear_console()
    

    
    print_banner()
    

    
    print_centered_line(50)
    

    
    print_centered(" НАСТРОЙКА API ДАННЫХ")
    

    
    print_centered_line(50)
    

    
    print()
    

    
    print_centered("Для работы программы необходимы API данные")
    

    
    print_centered("Получите их на https://my.telegram.org")
    

    
    print()
    

    
    print_centered_line(50)
    

    
    print()
    

    
    
    

    
    try:
    

    
        api_id_input = input(" " * get_center_position("Введите API ID: ") + "\033[97mВведите API ID: \033[0m").strip()
    

    
        api_hash_input = input(" " * get_center_position("Введите API Hash: ") + "\033[97mВведите API Hash: \033[0m").strip()
    

    
        
    

    
        api_id = int(api_id_input)
    

    
        api_hash = api_hash_input
    

    
        
    

    
        save_api_config(api_id, api_hash)
    

    
        
    

    
        print()
    

    
        print_centered("✓ API данные успешно сохранены!", settings['color_primary'])
    

    
        print_centered("Теперь можно использовать программу", settings['color_text'])
    

    
        print()
    

    
        print_centered_line(50)
    

    
        
    

    
        input("\n" + " " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
        return True
    

    
        
    

    
    except ValueError:
    

    
        print()
    

    
        print_centered("✗ Ошибка: API ID должен быть числом!", settings['color_primary'])
    

    
        input("\n" + " " * get_center_position("Нажмите Enter для повторной попытки...") + "\033[97mНажмите Enter для повторной попытки...\033[0m")
    

    
        return False
    

    
    except Exception as e:
    

    
        print()
    

    
        print_centered(f"✗ Ошибка: {e}", settings['color_primary'])
    

    
        input("\n" + " " * get_center_position("Нажмите Enter для повторной попытки...") + "\033[97mНажмите Enter для повторной попытки...\033[0m")
    

    
        return False
    

    
async def check_username(client, username):
    

    
    try:
    

    
        await client.get_entity(username)
    

    
        return False, "занят"
    

    
    except ValueError:
    

    
        return True, "свободен"
    

    
    except Exception as e:
    

    
        error_msg = str(e).lower()
    

    
        if "unacceptable" in error_msg or "match" in error_msg:
    

    
            return False, "на продаже"
    

    
        elif "flood" in error_msg:
    

    
            return False, "ограничение Telegram"
    

    
        elif "username" in error_msg and "purchase" in error_msg:
    

    
            return False, "на продаже"
    

    
        elif "username" in error_msg and "not found" in error_msg:
    

    
            return True, "свободен"
    

    
        elif "username" in error_msg:
    

    
            return False, "скрыт/приватный"
    

    
        elif "a wait of" in error_msg:
    

    
            return False, "лимит запросов"
    

    
        else:
    

    
            return False, f"ошибка: {str(e)}"
    

    
async def create_channel(client, username, title):
    

    
    try:
    

    
        result = await client(CreateChannelRequest(
    

    
            title=title,
    

    
            about=f"Канал {title}",
    

    
            megagroup=False
    

    
        ))
    

    
        
    

    
        channel = result.chats[0]
    

    
        
    

    
        await client(UpdateUsernameRequest(
    

    
            channel=channel,
    

    
            username=username
    

    
        ))
    

    
        
    

    
        return True, f" Канал '{title}' создан с юзернеймом @{username}"
    

    
    except Exception as e:
    

    
        return False, f" Ошибка создания канала: {str(e)}"
    

    
def ai_generate_usernames(theme, count=10):
    

    
    themes_dict = {
    

    
        'технологии': ['tech', 'ai', 'digital', 'future', 'innovation', 'smart', 'cyber', 'data', 'cloud', 'code', 'bot', 'net', 'web', 'app', 'soft'],
    

    
        'игры': ['game', 'play', 'win', 'level', 'quest', 'arena', 'boss', 'epic', 'gaming', 'player', 'fun', 'joy', 'zone', 'world', 'craft'],
    

    
        'спорт': ['sport', 'fit', 'gym', 'train', 'champ', 'victory', 'energy', 'power', 'active', 'move', 'run', 'fit', 'strong', 'health', 'body'],
    

    
        'музыка': ['music', 'sound', 'beat', 'tune', 'melody', 'rhythm', 'audio', 'track', 'band', 'song', 'vibe', 'wave', 'tone', 'harmony', 'chord'],
    

    
        'кино': ['movie', 'film', 'cinema', 'screen', 'scene', 'actor', 'drama', 'story', 'show', 'video', 'clip', 'reel', 'frame', 'shot', 'take'],
    

    
        'бизнес': ['biz', 'profit', 'success', 'money', 'wealth', 'trade', 'market', 'capital', 'venture', 'startup', 'biz', 'corp', 'inc', 'ltd', 'co'],
    

    
        'красота': ['beauty', 'style', 'fashion', 'glam', 'chic', 'vogue', 'trend', 'look', 'pretty', 'aesthetic', 'care', 'skin', 'hair', 'makeup', 'style'],
    

    
        'путешествия': ['travel', 'tour', 'journey', 'voyage', 'explore', 'adventure', 'wander', 'trip', 'world', 'global', 'tourist', 'visit', 'see', 'go']
    

    
    }
    

    
    
    

    
    base_words = themes_dict.get(theme.lower(), ['cool', 'awesome', 'epic', 'best', 'top', 'prime', 'vip', 'pro', 'good', 'nice'])
    

    
    
    

    
    usernames = []
    

    
    
    

    
    patterns = [
    

    
        lambda: f"{random.choice(base_words)}{random.choice(base_words)}",
    

    
        lambda: f"{random.choice(base_words)}{random.randint(100, 9999)}",
    

    
        lambda: f"{random.choice(base_words)}{random.choice(base_words)}{random.randint(10, 99)}",
    

    
        lambda: f"{random.choice(base_words)}_{random.choice(base_words)}",
    

    
        lambda: f"{random.choice(base_words)}_{random.randint(100, 999)}",
    

    
        lambda: f"the_{random.choice(base_words)}",
    

    
        lambda: f"my_{random.choice(base_words)}",
    

    
        lambda: f"best_{random.choice(base_words)}",
    

    
        lambda: f"top_{random.choice(base_words)}",
    

    
        lambda: f"only_{random.choice(base_words)}",
    

    
        lambda: f"{random.choice(base_words)}_{random.choice(base_words)}{random.randint(1, 9)}",
    

    
        lambda: f"{random.choice(base_words)}{random.randint(1, 9)}_{random.choice(base_words)}",
    

    
    ]
    

    
    
    

    
    attempts = 0
    

    
    max_attempts = count * 5
    

    
    
    

    
    while len(usernames) < count and attempts < max_attempts:
    

    
        attempts += 1
    

    
        
    

    
        username = random.choice(patterns)()
    

    
        
    

    
        if len(username) < 5 or len(username) > 32:
    

    
            continue
    

    
            
    

    
        if not username[0].isalpha():
    

    
            continue
    

    
            
    

    
        if not username[-1].isalnum():
    

    
            continue
    

    
            
    

    
        if not all(c.isalnum() or c == '_' for c in username):
    

    
            continue
    

    
            
    

    
        if '__' in username:
    

    
            continue
    

    
            
    

    
        if username.endswith('_'):
    

    
            continue
    

    
            
    

    
        if username.startswith('_'):
    

    
            continue
    

    
            
    

    
        if username not in usernames:
    

    
            usernames.append(username)
    

    
    
    

    
    if len(usernames) < count:
    

    
        additional_needed = count - len(usernames)
    

    
        for i in range(additional_needed):
    

    
            simple_username = f"{random.choice(base_words)}{random.randint(1000, 9999)}"
    

    
            if simple_username not in usernames:
    

    
                usernames.append(simple_username)
    

    
    
    

    
    return usernames[:count]
    

    
def get_display_name(filename):
    

    
    base_name = filename.replace('.txt', '')
    

    
    parts = base_name.split('_')
    

    
    
    

    
    if len(parts) >= 3:
    

    
        username = parts[0]
    

    
        start = parts[1]
    

    
        end = parts[2]
    

    
        return f"{username} {start}-{end}"
    

    
    else:
    

    
        return base_name
    

    
def show_settings():
    

    
    while True:
    

    
        clear_console()
    

    
        print_banner()
    

    
        print_centered_line(50)
    

    
        print_centered(" НАСТРОЙКИ")
    

    
        print_centered_line(50)
    

    
        print()
    

    
        
    

    
        current_color_code = settings['color_primary']
    

    
        current_color_name = current_color_code
    

    
        for color_info in COLOR_PRESETS.values():
    

    
            if color_info['code'] == current_color_code:
    

    
                current_color_name = color_info['name']
    

    
                break
    

    
        print_centered(f"Скорость проверки: \033[{settings['color_primary']}m{settings['check_speed']}s\033[{settings['color_text']}m")
    

    
        print_centered(f"Основной цвет: \033[{current_color_code}m{current_color_name}\033[{settings['color_text']}m")
    

    
        print()
    

    
        
    

    
        menu_lines = [
    

    
            f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m1\033[{settings['color_primary']}m]\033[{settings['color_text']}m Изменить скорость проверки",
    

    
            f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m2\033[{settings['color_primary']}m]\033[{settings['color_text']}m Изменить цвет",
    

    
            f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m3\033[{settings['color_primary']}m]\033[{settings['color_text']}m Сбросить сессию Telegram",
    

    
            f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m4\033[{settings['color_primary']}m]\033[{settings['color_text']}m Назад"
    

    
        ]
    

    
        
    

    
        print_centered_multiline(menu_lines)
    

    
        print()
    

    
        print_centered_line(50)
    

    
        
    

    
        choice = input(" " * get_center_position("Выберите действие [1-4]: ") + f"\033[97mВыберите действие [1-4]: \033[0m").strip()
    

    
        
    

    
        if choice == '1':
    

    
            clear_console()
    

    
            print_banner()
    

    
            print_centered_line(50)
    

    
            print_centered("ИЗМЕНЕНИЕ СКОРОСТИ ПРОВЕРКИ")
    

    
            print_centered_line(50)
    

    
            print()
    

    
            
    

    
            try:
    

    
                speed = float(input(" " * get_center_position("Введите скорость проверки (секунды): ") + "\033[97mВведите скорость проверки (секунды): \033[0m").strip())
    

    
                if 0.1 <= speed <= 10:
    

    
                    settings['check_speed'] = speed
    

    
                    save_settings(settings)
    

    
                    print_centered("✓ Скорость изменена!", settings['color_primary'])
    

    
                else:
    

    
                    print_centered("✗ Скорость должна быть от 0.1 до 10 секунд")
    

    
            except ValueError:
    

    
                print_centered("✗ Введите корректное число")
    

    
            
    

    
            input("\n" + " " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
            
    

    
        elif choice == '2':
    

    
            clear_console()
    

    
            print_banner()
    

    
            print_centered_line(50)
    

    
            print_centered("ИЗМЕНЕНИЕ ЦВЕТА")
    

    
            print_centered_line(50)
    

    
            print()
    

    
            print_centered("Доступные цвета:")
    

    
            print()
    

    
            for num, color_info in COLOR_PRESETS.items():
    

    
                print_centered(f"  {num}. {color_info['name']}")
    

    
            print()
    

    
            
    

    
            color_choice = input(" " * get_center_position("Выберите цвет [1-15]: ") + "\033[97mВыберите цвет [1-15]: \033[0m").strip()
    

    
            
    

    
            if color_choice in COLOR_PRESETS:
    

    
                settings['color_primary'] = COLOR_PRESETS[color_choice]['code']
    

    
                save_settings(settings)
    

    
                print_centered("✓ Цвет изменен!", settings['color_primary'])
    

    
            else:
    

    
                print_centered("✗ Неверный номер цвета!")
    

    
            
    

    
            input("\n" + " " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
            
    

    
        elif choice == '3':
    

    
            clear_session()
    

    
            print_centered("✓ Сессия Telegram сброшена!", settings['color_primary'])
    

    
            print_centered("При следующем запуске потребуется авторизация", settings['color_text'])
    

    
            input("\n" + " " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
            
    

    
        elif choice == '4':
    

    
            break
    

    
        else:
    

    
            print_centered("✗ Неверный выбор! Попробуйте снова.")
    

    
            input("\n" + " " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
def show_history():
    

    
    clear_console()
    

    
    print_banner()
    

    
    print_centered_line(50)
    

    
    print_centered(" ИСТОРИЯ ПРОВЕРОК")
    

    
    print_centered_line(50)
    

    
    print()
    

    
    
    

    
    history_files = glob.glob("*.txt")
    

    
    
    

    
    if not history_files:
    

    
        print_centered(" История пуста")
    

    
        print_centered("Сначала выполните проверку юзернеймов")
    

    
        return
    

    
    
    

    
    print_centered("Доступные проверки:")
    

    
    print()
    

    
    
    

    
    menu_lines = []
    

    
    for i, filename in enumerate(history_files, 1):
    

    
        display_name = get_display_name(filename)
    

    
        menu_line = f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m{i}\033[{settings['color_primary']}m]\033[{settings['color_text']}m {display_name}"
    

    
        menu_lines.append(menu_line)
    

    
    
    

    
    print_centered_multiline(menu_lines)
    

    
    print()
    

    
    print_centered_line(50)
    

    
    
    

    
    try:
    

    
        choice = input(" " * get_center_position(f"Выберите проверку [1-{len(history_files)}]: ") + f"\033[97mВыберите проверку [1-{len(history_files)}]: \033[0m").strip()
    

    
        
    

    
        file_index = int(choice) - 1
    

    
        
    

    
        if 0 <= file_index < len(history_files):
    

    
            selected_file = history_files[file_index]
    

    
            display_name = get_display_name(selected_file)
    

    
            
    

    
            clear_console()
    

    
            print_banner()
    

    
            print_centered_line(50)
    

    
            print_centered(f" {display_name}")
    

    
            print_centered_line(50)
    

    
            print()
    

    
            
    

    
            try:
    

    
                with open(selected_file, 'r', encoding='utf-8') as f:
    

    
                    content = f.read()
    

    
                    lines = content.split('\n')
    

    
                    for line in lines:
    

    
                        if line.strip():
    

    
                            if '=' in line:
    

    
                                line = "=" * 50
    

    
                                centered_line = " " * get_center_position(line) + line
    

    
                                print(f"\033[{settings['color_primary']}m{centered_line}\033[0m")
    

    
                            else:
    

    
                                print_centered(line)
    

    
            except Exception as e:
    

    
                print_centered(f"✗ Ошибка чтения файла: {e}")
    

    
        else:
    

    
            print_centered("✗ Неверный выбор!")
    

    
    
    

    
    except ValueError:
    

    
        print_centered("✗ Введите корректный номер!")
    

    
    except Exception as e:
    

    
        print_centered(f"✗ Ошибка: {e}")
    

    
async def create_telegram_client():
    

    
    if api_id is None or api_hash is None:
    

    
        return None, "API данные не настроены!"
    

    
    
    

    
    session_string = load_session()
    

    
    if session_string:
    

    
        client = TelegramClient(StringSession(session_string), api_id, api_hash)
    

    
    else:
    

    
        client = TelegramClient(StringSession(), api_id, api_hash)
    

    
    
    

    
    return client, None
    

    
async def authorize_client(client):
    

    
    try:
    

    
        await client.connect()
    

    
        
    

    
        if not await client.is_user_authorized():
    

    
            clear_console()
    

    
            print_banner()
    

    
            print_centered_line(50)
    

    
            print_centered(" АВТОРИЗАЦИЯ В TELEGRAM")
    

    
            print_centered_line(50)
    

    
            print()
    

    
            
    

    
            phone = input(" " * get_center_position("Введите ваш номер телефона: ") + "\033[97mВведите ваш номер телефона: \033[0m").strip()
    

    
            
    

    
            try:
    

    
                await client.send_code_request(phone)
    

    
                print_centered("✓ Код отправлен!", settings['color_primary'])
    

    
            except Exception as e:
    

    
                return False, f"Ошибка отправки кода: {e}"
    

    
            
    

    
            code = input(" " * get_center_position("Введите код из Telegram: ") + "\033[97mВведите код из Telegram: \033[0m").strip()
    

    
            
    

    
            try:
    

    
                await client.sign_in(phone, code)
    

    
                print_centered("✓ Успешная авторизация!", settings['color_primary'])
    

    
                
    

    
            except SessionPasswordNeededError:
    

    
                print_centered(" Требуется пароль двухфакторной аутентификации")
    

    
                password = input(" " * get_center_position("Введите пароль 2FA: ") + "\033[97mВведите пароль 2FA: \033[0m")
    

    
                try:
    

    
                    await client.sign_in(password=password)
    

    
                    print_centered("✓ Успешная авторизация с 2FA!", settings['color_primary'])
    

    
                except Exception as e:
    

    
                    return False, f"Ошибка входа с паролем: {e}"
    

    
                    
    

    
            except PhoneCodeInvalidError:
    

    
                return False, "Неверный код! Попробуйте снова."
    

    
            except Exception as e:
    

    
                return False, f"Ошибка авторизации: {e}"
    

    
        
    

    
        session_string = client.session.save()
    

    
        save_session(session_string)
    

    
        
    

    
        return True, "Успешная авторизация!"
    

    
        
    

    
    except Exception as e:
    

    
        return False, f"Ошибка подключения: {e}"
    

    
async def username_checker():
    

    
    if api_id is None or api_hash is None:
    

    
        print_centered("✗ API данные не настроены!")
    

    
        print_centered("Запустите настройку API данных из меню")
    

    
        return
    

    
    
    

    
    client, error = await create_telegram_client()
    

    
    if error:
    

    
        print_centered(f"✗ {error}")
    

    
        return
    

    
    
    

    
    try:
    

    
        success, message = await authorize_client(client)
    

    
        if not success:
    

    
            print_centered(f"✗ {message}")
    

    
            return
    

    
        
    

    
        clear_console()
    

    
        print_banner()
    

    
        print_centered_line(50)
    

    
        print_centered(" ПРОВЕРКА ЮЗЕРНЕЙМОВ")
    

    
        print_centered_line(50)
    

    
        print()
    

    
        
    

    
        base_username = input(" " * get_center_position("Введите базовый юзернейм: ") + "\033[97mВведите базовый юзернейм: \033[0m").strip()
    

    
        
    

    
        try:
    

    
            start_num = int(input(" " * get_center_position("Начальная цифра: ") + "\033[97mНачальная цифра: \033[0m"))
    

    
            end_num = int(input(" " * get_center_position("Конечная цифра: ") + "\033[97mКонечная цифра: \033[0m"))
    

    
        except ValueError:
    

    
            print_centered("✗ Ошибка: введите корректные числа!")
    

    
            return
    

    
        
    

    
        print()
    

    
        print_centered(f" Проверяю юзернеймы: {base_username}[{start_num}-{end_num}]")
    

    
        print_centered_line(50)
    

    
        
    

    
        available_usernames = []
    

    
        total_checked = 0
    

    
        
    

    
        if start_num == 0:
    

    
            username_without_number = b
    Второй файл(bot.py):

    Python
    import os
    

    
import json
    

    
import asyncio
    

    
import logging
    

    
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
    

    
from telegram.ext import Application, CommandHandler, CallbackQueryHandler, MessageHandler, filters, ContextTypes
    

    
from telethon import TelegramClient
    

    
from telethon.sessions import StringSession
    

    
import sqlite3
    

    
logging.basicConfig(
    

    
    level=logging.INFO,
    

    
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    

    
)
    

    
logger = logging.getLogger(__name__)
    

    
def load_settings():
    

    
    try:
    

    
        with open('checker_settings.json', 'r', encoding='utf-8') as f:
    

    
            return json.load(f)
    

    
    except:
    

    
        return {'color_primary': '91', 'color_text': '97'}
    

    
settings = load_settings()
    

    
def init_db():
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('''
    

    
        CREATE TABLE IF NOT EXISTS bots (
    

    
            id INTEGER PRIMARY KEY AUTOINCREMENT,
    

    
            token TEXT UNIQUE,
    

    
            username TEXT,
    

    
            is_active BOOLEAN DEFAULT FALSE,
    

    
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    

    
        )
    

    
    ''')
    

    
    cursor.execute('''
    

    
        CREATE TABLE IF NOT EXISTS check_history (
    

    
            id INTEGER PRIMARY KEY AUTOINCREMENT,
    

    
            bot_token TEXT,
    

    
            base_username TEXT,
    

    
            start_num INTEGER,
    

    
            end_num INTEGER,
    

    
            available_count INTEGER,
    

    
            occupied_count INTEGER,
    

    
            for_sale_count INTEGER,
    

    
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    

    
        )
    

    
    ''')
    

    
    cursor.execute('''
    

    
        CREATE TABLE IF NOT EXISTS available_usernames (
    

    
            id INTEGER PRIMARY KEY AUTOINCREMENT,
    

    
            history_id INTEGER,
    

    
            username TEXT
    

    
        )
    

    
    ''')
    

    
    conn.commit()
    

    
    conn.close()
    

    
init_db()
    

    
def add_bot(token, username):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    try:
    

    
        cursor.execute('INSERT INTO bots (token, username) VALUES (?, ?)', (token, username))
    

    
        conn.commit()
    

    
        return True
    

    
    except sqlite3.IntegrityError:
    

    
        return False
    

    
    finally:
    

    
        conn.close()
    

    
def get_bots():
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('SELECT id, token, username, is_active FROM bots ORDER BY created_at DESC')
    

    
    bots = cursor.fetchall()
    

    
    conn.close()
    

    
    return bots
    

    
def delete_bot(bot_id):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('DELETE FROM bots WHERE id = ?', (bot_id,))
    

    
    conn.commit()
    

    
    conn.close()
    

    
def update_bot_status(bot_id, is_active):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('UPDATE bots SET is_active = ? WHERE id = ?', (is_active, bot_id))
    

    
    conn.commit()
    

    
    conn.close()
    

    
def save_check_history(bot_token, base_username, start_num, end_num, available_count, occupied_count, for_sale_count, available_usernames):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('''
    

    
        INSERT INTO check_history (bot_token, base_username, start_num, end_num, available_count, occupied_count, for_sale_count)
    

    
        VALUES (?, ?, ?, ?, ?, ?, ?)
    

    
    ''', (bot_token, base_username, start_num, end_num, available_count, occupied_count, for_sale_count))
    

    
    
    

    
    history_id = cursor.lastrowid
    

    
    
    

    
    for username in available_usernames:
    

    
        cursor.execute('INSERT INTO available_usernames (history_id, username) VALUES (?, ?)', (history_id, username))
    

    
    
    

    
    conn.commit()
    

    
    conn.close()
    

    
    return history_id
    

    
def get_check_history(bot_token):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('''
    

    
        SELECT id, base_username, start_num, end_num, available_count, created_at
    

    
        FROM check_history
    

    
        WHERE bot_token = ?
    

    
        ORDER BY created_at DESC
    

    
    ''', (bot_token,))
    

    
    history = cursor.fetchall()
    

    
    conn.close()
    

    
    return history
    

    
def get_available_usernames(history_id):
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('SELECT username FROM available_usernames WHERE history_id = ?', (history_id,))
    

    
    usernames = [row[0] for row in cursor.fetchall()]
    

    
    conn.close()
    

    
    return usernames
    

    
async def check_username(client, username):
    

    
    try:
    

    
        await client.get_entity(username)
    

    
        return False, "занят"
    

    
    except ValueError:
    

    
        return True, "свободен"
    

    
    except Exception as e:
    

    
        error_msg = str(e).lower()
    

    
        if "unacceptable" in error_msg or "match" in error_msg:
    

    
            return False, "на продаже"
    

    
        elif "flood" in error_msg:
    

    
            return False, "ограничение Telegram"
    

    
        elif "username" in error_msg and "purchase" in error_msg:
    

    
            return False, "на продаже"
    

    
        elif "username" in error_msg and "not found" in error_msg:
    

    
            return True, "свободен"
    

    
        elif "username" in error_msg:
    

    
            return False, "скрыт/приватный"
    

    
        elif "a wait of" in error_msg:
    

    
            return False, "лимит запросов"
    

    
        else:
    

    
            return False, f"ошибка: {str(e)}"
    

    
def load_api_config():
    

    
    try:
    

    
        with open('api_config.json', 'r', encoding='utf-8') as f:
    

    
            config = json.load(f)
    

    
            return config.get('api_id'), config.get('api_hash')
    

    
    except:
    

    
        return None, None
    

    
async def create_telegram_client():
    

    
    api_id, api_hash = load_api_config()
    

    
    if not api_id or not api_hash:
    

    
        return None, "API данные не настроены"
    

    
    
    

    
    session_string = None
    

    
    try:
    

    
        with open('telegram_session.session', 'r') as f:
    

    
            session_string = f.read().strip()
    

    
    except:
    

    
        pass
    

    
    
    

    
    if session_string:
    

    
        client = TelegramClient(StringSession(session_string), api_id, api_hash)
    

    
    else:
    

    
        client = TelegramClient(StringSession(), api_id, api_hash)
    

    
    
    

    
    return client, None
    

    
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    

    
    keyboard = [
    

    
        [InlineKeyboardButton(" Чекер", callback_data="checker")],
    

    
        [InlineKeyboardButton(" История", callback_data="history")],
    

    
        [InlineKeyboardButton(" О программе", callback_data="about")],
    

    
        [InlineKeyboardButton(" Тех поддержка", url="https://t.me/FunPayBad")]
    

    
    ]
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    
    

    
    welcome_text = """ Добро пожаловать в Чекер юзернеймов!
    

    
Этот бот поможет вам находить свободные юзернеймы в Telegram.
    

    
<b>Чекер</b> - поиск свободных юзернеймов
    

    
<b>История</b> - просмотр предыдущих проверок
    

    
<b>О программе</b> - информация о боте
    

    
<b>Тех поддержка</b> - помощь и консультации
    

    
Выберите действие:"""
    

    
    
    

    
    await update.message.reply_text(welcome_text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    

    
    query = update.callback_query
    

    
    await query.answer()
    

    
    
    

    
    data = query.data
    

    
    
    

    
    if data == "checker":
    

    
        await show_checker_menu(query, context)
    

    
    elif data == "history":
    

    
        await show_history_menu(query, context)
    

    
    elif data == "about":
    

    
        await show_about(query, context)
    

    
    elif data == "back_to_menu":
    

    
        await start_callback(query, context)
    

    
    elif data.startswith("history_"):
    

    
        history_id = int(data.split("_")[1])
    

    
        await show_history_details(query, context, history_id)
    

    
    elif data.startswith("usernames_"):
    

    
        history_id = int(data.split("_")[1])
    

    
        await show_available_usernames(query, context, history_id)
    

    
async def start_callback(query, context):
    

    
    keyboard = [
    

    
        [InlineKeyboardButton(" Чекер", callback_data="checker")],
    

    
        [InlineKeyboardButton(" История", callback_data="history")],
    

    
        [InlineKeyboardButton(" О программе", callback_data="about")],
    

    
        [InlineKeyboardButton(" Тех поддержка", url="https://t.me/FunPayBad")]
    

    
    ]
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    
    

    
    welcome_text = " Добро пожаловать в Чекер юзернеймов!\n\nВыберите действие:"
    

    
    
    

    
    await query.edit_message_text(welcome_text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def show_checker_menu(query, context):
    

    
    text = """ <b>Проверка юзернеймов</b>
    

    
Введите базовый юзернейм и диапазон цифр через тире.
    

    
<b>Формат:</b> <code>юзернейм 0-10</code>
    

    
<b>Пример:</b> <code>username 0-20</code>
    

    
Теперь введите данные для проверки:"""
    

    
    
    

    
    keyboard = [[InlineKeyboardButton(" Назад", callback_data="back_to_menu")]]
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    
    

    
    await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='HTML')
    

    
    context.user_data['waiting_for_check'] = True
    

    
async def show_history_menu(query, context):
    

    
    bot_token = context.bot.token
    

    
    history = get_check_history(bot_token)
    

    
    
    

    
    if not history:
    

    
        text = " <b>История проверок</b>\n\nИстория пуста."
    

    
        keyboard = [[InlineKeyboardButton(" Назад", callback_data="back_to_menu")]]
    

    
    else:
    

    
        text = " <b>История проверок</b>\n\nВот юзернеймы которые вы искали:\n\n"
    

    
        keyboard = []
    

    
        
    

    
        for i, (history_id, base_username, start_num, end_num, available_count, created_at) in enumerate(history, 1):
    

    
            text += f"{i}. {base_username} {start_num}-{end_num}\n"
    

    
            keyboard.append([InlineKeyboardButton(
    

    
                f"{base_username} {start_num}-{end_num}",
    

    
                callback_data=f"history_{history_id}"
    

    
            )])
    

    
        
    

    
        keyboard.append([InlineKeyboardButton(" Назад", callback_data="back_to_menu")])
    

    
    
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def show_history_details(query, context, history_id):
    

    
    bot_token = context.bot.token
    

    
    conn = sqlite3.connect('bots.db')
    

    
    cursor = conn.cursor()
    

    
    cursor.execute('''
    

    
        SELECT base_username, start_num, end_num, available_count, occupied_count, for_sale_count
    

    
        FROM check_history
    

    
        WHERE id = ?
    

    
    ''', (history_id,))
    

    
    result = cursor.fetchone()
    

    
    conn.close()
    

    
    
    

    
    if result:
    

    
        base_username, start_num, end_num, available_count, occupied_count, for_sale_count = result
    

    
        
    

    
        text = f""" <b>Результаты проверки</b>
    

    
<b>Юзернейм:</b> {base_username}
    

    
<b>Диапазон:</b> {start_num}-{end_num}
    

    
<b>Свободно:</b> {available_count}
    

    
<b>Занято:</b> {occupied_count}
    

    
<b>На продаже:</b> {for_sale_count}
    

    
Нажмите кнопку ниже чтобы посмотреть свободные юзернеймы:"""
    

    
        
    

    
        keyboard = [
    

    
            [InlineKeyboardButton(" Юзернеймы", callback_data=f"usernames_{history_id}")],
    

    
            [InlineKeyboardButton(" Меню", callback_data="back_to_menu")]
    

    
        ]
    

    
    else:
    

    
        text = " История не найдена"
    

    
        keyboard = [[InlineKeyboardButton(" Назад", callback_data="history")]]
    

    
    
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def show_available_usernames(query, context, history_id):
    

    
    usernames = get_available_usernames(history_id)
    

    
    
    

    
    if usernames:
    

    
        text = " <b>Свободные юзернеймы:</b>\n\n" + "\n".join([f"• @{username}" for username in usernames])
    

    
    else:
    

    
        text = " Свободные юзернеймы не найдены"
    

    
    
    

    
    keyboard = [[InlineKeyboardButton(" Меню", callback_data="back_to_menu")]]
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def show_about(query, context):
    

    
    text = """ <b>О программе</b>
    

    
<b>Создатель:</b> FunPayBad
    

    
<b>Канал:</b> @FunPayBad
    

    
<b>Версия:</b> 2.0 ПРЕМИУМ
    

    
<b>Тип программы:</b> ПРЕМИУМ
    

    
<b>Тех поддержка:</b> @woriot
    

    
<b>Дешевый магазин:</b> @FreeShopGo
    

    
<b>ПРЕМИУМ ФУНКЦИИ:</b>
    

    
• AI-генерация умных юзернеймов
    

    
• Создание каналов после проверки
    

    
• Умный подбор по темам
    

    
• Расширенная статистика"""
    

    
    
    

    
    keyboard = [[InlineKeyboardButton(" Назад", callback_data="back_to_menu")]]
    

    
    reply_markup = InlineKeyboardMarkup(keyboard)
    

    
    await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='HTML')
    

    
async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    

    
    if context.user_data.get('waiting_for_check'):
    

    
        await process_check_request(update, context)
    

    
async def process_check_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
    

    
    user_input = update.message.text.strip()
    

    
    
    

    
    try:
    

    
        if ' ' in user_input:
    

    
            base_username, range_str = user_input.rsplit(' ', 1)
    

    
            if '-' in range_str:
    

    
                start_num, end_num = map(int, range_str.split('-'))
    

    
            else:
    

    
                await update.message.reply_text(" Неверный формат. Используйте: юзернейм 0-10")
    

    
                return
    

    
        else:
    

    
            await update.message.reply_text(" Неверный формат. Используйте: юзернейм 0-10")
    

    
            return
    

    
    except ValueError:
    

    
        await update.message.reply_text(" Неверный формат чисел. Используйте: юзернейм 0-10")
    

    
        return
    

    
    
    

    
    processing_msg = await update.message.reply_text(" Начинается проверка, ожидайте...")
    

    
    
    

    
    client, error = await create_telegram_client()
    

    
    if error:
    

    
        await processing_msg.edit_text(f" Ошибка: {error}")
    

    
        return
    

    
    
    

    
    try:
    

    
        await client.connect()
    

    
        if not await client.is_user_authorized():
    

    
            await processing_msg.edit_text(" Ошибка авторизации Telegram")
    

    
            return
    

    
        
    

    
        available_usernames = []
    

    
        occupied_count = 0
    

    
        for_sale_count = 0
    

    
        
    

    
        if start_num == 0:
    

    
            is_available, status = await check_username(client, base_username)
    

    
            if is_available:
    

    
                available_usernames.append(base_username)
    

    
            elif "на продаже" in status:
    

    
                for_sale_count += 1
    

    
            else:
    

    
                occupied_count += 1
    

    
            await asyncio.sleep(1)
    

    
        
    

    
        for num in range(start_num, end_num + 1):
    

    
            username = f"{base_username}{num}"
    

    
            is_available, status = await check_username(client, username)
    

    
            
    

    
            if is_available:
    

    
                available_usernames.append(username)
    

    
            elif "на продаже" in status:
    

    
                for_sale_count += 1
    

    
            else:
    

    
                occupied_count += 1
    

    
            
    

    
            await asyncio.sleep(1)
    

    
        
    

    
        available_count = len(available_usernames)
    

    
        
    

    
        bot_token = context.bot.token
    

    
        history_id = save_check_history(
    

    
            bot_token, base_username, start_num, end_num,
    

    
            available_count, occupied_count, for_sale_count, available_usernames
    

    
        )
    

    
        
    

    
        result_text = f""" <b>Результаты проверки</b>
    

    
<b>Юзернейм:</b> {base_username}
    

    
<b>Диапазон:</b> {start_num}-{end_num}
    

    
<b>Свободно:</b> {available_count}
    

    
<b>Занято:</b> {occupied_count}
    

    
<b>На продаже:</b> {for_sale_count}
    

    
Нажмите кнопку ниже чтобы посмотреть свободные юзернеймы:"""
    

    
        
    

    
        keyboard = [
    

    
            [InlineKeyboardButton(" Юзернеймы", callback_data=f"usernames_{history_id}")],
    

    
            [InlineKeyboardButton(" Меню", callback_data="back_to_menu")]
    

    
        ]
    

    
        reply_markup = InlineKeyboardMarkup(keyboard)
    

    
        
    

    
        await processing_msg.edit_text(result_text, reply_markup=reply_markup, parse_mode='HTML')
    

    
        
    

    
    except Exception as e:
    

    
        await processing_msg.edit_text(f" Произошла ошибка: {str(e)}")
    

    
    finally:
    

    
        try:
    

    
            await client.disconnect()
    

    
        except:
    

    
            pass
    

    
    
    

    
    context.user_data['waiting_for_check'] = False
    

    
def run_bot(token):
    

    
    """Запуск бота с правильной обработкой event loop"""
    

    
    try:
    

    
        # Создаем новый event loop для этого потока
    

    
        loop = asyncio.new_event_loop()
    

    
        asyncio.set_event_loop(loop)
    

    
        
    

    
        application = Application.builder().token(token).build()
    

    
        
    

    
        application.add_handler(CommandHandler("start", start))
    

    
        application.add_handler(CallbackQueryHandler(handle_callback))
    

    
        application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    

    
        
    

    
        print_centered(" Бот запущен!", settings['color_primary'])
    

    
        print_centered("Для остановки нажмите Ctrl+C", settings['color_text'])
    

    
        print()
    

    
        
    

    
        # Запускаем бота в созданном event loop
    

    
        application.run_polling()
    

    
        
    

    
    except Exception as e:
    

    
        logger.error(f"Ошибка запуска бота: {e}")
    

    
        print_centered(f" Ошибка запуска бота: {e}")
    

    
def main_bot_menu():
    

    
    clear_console()
    

    
    print_banner()
    

    
    print_centered_line(50)
    

    
    print_centered(" БОТ МЕНЕДЖЕР")
    

    
    print_centered_line(50)
    

    
    print()
    

    
    
    

    
    menu_lines = [
    

    
        f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m1\033[{settings['color_primary']}m]\033[{settings['color_text']}m Создать бота",
    

    
        f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m2\033[{settings['color_primary']}m]\033[{settings['color_text']}m Мои боты",
    

    
        f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m3\033[{settings['color_primary']}m]\033[{settings['color_text']}m Назад"
    

    
    ]
    

    
    
    

    
    print_centered_multiline(menu_lines)
    

    
    print()
    

    
    print_centered_line(50)
    

    
def clear_console():
    

    
    os.system('cls' if os.name == 'nt' else 'clear')
    

    
def print_centered(text, color_code=None):
    

    
    if color_code is None:
    

    
        color_code = settings['color_text']
    

    
    try:
    

    
        terminal_size = os.get_terminal_size()
    

    
        centered_text = " " * ((terminal_size.columns - len(text)) // 2) + text
    

    
        print(f"\033[{color_code}m{centered_text}\033[0m")
    

    
    except:
    

    
        print(f"\033[{color_code}m{text}\033[0m")
    

    
def print_centered_multiline(lines, color_code=None):
    

    
    if color_code is None:
    

    
        color_code = settings['color_text']
    

    
    
    

    
    max_length = 0
    

    
    for line in lines:
    

    
        clean_line = line.replace(f'\033[{settings["color_primary"]}m', '').replace(f'\033[{settings["color_text"]}m', '').replace('\033[0m', '')
    

    
        max_length = max(max_length, len(clean_line))
    

    
    
    

    
    try:
    

    
        center_pos = (os.get_terminal_size().columns - max_length) // 2
    

    
    except:
    

    
        center_pos = 0
    

    
    
    

    
    for line in lines:
    

    
        centered_line = " " * center_pos + line
    

    
        print(f"\033[{color_code}m{centered_line}\033[0m")
    

    
def print_centered_line(length=50):
    

    
    try:
    

    
        terminal_size = os.get_terminal_size()
    

    
        line = "=" * length
    

    
        center_pos = (terminal_size.columns - length) // 2
    

    
        centered_line = " " * center_pos + line
    

    
        print(f"\033[{settings['color_primary']}m{centered_line}\033[0m")
    

    
    except:
    

    
        print(f"\033[{settings['color_primary']}m{'=' * length}\033[0m")
    

    
def print_banner():
    

    
    banner_lines = [
    

    
        "******╗  ******╗ ********╗",
    

    
        "**╔══**╗**╔═══**╗╚══**╔══╝",
    

    
        "******╔╝**║   **║   **║   ",
    

    
        "**╔══**╗**║   **║   **║   ",
    

    
        "******╔╝╚******╔╝   **║   ",
    

    
        "╚═════╝  ╚═════╝    ╚═╝   "
    

    
    ]
    

    
    
    

    
    for line in banner_lines:
    

    
        print_centered(line, settings['color_primary'])
    

    
def get_center_position(text):
    

    
    try:
    

    
        terminal_size = os.get_terminal_size()
    

    
        return (terminal_size.columns - len(text)) // 2
    

    
    except:
    

    
        return 0
    

    
def create_bot():
    

    
    clear_console()
    

    
    print_banner()
    

    
    print_centered_line(50)
    

    
    print_centered(" СОЗДАНИЕ БОТА")
    

    
    print_centered_line(50)
    

    
    print()
    

    
    
    

    
    token = input(" " * get_center_position("Введите токен бота: ") + "\033[97mВведите токен бота: \033[0m").strip()
    

    
    
    

    
    if not token:
    

    
        print_centered(" Токен не может быть пустым!")
    

    
        input(" " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
        return
    

    
    
    

    
    try:
    

    
        from telegram import Bot
    

    
        
    

    
        # Создаем отдельный event loop для проверки токена
    

    
        loop = asyncio.new_event_loop()
    

    
        asyncio.set_event_loop(loop)
    

    
        
    

    
        async def get_bot_info():
    

    
            bot = Bot(token=token)
    

    
            return await bot.get_me()
    

    
        
    

    
        bot_info = loop.run_until_complete(get_bot_info())
    

    
        username = bot_info.username
    

    
        loop.close()
    

    
        
    

    
        if add_bot(token, username):
    

    
            print_centered(f" Бот @{username} успешно создан!", settings['color_primary'])
    

    
            print_centered("Запускаю бота...", settings['color_text'])
    

    
            print()
    

    
            
    

    
            run_bot(token)
    

    
            
    

    
        else:
    

    
            print_centered(" Бот с таким токеном уже существует!")
    

    
            input(" " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
            
    

    
    except Exception as e:
    

    
        print_centered(f" Ошибка: Неверный токен бота - {str(e)}")
    

    
        input(" " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
def show_my_bots():
    

    
    while True:
    

    
        clear_console()
    

    
        print_banner()
    

    
        print_centered_line(50)
    

    
        print_centered(" МОИ БОТЫ")
    

    
        print_centered_line(50)
    

    
        print()
    

    
        
    

    
        bots = get_bots()
    

    
        
    

    
        if not bots:
    

    
            print_centered(" У вас нет созданных ботов")
    

    
            print()
    

    
            print_centered_line(50)
    

    
            input(" " * get_center_position("Нажмите Enter для возврата...") + "\033[97mНажмите Enter для возврата...\033[0m")
    

    
            return
    

    
        
    

    
        print_centered("Ваши боты:")
    

    
        print()
    

    
        
    

    
        for i, (bot_id, token, username, is_active) in enumerate(bots, 1):
    

    
            status = " Запущен" if is_active else " Остановлен"
    

    
            print_centered(f"{i}. @{username} - {status}")
    

    
        
    

    
        print()
    

    
        print_centered_line(50)
    

    
        
    

    
        try:
    

    
            choice = input(" " * get_center_position("Выберите бота [1-{}] или 0 для возврата: ".format(len(bots))) + "\033[97mВыберите бота [1-{}] или 0 для возврата: \033[0m".format(len(bots))).strip()
    

    
            
    

    
            if choice == '0':
    

    
                return
    

    
            
    

    
            bot_index = int(choice) - 1
    

    
            if 0 <= bot_index < len(bots):
    

    
                bot_id, token, username, is_active = bots[bot_index]
    

    
                manage_bot(bot_id, token, username, is_active)
    

    
            else:
    

    
                print_centered(" Неверный выбор!")
    

    
                input(" " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
                
    

    
        except ValueError:
    

    
            print_centered(" Введите корректный номер!")
    

    
            input(" " * get_center_position("Нажмите Enter для продолжения...") + "\033[97mНажмите Enter для продолжения...\033[0m")
    

    
def manage_bot(bot_id, token, username, is_active):
    

    
    while True:
    

    
        clear_console()
    

    
        print_banner()
    

    
        print_centered_line(50)
    

    
        print_centered(f" УПРАВЛЕНИЕ БОТОМ @{username}")
    

    
        print_centered_line(50)
    

    
        print()
    

    
        
    

    
        status = " Запущен" if is_active else " Остановлен"
    

    
        print_centered(f"Статус: {status}")
    

    
        print()
    

    
        
    

    
        menu_lines = []
    

    
        if is_active:
    

    
            menu_lines.append(f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m1\033[{settings['color_primary']}m]\033[{settings['color_text']}m Остановить")
    

    
        else:
    

    
            menu_lines.append(f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m1\033[{settings['color_primary']}m]\033[{settings['color_text']}m Запустить")
    

    
        
    

    
        menu_lines.append(f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m2\033[{settings['color_primary']}m]\033[{settings['color_text']}m Удалить")
    

    
        menu_lines.append(f"\033[{settings['color_primary']}m[\033[{settings['color_text']}m3\033[{settings['color_primary']}m]\033[{settings['color_text']}m Назад")
    

    
        
    

    
        print_centered_multiline(menu_lines)
    

    
        print()
    

    
        print_centered_line(50)
    

    
        
    

    
        choice = input(" " * get_center_position("Выберите действие [1-3]: ") + "\033[97mВыберите действие [1-3]: \033[0m").strip()
    

    
        
    

    
        if choice == '1':
    

    
            if is_active:
    

    
                update_bot_status(bot_id, False)
    

    
                print_centered(" Бот остановлен!", settings['color_primary'])
    

    
            else:
    

    
                print_centered(" Запускаю бота...", settings['color_primary'])
    

    
                print()
    

    
                run_bot(token)

    Так же он есть на GitHub
     
    Jan 26, 2026
  2. teracota
    teracota Jan 31, 2026 Banned 18 Dec 31, 2025
    Привет. Очень интересный код в плане того, что ты буквально каждую строчку пишешь через enter(че то не додумал тут слово xD). А еще зачем ты модули импортируешь в середине кода? Да и генерация юзернеймов такая себе. К сожалению по истине уникального ИИ еще не особо хорошо научился делать, но за старания респект
     
    Jan 31, 2026
    1. Apelsynca
      avatarteracota, я думаю enter это лолзтим сделал а не он
      Feb 12, 2026
    2. Eblocrut
      avatarApelsynca, так там только ии пишет код, тс сам не может что либо писать адекватное
      Feb 14, 2026
    3. Blox
      avatarteracota, так называемый "PEP 8"
      Feb 24, 2026
Loading...