Вот правильная авторизация аккаунта, прокси именно в таком виде, библиотека именна такая, обязательно передавать параметр use_ipv6=True) это ЭТАЛОН.

import python_socks
from telethon import TelegramClient
import asyncio
import logging

logging.basicConfig(level=logging.DEBUG)



api_id = 123
api_hash = '123'

proxy = {
    'proxy_type': python_socks.ProxyType.SOCKS5,  # (mandatory) protocol to use (see above)
    'addr': '191.101.224.123',  # (mandatory) proxy IP address
    'port': 14377,  # (mandatory) proxy port number
    'username': 'user273786',  # (optional) username if the proxy requires auth
    'password': 'qrflw8',  # (optional) password if the proxy requires auth
}

client = TelegramClient('7316232521.session', api_id, api_hash, proxy=proxy,use_ipv6=True)

Лишние импорты можешь убрать (socks)
Перепиши авторизацию этого кода под такой вид и учти где что может изменится, если не меняется ничего кроме авторизации, то так и напиши:
import os
import json
import asyncio
import random
import logging
import socks
from telethon import TelegramClient, errors
from telethon.errors import UserAlreadyParticipantError
from telethon.tl.functions.channels import JoinChannelRequest
from telethon.tl.functions.account import UpdateProfileRequest, UpdateUsernameRequest, SetPrivacyRequest
from telethon.tl.functions.account import UpdatePasswordSettingsRequest
from telethon.tl.functions.messages import GetHistoryRequest, GetMessagesViewsRequest
from telethon.tl.functions.messages import SendReactionRequest
from telethon.tl.types import InputPeerChannel, ReactionEmoji, InputPrivacyKeyStatusTimestamp, InputPrivacyValueAllowAll
from telethon.tl.functions.account import UpdateStatusRequest
from telethon.tl.functions.photos import UploadProfilePhotoRequest, DeletePhotosRequest
from telethon.tl.types import InputPhoto
from openpyxl import Workbook, load_workbook
from datetime import datetime, timedelta
import time
from python_socks import ProxyType
LOGS_DIR = "logs"
os.makedirs(LOGS_DIR, exist_ok=True)

logger = logging.getLogger("telegram_warmer_1sposob")
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')

API_ID = 28248459
API_HASH = "1d964bad240e82afed769b82c89292fe"
SESSIONS_DIR = os.path.abspath("sessions_progrev1")
PROXIES_FILE = os.path.abspath("25_proxies_progrev1.txt")

FEMALE_NAMES_FILE = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "female_names.txt"))
FEMALE_SURNAMES_FILE = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "female_surnames.txt"))
AVATARS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "avatars"))
ABOUT_TEXTS_FILE = "about_texts.txt"  # Тексты для "О себе"
MILLION_CHANNEL = "https://t.me/+8AqnUALHTpZkNmJi"  # Канал миллионник


def log_action(session_name: str, msg: str):
    log_path = os.path.join(LOGS_DIR, f"{session_name}.xlsx")

    if not os.path.exists(log_path):
        wb = Workbook()
        ws = wb.active
        ws.title = "Logs"
        ws['A1'] = "Время"
        ws['B1'] = "День"
        ws['C1'] = "Действие"
    else:
        wb = load_workbook(log_path)
        ws = wb.active

    row = ws.max_row + 1
    ws[f"A{row}"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    ws[f"B{row}"] = (datetime.now() - datetime.strptime(ws['A2'].value, "%Y-%m-%d %H:%M:%S")).days + 1
    ws[f"C{row}"] = msg
    wb.save(log_path)


def load_names_from_file(filename):
    if not os.path.exists(filename):
        logger.warning(f"Файл не найден: {filename}")
        return []
    with open(filename, "r", encoding="utf-8") as f:
        names = [line.strip() for line in f if line.strip()]
    logger.info(f"Загружено {len(names)} элементов из {filename}")
    return names


def load_proxies():
    proxies = []
    if not os.path.exists(PROXIES_FILE):
        logger.warning("Прокси файл не найден")
        return proxies
    with open(PROXIES_FILE, 'r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if line:
                proxies.append(line)
    logger.info(f"Загружено прокси: {len(proxies)}")
    return proxies


from python_socks import ProxyType
def proxy_tuple_from_str(proxy_line):
    parts = proxy_line.split(":")
    if len(parts) != 4:
        raise ValueError(f"Неправильный формат прокси: {proxy_line}")
    ip, port, user, password = parts
    
    return {
        'proxy_type': ProxyType.SOCKS5,  # <-- используем ProxyType.SOCKS5, а не строку
        'addr': ip,
        'port': int(port),
        'username': user,
        'password': password,
        'rdns': True  # Лучше разрешить remote DNS для telegram
    }


def load_client_params(session_file_path):
    json_file = os.path.splitext(session_file_path)[0] + '.json'
    if not os.path.exists(json_file):
        logger.info(f"[load_client_params] JSON файл не найден: {json_file}")
        return {}

    try:
        with open(json_file, 'r', encoding='utf-8') as f:
            data = json.load(f)

        params = {}
        if 'device' in data and data['device']:
            params['device_model'] = data['device']
        if 'sdk' in data and data['sdk']:
            params['system_version'] = data['sdk']
        if 'app_version' in data and data['app_version']:
            params['app_version'] = data['app_version']
        if 'lang_code' in data and data['lang_code']:
            params['lang_code'] = data['lang_code']

        logger.debug(f"[load_client_params] Параметры из {json_file}: {params}")
        return params
    except Exception as e:
        logger.warning(f"[load_client_params] Ошибка чтения {json_file}: {e}")
        return {}


async def wait_and_log(seconds, msg, session_name):
    logger.info(f"[{session_name}] {msg}. Ждем {seconds} секунд...")
    log_action(session_name, f"{msg}. Ждем {seconds} секунд...")
    await asyncio.sleep(seconds)


async def get_channel_entity(client, invite_link):
    try:
        if any(invite_link.startswith(prefix) for prefix in ["https://t.me/+", "http://t.me/+", "t.me/+"]):
            invite_hash = invite_link.split("+")[-1]
            try:
                result = await client(telethon.tl.functions.messages.ImportChatInviteRequest(invite_hash))
                entity = result.chats[0]
                return entity
            except UserAlreadyParticipantError:
                logger.info(f"Пользователь уже участник канала по пригласительной ссылке {invite_link}")
                entity = await client.get_entity(invite_link)
                return entity
        else:
            entity = await client.get_entity(invite_link)
            return entity
    except Exception as e:
        logger.error(f"Ошибка получения entity канала по ссылке {invite_link}: {e}")
        raise


async def set_avatar(client, session_name):
    if not os.path.exists(AVATARS_DIR):
        logger.warning(f"[{session_name}] Папка с аватарками не найдена")
        return False

    avatar_files = [f for f in os.listdir(AVATARS_DIR) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
    if not avatar_files:
        logger.warning(f"[{session_name}] Нет доступных аватарок")
        return False

    avatar_path = os.path.join(AVATARS_DIR, random.choice(avatar_files))
    try:
        await client(UploadProfilePhotoRequest(await client.upload_file(avatar_path)))
        logger.info(f"[{session_name}] Аватар успешно установлен")
        log_action(session_name, "Аватар успешно установлен")
        return True
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка установки аватара: {e}")
        log_action(session_name, f"Ошибка установки аватара: {e}")
        return False


async def connect_and_auth(client, session_name):
    """Подключение и авторизация клиента"""
     # Пробуем альтернативные DNS-серверы
    os.environ['RES_OPTIONS'] = 'rotate timeout:1 attempts:1'
    os.environ['RESOLV_CONF'] = '/etc/resolv.conf.google'
    try:
        if not client.is_connected():
            await client.connect()

        if not await client.is_user_authorized():
            await client.start()
            logger.info(f"[{session_name}] Авторизация успешно завершена")
            log_action(session_name, "Авторизация успешно завершена")

        # Устанавливаем статус "в сети"
        await client(UpdateStatusRequest(offline=False))
        log_action(session_name, "Статус установлен: В сети")
        return True
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка подключения/авторизации: {e}")
        log_action(session_name, f"Ошибка подключения/авторизации: {e}")
        return False


async def disconnect_client(client, session_name):
    """Отключение клиента без закрытия сессии"""
    try:
        # Устанавливаем статус "не в сети"
        await client(UpdateStatusRequest(offline=True))
        log_action(session_name, "Статус установлен: Не в сети")

        if client.is_connected():
            await client.disconnect()
        logger.info(f"[{session_name}] Клиент отключен (без закрытия сессии)")
        log_action(session_name, "Клиент отключен (без закрытия сессии)")
        return True
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка отключения: {e}")
        log_action(session_name, f"Ошибка отключения: {e}")
        return False


async def wait_with_random_online(client, session_name, total_seconds):
    """Ожидание со случайными периодами онлайн"""
    logger.info(f"[{session_name}] Начинаем период ожидания {total_seconds} секунд со случайными онлайн-сессиями")
    start_time = time.time()
    elapsed = 0

    while elapsed < total_seconds:
        # Случайная задержка перед следующим онлайн-сеансом
        next_online_delay = random.randint(60 * 60, 8 * 60 * 60)  # 1-8 часов
        if elapsed + next_online_delay > total_seconds:
            next_online_delay = total_seconds - elapsed

        logger.info(f"[{session_name}] Ожидаем {next_online_delay} сек до следующего онлайн-сеанса")
        await asyncio.sleep(next_online_delay)
        elapsed = time.time() - start_time

        if elapsed >= total_seconds:
            break

        # Подключаемся и устанавливаем онлайн
        if not await connect_and_auth(client, session_name):
            continue

        # Случайная продолжительность онлайн-сеанса (10-60 минут)
        online_duration = random.randint(10 * 60, 60 * 60)
        logger.info(f"[{session_name}] Онлайн-сеанс начат, продолжительность: {online_duration} сек")

        # Ждем указанное время в онлайн-статусе
        await asyncio.sleep(online_duration)
        elapsed = time.time() - start_time

        # Отключаемся
        await disconnect_client(client, session_name)
        logger.info(f"[{session_name}] Онлайн-сеанс завершен, прошло времени: {elapsed:.1f}/{total_seconds} сек")

    logger.info(f"[{session_name}] Период ожидания завершен")


async def day_one_actions(client, session_name, female_names, female_surnames):
    """Действия для первого дня: авторизация, имя, фамилия, аватар, 2FA"""
    try:
        # Подключаемся и авторизуемся
        if not await connect_and_auth(client, session_name):
            return

        # Установка имени и фамилии
        await wait_and_log(random.randint(30, 120), "Перед установкой имени", session_name)

        new_name = random.choice(female_names) if female_names else "Анастасия"
        new_surname = random.choice(female_surnames) if female_surnames else "Иванова"
        await client(UpdateProfileRequest(first_name=new_name, last_name=new_surname))
        logger.info(f"[{session_name}] Имя изменено на {new_name} {new_surname}")
        log_action(session_name, f"Имя изменено на {new_name} {new_surname}")

        # Установка аватара
        await wait_and_log(random.randint(60, 180), "Перед установкой аватара", session_name)
        await set_avatar(client, session_name)

        # Включение 2FA
        await wait_and_log(random.randint(120, 300), "Перед включением 2FA", session_name)
        from telethon.tl.functions.account import GetPasswordRequest
        pwd = await client(GetPasswordRequest())
        if not pwd.has_password:
            try:
                await client.edit_2fa(new_password='StrongPassword123!')
                logger.info(f"[{session_name}] 2FA успешно включена")
                log_action(session_name, "2FA успешно включена")
            except Exception as e:
                logger.error(f"[{session_name}] Ошибка включения 2FA: {e}")
                log_action(session_name, f"Ошибка включения 2FA: {e}")

        # В конце дня отключаемся
        await disconnect_client(client, session_name)
        log_action(session_name, "День 1 завершен")
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка в день 1: {e}")
        log_action(session_name, f"Ошибка в день 1: {e}")
        await disconnect_client(client, session_name)


async def day_two_actions(client, session_name):
    """Действия для второго дня: username, о себе, код-пароль"""
    try:
        # Подключаемся и авторизуемся
        if not await connect_and_auth(client, session_name):
            return


        # Установка username
        await wait_and_log(random.randint(30, 120), "Перед установкой username", session_name)

        # Получаем текущее имя и фамилию пользователя
        me = await client.get_me()
        first_name = me.first_name or ""
        last_name = me.last_name or ""

        # Функция для транслитерации кириллицы в латиницу
        def translit(text):
            translit_dict = {
                'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd', 'е': 'e', 'ё': 'yo',
                'ж': 'zh', 'з': 'z', 'и': 'i', 'й': 'y', 'к': 'k', 'л': 'l', 'м': 'm',
                'н': 'n', 'о': 'o', 'п': 'p', 'р': 'r', 'с': 's', 'т': 't', 'у': 'u',
                'ф': 'f', 'х': 'h', 'ц': 'ts', 'ч': 'ch', 'ш': 'sh', 'щ': 'sch', 'ъ': '',
                'ы': 'y', 'ь': '', 'э': 'e', 'ю': 'yu', 'я': 'ya'
            }
            result = []
            for char in text.lower():
                if char in translit_dict:
                    result.append(translit_dict[char])
                elif char.isalnum():
                    result.append(char)
            return ''.join(result)

        # Создаем базовый username из имени и фамилии
        base_username = translit(f"{first_name}_{last_name}".replace(" ", "_")).lower()
        base_username = ''.join(c for c in base_username if c.isalnum() or c == '_')

        # Пытаемся установить username с разными суффиксами
        max_attempts = 7
        username_set = False

        for attempt in range(max_attempts):
            if attempt == 0:
                # Первая попытка - только имя и фамилия
                username = base_username
            else:
                # Последующие попытки - добавляем случайные цифры
                username = f"{base_username}_{random.randint(1, 9999)}"

            try:
                await client(UpdateUsernameRequest(username))
                logger.info(f"[{session_name}] Username установлен: {username}")
                log_action(session_name, f"Username установлен: {username}")
                username_set = True
                break
            except errors.UsernameOccupiedError:
                logger.warning(f"[{session_name}] Username {username} уже занят (попытка {attempt + 1}/{max_attempts})")
                await asyncio.sleep(2)  # Небольшая пауза между попытками

        if not username_set:
            # Если все попытки с именем+фамилией провалились, генерируем полностью случайный
            username = f"user_{random.randint(100000, 999999)}"
            try:
                await client(UpdateUsernameRequest(username))
                logger.info(f"[{session_name}] Установлен случайный username: {username}")
                log_action(session_name, f"Установлен случайный username: {username}")
            except errors.UsernameOccupiedError:
                logger.warning(f"[{session_name}] Не удалось установить username после {max_attempts + 1} попыток")
                log_action(session_name, "Не удалось установить username")

        # Установка "О себе"
        await wait_and_log(random.randint(60, 180), "Перед установкой 'О себе'", session_name)
        about_texts = load_names_from_file(ABOUT_TEXTS_FILE)
        about = random.choice(about_texts) if about_texts else "Привет! Я новичок в Telegram"
        await client(UpdateProfileRequest(about=about))
        logger.info(f"[{session_name}] 'О себе' установлено: {about}")
        log_action(session_name, f"'О себе' установлено: {about}")

        # Установка кода-пароля через UpdatePasswordSettingsRequest
        await wait_and_log(random.randint(120, 300), "Перед установкой кода-пароля", session_name)
        try:
            from telethon.tl.functions.account import UpdatePasswordSettingsRequest
            from telethon.tl.types import PasswordInputSettings
            from telethon.tl.types import InputCheckPasswordEmpty

            # Создаем настройки пароля
            password_settings = PasswordInputSettings(
                new_algo=None,  # Автоматически выберется подходящий алгоритм
                new_password_hash=None,  # Не требуется, так как мы устанавливаем новый пароль
                hint="Мой пароль",  # Подсказка для пароля
                email=None,  # Можно указать email для восстановления
                new_secure_settings=None  # Дополнительные настройки безопасности
            )

            # Устанавливаем новый пароль (используем InputCheckPasswordEmpty так как пароль еще не установлен)
            result = await client(UpdatePasswordSettingsRequest(
                password=InputCheckPasswordEmpty(),
                new_settings=password_settings
            ))

            if result:
                logger.info(f"[{session_name}] Код-пароль успешно установлен через UpdatePasswordSettingsRequest")
                log_action(session_name, "Код-пароль успешно установлен через UpdatePasswordSettingsRequest")
            else:
                logger.error(f"[{session_name}] Не удалось установить код-пароль")
                log_action(session_name, "Не удалось установить код-пароль")

        except Exception as e:
            logger.error(f"[{session_name}] Ошибка установки кода-пароля через UpdatePasswordSettingsRequest: {e}")
            log_action(session_name, f"Ошибка установки кода-пароля: {e}")

        # В конце дня отключаемся
        await disconnect_client(client, session_name)
        log_action(session_name, "День 2 завершен")
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка в день 2: {e}")
        log_action(session_name, f"Ошибка в день 2: {e}")
        await disconnect_client(client, session_name)


async def day_three_actions(client, session_name):
    """Действия для третьего дня: убираем время захода, подписка, просмотр постов, реакции"""
    try:
        # Подключаемся и авторизуемся
        if not await connect_and_auth(client, session_name):
            return
        await wait_and_log(random.randint(30, 120), "Перед скрытием времени захода", session_name)
        await client(SetPrivacyRequest(
            key=telethon.tl.types.InputPrivacyKeyStatusTimestamp(),
            rules=[telethon.tl.types.InputPrivacyValueDisallowAll()]))

        logger.info(f"[{session_name}] Время последнего захода скрыто")
        log_action(session_name, "Время последнего захода скрыто")

        # Подписка на канал миллионник
        await wait_and_log(random.randint(60, 180), "Перед подпиской на канал", session_name)
        try:
            entity = await get_channel_entity(client, MILLION_CHANNEL)
            try:
                await client(JoinChannelRequest(entity))
                logger.info(f"[{session_name}] Подписан на канал {MILLION_CHANNEL}")
                log_action(session_name, f"Подписан на канал {MILLION_CHANNEL}")
            except UserAlreadyParticipantError:
                logger.info(f"[{session_name}] Уже подписан на канал {MILLION_CHANNEL}")
                log_action(session_name, f"Уже подписан на канал {MILLION_CHANNEL}")
        except Exception as e:
            logger.error(f"[{session_name}] Ошибка подписки на канал: {e}")
            log_action(session_name, f"Ошибка подписки на канал: {e}")

        # Просмотр постов и реакции
        await wait_and_log(random.randint(120, 300), "Перед просмотром постов", session_name)
        try:
            entity = await get_channel_entity(client, MILLION_CHANNEL)
            posts = await client.get_messages(entity, limit=2)

            for i, post in enumerate(posts):
                await wait_and_log(random.randint(10, 30), f"Перед просмотром поста {i + 1}", session_name)
                await client(GetMessagesViewsRequest(peer=entity, id=[post.id], increment=True))
                logger.info(f"[{session_name}] Просмотрен пост {post.id}")
                log_action(session_name, f"Просмотрен пост {post.id}")

                if i == 0:  # Реакцию ставим только на первый пост
                    await wait_and_log(random.randint(5, 15), "Перед установкой реакции", session_name)
                    reaction = ReactionEmoji(emoticon=random.choice(["👍", "❤️", "🔥", "👏"]))
                    await client(SendReactionRequest(peer=entity, msg_id=post.id, reaction=[reaction]))
                    logger.info(f"[{session_name}] Установлена реакция на пост {post.id}")
                    log_action(session_name, f"Установлена реакция на пост {post.id}")

        except Exception as e:
            logger.error(f"[{session_name}] Ошибка работы с постами: {e}")
            log_action(session_name, f"Ошибка работы с постами: {e}")

        # В конце дня отключаемся
        await disconnect_client(client, session_name)
        log_action(session_name, "День 3 завершен")
    except Exception as e:
        logger.error(f"[{session_name}] Ошибка в день 3: {e}")
        log_action(session_name, f"Ошибка в день 3: {e}")
        await disconnect_client(client, session_name)


async def process_account(session_file, proxy_line, female_names, female_surnames):
    proxy = proxy_tuple_from_str(proxy_line)
    client_params = load_client_params(session_file)
    client = TelegramClient(session_file, API_ID, API_HASH, proxy=proxy, **client_params)
    session_name = os.path.basename(session_file)

    try:
        # День 1
        logger.info(f"[{session_name}] Начинаем День 1")
        log_action(session_name, f"Начинаем День 1")
        await day_one_actions(client, session_name, female_names, female_surnames)

        # Ждем до следующего дня (минимум 24 часа) со случайными онлайн-сессиями
        logger.info(f"[{session_name}] Ожидание перед Днем 2")
        log_action(session_name, f"Ожидание перед Днем 2")
        await wait_with_random_online(client, session_name, 24 * 60 * 60)

        # День 2
        logger.info(f"[{session_name}] Начинаем День 2")
        log_action(session_name, f"Начинаем День 2")
        await day_two_actions(client, session_name)

        # Ждем до следующего дня (минимум 24 часа) со случайными онлайн-сессиями
        logger.info(f"[{session_name}] Ожидание перед Днем 3")
        log_action(session_name, f"Ожидание перед Днем 3")
        await wait_with_random_online(client, session_name, 24 * 60 * 60)

        # День 3
        logger.info(f"[{session_name}] Начинаем День 3")
        log_action(session_name, f"Начинаем День 2")
        await day_three_actions(client, session_name)

    except Exception as e:
        logger.error(f"[{session_name}] Критическая ошибка: {e}")
        log_action(session_name, f"Критическая ошибка: {e}")
    finally:
        # Полное отключение в конце всех дней
        try:
            if client.is_connected():
                await client.disconnect()
            logger.info(f"[{session_name}] Полное отключение клиента")
        except:
            pass


async def main():
    sessions = [os.path.join(SESSIONS_DIR, f) for f in os.listdir(SESSIONS_DIR) if f.endswith(".session")]
    proxies = load_proxies()
    female_names = load_names_from_file(FEMALE_NAMES_FILE)
    female_surnames = load_names_from_file(FEMALE_SURNAMES_FILE)

    if not sessions:
        logger.error("Сессий не найдено! Выход.")
        return
    if not proxies:
        logger.error("Прокси не найдены! Выход.")
        return
    if not female_names:
        logger.warning("Список имён пустой.")
    if not female_surnames:
        logger.warning("Список фамилий пустой.")

    logger.info(f"Запускаем прогрев на {len(sessions)} сессиях и {len(proxies)} прокси")

    tasks = []
    for i, session_file in enumerate(sessions):
        proxy_line = proxies[i % len(proxies)]
        task = asyncio.create_task(process_account(session_file, proxy_line, female_names, female_surnames))
        tasks.append(task)
        await asyncio.sleep(random.uniform(5, 15))  # Задержка между запуском аккаунтов

    await asyncio.gather(*tasks)


if __name__ == "__main__":
    import telethon
    import sys
    import traceback

    asyncio.run(main())