USER
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.DEBUG, 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': False # Лучше разрешить 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-серверы
logger.info(f"[{session_name}] Пробую выполнить авторизацию")
try:
logger.info(f"[{session_name}] Авторизация успешно завершена")
log_action(session_name, "Авторизация успешно завершена")
# Устанавливаем статус "в сети"
await client(UpdateStatusRequest(offline=False))
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 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):
logger.info(f"[{session_name}] Не прошел проверку в первом дне в функции connect_and_auth")
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,use_ipv6=True, **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())
Почему я получаю "JSON файл не найден: 7090492991.json"