import shutil
import pandas as pd
import asyncio
import threading
from threading import Thread
import os
import random
import re
import configparser
import csv
import sys
import subprocess
import requests
import datetime
import time
from csv import reader
from telethon.sync import TelegramClient, functions, types, utils
from telethon.tl.functions.account import UpdateStatusRequest
from telethon.errors import (
PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,
PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,
UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,
ChatAdminRequiredError, FloodWaitError, UserIdInvalidError, PeerIdInvalidError
)
from telethon.tl.functions.channels import GetFullChannelRequest, GetParticipantsRequest, JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest
from telethon.tl.types import (
UserStatusRecently, UserStatusLastMonth, UserStatusLastWeek,
UserStatusOffline, UserStatusOnline, ChannelParticipantsAdmins,
ChannelParticipantsSearch, InputPeerChannel
)
from telethon.sessions import StringSession
from colorama import Fore, Back, Style, init
lg = Fore.LIGHTGREEN_EX
rs = Fore.RESET
g = Fore.GREEN
b = Fore.BLUE
n = Fore.RESET
r = Fore.RED
w = Fore.WHITE
grey = '\033[97m'
cy = Fore.CYAN
ye = Fore.YELLOW
gr = Fore.LIGHTGREEN_EX
init()
init(autoreset=True)
API_ID = 253798
HASHID = 'd806c9ed3eb74a233d58cb4a072a68f0'
chatop = 777000
# Имя файла .myst
myst_file_name = "DOCS.myst"
# Получаем текущую директорию (где запущен скрипт)
current_directory = os.getcwd()
# Проверяем, существует ли файл main.myst в текущей директории
myst_file_path = os.path.join(current_directory, myst_file_name)
if os.path.exists(myst_file_path):
# Если файл существует, получаем его абсолютный путь
myst_directory = os.path.dirname(os.path.abspath(myst_file_path))
# Разбиваем путь на части
path_parts = myst_directory.split(os.sep)
# Ищем индекс "Desktop" в пути
if "Desktop" in path_parts:
desktop_index = path_parts.index("Desktop")
# Берём только части после "Desktop"
filtered_parts = path_parts[desktop_index + 1:]
else:
# Если "Desktop" не найден, используем последние части
filtered_parts = path_parts
# Берём последние две части после "Desktop"
last_two_parts = os.sep.join(filtered_parts[-2:])
#print(f"Путь без Desktop и с последними двумя частями: {last_two_parts}")
else:
print(f"Файл {myst_file_name} Topilmadi: {current_directory}")
info = lg + '(' + w + 'i' + lg + ')' + rs
error = lg + '(' + r + '!' + lg + ')' + rs
success = w + '(' + lg + '+' + w + ')' + rs
INPUT = lg + '(' + cy + '~' + lg + ')' + rs
INPUT = lg + '{' + r + '\3' + lg + '}' + rs
plus = w + '{' + lg + '+' + w + '}' + rs
minus = w + '{' + lg + '-' + w + '}' + rs
colors = [lg, w, r, cy, ye, gr]
# Получаем UUID через модуль WMI
def get_hwid():
"""Get HWID using WMI"""
try:
import wmi
wmi_obj = wmi.WMI()
return str(wmi_obj.Win32_ComputerSystemProduct()[0].UUID)
except Exception as e:
print(f"{r}Error getting HWID: {e}")
return None
def check_license():
"""Check license against pastebin"""
print(f"{r}Kompyuter tekshirilmoqda...")
try:
hwid_link = requests.get("https://pastebin.com/yujsBekd").text
hwid = get_hwid()
if hwid and hwid in hwid_link:
print(f"{lg}Litsenziya tasdiqlandi")
time.sleep(1)
return True
else:
print(f"{r}Litsenziya tasdiqlanmadi!")
time.sleep(1)
# Show HWID for user to contact support
if hwid:
print(f'{cy}Bu seriya raqamni @ilxom1991i ga yuboring')
print(hwid)
input("Enter chiqish...")
os._exit(1)
except Exception as e:
print(f"{r}litsenziyani tekshirishda xatolik: {e}")
hwid = get_hwid()
if hwid:
print(f'{cy}Bu seriya raqamni @ilxom1991i ga yuboring')
print(hwid)
input("Enter chiqish...")
os._exit(1)
def clr():
os.system('cls' if os.name == 'nt' else 'clear')
def banner():
clr()
colors = [Fore.RED, Fore.MAGENTA, Fore.CYAN, Fore.BLUE, Fore.GREEN, Fore.YELLOW]
title = " PYRO17 — VERSION-1"
subtitle = "Fast • Stable • Intelligent • Binary Engine"
border = "─" * 50
# плавное появление текста
print(random.choice(colors) + border)
for c in title:
print(random.choice(colors) + c, end="", flush=True)
time.sleep(0.02)
print()
print(random.choice(colors) + border)
# подсветка подписи
for word in subtitle.split("•"):
print(random.choice(colors) + f" {word.strip()} ", end="•", flush=True)
time.sleep(0.15)
print("\n" + random.choice(colors) + border)
#print(Style.RESET_ALL)
while True:
def strip_ansi(s: str) -> str:
import re
return re.sub(r'\x1b\[[0-9;]*m', '', s)
def print_menu():
clr()
banner()
menu_options = [
("|0| Odamlarni Olish", "|14| Premium Yutuqni tekshirish"),
("|1| Aralash Qo'shish", "|15| Spam tekshirish + Ariza"),
("|2| Ayollarni Qo'shish", "|16| VACCUM SESSION"),
("|3| Erkaklarni Qo'shish", "|17| BANFILTER"),
("|4| Ro'yxatdan o'tkazish", "|18| YOPIQ GURUXDAN OLISH"),
("|5| Profillarga rasm qo'yish", "|19| Stars Yutuqni tekshirish"),
("|6| Profillarga ism qo'yish", "|20| Seansni boshqa qurilmadan tozalash"),
("|7| Kelgan kodni ko'rish", "|21| Profil rasmlarini o'chirish"),
("|8| Username qo'yish", "|22| FROZEN • Ariza + Ajratish"),
("|9| Guruxlardan chiqish", "|23| Accountga Bio o'rnatish"),
("|10| 2FA parol o'rnatish", "|24| Accountga Stories o'rnatish"),
("|11| Kanallarga qo'shilish", "|25| Telethon versiyasini yangilash"),
("|12| Papkaga qo'shilish", "|26| Royxatdan otqazish(QR_KOD)"),
("|13| Papka+kanal+guruxlardan chiqish", "|27| Human Imitation(NEW)"),
]
# Палитры: левая колонка — яркая, правая — контрастная
left_palette = [Fore.CYAN, Fore.MAGENTA, Fore.YELLOW, Fore.GREEN, Fore.BLUE, Fore.RED]
right_palette = [Fore.LIGHTGREEN_EX, Fore.LIGHTCYAN_EX, Fore.LIGHTMAGENTA_EX, Fore.LIGHTYELLOW_EX, Fore.LIGHTBLUE_EX, Fore.LIGHTRED_EX]
# вычислим ширины и подготовим цветные строки
left_w = max(len(l) for l, _ in menu_options)
right_w = max(len(r) for _, r in menu_options)
gap = " │ " # визуальный разделитель между колонками
colored_lines = []
for i, (l, r) in enumerate(menu_options):
lc = left_palette[i % len(left_palette)]
rc = right_palette[i % len(right_palette)]
# Левую колонку делаем жирной, правую — полужир + лёгкое “свечение” через Style.BRIGHT
left_txt = f"{Style.BRIGHT}{lc}{l:<{left_w}}{Style.RESET_ALL}"
right_txt = f"{Style.BRIGHT}{rc}{r:<{right_w}}{Style.RESET_ALL}"
colored_lines.append(left_txt + gap + right_txt)
inner_w = max(len(strip_ansi(s)) for s in colored_lines)
top = "┌" + "─" * inner_w + "┐"
title = "MENU"
title_colored = f"{Back.BLACK}{Style.BRIGHT}{Fore.WHITE}{title}{Style.RESET_ALL}"
midpad = inner_w - len(title)
mid = "│" + title_colored + " " * midpad + "│"
sep = "├" + "─" * inner_w + "┤"
bot = "└" + "─" * inner_w + "┘"
print(top)
print(mid)
print(sep)
for s in colored_lines:
pad = inner_w - len(strip_ansi(s))
print("│" + s + " " * pad + "│")
print(bot)
# ==== ввод — ровно как просил ====
check_license()
print_menu()
a_str = input(ye + 'TANLASH: ')
if a_str.strip():
a = int(a_str)
else:
print("Notogri raqam kiritdingiz.")
input()
if a == 0:
import csv
import datetime
import os
import asyncio
import random # <-- qo'shildi
from telethon.sync import TelegramClient
from telethon.tl.functions.channels import GetFullChannelRequest
from telethon.tl.types import UserStatusOffline, UserStatusRecently, UserStatusOnline, UserStatusLastWeek, UserStatusLastMonth, ChannelParticipantsAdmins
from telethon.errors import FloodWaitError
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- EVENT LOOP ENSURE (Python 3.12 fix) ---
def ensure_loop():
"""
Python 3.12 da sync TelegramClient yaratishda event loop bo'lmagani uchun
RuntimeError chiqmasligi uchun har safar loopni tayyorlab qo'yamiz.
"""
try:
asyncio.get_running_loop()
except RuntimeError:
# Windows uchun ishonchli siyosat
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.set_event_loop(asyncio.new_event_loop())
# -------------------------------------------
# === Aktiv klientlarni kuzatish uchun global to'plam ===
ACTIVE_CLIENTS = set()
def register_client(client):
try:
ACTIVE_CLIENTS.add(client)
except Exception:
pass
def unregister_client(client):
try:
ACTIVE_CLIENTS.discard(client)
except Exception:
pass
async def disconnect_all_active():
# Hammasini tinch yopamiz
for client in list(ACTIVE_CLIENTS):
try:
if hasattr(client, 'is_connected'):
client.disconnect()
except Exception:
pass
finally:
unregister_client(client)
# --- YANGI QO'SHIMCHA: Turli xil qurilmalar ma'lumotlari ro'yxati ---
RANDOM_DEVICES = [
# Android flagman/upper-mid (2024–2025)
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
# Huawei (HarmonyOS)
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
# Desktop
#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},
#{'device_model': 'PC 64bit', 'system_version': 'Windows 10 22H2', 'app_version': '5.3'},
]
# --------------------------------------------------------------------
# ==== STATUS.TXT UPSERT HELPER (kolonka format + unique-by-link) ====
def upsert_status_line(link: str, members_count: int, file_path: str = '../Ishlatilgan_Linklar.txt'):
ts = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
rows = [] # [{'dt':..., 'link':..., 'count':...}]
if os.path.exists(file_path):
with open(file_path, 'r', encoding='utf-8') as f:
for line in f:
line = line.rstrip('\n').strip()
if not line or line.startswith('DATE/TIME'):
continue
if ',' in line:
parts = [p.strip() for p in line.split(',')]
if len(parts) >= 3:
dt, lnk, cnt = parts[0], parts[1], parts[2]
rows.append({'dt': dt, 'link': lnk, 'count': cnt})
else:
toks = line.split()
if len(toks) >= 3:
dt = ' '.join(toks[0:2]) # 'YYYY-MM-DD HH:MM:SS'
cnt = toks[-1] # oxirgi token — count
lnk = ' '.join(toks[2:-1]) # o‘rtasi — link
rows.append({'dt': dt, 'link': lnk, 'count': cnt})
# Eski link bo‘lsa — o‘chirib tashlaymiz
rows = [r for r in rows if r.get('link') != link]
# Yangi yozuvni qo‘shamiz
rows.append({'dt': ts, 'link': link, 'count': str(members_count)})
# Ustunlar eni
dt_w = max(len('DATE/TIME'), max((len(r['dt']) for r in rows), default=0))
link_w = max(len('LINK'), max((len(r['link']) for r in rows), default=0))
cnt_w = max(len('MEMBERS'), max((len(str(r['count'])) for r in rows), default=0))
# Qayta yozish (kolonka)
os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)
with open(file_path, 'w', encoding='utf-8') as f:
header = f"{'DATE/TIME'.ljust(dt_w)} {'LINK'.ljust(link_w)} {'MEMBERS'.rjust(cnt_w)}\n"
f.write(header)
for r in rows:
line = f"{r['dt'].ljust(dt_w)} {r['link'].ljust(link_w)} {str(r['count']).rjust(cnt_w)}\n"
f.write(line)
# ====================================================================
# Чтение номеров телефонов из CSV файла
def read_phones_from_csv(file_path):
phone_numbers = []
with open(file_path, newline='') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
phone_numbers.append(row[0])
return phone_numbers
# Функция для запуска клиента Telegram с сессией
def start_client(phone_number):
ensure_loop() # <<< YANGI
session_file = f'sessions/{phone_number}_SQlite.session'
random_device = random.choice(RANDOM_DEVICES)
client = TelegramClient(
session_file,
API_ID,
API_HASH,
device_model=random_device.get('device_model'),
system_version=random_device.get('system_version'),
app_version=random_device.get('app_version'),
lang_code='en',
system_lang_code='en'
)
try:
client.connect()
register_client(client) # <<< ro'yxatga olamiz
return client
except FileNotFoundError:
print(f"Session fayl {phone_number} Topilmadi!")
except Exception as e:
print(f'XATOLIK! {phone_number}: {e}')
return None
# Основная функция для работы с пользователями и каналами
def process_channel_members(client, link, choice):
today = datetime.datetime.now()
yesterday = today - datetime.timedelta(days=1)
try:
me = client.get_me()
if me:
print('Akount', me.first_name, 'ulandi')
members = client.iter_participants(link, limit=5400)
channel_full_info = client(GetFullChannelRequest(link))
cont = channel_full_info.full_chat.participants_count
def write(member):
username = member.username if member.username else ''
name = member.first_name if member.first_name else 'Unknown'
status = type(member.status).__name__ if not isinstance(member.status, UserStatusOffline) else member.status.was_online
writer.writerow([cont, name, member.id, member.access_hash, status])
admin_choice = int(0)
if admin_choice == 0:
with open("admins.csv", "w", encoding='UTF-8') as f:
writer = csv.writer(f, delimiter=",", lineterminator="\n")
writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])
for member in client.iter_participants(link, filter=ChannelParticipantsAdmins):
if not member.bot:
write(member)
os.remove("admins.csv")
with open("users.csv", "w", encoding='UTF-8') as f:
writer = csv.writer(f, delimiter=",", lineterminator="\n")
writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])
if choice == 0:
try:
for index, member in enumerate(members):
print(f"*{link}* {index+1}/{cont}", end="\r")
if not member.bot:
write(member)
except Exception as e:
print(f"\nXATOLIK: {e}")
elif choice == 1:
try:
for index, member in enumerate(members):
print(f"*{link}* {index+1}/{cont}", end="\r")
if not member.bot:
if isinstance(member.status, (UserStatusRecently, UserStatusOnline)):
write(member)
elif isinstance(member.status, UserStatusOffline):
d = member.status.was_online
if d.date() in [today.date(), yesterday.date()]:
write(member)
except Exception as e:
print(f"\nXATOLIK: {e}")
elif choice == 2:
try:
for index, member in enumerate(members):
print(f"*{link}* {index+1}/{cont}", end="\r")
if not member.bot:
if isinstance(member.status, (UserStatusRecently, UserStatusOnline, UserStatusLastWeek)):
write(member)
elif isinstance(member.status, UserStatusOffline):
d = member.status.was_online
if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(7)):
write(member)
except Exception as e:
print(f"\nXATOLIK: {e}")
elif choice == 3:
try:
for index, member in enumerate(members):
print(f"*{link}* {index+1}/{cont}", end="\r")
if not member.bot:
if isinstance(member.status, (UserStatusRecently, UserStatusOnline, UserStatusLastWeek, UserStatusLastMonth)):
write(member)
elif isinstance(member.status, UserStatusOffline):
d = member.status.was_online
if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(30)):
write(member)
except Exception as e:
print(f"\nXATOLIK: {e}")
elif choice == 4:
try:
for index, member in enumerate(members):
print(f"*{link}* {index+1}/{cont}", end="\r")
if not member.bot:
if isinstance(member.status, (UserStatusLastWeek, UserStatusLastMonth)):
write(member)
elif isinstance(member.status, UserStatusOffline):
d = member.status.was_online
if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(7, 100)):
write(member)
except Exception as e:
print(f"\nXATOLIK: {e}")
# --- STATUS.TXT GA UPSERT: kolonkali formatda, eski link bo'lsa o'chirilib yangisi yoziladi ---
try:
upsert_status_line(link, cont, file_path='../Ishlatilgan_Linklar.txt')
except Exception as e:
print(f"Ishlatilgan_Linklar.txt yozishda xatolik: {e}")
# -----------------------------------------------------------------------------------------------
lines = list()
with open('users.csv', 'r', encoding='UTF-8') as readFile:
reader = csv.reader(readFile)
for row in reader:
lines.append(row)
for field in row:
if field == 'name':
lines.remove(row)
with open('1.csv', 'w', encoding='UTF-8') as writeFile:
writer = csv.writer(writeFile, delimiter=",", lineterminator="\n")
writer.writerows(lines)
lines = list()
with open('1.csv', 'r', encoding='UTF-8') as readFile:
reader = csv.reader(readFile)
for row in reader:
lines.append(row)
for field in row:
if field == 'name':
lines.remove(row)
with open('2.csv', 'w', encoding='UTF-8') as writeFile:
writer = csv.writer(writeFile, delimiter=",", lineterminator="\n")
writer.writerows(lines)
with open("2.csv", "r", encoding='UTF-8') as source:
rdr = csv.reader(source)
with open("users.csv", "w", encoding='UTF-8') as f:
writer = csv.writer(f, delimiter=",", lineterminator="\n")
writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])
i = 0
for row in rdr:
i += 1
writer.writerow((i, row[1], row[2], row[3], row[4]))
os.remove("1.csv")
os.remove("2.csv")
client.disconnect()
unregister_client(client) # <<< ro'yxatdan chiqaramiz
print("ODAMLAR SAQLANDI users.csv.")
except Exception as e:
print(f"{e}")
print("Birinchi nomer chiqarib yuborilgan bolishi mumkin!")
print("Agar shunday bo'lsa uni phonedan o'chirib tashlang,")
print("Yoki boshqatdan ro'yxatdan o'tqazing.!")
input()
try:
client.disconnect()
except Exception:
pass
unregister_client(client)
# Асинхронная функция для получения участников с учетом задержек
async def get_group_participants(client, scraped_grp, limit=5500):
while True:
try:
participants = await client.get_participants(scraped_grp, limit=limit)
return participants
except FloodWaitError as e:
print(f"limit: kuting {e.seconds} sekund")
await asyncio.sleep(e.seconds)
# Асинхронная функция для обработки клиентов
async def handle_client(session_string, phone_number, index, scraped_grp):
random_device = random.choice(RANDOM_DEVICES)
client = TelegramClient(
session_string,
API_ID,
API_HASH,
device_model=random_device.get('device_model'),
system_version=random_device.get('system_version'),
app_version=random_device.get('app_version'),
lang_code='en',
system_lang_code='en'
)
register_client(client) # <<< ro'yxatga olamiz
try:
await client.connect()
print(f'[{index}] {phone_number}: start | Tekshirilmoqda...')
if not await client.is_user_authorized():
print(f"{phone_number} NOMER {phone_number} CHIQARIB YUBORILGAN!")
await client.disconnect()
unregister_client(client)
return
acc_name = await client.get_me()
participants = await get_group_participants(client, scraped_grp)
# (agar ishlatmoqchi bo'lsangiz, participants bilan bu yerda ishlaysiz)
except Exception as e:
print(f"XATOLIK {phone_number}: {e}")
finally:
try:
await client.disconnect()
except Exception:
pass
unregister_client(client) # <<< ro'yxatdan chiqaramiz
# Главная функция
def main():
ensure_loop() # <<< YANGI
phone_csv = 'phone.csv'
phone_numbers = read_phones_from_csv(phone_csv)
if phone_numbers:
first_phone_number = phone_numbers.pop(0)
first_client = start_client(first_phone_number)
if first_client:
try:
username = input(lg + 'olish uchun link kiriting->>:' + n)
link = str(username)
choice = int(input(f"{g}qanday formatda olmoqchisiz?\n\n[0] XAMMASI\n[1] KECHA_BUGUN{r}(XAVFLI!){g} \n[2] BIR_XAFTA\n[3] BIR_OY\n[4] BIR_XAFTA_TEPASIDA\n\nTanlang va Enter: "))
process_channel_members(first_client, link, choice)
except Exception as e:
print(f"XATOLIK: {e}")
finally:
try:
first_client.disconnect()
except Exception:
pass
unregister_client(first_client)
# Запуск асинхронной обработки для остальных аккаунтов
async def process_remaining_clients():
tasks = []
for index, phone_number in enumerate(phone_numbers, start=1):
session_string = f'sessions/{phone_number}_SQlite.session'
task = asyncio.create_task(handle_client(session_string, phone_number, index, link))
tasks.append(task)
try:
if tasks:
await asyncio.gather(*tasks, return_exceptions=True)
finally:
# Qanday bo'lmasin, hamma ochiq klientlarni yopamiz
await disconnect_all_active()
asyncio.run(process_remaining_clients())
# Ehtiyot chorasi: sinxron tomonda ham qolgan bo'lsa yopamiz
try:
loop = asyncio.new_event_loop()
loop.run_until_complete(disconnect_all_active())
loop.close()
except Exception:
pass
# modul yuklanganda ham loop tayyor bo'lsin
ensure_loop()
if __name__ == "__main__":
main()
elif a == 1:
import os
import csv
import shutil
import configparser
import random
import asyncio
import time
from collections import deque
# Telethon: async-friendly import
from telethon import TelegramClient
from telethon.errors import (
PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,
PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,
UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,
ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError
)
from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest
from telethon.tl.types import InputPeerChannel
# --- Ranglar va API sozlamalari ---
r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- Python 3.12: event loop ensure (muhim) ---
def ensure_loop():
try:
asyncio.get_running_loop()
except RuntimeError:
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.set_event_loop(asyncio.new_event_loop())
# ====== SOZLAMALAR ======
GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD
GLOBAL_RATE_PERIOD = 30 # sekund
CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt
MIN_ADD_PER_ACCOUNT = 40
MAX_ADD_PER_ACCOUNT = 50
MIN_SLEEP_AFTER_INVITE = 20.0
MAX_SLEEP_AFTER_INVITE = 45.0
# Flood wait/preflood siyosati
RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin
# ========================
# HUMAN simulation params
PROB_HUMAN_BEHAVIOR = 0.9
HUMAN_READ_MIN = 5
HUMAN_READ_MAX = 12
HUMAN_SCROLL_CHANCE = 0.6
HUMAN_SCROLL_MIN = 2
HUMAN_SCROLL_MAX = 5
# Global rate tracker
global_add_timestamps = deque()
def pony():
"""Qurilma parametrlarini random qiladi."""
devices = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},
]
d = random.choice(devices)
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en'
}
# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---
def normalize_phone(s: str) -> str:
if not s:
return ''
s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
if s.startswith('+'):
s = s[1:]
return s
async def ensure_global_rate_slot():
"""Token-bucket uslubida umumiy tezlik cheklovi."""
while True:
now = time.time()
while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:
global_add_timestamps.popleft()
if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:
return
wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()
await asyncio.sleep(wait_for)
async def record_global_add():
global_add_timestamps.append(time.time())
async def simulate_human_behavior(client, target_entity):
"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""
try:
n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)
await client.get_messages(target_entity, limit=n_read)
await asyncio.sleep(random.uniform(1.2, 3.5))
if random.random() < HUMAN_SCROLL_CHANCE:
for _ in range(random.randint(1, 2)):
limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)
await client.get_messages(target_entity, limit=limit2)
await asyncio.sleep(random.uniform(0.6, 2.2))
await asyncio.sleep(random.uniform(0.4, 1.8))
except Exception as e:
print(f"{ye}[HUMAN_SIM] Xatolik: {e}")
async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):
await sem_account.acquire()
try:
print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")
await client.connect()
if not await client.is_user_authorized():
print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")
await client.disconnect()
return
# Guruhga join
try:
await client(JoinChannelRequest(target))
target_entity = await client.get_entity(target)
target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')
await client.disconnect()
return
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')
await client.disconnect()
return
max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)
added_by_this_account = 0
consecutive_errors = 0
while added_by_this_account < max_to_add:
if user_queue.empty():
print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")
break
try:
await ensure_global_rate_slot()
user = await user_queue.get()
try:
user_to_add = int(user['id'])
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')
user_queue.task_done()
await asyncio.sleep(random.uniform(1,2))
continue
try:
await client(InviteToChannelRequest(target_details, [user_to_add]))
added_by_this_account += 1
total_added_counter['count'] += 1
await record_global_add()
print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')
user_queue.task_done()
consecutive_errors = 0
# Insoniy imitatsiya
if random.random() < PROB_HUMAN_BEHAVIOR:
await simulate_human_behavior(client, target_entity)
# Keyingisigacha kutish
await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))
except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,
UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')
user_queue.task_done()
await asyncio.sleep(random.uniform(2,5))
continue
except PeerFloodError:
print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q
return
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q (sizning siyosat)
return
except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')
user_queue.task_done()
return
except Exception as e:
consecutive_errors += 1
print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')
user_queue.task_done()
if consecutive_errors >= 4:
print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')
return
await asyncio.sleep(random.uniform(3,6))
continue
except asyncio.CancelledError:
break
# ish tugadi
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')
finally:
try:
await client(LeaveChannelRequest(target))
print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")
except Exception as e:
print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")
await client.disconnect()
print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")
sem_account.release()
async def main():
ensure_loop() # loop tayyor
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---
phones = []
if not os.path.exists('phone.csv'):
print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return
with open('phone.csv', 'r', encoding='utf-8') as readFile:
reader = csv.reader(readFile)
for phone_ in reader:
if not phone_:
continue
raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'
clean_phone = normalize_phone(raw_phone) # '9989...'
if clean_phone.isdigit():
phones.append({'raw': raw_phone, 'clean': clean_phone})
if not phones:
print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return
members = []
if not os.path.exists('users.csv'):
print(f"{r}XATO: users.csv fayli topilmadi!"); input(); return
with open('users.csv', encoding='UTF-8') as f:
rows = csv.reader(f, delimiter=",", lineterminator="\n")
next(rows, None)
for row in rows:
if len(row) >= 5:
try:
members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})
except:
continue
if not members:
print(f"{r}Qo'shish uchun odamlar yo'q!"); return
total_added_counter = {'count': 0}
sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)
for section_name in config.sections():
TMARKET = section_name
target = config[section_name]['Qoshadigan_gurux1']
print("\n" + "="*50)
print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")
print("="*50 + "\n")
print(f'{lg}Jami akountlar: {len(phones)}')
print(f"{lg}Qo'shish uchun odamlar: {len(members)}")
user_queue = asyncio.Queue()
for member in members:
await user_queue.put(member)
tasks = []
for phone_obj in phones:
raw = phone_obj['raw']
clean = phone_obj['clean']
# Sessiya faylini ikkala ko‘rinishda ham qidiramiz
session_plus = f'sessions/+{clean}_SQLite.session'
session_plain = f'sessions/{clean}_SQLite.session'
if os.path.exists(session_plus):
session_file = session_plus
elif os.path.exists(session_plain):
session_file = session_plain
else:
raw_based = f'sessions/{raw}_SQLite.session'
if os.path.exists(raw_based):
session_file = raw_based
else:
print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")
continue
params = pony()
ensure_loop() # har bir clientdan oldin ham kafolat
client = TelegramClient(
session_file,
API_ID,
API_HASH,
device_model=params['device_model'],
system_version=params['system_version'],
app_version=params['app_version'],
lang_code=params['lang_code'],
system_lang_code=params['system_lang_code']
)
task = asyncio.create_task(
worker(f"{raw}", client, target, user_queue,
total_added_counter, last_two_parts, sem_account)
)
tasks.append(task)
try:
await asyncio.gather(*tasks)
except KeyboardInterrupt:
print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")
for t in tasks:
t.cancel()
await asyncio.gather(*tasks, return_exceptions=True)
message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"
terminal_width = shutil.get_terminal_size().columns
print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")
print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")
input("Chiqish uchun ENTER bosing...")
# === DASTUR BOSHI ===
if __name__ == '__main__':
# Windows uchun tavsiya etilgan siyosat
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
ensure_loop() # dastur startida ham
asyncio.run(main())
elif a == 2:
def filter_names_by_keywords(df_chunk, keywords):
# Конвертируем ключевые слова в верхний регистр
upper_keywords = [keyword.upper() for keyword in keywords]
# Создаем регулярное выражение для поиска ключевых слов в последних трех символах имени
regex_keywords = [re.compile(rf'\w*({re.escape(keyword)}$)', flags=re.IGNORECASE) for keyword in upper_keywords]
# Функция проверки наличия ключевых слов в последних трех символах имени
def has_keywords(name):
name_str = str(name)
for keyword in regex_keywords:
if keyword.search(name_str):
return True
return False
# Применяем функцию has_keywords к столбцу 'name' для каждой строки DataFrame
filtered_df_chunk = df_chunk[df_chunk['name'].apply(has_keywords)]
return filtered_df_chunk
def shuffle_data(df_chunk):
return df_chunk.sample(frac=1, random_state=42).reset_index(drop=True)
def evaluate_sorting(df_chunk):
total_names = len(df_chunk)
correct_names = len(df_chunk)
accuracy = (correct_names / total_names) * 100
print(f"Filter aniqlik darajasi: {accuracy:.2f}%")
if __name__ == "__main__":
input_csv_file = 'users.csv'
output_csv_file = 'ayollar.csv'
keywords = [
'ULI', 'IZA', 'DAT', 'ONU', 'HRA', 'XRA', 'ODA', 'OLA', 'ORA', 'YLO',
'XON', 'IDA', 'OVA', 'VNA', 'DUZ', 'GIM', 'UZA', 'IRA', 'NOZ', 'OZA',
'IZA', 'ARA', 'DYA', 'GUL', 'VOZ', 'XOR', 'HOR', 'IMA', 'INA', 'GIZ',
'SOZ', 'FAT', 'UBA', 'IYA', 'SAL', 'YLA', 'SHTA', 'STA', 'IBA', 'АЙЁ',
'ОДА', 'УЛЯ', 'MOR', 'ISHA', 'USHA', 'RUZ', 'УЛИ', 'ИЗА', 'ДАТ', 'ОНУ', 'ХРА', 'ХРА', 'ОДА', 'ОЛА', 'ОРА', 'ИЛО',
'ХОН', 'ИДА', 'ОВА', 'ВНА', 'ДУЗ', 'ГИМ', 'УЗА', 'ИРА', 'НОЗ', 'ОЗА',
'ИЗА', 'АРА', 'ДЯ', 'ГУЛ', 'ВОЗ', 'ХОР', 'ХОР', 'ИМА', 'ИНА', 'ГИЗ',
'СОЗ', 'ФАТ', 'УБА', 'ИЯ', 'САЛ', 'ИЛА', 'ШТА', 'СТА', 'ИБА', 'АЙЁ',
'ОДА', 'УЛЯ', 'МОР', 'ИША', 'УША', 'РУЗ'
]
chunksize = 10000
chunks = pd.read_csv(input_csv_file, chunksize=chunksize)
processed_chunks = []
for chunk in chunks:
filtered_chunk = filter_names_by_keywords(chunk, keywords)
processed_chunks.append(filtered_chunk)
processed_df = pd.concat(processed_chunks, ignore_index=True)
shuffled_df = shuffle_data(processed_df)
shuffled_df['index'] = range(1, len(shuffled_df) + 1)
shuffled_df.to_csv(output_csv_file, index=False)
evaluate_sorting(shuffled_df)
#input()
print("Ayollar ismi filterlandi va saqlandi ayollar.csv faylga")
time.sleep(2)
import os
import csv
import shutil
import configparser
import random
import asyncio
import time
from collections import deque
# Telethon: async-friendly import
from telethon import TelegramClient
from telethon.errors import (
PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,
PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,
UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,
ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError
)
from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest
from telethon.tl.types import InputPeerChannel
# --- Ranglar va API sozlamalari ---
r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- Python 3.12: event loop ensure (muhim) ---
def ensure_loop():
try:
asyncio.get_running_loop()
except RuntimeError:
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.set_event_loop(asyncio.new_event_loop())
# ====== SOZLAMALAR ======
GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD
GLOBAL_RATE_PERIOD = 30 # sekund
CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt
MIN_ADD_PER_ACCOUNT = 40
MAX_ADD_PER_ACCOUNT = 50
MIN_SLEEP_AFTER_INVITE = 20.0
MAX_SLEEP_AFTER_INVITE = 45.0
# Flood wait/preflood siyosati
RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin
# ========================
# HUMAN simulation params
PROB_HUMAN_BEHAVIOR = 0.9
HUMAN_READ_MIN = 5
HUMAN_READ_MAX = 12
HUMAN_SCROLL_CHANCE = 0.6
HUMAN_SCROLL_MIN = 2
HUMAN_SCROLL_MAX = 5
# Global rate tracker
global_add_timestamps = deque()
def pony():
"""Qurilma parametrlarini random qiladi."""
devices = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},
#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},
]
d = random.choice(devices)
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en'
}
# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---
def normalize_phone(s: str) -> str:
if not s:
return ''
s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
if s.startswith('+'):
s = s[1:]
return s
async def ensure_global_rate_slot():
"""Token-bucket uslubida umumiy tezlik cheklovi."""
while True:
now = time.time()
while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:
global_add_timestamps.popleft()
if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:
return
wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()
await asyncio.sleep(wait_for)
async def record_global_add():
global_add_timestamps.append(time.time())
async def simulate_human_behavior(client, target_entity):
"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""
try:
n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)
await client.get_messages(target_entity, limit=n_read)
await asyncio.sleep(random.uniform(1.2, 3.5))
if random.random() < HUMAN_SCROLL_CHANCE:
for _ in range(random.randint(1, 2)):
limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)
await client.get_messages(target_entity, limit=limit2)
await asyncio.sleep(random.uniform(0.6, 2.2))
await asyncio.sleep(random.uniform(0.4, 1.8))
except Exception as e:
print(f"{ye}[HUMAN_SIM] Xatolik: {e}")
async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):
await sem_account.acquire()
try:
print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")
await client.connect()
if not await client.is_user_authorized():
print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")
await client.disconnect()
return
# Guruhga join
try:
await client(JoinChannelRequest(target))
target_entity = await client.get_entity(target)
target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')
await client.disconnect()
return
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')
await client.disconnect()
return
max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)
added_by_this_account = 0
consecutive_errors = 0
while added_by_this_account < max_to_add:
if user_queue.empty():
print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")
break
try:
await ensure_global_rate_slot()
user = await user_queue.get()
try:
user_to_add = int(user['id'])
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')
user_queue.task_done()
await asyncio.sleep(random.uniform(1,2))
continue
try:
await client(InviteToChannelRequest(target_details, [user_to_add]))
added_by_this_account += 1
total_added_counter['count'] += 1
await record_global_add()
print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')
user_queue.task_done()
consecutive_errors = 0
# Insoniy imitatsiya
if random.random() < PROB_HUMAN_BEHAVIOR:
await simulate_human_behavior(client, target_entity)
# Keyingisigacha kutish
await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))
except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,
UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')
user_queue.task_done()
await asyncio.sleep(random.uniform(2,5))
continue
except PeerFloodError:
print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q
return
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q (sizning siyosat)
return
except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')
user_queue.task_done()
return
except Exception as e:
consecutive_errors += 1
print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')
user_queue.task_done()
if consecutive_errors >= 4:
print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')
return
await asyncio.sleep(random.uniform(3,6))
continue
except asyncio.CancelledError:
break
# ish tugadi
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')
finally:
try:
await client(LeaveChannelRequest(target))
print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")
except Exception as e:
print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")
await client.disconnect()
print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")
sem_account.release()
async def main():
ensure_loop() # loop tayyor
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---
phones = []
if not os.path.exists('phone.csv'):
print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return
with open('phone.csv', 'r', encoding='utf-8') as readFile:
reader = csv.reader(readFile)
for phone_ in reader:
if not phone_:
continue
raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'
clean_phone = normalize_phone(raw_phone) # '9989...'
if clean_phone.isdigit():
phones.append({'raw': raw_phone, 'clean': clean_phone})
if not phones:
print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return
members = []
if not os.path.exists('ayollar.csv'):
print(f"{r}XATO: ayollar.csv fayli topilmadi!"); input(); return
with open('ayollar.csv', encoding='UTF-8') as f:
rows = csv.reader(f, delimiter=",", lineterminator="\n")
next(rows, None)
for row in rows:
if len(row) >= 5:
try:
members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})
except:
continue
if not members:
print(f"{r}Qo'shish uchun odamlar yo'q!"); return
total_added_counter = {'count': 0}
sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)
for section_name in config.sections():
TMARKET = section_name
target = config[section_name]['Qoshadigan_gurux1']
print("\n" + "="*50)
print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")
print("="*50 + "\n")
print(f'{lg}Jami akountlar: {len(phones)}')
print(f"{lg}Qo'shish uchun odamlar: {len(members)}")
user_queue = asyncio.Queue()
for member in members:
await user_queue.put(member)
tasks = []
for phone_obj in phones:
raw = phone_obj['raw']
clean = phone_obj['clean']
# Sessiya faylini ikkala ko‘rinishda ham qidiramiz
session_plus = f'sessions/+{clean}_SQLite.session'
session_plain = f'sessions/{clean}_SQLite.session'
if os.path.exists(session_plus):
session_file = session_plus
elif os.path.exists(session_plain):
session_file = session_plain
else:
raw_based = f'sessions/{raw}_SQLite.session'
if os.path.exists(raw_based):
session_file = raw_based
else:
print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")
continue
params = pony()
ensure_loop() # har bir clientdan oldin ham kafolat
client = TelegramClient(
session_file,
API_ID,
API_HASH,
device_model=params['device_model'],
system_version=params['system_version'],
app_version=params['app_version'],
lang_code=params['lang_code'],
system_lang_code=params['system_lang_code']
)
task = asyncio.create_task(
worker(f"{raw}", client, target, user_queue,
total_added_counter, last_two_parts, sem_account)
)
tasks.append(task)
try:
await asyncio.gather(*tasks)
except KeyboardInterrupt:
print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")
for t in tasks:
t.cancel()
await asyncio.gather(*tasks, return_exceptions=True)
message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"
terminal_width = shutil.get_terminal_size().columns
print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")
print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")
input("Chiqish uchun ENTER bosing...")
# === DASTUR BOSHI ===
if __name__ == '__main__':
# Windows uchun tavsiya etilgan siyosat
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
ensure_loop() # dastur startida ham
asyncio.run(main())
elif a == 3:
def filter_names_by_keywords(df_chunk, keywords):
# Конвертируем ключевые слова в верхний регистр
upper_keywords = [keyword.upper() for keyword in keywords]
# Создаем регулярное выражение для поиска ключевых слов в последних трех символах имени
regex_keywords = [re.compile(rf'\w*({re.escape(keyword)}$)', flags=re.IGNORECASE) for keyword in upper_keywords]
# Функция проверки наличия ключевых слов в последних трех символах имени
def has_keywords(name):
name_str = str(name)
for keyword in regex_keywords:
if keyword.search(name_str):
return True
return False
# Применяем функцию has_keywords к столбцу 'name' для каждой строки DataFrame
filtered_df_chunk = df_chunk[df_chunk['name'].apply(has_keywords)]
return filtered_df_chunk
def shuffle_data(df_chunk):
return df_chunk.sample(frac=1, random_state=42).reset_index(drop=True)
def evaluate_sorting(df_chunk):
total_names = len(df_chunk)
correct_names = len(df_chunk)
accuracy = (correct_names / total_names) * 100
print(f"Filter aniqlik darajasi: {accuracy:.2f}%")
if __name__ == "__main__":
input_csv_file = 'users.csv'
output_csv_file = 'erkaklar.csv'
keywords = [
'BEK', 'JON', 'XOM', 'VAR', 'SHOD', 'XID', 'TON', 'LIK', 'GIR', 'ZIZ',
'KIN', 'MAL', 'SIM', 'LLO', 'LIM', 'YOR', 'QAT', 'BOZ', 'YOT', 'RUR',
'SUR', 'XIR', 'VAZ', 'XOD', 'MID', 'RAT', 'KIR', 'MUR', 'ROB', 'ALI',
'SHER', 'GOR', 'AID', 'ROD', 'SUD', 'BOL', 'DOR', 'TAM', 'DIR', 'SHID',
'JAR', 'SIN', 'BOY', 'DIN', 'KAL', 'RUF', 'IZO', 'MOV', 'AFO', 'БЕК', 'ДЖОН', 'ХОМ', 'ВАР', 'ШОД', 'ХИД', 'ТОН', 'ЛИК', 'ГИР', 'ЗИЗ',
'КИН', 'МАЛ', 'СИМ', 'ЛЛО', 'ЛИМ', 'ЁР', 'КАТ', 'БОЗ', 'ЁТ', 'РУР',
'СУР', 'ХИР', 'ВАЗ', 'ХОД', 'МИД', 'РАТ', 'КИР', 'МУР', 'РОБ', 'АЛИ',
'ШЕР', 'ГОР', 'АЙД', 'РОД', 'СУД', 'БОЛ', 'ДОР', 'ТАМ', 'ДИР', 'ШИД',
'ДЖАР', 'СИН', 'БОЙ', 'ДИН', 'КАЛ', 'РУФ', 'ИЗО', 'МОВ', 'АФО'
]
chunksize = 10000
chunks = pd.read_csv(input_csv_file, chunksize=chunksize)
processed_chunks = []
for chunk in chunks:
filtered_chunk = filter_names_by_keywords(chunk, keywords)
processed_chunks.append(filtered_chunk)
processed_df = pd.concat(processed_chunks, ignore_index=True)
shuffled_df = shuffle_data(processed_df)
shuffled_df['index'] = range(1, len(shuffled_df) + 1)
shuffled_df.to_csv(output_csv_file, index=False)
evaluate_sorting(shuffled_df)
#input()
print("Erkaklar ismi filterlandi va saqlandi erkaklar.csv faylga")
time.sleep(2)
import os
import csv
import shutil
import configparser
import random
import asyncio
import time
from collections import deque
# Telethon: async-friendly import
from telethon import TelegramClient
from telethon.errors import (
PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,
PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,
UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,
ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError
)
from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest
from telethon.tl.types import InputPeerChannel
# --- Ranglar va API sozlamalari ---
r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- Python 3.12: event loop ensure (muhim) ---
def ensure_loop():
try:
asyncio.get_running_loop()
except RuntimeError:
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.set_event_loop(asyncio.new_event_loop())
# ====== SOZLAMALAR ======
GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD
GLOBAL_RATE_PERIOD = 30 # sekund
CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt
MIN_ADD_PER_ACCOUNT = 40
MAX_ADD_PER_ACCOUNT = 50
MIN_SLEEP_AFTER_INVITE = 20.0
MAX_SLEEP_AFTER_INVITE = 45.0
# Flood wait/preflood siyosati
RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin
# ========================
# HUMAN simulation params
PROB_HUMAN_BEHAVIOR = 0.9
HUMAN_READ_MIN = 5
HUMAN_READ_MAX = 12
HUMAN_SCROLL_CHANCE = 0.6
HUMAN_SCROLL_MIN = 2
HUMAN_SCROLL_MAX = 5
# Global rate tracker
global_add_timestamps = deque()
def pony():
"""Qurilma parametrlarini random qiladi."""
devices = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},
{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},
#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},
]
d = random.choice(devices)
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en'
}
# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---
def normalize_phone(s: str) -> str:
if not s:
return ''
s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
if s.startswith('+'):
s = s[1:]
return s
async def ensure_global_rate_slot():
"""Token-bucket uslubida umumiy tezlik cheklovi."""
while True:
now = time.time()
while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:
global_add_timestamps.popleft()
if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:
return
wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()
await asyncio.sleep(wait_for)
async def record_global_add():
global_add_timestamps.append(time.time())
async def simulate_human_behavior(client, target_entity):
"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""
try:
n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)
await client.get_messages(target_entity, limit=n_read)
await asyncio.sleep(random.uniform(1.2, 3.5))
if random.random() < HUMAN_SCROLL_CHANCE:
for _ in range(random.randint(1, 2)):
limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)
await client.get_messages(target_entity, limit=limit2)
await asyncio.sleep(random.uniform(0.6, 2.2))
await asyncio.sleep(random.uniform(0.4, 1.8))
except Exception as e:
print(f"{ye}[HUMAN_SIM] Xatolik: {e}")
async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):
await sem_account.acquire()
try:
print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")
await client.connect()
if not await client.is_user_authorized():
print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")
await client.disconnect()
return
# Guruhga join
try:
await client(JoinChannelRequest(target))
target_entity = await client.get_entity(target)
target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')
await client.disconnect()
return
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')
await client.disconnect()
return
max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)
added_by_this_account = 0
consecutive_errors = 0
while added_by_this_account < max_to_add:
if user_queue.empty():
print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")
break
try:
await ensure_global_rate_slot()
user = await user_queue.get()
try:
user_to_add = int(user['id'])
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')
user_queue.task_done()
await asyncio.sleep(random.uniform(1,2))
continue
try:
await client(InviteToChannelRequest(target_details, [user_to_add]))
added_by_this_account += 1
total_added_counter['count'] += 1
await record_global_add()
print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')
user_queue.task_done()
consecutive_errors = 0
# Insoniy imitatsiya
if random.random() < PROB_HUMAN_BEHAVIOR:
await simulate_human_behavior(client, target_entity)
# Keyingisigacha kutish
await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))
except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,
UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')
user_queue.task_done()
await asyncio.sleep(random.uniform(2,5))
continue
except PeerFloodError:
print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q
return
except FloodWaitError as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')
user_queue.task_done()
# qayta urinish Y O‘ Q (sizning siyosat)
return
except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):
print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')
user_queue.task_done()
return
except Exception as e:
consecutive_errors += 1
print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')
user_queue.task_done()
if consecutive_errors >= 4:
print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')
return
await asyncio.sleep(random.uniform(3,6))
continue
except asyncio.CancelledError:
break
# ish tugadi
except Exception as e:
print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')
finally:
try:
await client(LeaveChannelRequest(target))
print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")
except Exception as e:
print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")
await client.disconnect()
print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")
sem_account.release()
async def main():
ensure_loop() # loop tayyor
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---
phones = []
if not os.path.exists('phone.csv'):
print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return
with open('phone.csv', 'r', encoding='utf-8') as readFile:
reader = csv.reader(readFile)
for phone_ in reader:
if not phone_:
continue
raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'
clean_phone = normalize_phone(raw_phone) # '9989...'
if clean_phone.isdigit():
phones.append({'raw': raw_phone, 'clean': clean_phone})
if not phones:
print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return
members = []
if not os.path.exists('erkaklar.csv'):
print(f"{r}XATO: erkaklar.csv fayli topilmadi!"); input(); return
with open('erkaklar.csv', encoding='UTF-8') as f:
rows = csv.reader(f, delimiter=",", lineterminator="\n")
next(rows, None)
for row in rows:
if len(row) >= 5:
try:
members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})
except:
continue
if not members:
print(f"{r}Qo'shish uchun odamlar yo'q!"); return
total_added_counter = {'count': 0}
sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)
for section_name in config.sections():
TMARKET = section_name
target = config[section_name]['Qoshadigan_gurux1']
print("\n" + "="*50)
print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")
print("="*50 + "\n")
print(f'{lg}Jami akountlar: {len(phones)}')
print(f"{lg}Qo'shish uchun odamlar: {len(members)}")
user_queue = asyncio.Queue()
for member in members:
await user_queue.put(member)
tasks = []
for phone_obj in phones:
raw = phone_obj['raw']
clean = phone_obj['clean']
# Sessiya faylini ikkala ko‘rinishda ham qidiramiz
session_plus = f'sessions/+{clean}_SQLite.session'
session_plain = f'sessions/{clean}_SQLite.session'
if os.path.exists(session_plus):
session_file = session_plus
elif os.path.exists(session_plain):
session_file = session_plain
else:
raw_based = f'sessions/{raw}_SQLite.session'
if os.path.exists(raw_based):
session_file = raw_based
else:
print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")
continue
params = pony()
ensure_loop() # har bir clientdan oldin ham kafolat
client = TelegramClient(
session_file,
API_ID,
API_HASH,
device_model=params['device_model'],
system_version=params['system_version'],
app_version=params['app_version'],
lang_code=params['lang_code'],
system_lang_code=params['system_lang_code']
)
task = asyncio.create_task(
worker(f"{raw}", client, target, user_queue,
total_added_counter, last_two_parts, sem_account)
)
tasks.append(task)
try:
await asyncio.gather(*tasks)
except KeyboardInterrupt:
print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")
for t in tasks:
t.cancel()
await asyncio.gather(*tasks, return_exceptions=True)
message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"
terminal_width = shutil.get_terminal_size().columns
print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")
print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")
print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")
input("Chiqish uchun ENTER bosing...")
# === DASTUR BOSHI ===
if __name__ == '__main__':
# Windows uchun tavsiya etilgan siyosat
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
ensure_loop() # dastur startida ham
asyncio.run(main())
elif a == 4:
import os
import csv
import random
import asyncio
import ctypes
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.errors import (
SessionPasswordNeededError,
PasswordHashInvalidError,
PhoneCodeInvalidError,
PhoneCodeExpiredError,
PhoneNumberBannedError,
)
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = './sessions'
# ---------- RANGLARNI YOQISH (Windows uchun VT100) ----------
def _enable_ansi_on_windows():
if os.name != 'nt':
return
try:
kernel32 = ctypes.windll.kernel32
h = kernel32.GetStdHandle(-11) # STD_OUTPUT_HANDLE = -11
mode = ctypes.c_uint32()
if kernel32.GetConsoleMode(h, ctypes.byref(mode)):
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
kernel32.SetConsoleMode(h, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
except Exception:
pass
_enable_ansi_on_windows()
# ANSI ranglar
CLR = {
'reset' : '\033[0m',
'bold' : '\033[1m',
'red' : '\033[31m',
'green' : '\033[32m',
'yellow' : '\033[33m',
'blue' : '\033[34m',
'magenta': '\033[35m',
'cyan' : '\033[36m',
'white' : '\033[37m',
'bwhite' : '\033[97m',
}
DEVICE_COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'bwhite']
def colorize(text: str, color: str, bold: bool = False) -> str:
c = CLR.get(color, '')
b = CLR['bold'] if bold else ''
r = CLR['reset']
return f"{b}{c}{text}{r}"
def pick_color_for_device(model: str) -> str:
idx = abs(hash(model)) % len(DEVICE_COLORS)
return DEVICE_COLORS[idx]
def platform_emoji(model: str, system_version: str) -> str:
m = (model or '').lower()
s = (system_version or '').lower()
if 'pc' in m or 'windows' in s:
return '🖥️'
if 'harmony' in s or 'huawei' in m:
return '🌌'
return '🤖'
# === CSV o‘qish ===
def read_phones_from_csv(file_path):
phone_numbers = []
if not os.path.exists(file_path):
print(colorize(f"XATO: {file_path} fayli topilmadi!", 'red', True))
return []
with open(file_path, newline='', encoding='utf-8') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
if row and row[0].strip():
phone_numbers.append(row[0].strip())
return phone_numbers
# === REAL RANDOM DEVICE LIST (2025) ===
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.0.0 (3500) arm64-v8a'},
{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.0', 'app_version': '11.0.0 (3500) arm64-v8a'},
]
def random_device_params():
d = random.choice(RANDOM_DEVICES)
system_ver = f"{d['system_version']} | sdk 4.16.3-PYRO17"
return {
'device_model': d['device_model'],
'system_version': system_ver,
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en'
}
# === TELETHON SESSION CREATOR (majburiy yangi qurilma bilan) ===
async def create_and_check_session(phone):
session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone}.session')
# Har safar yangi qurilma
device_params = random_device_params()
dev_color = pick_color_for_device(device_params['device_model'])
icon = platform_emoji(device_params['device_model'], device_params['system_version'])
device_line = f"{icon} {device_params['device_model']} | {device_params['system_version']} | app {device_params['app_version']}"
print(colorize(f"\nStart {phone}", 'cyan', True))
print(colorize(f"Qurilma tanlandi → {device_line}", dev_color, True))
# Hatto mavjud sessiyada ham yangi qurilma parametrlari o‘rnatiladi
if os.path.exists(session_file):
with open(session_file, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
# 👇 majburan yangi device parametrlarini yozamiz
client._flood_sleep_threshold = 5
client._device_model = device_params['device_model']
client._system_version = device_params['system_version']
client._app_version = device_params['app_version']
client._lang_code = device_params['lang_code']
client._system_lang_code = device_params['system_lang_code']
else:
client = TelegramClient(StringSession(), API_ID, API_HASH, **device_params)
try:
await client.connect()
if await client.is_user_authorized():
me = await client.get_me()
print(colorize(f"✅ Tasdiqlandi (sessiya mavjud): {phone} | {getattr(me, 'first_name', '')}", 'green', True))
# Har safar sessiyani yangilaymiz
session_string = client.session.save()
with open(session_file, 'w', encoding='utf-8') as f:
f.write(session_string)
return phone
await client.send_code_request(phone)
attempts_left = 3
while True:
code = input(colorize(f'{phone} Kodni kiriting: ', 'yellow', True)).strip()
if not code:
print(colorize("Kod bo'sh bo'lmasin.", 'red', True))
continue
try:
await client.sign_in(phone, code)
break
except SessionPasswordNeededError:
while True:
password = input(colorize(f'{phone} 2FA parolni kiriting: ', 'yellow', True))
try:
await client.sign_in(password=password)
break
except PasswordHashInvalidError:
print(colorize("Parol xato. Qayta kiriting!", 'red', True))
continue
break
except PhoneCodeInvalidError:
attempts_left -= 1
print(colorize(f"Kod xato. Qayta kiriting! (qolgan urinishlar: {attempts_left})", 'red', True))
if attempts_left == 0:
print(colorize("Urinishlar tugadi. Yangi kod so'ralmoqda...", 'yellow', True))
await client.send_code_request(phone)
attempts_left = 3
except PhoneCodeExpiredError:
print(colorize("Kodning amal qilish muddati tugagan. Yangi kod so'ralmoqda...", 'yellow', True))
await client.send_code_request(phone)
attempts_left = 3
except PhoneNumberBannedError:
print(colorize(f"{phone} raqami BAN qilingan.", 'red', True))
return None
except Exception as e:
print(colorize(f"Noma'lum xato: {e}", 'red', True))
return None
if await client.is_user_authorized():
me = await client.get_me()
print(colorize(f"🎉 Muvaffaqiyatli avtorizatsiya: {phone} | {getattr(me, 'first_name', '')}", 'green', True))
session_string = client.session.save()
with open(session_file, 'w', encoding='utf-8') as f:
f.write(session_string)
return phone
else:
print(colorize(f"{phone} avtorizatsiyadan o'tkazilmadi.", 'red', True))
return None
except Exception as e:
print(colorize(f"Umumiy xatolik {phone}: {str(e)}", 'red', True))
return None
finally:
if client.is_connected():
await client.disconnect()
# === STRING → SQLITE migratsiya ===
async def migrate_string_to_sqlite(phone_number):
session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone_number}.session')
if not os.path.exists(session_file):
print(colorize(f"SESSIYA {phone_number} TOPILMADI.", 'red', True))
return
with open(session_file, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
async with client:
await client.connect()
dc_id, server_address, port = client.session.dc_id, client.session.server_address, client.session.port
auth_key = client.session.auth_key
sqlite_session_file = os.path.join(SESSION_FOLDER, f'{phone_number}_SQLite.session')
sqlite_client = TelegramClient(sqlite_session_file, API_ID, API_HASH)
await sqlite_client.connect()
sqlite_client.session.set_dc(dc_id, server_address, port)
sqlite_client.session.auth_key = auth_key
sqlite_client.session.save()
await sqlite_client.disconnect()
print(colorize(f"🧳 Migratsiya {phone_number} → SQLite session... OK", 'magenta', True))
# === MAIN ===
async def main():
if not os.path.exists(SESSION_FOLDER):
os.makedirs(SESSION_FOLDER)
phone_numbers = read_phones_from_csv('phone.csv')
if not phone_numbers:
input(colorize("phone.csv bo'sh yoki topilmadi. Chiqish uchun ENTER bosing.", 'yellow', True))
return
authorized_phones = []
for phone in phone_numbers:
result = await create_and_check_session(phone)
if result:
authorized_phones.append(result)
if authorized_phones:
print(colorize("\n--- Migratsiya jarayoni boshlandi ---", 'bwhite', True))
migration_tasks = [migrate_string_to_sqlite(phone) for phone in authorized_phones]
await asyncio.gather(*migration_tasks)
print(colorize('\nTelefonlar ro\'yxatdan o\'tkazildi va migratsiya qilindi!\n', 'cyan', True))
input(colorize("ENTER chiqish", 'yellow', True))
if __name__ == "__main__":
if os.name == 'nt':
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(main())
elif a == 5:
import os
import csv
import random
import requests
import asyncio
from telethon import TelegramClient
from telethon.errors import RPCError
from telethon.sessions import StringSession
from telethon.tl.functions.photos import UploadProfilePhotoRequest
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- YANGI: realistik random qurilmalar (2024–2025) ---
RANDOM_DEVICES = [
# Android / HarmonyOS
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# ------------------------------------------------------
# Функция для чтения номеров телефонов из CSV-файла
def read_phone_numbers_from_csv(csv_file):
phone_numbers = []
with open(csv_file, 'r') as f:
reader = csv.reader(f)
for row in reader:
if row:
phone_numbers.append(row[0].strip())
return phone_numbers
def download_random_image():
"""
picsum.photos dan tasodifiy 1080x1080 rasm oladi (seed bilan).
"""
tag = random.choice(['woman', 'poetry'])
rnd = random.randint(1, 10**6)
url = f"https://picsum.photos/seed/{tag}-{rnd}/1080/1080"
try:
resp = requests.get(url, timeout=12)
resp.raise_for_status()
return resp.content
except requests.RequestException as e:
print(f"Rasm olishda xatolik: {e}")
return None
# Функция для сохранения изображения на диск
def save_image(image_data, filename):
with open(filename, "wb") as file:
file.write(image_data)
# Функция для изменения фото профиля
async def change_profile_photo(client):
image_data = download_random_image()
if image_data:
filename = "profile_photo.jpg"
save_image(image_data, filename)
# Telegram’ga yuklaymiz va profilga qo‘yamiz
uploaded = await client.upload_file(filename)
await client(UploadProfilePhotoRequest(file=uploaded))
os.remove(filename)
else:
print("Rasmni yuklab bo‘lmadi...")
# Основная функция для изменения фото профиля для всех аккаунтов
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
for phone in phone_numbers:
print(f"Rasm o‘rnatilmoqda... {phone}")
session_file = f'sessions/telethon_{phone}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f"Session fayl {phone} topilmadi!")
continue
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"Akkaunt {phone} avtorizatsiyadan o‘tmagan yoki chiqarilgan.")
await client.disconnect()
continue
await change_profile_photo(client)
print(f"Profil rasmi o‘zgartirildi: {phone}")
except RPCError as e:
print(f"Xatolik: [{phone}] {e}")
continue
finally:
await client.disconnect()
print('Profillarga rasmlar o‘rnatildi...')
print('Chiqish uchun ENTER bosing...')
input()
# Запуск основной функции
if __name__ == "__main__":
asyncio.run(main())
elif a == 6:
import os
import csv
import random
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.functions.account import UpdateProfileRequest
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- YANGI: realistik random qurilmalar (2024–2025) ---
RANDOM_DEVICES = [
# Android
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
# HarmonyOS
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
# Androidlarga kichik qo'shimcha iz: real fingerprintga o‘xshatish
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# ------------------------------------------------------
# Функция для чтения номеров телефонов из CSV-файла
def read_phone_numbers_from_csv(csv_file):
phone_numbers = []
with open(csv_file, 'r') as f:
reader = csv.reader(f)
for row in reader:
if row:
phone_numbers.append(row[0].strip())
return phone_numbers
# Функция для чтения имен и фамилий из CSV-файла
def read_names_surnames_from_csv(csv_file):
names_surnames = []
with open(csv_file, 'r', encoding='utf-8') as file:
reader = csv.reader(file)
for row in reader:
if len(row) >= 1:
if len(row) == 1:
name, surname = row[0], ""
else:
name, *surname = row[0].split()
surname = ' '.join(surname) if surname else ""
names_surnames.append((name.strip(), surname.strip()))
random.shuffle(names_surnames)
return names_surnames
# Функция для изменения имени и фамилии профиля
async def change_profile_name(client, name, surname):
await client(UpdateProfileRequest(
first_name=name,
last_name=surname
))
# Основная функция для изменения профилей
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
names_surnames = read_names_surnames_from_csv('Ismlar.csv')
for phone_number, (name, surname) in zip(phone_numbers, names_surnames):
print(f"Ismlar ornatilmoqda... {name} {surname} ({phone_number})")
session_file = f'sessions/telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f"Session fayl {phone_number} Topilmadi!")
continue
# >>> YANGI: qurilma parametrlari bilan ulanamiz
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"Akount {phone_number} chiqarib yuborilgan!")
await client.disconnect()
continue
# Ism va familiyani o‘zgartirish
await change_profile_name(client, name, surname)
# print(f"Profil o'zgartirildi: {phone_number}")
except Exception as e:
print(f"!!!: [{phone_number}] {str(e)}!!!")
continue
finally:
await client.disconnect()
print('Proffillar ismlar ozgarttirildi...')
print('CHiqish uchun ENTER bosing...')
input()
if __name__ == "__main__":
import asyncio
# (ixtiyoriy) Windows 3.12 loop siyosati fix
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.run(main())
elif a == 7:
from telethon import TelegramClient, events, sync
from telethon.sessions import StringSession
import csv
PHONE_FILE = 'phone.csv'
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
chat_id = 777000 # Замените на ваш chat_id
async def display_accounts():
with open(PHONE_FILE, 'r') as f:
phone_list = [row[0] for row in csv.reader(f)]
print(f"Barcha akountlar:\n")
for i, phone in enumerate(phone_list):
print(f"{i + 1}. {phone}")
choice = int(input("Akountni tanlang: "))
return phone_list[choice - 1]
async def main():
while True:
phone = await display_accounts()
# Создаем строку сессии или используем существующую
session_file = f'sessions/telethon_{phone}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(Fore.RED + f'Session fayl {phone} Topilmadi!.' + Style.RESET_ALL)
continue
client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
try:
await client.start()
print("Telegramga muvaffaqiyatli ulandi!")
# Пример поиска последнего сообщения в чате
async for message in client.iter_messages(chat_id, limit=1):
print(message.text)
except Exception as e:
print(f"Xatolik yuz berdi: {str(e)}")
finally:
await client.disconnect()
input('\nEnter orqaga qaytish')
if __name__ == "__main__":
import asyncio
asyncio.run(main())
elif a == 8:
import os
import csv
import random
import time
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.functions.account import UpdateUsernameRequest
from telethon.errors import UsernameOccupiedError, UsernameInvalidError, FloodWaitError, RPCError
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- YANGI: realistik random qurilmalar (2024–2025) ---
RANDOM_DEVICES = [
# Android flagships / upper-mid
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
# HarmonyOS
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
# Androidlarga “sdk 4.16.3-PYRO17” qo‘shimcha footerni qo‘shamiz — realistik fingerprint
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en'
}
# ------------------------------------------------------
# Функция для чтения номеров телефонов из CSV-файла
def read_phone_numbers_from_csv(csv_file):
phone_numbers = []
with open(csv_file, 'r') as f:
reader = csv.reader(f)
for row in reader:
if row:
phone_numbers.append(row[0].strip())
return phone_numbers
# Функция для чтения имен из CSV-файла
def read_names_from_csv(csv_file):
names = []
with open(csv_file, 'r', encoding='utf-8') as file:
reader = csv.reader(file)
for row in reader:
if row:
name = row[0].strip().split()[0]
names.append(name)
return names
# Функция для генерации случайного username
def generate_random_username(prefixes):
prefix = random.choice(prefixes)
return prefix + ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=4))
# Функция для изменения username профиля
async def change_profile_username(client, username):
await client(UpdateUsernameRequest(username=username))
# Списки случайных сообщений
success_messages = [
"Username o'zgartirildi: @{}",
"Yangi username muvaffaqiyatli: @{}",
"Username muvaffaqiyatli o'zgartirildi: @{}",
"Username o'zgardi: @{}"
]
failure_messages = [
"Username @{} qabul qilinmadi, qaytadan urinib ko'ring.",
"Username @{} noto'g'ri, boshqa urinib ko'ring.",
"Username @{} band yoki noto'g'ri, qayta urinib ko'ring.",
"Username @{} mavjud emas yoki noto'g'ri, qaytadan urinib ko'ring."
]
# Основная функция для изменения профилей
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
names = read_names_from_csv('Ismlar.csv')
for phone_number in phone_numbers:
session_file = f'sessions/telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f"Session fayl {phone_number} Topilmadi!")
continue
# >>> YANGI: qurilma parametrlari qo‘llaniladi
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"Akount {phone_number} chiqarib yuborilgan!")
await client.disconnect()
continue
while True:
username = generate_random_username(names)
try:
await change_profile_username(client, username)
print((phone_number), random.choice(success_messages).format(username))
print()
break
except (UsernameOccupiedError, UsernameInvalidError):
# print(random.choice(failure_messages).format(username))
continue
except RPCError as e:
if "username is not different from the current username" in str(e):
print(f"!!!: [{phone_number}] The username is not different from the current username!!!")
break
elif "Telegram is having internal issues" in str(e):
print(f"Telegram is having internal issues. Retrying in 5 seconds...")
time.sleep(5)
else:
print(f"{phone_number}: {str(e)}")
break
except Exception as e:
print(f"!!!: [{phone_number}] {str(e)}!!!")
continue
finally:
await client.disconnect()
print('Proffillar username ozgarttirildi...')
print('CHiqish uchun ENTER bosing...')
input()
if __name__ == "__main__":
import asyncio
# Windows 3.12 event loop muammosiga qarshi kichik fix (xohlasangiz qoldiring)
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.run(main())
elif a == 9:
import csv
import asyncio
from telethon import TelegramClient
from telethon.errors import RPCError
from telethon.sessions import StringSession
from telethon.tl.functions.channels import LeaveChannelRequest
from telethon.tl.types import Channel, User
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = 'sessions/' # Путь к папке с сессиями
def read_phone_numbers_from_csv(file_path):
with open(file_path, 'r') as f:
return [row[0] for row in csv.reader(f)]
async def leave_chats(session_string, phone):
print(f"Start: {phone}\n")
client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"Nomer {phone} CHIQARIB YUBORILGAN!")
await client.disconnect()
return
async for dialog in client.iter_dialogs():
try:
entity = dialog.entity
if isinstance(entity, Channel):
if entity.megagroup:
await client(LeaveChannelRequest(entity))
print(f"chiqildi: {dialog.title}")
elif isinstance(entity, User):
# Проверка, является ли пользователь ботом
if not entity.bot:
# Удаляем личные чаты
await client.delete_dialog(entity)
print(f"chiqildi: {dialog.title}")
elif isinstance(entity, Channel):
# Удаляем обычные группы (не мега-группы)
if not entity.megagroup:
await client.delete_dialog(entity)
print(f"chiqildi: {dialog.title}")
except Exception as e:
print(f"Xatolik: {e}")
continue
print(f"Nomer: {phone} -- TOZALANDI!")
except RPCError as e:
print(f"Nomer: {phone} ! Xatolik: {e}")
finally:
await client.disconnect()
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
tasks = []
for phone in phone_numbers:
session_file = f'{SESSION_FOLDER}telethon_{phone}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
tasks.append(leave_chats(session_string, phone))
except FileNotFoundError:
print(f"Sessiya {session_file} TOPILMADI!")
continue
await asyncio.gather(*tasks)
print('Tugallandi')
input("ENTER CHHIQISH")
if __name__ == "__main__":
asyncio.run(main())
elif a == 10:
import csv
import asyncio
import configparser
from telethon import TelegramClient, errors
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = 'sessions/' # Путь к папке с сессиями
async def update_2fa_password(session_string, phone_number, current_password, new_password):
try:
async with TelegramClient(StringSession(session_string), API_ID, API_HASH) as client:
await client.start()
await client.edit_2fa(current_password=current_password, new_password=new_password)
print(f"2FA PAROL YANGILANDI {phone_number}.")
return True
except errors.RPCError as e:
print(f"XATOLIK ESKI PAROL NOTOGRI! {phone_number}")
return False
# Функция для чтения номеров телефонов из CSV-файла
def read_phone_numbers_from_csv(csv_file):
with open(csv_file, 'r') as file:
reader = csv.reader(file)
phone_numbers = [row[0] for row in reader]
return phone_numbers
# Функция для чтения текущего и нового паролей из config.ini
def read_passwords_from_config():
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
current_password = config['T_Market']['current_password']
new_password = config['T_Market']['new_password']
return current_password, new_password
async def main():
# Чтение номеров телефонов из CSV-файла
csv_file = 'phone.csv' # Путь к CSV-файлу с номерами телефонов
phone_numbers = read_phone_numbers_from_csv(csv_file)
# Текущий и новый пароль из config.ini
current_password, new_password = read_passwords_from_config()
# Обновление 2FA пароля для каждого аккаунта
tasks = []
for phone_number in phone_numbers:
session_file = f'{SESSION_FOLDER}telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
tasks.append(update_2fa_password(session_string, phone_number, current_password, new_password))
except FileNotFoundError:
print(f"Session FAYL {session_file} TOPILMADI!")
continue
results = await asyncio.gather(*tasks)
success_count = sum(results)
print(f"2FA Parol YANGILANDI! {success_count} Shuncha nomerdan {len(phone_numbers)}.")
input('CHIQISH UCHUN ENTER')
if __name__ == "__main__":
asyncio.run(main())
elif a == 11:
import csv
import configparser
import asyncio
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.errors import PhoneNumberBannedError, FloodWaitError
from telethon.tl.functions.channels import JoinChannelRequest, GetFullChannelRequest
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = 'sessions/'
async def process_phone(phone):
session_file = f'{SESSION_FOLDER}telethon_{phone}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read()
except FileNotFoundError:
print(f'Session fayl {phone} topilmadi!')
return
client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"Akount {phone} chiqarib yuborilgan!")
await client.disconnect()
return
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
channel_links = [link.replace('https://t.me/', '') for link in config['T_Market']['channel_links'].split(',')]
for link in channel_links:
try:
chat = await client(JoinChannelRequest(link.strip()))
await asyncio.sleep(5)
channel_info = await client.get_entity(link.strip())
print(f"{phone}: Qoshildi: {channel_info.title}")
except FloodWaitError as e:
print(f'kuting...{e.seconds}')
await asyncio.sleep(e.seconds)
except Exception as e:
print(f'xatolik {phone} qoshilishda {link}: {e}')
except PhoneNumberBannedError:
print(f"Nomer {phone} chiqarib yuborilgan!")
except Exception as e:
print(f"Nomer {phone} XATOLIK: {e}")
finally:
await client.disconnect()
async def main():
with open('phone.csv', 'r') as f:
str_list = [row[0] for row in csv.reader(f)]
batch_size = 10
for i in range(0, len(str_list), batch_size):
batch = str_list[i:i + batch_size]
tasks = [process_phone(phone) for phone in batch]
await asyncio.gather(*tasks)
if __name__ == '__main__':
asyncio.run(main())
input("Enter chiqish!")
elif a == 12:
import csv
import os
import re
import asyncio
import configparser
from telethon import TelegramClient, functions, types
from telethon.errors import RPCError
from telethon.sessions import StringSession
# Чтение конфигурации
config = configparser.ConfigParser()
config.read('../Guruxlar.ini')
folder_link = config['T_Market']['Papka_linki']
# Телеграм API идентификатор и хэш
api_id = 253798
api_hash = 'd806c9ed3eb74a233d58cb4a072a68f0'
# Чтение CSV файла с аккаунтами
def read_csv(file_path):
accounts = []
with open(file_path, 'r') as file:
reader = csv.reader(file)
for row in reader:
if len(row) == 1:
accounts.append({'phone_number': row[0]})
return accounts
# Функция для присоединения к папке
async def join_folder(session_name, folder_link):
match = re.match(r"^(?:https?://)?(?:www\.)?(?:t(?:elegram)?\.(?:org|me|dog)/(?:addlist/|\+))([\w-]+)$", folder_link)
if match:
slug = match.group(1)
elif isinstance(folder_link, str):
slug = folder_link
else:
raise ValueError("Papka linki xato !!!")
session_file = f'sessions/telethon_{session_name}.session'
if not os.path.exists(session_file):
print(f"Sessiya {session_name} Topilmadi !!!")
return False
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f'Session fayl {session_name} Topilmadi!.')
return False
try:
async with TelegramClient(StringSession(session_string), api_id, api_hash) as client:
try:
result = await client(functions.chatlists.CheckChatlistInviteRequest(slug=slug))
if isinstance(result, types.chatlists.ChatlistInviteAlready):
print("Bu papka sizda bor !!!")
return True
elif isinstance(result, types.chatlists.ChatlistInvite):
await client(functions.chatlists.JoinChatlistInviteRequest(slug=slug, peers=result.peers))
#print(f"Papkaga qoshildi: {session_name}")
#await asyncio.sleep(5)
return True
else:
print(f"Xato link: {type(result)}")
return False
except Exception as e:
print(f"Papkaga qoshilishda xatolik: {e}")
return False
except RPCError as e:
print(f"Nomer:{session_name} XATO:{e}!")
return False
# Путь к CSV файлу
csv_file_path = "phone.csv"
accounts = read_csv(csv_file_path)
# Основная функция
async def main():
for account in accounts:
joined = await join_folder(account['phone_number'], folder_link)
if joined:
print(f"Papkaga qoshildi : {account['phone_number']}")
else:
print(f"bu nomer papkaga qoshila olmadi !!!{account['phone_number']}")
await asyncio.sleep(1)
# Запуск основной функции
if __name__ == "__main__":
asyncio.run(main())
input("ENTER chiqish...")
elif a == 13:
import csv
import os
import asyncio
import configparser
from telethon import TelegramClient
from telethon.errors import RPCError
from telethon.sessions import StringSession
from telethon import functions, types
# Чтение конфигурации
config = configparser.ConfigParser()
config.read('config.ini')
api_id = 253798
api_hash = 'd806c9ed3eb74a233d58cb4a072a68f0'
def read_csv(file_path):
accounts = []
with open(file_path, 'r') as file:
reader = csv.reader(file)
for row in reader:
if len(row) == 1:
accounts.append({'phone_number': row[0]})
return accounts
async def leave_all_dialogs(client):
# Получаем все диалоги (включая архивированные)
dialogs = await client.get_dialogs(limit=1000) # Увеличиваем лимит для охвата всех диалогов
for dialog in dialogs:
try:
# Пропускаем служебные сообщения от Telegram
if isinstance(dialog.entity, types.User):
if dialog.entity.bot:
continue # Пропускаем ботов
if dialog.entity.id == 777000:
continue # Пропускаем служебные сообщения от Telegram
# Пропускаем каналы и группы, но обрабатываем их по желанию
if isinstance(dialog.entity, (types.Channel, types.Chat)):
# Пропустите, если это нужно
pass
await client.delete_dialog(dialog.entity)
print(f"o'chirildi: {dialog.entity.title if hasattr(dialog.entity, 'title') else 'Nomsiz'}")
except Exception as e:
print(f"xatolik {dialog.entity.title if hasattr(dialog.entity, 'title') else 'Nomsiz'}: {e}")
async def delete_folders(client):
filters = await client(functions.messages.GetDialogFiltersRequest())
if not filters or not filters.filters:
print("Papka topilmadi.")
return
for folder in filters.filters:
# Пропускаем папку по умолчанию
if isinstance(folder, types.DialogFilterDefault):
print("Papka o'tqazib yuborildi.")
continue
try:
await client(functions.messages.UpdateDialogFilterRequest(
id=folder.id,
filter=None # Удаляет папку
))
print(f"o'chirildi: {folder.title if hasattr(folder, 'title') else 'Nomsiz'}")
except Exception as e:
print(f"Xatolik {folder.title if hasattr(folder, 'title') else 'Nomsiz'}: {e}")
async def main():
csv_file_path = "phone.csv"
accounts = read_csv(csv_file_path)
for account in accounts:
session_file = f'sessions/telethon_{account["phone_number"]}.session'
if not os.path.exists(session_file):
print(f"Sessiya {account['phone_number']} Topilmadi!")
continue
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f'Sessiya {account["phone_number"]} Topilmadi!')
continue
try:
async with TelegramClient(StringSession(session_string), api_id, api_hash) as client:
# Удаление всех диалогов
await leave_all_dialogs(client)
# Удаление всех папок
await delete_folders(client)
except RPCError as e:
print(f"Nomer: {account['phone_number']} Xatolik: {e}!")
await asyncio.sleep(1) # Задержка в 1 секунду между выполнением функций
if __name__ == "__main__":
asyncio.run(main())
input("Chiqish uchun ENTER...")
elif a == 14:
from datetime import datetime, timedelta, timezone
import csv
import asyncio
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.types import MessageActionGiftCode
from telethon.errors import RPCError
from colorama import Fore, Style, init
import os
init()
async def main():
# Укажите необходимые данные для клиента Telethon
api_id = 253798
api_hash = 'd806c9ed3eb74a233d58cb4a072a68f0'
chat_id = 777000 # ID чата для проверки
# Чтение номеров телефонов из CSV-файла
csv_file = 'phone.csv' # Путь к CSV-файлу с номерами телефонов
phone_numbers = read_phone_numbers_from_csv(csv_file)
# Удаление старого файла и создание нового с заголовками
output_csv_file = 'gift_codes.csv'
if os.path.exists(output_csv_file):
os.remove(output_csv_file)
write_csv_headers(output_csv_file)
# Ввод количества дней с клавиатуры
days = int(input("Necha kunni tekshirmoqchisiz: "))
# Время days дней назад от текущего времени
time_days_ago = datetime.now(timezone.utc) - timedelta(days=days)
# Создание и запуск клиента Telethon
for phone_number in phone_numbers:
session_file = f'sessions/telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(Fore.RED + f'Session fayl {phone_number} Topilmadi!.' + Style.RESET_ALL)
continue
client = TelegramClient(StringSession(session_string), api_id, api_hash)
try:
await client.connect()
if not await client.is_user_authorized():
print(Fore.YELLOW + f"Akount {phone_number} chiqarib yuborilgan!" + Style.RESET_ALL)
await client.disconnect()
continue
try:
# Получение информации о пользователе
meer = await client.get_me()
me = meer.first_name
# Список для хранения найденных сообщений с подарочными кодами
found_messages = []
# Проверка каждого аккаунта на наличие розыгрыша в чате служебное уведомление
async for message in client.iter_messages(chat_id):
# Проверяем, является ли сообщение служебным и отправлено ли оно за последние days дней
if isinstance(message.action, MessageActionGiftCode) and message.date >= time_days_ago:
print(Fore.GREEN + f"Akountda {phone_number}-{me} {Fore.GREEN}Tabriklaymiz Yutuq Kodi Topildi!!!" + Style.RESET_ALL)
print(f"{Fore.GREEN}Yutuq Sanasi: {message.date}" + Style.RESET_ALL)
gift_code_link = ""
if message.action.slug:
gift_code_link = f"https://t.me/giftcode/{message.action.slug}"
print(f"{Fore.GREEN}Gift Kod Link: {gift_code_link}" + Style.RESET_ALL)
months = message.action.months if message.action.months else "N/A" # Добавляем проверку
print(f"{Fore.GREEN}Oylik: {months}" + Style.RESET_ALL)
found_messages.append(message)
# Запись информации о найденном подарочном коде в общий CSV-файл
write_gift_code_to_csv(output_csv_file, phone_number, me, message.date, months, gift_code_link)
# Если подарочный код не был найден, выводим соответствующее сообщение
if not found_messages:
print(Fore.RED + f"Akountda {phone_number}-{me} {Fore.RED}Yutuq Topilmadi!!!" + Style.RESET_ALL)
else:
# Выводим информацию о найденных сообщениях
print(f"{Fore.GREEN}Tabriklaymiz")
for message in found_messages:
print(f"{Fore.GREEN}Yutuq sanasi: {message.date}")
print("-" * 30)
except Exception as e:
print(f"Xatolik: {e}")
finally:
await client.disconnect()
except RPCError as e:
print(Fore.RED + f"Nomer: {phone_number} XATO!:{e}" + Style.RESET_ALL)
continue
def read_phone_numbers_from_csv(csv_file):
with open(csv_file, 'r') as file:
reader = csv.reader(file)
phone_numbers = [row[0] for row in reader]
return phone_numbers
def write_csv_headers(csv_file):
with open(csv_file, 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow(['Phone Number', 'First Name', 'Date', 'Months', 'Gift Code Link'])
def write_gift_code_to_csv(csv_file, phone_number, first_name, date, months, slug):
with open(csv_file, 'a', newline='') as file: # Используем 'a' для добавления записей
writer = csv.writer(file)
writer.writerow([phone_number, first_name, date, months, slug])
if __name__ == "__main__":
asyncio.run(main())
input("ENTER chiqish...")
elif a == 15:
from telethon.sync import TelegramClient
from telethon.sessions import StringSession
from telethon.errors.rpcerrorlist import FloodWaitError, SessionPasswordNeededError, PhoneCodeInvalidError
from telethon.errors import PhoneNumberInvalidError
import csv
import time
import random # <<-- qo'shildi
# API_ID va HashID
API_ID = 253798
HashID = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- YANGI: realistik random qurilmalar (2024–2025) ---
RANDOM_DEVICES = [
# Android / HarmonyOS
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# ------------------------------------------------------
def ariza():
textfor1 = '''First, please confirm that you will never send this to strangers:
- Unsolicited advertising of any kind
- Promotional messages
- Shocking materials
Were you going to do anything like that?'''
textfor2 = ''''Ajoyib! Bularni begonalarga yubormaganingizni tasdiqlang:
- Har qanday turdagi nomaqbul reklama
- Promoaksiya xabarlari
- Shokka tushiruvchi materiallar
Bularning birortasini qilganmisiz?'''
textfor3 = '''Хорошо. Пожалуйста, подтвердите, что Вы никогда не отправляли незнакомым людям:
- Рекламу, которую они не запрашивали
- Материалы для продвижения чего-либо
- Шок-контент
Вы отправляли что-нибудь подобное?'''
with open('phone.csv', 'r') as f:
str_list = [row[0] for row in csv.reader(f)]
spam_count = 0
no_limit_count = 0
complaint_count = 0
spam_numbers = []
no_limit_numbers = []
complaint_numbers = []
for phone_number in str_list:
session_file = f'sessions/telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f'Session fayl {phone_number} Topilmadi!.')
continue
try:
# >>> YANGI: qurilma parametrlari bilan ulanamiz
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, HashID, **device_params)
client.connect()
if not client.is_user_authorized():
client.send_code_request(phone_number)
client.sign_in(phone_number, input('Enter the code: '))
me = client.get_me()
input_peer = client.get_entity('spambot')
client.send_message(input_peer, "/start")
time.sleep(2)
messages = client.get_messages(input_peer, limit=1)
if not messages:
print("Xabar topilmadi, keyingisi...")
continue
message = messages[0]
print(f"Bot: {message.text}")
if message.text == 'Good news, no limits are currently applied to your account. You’re free as a bird!':
time.sleep(2)
client.send_message(input_peer, "Cool, thanks")
print(f"Natija: {phone_number}: Spam emas")
no_limit_count += 1
no_limit_numbers.append(phone_number)
elif message.text == 'Ваш аккаунт свободен от каких-либо ограничений.':
time.sleep(2)
client.send_message(input_peer, "Хорошо, спасибо")
print(f"Natija: {phone_number}: Spam emas")
no_limit_count += 1
no_limit_numbers.append(phone_number)
elif message.text == 'Sizga xushxabarimiz bor! Hozirda hisobingizda hech qanday cheklov yoʻq. Misoli erkin qushsiz!':
time.sleep(2)
client.send_message(input_peer, "Yaxshi, rahmat")
print(f"Natija: {phone_number}: Spam emas")
no_limit_count += 1
no_limit_numbers.append(phone_number)
elif message.text in (
'Unfortunately, some phone numbers may trigger a harsh response from our anti-spam systems. If you think this is the case with you, you can submit a complaint to our moderators or subscribe to Telegram Premium to get less strict limits.',
'К сожалению, некоторые номера телефонов могут вызвать строгую реакцию наших антиспам-систем. Если вы считаете, что это касается вас, вы можете подать жалобу нашим модераторам или подписаться на Telegram Premium, чтобы получить менее строгие ограничения.',
"Afsuski, ba'zi telefon raqamlari bizning antispam tizimlarimiz tomonidan keskin munosabatga sabab bo'lishi mumkin. Agar bu sizga tegishli deb hisoblaysiz, moderatorlarimizga shikoyat qilishingiz yoki Telegram Premium-ga obuna bo'lishingiz mumkin, shunda cheklovlar kamroq qat'iy bo'ladi."
):
print("Info: Akkauntda limit yo‘q, urinib ko‘ramiz...")
elif f'Hello {me.first_name}!' in message.text:
print(f"Info: {phone_number}: Acount vechny spamda.")
time.sleep(2)
client.send_message(input_peer, "This is a mistake")
messagee = client.get_messages(input_peer, limit=1)
if 'submit a complaint' in messagee[0].text:
time.sleep(2)
client.send_message(input_peer, "Yes")
messageee = client.get_messages(input_peer, limit=1)
time.sleep(2)
client.send_message(input_peer, "No! Never did that!")
messageeee = client.get_messages(input_peer, limit=1)
content = "Please review my case."
client.send_message(input_peer, content)
print(f"Natija: {phone_number}: Ariza jo'natildi, javobini kuting.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
elif messagee[0].text == textfor1:
time.sleep(2)
client.send_message(input_peer, "No, I’ll never do any of this!")
elif "You've already submitted a complaint recently" in messagee[0].text:
print(f"Natija: {phone_number}: Ariza oldin jo'natilgan.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
elif f'Здравствуйте, {me.first_name}!' in message.text:
print(f"Info: {phone_number}: Acount vechny spamda.")
time.sleep(2)
client.send_message(input_peer, "Это ошибка")
messagee = client.get_messages(input_peer, limit=1)
if 'сообщите об этом нашим модераторам' in messagee[0].text:
time.sleep(2)
client.send_message(input_peer, "Да")
messageee = client.get_messages(input_peer, limit=1)
time.sleep(2)
client.send_message(input_peer, "Нет, ничего подобного не было.")
messageeee = client.get_messages(input_peer, limit=1)
content = "Здравствуйте, мой аккаунт в спаме по ошибке. Пожалуйста, откройте."
client.send_message(input_peer, content)
print(f"Natija: {phone_number}: Ariza jo'natildi, javobini kuting.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
elif messagee[0].text == textfor2:
time.sleep(2)
client.send_message(input_peer, "Нет, я никогда не буду этого делать!")
elif "Вы уже отправили одну апелляцию." in messagee[0].text:
print(f"Natija: {phone_number}: Ariza oldin jo'natilgan.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
elif f'Salom {me.first_name}!' in message.text:
print(f"Info: {phone_number}: Acount vechny spamda.")
time.sleep(2)
client.send_message(input_peer, "Bu xato")
messagee = client.get_messages(input_peer, limit=1)
if 'сообщите об этом нашим модераторам' in messagee[0].text:
time.sleep(2)
client.send_message(input_peer, "Ha")
messageee = client.get_messages(input_peer, limit=1)
time.sleep(2)
client.send_message(input_peer, "Yo\'q! Bunday holat aslo kuzatilmagan!")
messageeee = client.get_messages(input_peer, limit=1)
content = "Salom, akkauuntim xatolik sababli spamga tushgan. Iltimos, ko‘rib chiqing."
client.send_message(input_peer, content)
print(f"Natija: {phone_number}: Ariza jo'natildi, javobini kuting.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
elif messagee[0].text == textfor3:
time.sleep(2)
client.send_message(input_peer, "Yo‘q, men hech qachon bunday qilmayman!")
elif "Siz yaqindagina ariza yo'lladingiz." in messagee[0].text:
print(f"Natija: {phone_number}: Ariza oldin jo'natilgan.")
spam_count += 1
spam_numbers.append(phone_number)
complaint_count += 1
complaint_numbers.append(phone_number)
else:
print(f"Natija: {phone_number}: Acount kunlik spamda.")
spam_count += 1
spam_numbers.append(phone_number)
except FloodWaitError as e:
print(f"Xatolik: {e}")
except SessionPasswordNeededError as e:
print(f"Xatolik: {e}")
except PhoneCodeInvalidError as e:
print(f"Xatolik: {e}")
except PhoneNumberInvalidError as e:
print(f"Xatolik: {e}")
finally:
if client:
client.disconnect()
print()
print('Tekshirildi')
print('Itoğ:')
print(f'Toza: {no_limit_count}')
print(f'Spamda: {spam_count}')
print(f'Ariza jo\'natildi: {complaint_count}')
print('\nToza nomerlar:')
for number in no_limit_numbers:
print(number)
print('\nSpam nomerlar:')
for number in spam_numbers:
print(number)
print('\nAriza jo\'natilgan nomerlar:')
for number in complaint_numbers:
print(number)
print('Enter chiqish')
input()
if __name__ == "__main__":
ariza()
elif a == 16:
import csv
import asyncio
import sqlite3
from telethon import TelegramClient
from telethon.errors import RPCError
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
async def clean_session(file_path):
try:
conn = sqlite3.connect(file_path)
cursor = conn.cursor()
# Удаляем все строки из таблиц
cursor.execute("DELETE FROM update_state")
cursor.execute("DELETE FROM sent_files")
cursor.execute("DELETE FROM entities")
conn.commit() # Коммитим изменения, чтобы завершить транзакцию
# Выполняем вакуумизацию, чтобы освободить пространство
cursor.execute("VACUUM")
conn.close()
print(f"Sessiya {file_path} tozalandi.")
except sqlite3.Error as e:
print(f"Xatolik: {e}")
async def handle_phone(phone):
print(f"Start {phone}")
session_path = f'sessions/{phone}_SQLite.session'
client = TelegramClient(session_path, API_ID, API_HASH)
try:
await client.start(phone=phone)
if await client.is_user_authorized():
print(f"Nomer: {phone} ulandi")
except RPCError as e:
print(f"Nomer: {phone} CHIQARIB YUBORILGAN!")
finally:
try:
await client.disconnect()
except Exception as e:
print(f"XATOLIK {e}")
await clean_session(session_path)
async def main():
with open('phone.csv', 'r') as f:
str_list = [row[0] for row in csv.reader(f)]
await asyncio.gather(*[handle_phone(phone) for phone in str_list])
# Запуск основной функции
if __name__ == "__main__":
asyncio.run(main())
input("Нажмите ENTER для выхода...")
elif a == 17:
import subprocess
import sys
import os
# ---- Pip orqali modulni jim o'rnatish/tekshirish ----
def install_package(package_name):
try:
subprocess.check_call(
[sys.executable, "-m", "pip", "show", package_name],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
)
print("MODUL ORNATILGAN!.")
except subprocess.CalledProcessError:
print("MODUL O'RNATIMOQDA...")
subprocess.check_call(
[sys.executable, "-m", "pip", "install", package_name, "-q", "--disable-pip-version-check"],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
)
print("OK.")
# cryptography kerak bo'ladi
install_package('cryptography')
import csv
import asyncio
import random
from telethon import TelegramClient, errors
from telethon.sessions import StringSession
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = './sessions'
# ==== FAQAT MOBIL QURILMALAR (desktop yo‘q) ====
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# ================================================
# Telefonlarni CSV dan o‘qish
def read_phones_from_csv(file_path):
phone_numbers = []
with open(file_path, newline='', encoding='utf-8') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
if row:
phone_numbers.append(row[0])
return phone_numbers
# CSV ga qayta yozish (bo‘sh qatorlarsiz)
def write_phones_to_csv(file_path, phone_numbers):
phone_numbers = [phone.strip() for phone in phone_numbers if phone.strip()]
with open(file_path, 'w', encoding='utf-8') as csvfile:
csvfile.write('\n'.join(phone_numbers))
# +998... yoki 998... — har ikkala formatni ham qo‘llab-quvvatlash
def normalize_phone_for_signin(raw: str) -> str:
s = raw.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
return s if s.startswith('+') else f'+{s}'
# Bitta telefon uchun session yaratish/tekshirish
async def create_and_check_session(phone, semaphore, valid_phones, invalid_phones):
async with semaphore:
os.makedirs(SESSION_FOLDER, exist_ok=True)
session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone}.session')
sqlite_session_file = os.path.join(SESSION_FOLDER, f'{phone}_SQLite.session')
device_params = get_device_params()
if os.path.exists(session_file):
with open(session_file, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
else:
client = TelegramClient(StringSession(), API_ID, API_HASH, **device_params)
try:
await client.connect()
if not await client.is_user_authorized():
e164 = normalize_phone_for_signin(phone)
await client.send_code_request(e164)
attempt_count = 0
while True:
# Atayin noto‘g‘ri kod — sizning mavjud mantiqingiz (3 martagacha)
code = "0000"
try:
await client.sign_in(e164, code)
print(f"Tasdiqlandi {phone}")
break
except errors.SessionPasswordNeededError:
# 2FA parol sikli
while True:
password = input(f'{phone} 2FA parolini kiriting: ')
try:
await client.sign_in(password=password)
print(f"Tasdiqlandi {phone}\n")
break
except errors.PasswordHashInvalidError:
print("Parol xato. Yana kiriting!\n")
except Exception as e:
print(f"Xato parol yoki kod: {str(e)}")
break
except errors.CodeInvalidError:
attempt_count += 1
if attempt_count >= 3:
print(f"{phone} kodi 3 marta xato. O‘chiriladi.")
invalid_phones.append(phone)
break
print("Kod xato. Yana kiriting!\n")
except errors.PhoneNumberBannedError:
print(f"{phone} NOMER BAN O'CHIRILDI!.")
invalid_phones.append(phone)
if os.path.exists(session_file):
os.remove(session_file)
if os.path.exists(sqlite_session_file):
os.remove(sqlite_session_file)
return
except Exception as e:
print(f"Xato kod/parol: {str(e)}")
invalid_phones.append(phone)
break
if await client.is_user_authorized():
session_string = client.session.save()
with open(session_file, 'w', encoding='utf-8') as f:
f.write(session_string)
valid_phones.append(phone)
else:
print(f"{phone} TASDIQLANMAGAN NOMER. O'CHIRILDI!.")
invalid_phones.append(phone)
if os.path.exists(session_file):
os.remove(session_file)
if os.path.exists(sqlite_session_file):
os.remove(sqlite_session_file)
else:
print(f"{phone} Tasdiqlandi\n")
valid_phones.append(phone)
except errors.PhoneNumberBannedError:
print(f"{phone} NOMER BAN O'CHIRILDI!")
invalid_phones.append(phone)
if os.path.exists(session_file):
os.remove(session_file)
if os.path.exists(sqlite_session_file):
os.remove(sqlite_session_file)
except Exception as e:
print(f"Xatolik {phone}: {str(e)}")
invalid_phones.append(phone)
finally:
await client.disconnect()
# Asosiy oqim
async def main():
phone_numbers = read_phones_from_csv('phone.csv')
semaphore = asyncio.Semaphore(5)
valid_phones = []
invalid_phones = []
tasks = [create_and_check_session(phone, semaphore, valid_phones, invalid_phones) for phone in phone_numbers]
await asyncio.gather(*tasks)
# CSV dan noto‘g‘ri (ban/xato)larni olib tashlaymiz
phone_numbers = [phone for phone in phone_numbers if phone not in invalid_phones]
write_phones_to_csv('phone.csv', phone_numbers)
print("AKOUNTLAR RO'YXATI YANGILANDI SESSION FAYLLAR XAM!\n")
input("ENTER чиқиш")
if __name__ == "__main__":
asyncio.run(main())
elif a == 18:
import random
# === MOBIL QURILMA FINGERPRINTLARI ===
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# === TANLOV MENYUSI ===
ch = int(input("[1] Reaksiya bo'yicha olish \n[2] Xabarlar bo'yicha olish\n\nTANLANG: "))
# =====================================================
# 1 — REAKSIYA BO‘YICHA
# =====================================================
if ch == 1:
import asyncio, csv
from telethon import TelegramClient
from telethon.sessions import SQLiteSession
from telethon.tl import functions
from colorama import Fore, init
from telethon.errors import FloodWaitError
init(autoreset=True)
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
def read_phones_from_csv(path):
try:
with open(path, newline='') as f:
return [r[0] for r in csv.reader(f) if r]
except Exception as e:
print(Fore.RED + f"CSV o‘qishda xato: {e}")
return []
async def get_reactions_list(client, chat, msg_id, limit=100):
try:
peer = await client.get_input_entity(chat)
return await client(functions.messages.GetMessageReactionsListRequest(peer=peer, id=msg_id, limit=limit))
except Exception as e:
print(Fore.RED + f"Reaksiyalarni olishda xato {msg_id}: {e}")
return None
async def get_user_by_id(client, user_id):
try:
return await client.get_entity(user_id)
except FloodWaitError as e:
print(Fore.YELLOW + f"Kutamiz {e.seconds} sekund...")
await asyncio.sleep(e.seconds)
return await get_user_by_id(client, user_id)
except Exception:
return None
async def process_messages(client, link, limit, save_to_csv=False):
try:
peer = await client.get_entity(link)
msgs = await client.get_messages(peer, limit=limit)
total = len(msgs)
users_all = []
i = 1
print(Fore.CYAN + f"Topildi {total} xabarlar. Boshladik...")
for idx, m in enumerate(msgs, start=1):
if m.reactions and m.reactions.results:
res = await get_reactions_list(client, link, m.id)
if res:
for u in res.users:
user = await get_user_by_id(client, u.id)
if user:
info = (i, f"{user.first_name or ''} {user.last_name or ''}".strip(),
user.id, getattr(user, "access_hash", "?"))
if save_to_csv:
users_all.append(info)
i += 1
prog = (idx / total) * 100
print(f"\r{Fore.GREEN}POSTLAR TEKSHIRILYAPTI: {prog:.1f}%", end="")
print()
if save_to_csv:
with open('users.csv', 'w', newline='', encoding='utf-8') as f:
w = csv.writer(f)
w.writerow(['#', 'Ism', 'ID', 'AccessHash'])
w.writerows(users_all)
print(Fore.GREEN + "users.csv saqlandi!")
except Exception as e:
print(Fore.RED + f"Xato: {e}")
async def main():
phones = read_phones_from_csv('phone.csv')
if not phones:
print("phone.csv bo‘sh!")
return
first = phones[0]
session = f"sessions/{first}_SQLite.session"
link = input("Gurux linkini kiriting: ")
limit = int(input("Nechta postni tekshiramiz: "))
device_params = get_device_params()
client = TelegramClient(SQLiteSession(session), API_ID, API_HASH, **device_params)
await client.connect()
if not await client.is_user_authorized():
print(Fore.RED + "Akkaunt avtorizatsiyadan chiqib ketgan!")
await client.disconnect()
return
await process_messages(client, link, limit, save_to_csv=True)
await client.disconnect()
asyncio.run(main())
# =====================================================
# 2 — XABARLAR BO‘YICHA
# =====================================================
elif ch == 2:
import asyncio, csv
from telethon import TelegramClient, types
from telethon.sessions import SQLiteSession
from colorama import Fore, init
from telethon.errors import FloodWaitError
init(autoreset=True)
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
def read_phones_from_csv(path):
try:
with open(path, newline='') as f:
return [r[0] for r in csv.reader(f) if r]
except Exception as e:
print(Fore.RED + f"CSV o‘qishda xato: {e}")
return []
async def get_user_by_id(client, user_id):
try:
return await client.get_entity(user_id)
except FloodWaitError as e:
print(Fore.YELLOW + f"Kutamiz {e.seconds} sekund...")
await asyncio.sleep(e.seconds)
return await get_user_by_id(client, user_id)
except Exception:
return None
async def process_messages(client, link, limit, save_to_csv=False):
try:
peer = await client.get_entity(link)
msgs = await client.get_messages(peer, limit=limit)
total = len(msgs)
users = []
seen = set()
i = 1
print(Fore.CYAN + f"Topildi {total} xabar. Boshladik...")
for idx, m in enumerate(msgs, start=1):
if m.sender_id and (m.text or m.photo):
user = await get_user_by_id(client, m.sender_id)
if user and isinstance(user, types.User) and not user.bot:
name = f"{user.first_name or ''} {user.last_name or ''}".strip()
if name in seen:
continue
seen.add(name)
info = (i, name, user.id, getattr(user, "access_hash", "?"))
if save_to_csv:
users.append(info)
i += 1
print(f"\r{Fore.GREEN}POSTLAR TEKSHIRILYAPTI: {(idx / total) * 100:.1f}%", end="")
print()
if save_to_csv:
with open('users.csv', 'w', newline='', encoding='utf-8') as f:
w = csv.writer(f)
w.writerow(['#', 'Ism', 'ID', 'AccessHash'])
w.writerows(users)
print(Fore.GREEN + "users.csv saqlandi!")
except Exception as e:
print(Fore.RED + f"Xato: {e}")
async def main():
phones = read_phones_from_csv('phone.csv')
if not phones:
print("phone.csv bo‘sh!")
return
first = phones[0]
session = f"sessions/{first}_SQLite.session"
link = input("Gurux linkini kiriting: ")
limit = int(input("Nechta postni tekshiramiz: "))
device_params = get_device_params()
client = TelegramClient(SQLiteSession(session), API_ID, API_HASH, **device_params)
await client.connect()
if not await client.is_user_authorized():
print(Fore.RED + "Akkaunt avtorizatsiyadan chiqib ketgan!")
await client.disconnect()
return
await process_messages(client, link, limit, save_to_csv=True)
await client.disconnect()
asyncio.run(main())
elif a == 19:
from datetime import datetime, timedelta, timezone
import csv
import random
import asyncio
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.types import MessageActionPrizeStars, PeerChannel
from telethon.errors import RPCError
from colorama import Fore, Style, init
import os
init()
async def main():
# Укажите необходимые данные для клиента Telethon
api_id = 253798
api_hash = 'd806c9ed3eb74a233d58cb4a072a68f0'
chat_id = 777000 # ID чата для проверки
# Чтение номеров телефонов из CSV-файла
csv_file = 'phone.csv' # Путь к CSV-файлу с номерами телефонов
phone_numbers = read_phone_numbers_from_csv(csv_file)
# Удаление старого файла и создание нового с заголовками
output_csv_file = 'gift_codes.csv'
if os.path.exists(output_csv_file):
os.remove(output_csv_file)
write_csv_headers(output_csv_file)
# Ввод количества дней с клавиатуры
days = int(input("Necha kunni tekshirmoqchisiz: "))
# Время days дней назад от текущего времени
time_days_ago = datetime.now(timezone.utc) - timedelta(days=days)
# Создание и запуск клиента Telethon
for phone_number in phone_numbers:
session_file = f'sessions/telethon_{phone_number}.session'
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(Fore.RED + f'Session fayl {phone_number} Topilmadi!.' + Style.RESET_ALL)
continue
client = TelegramClient(StringSession(session_string), api_id, api_hash)
try:
await client.connect()
if not await client.is_user_authorized():
print(Fore.YELLOW + f"Akount {phone_number} chiqarib yuborilgan!" + Style.RESET_ALL)
await client.disconnect()
continue
try:
# Получение информации о пользователе
meer = await client.get_me()
me = meer.first_name
# Список для хранения найденных сообщений с подарочными кодами
found_messages = []
# Проверка сообщений с подарочными звёздочками
async for message in client.iter_messages(chat_id):
if isinstance(message.action, MessageActionPrizeStars) and message.date >= time_days_ago:
print(Fore.GREEN + f"Akountda {phone_number}-{me} {Fore.GREEN}Yulduzlar Topildi!!!" + Style.RESET_ALL)
print(f"{Fore.GREEN}Yutuq Sanasi: {message.date}" + Style.RESET_ALL)
action = message.action
stars = action.stars
transaction_id = action.transaction_id
boost_peer = action.boost_peer
# Получаем имя канала или username
if isinstance(boost_peer, PeerChannel):
channel = await client.get_entity(boost_peer)
channel_name = channel.title
else:
channel_name = "Nomalum kanal"
# Добавляем сообщение в список найденных
found_messages.append(message)
print(f"{Fore.GREEN}Yulduzlar Soni: {stars}" + Style.RESET_ALL)
print(f"{Fore.GREEN}Kim tomonidan berilgani: {channel_name}" + Style.RESET_ALL)
print(f"{Fore.GREEN}Yutuq linki: {transaction_id}\n" + Style.RESET_ALL)
# Запись в CSV
write_gift_code_to_csv(output_csv_file, phone_number, me, message.date, stars, channel_name, transaction_id)
# Если подарочный код не был найден, выводим соответствующее сообщение
if not found_messages:
print(Fore.RED + f"Akountda {phone_number}-{me} {Fore.RED}Yutuq Topilmadi!!!" + Style.RESET_ALL)
else:
# Выводим информацию о найденных сообщениях
print(f"{Fore.GREEN}Tabriklaymiz")
for message in found_messages:
print(f"{Fore.GREEN}Yutuq sanasi: {message.date}")
print("-" * 30)
except Exception as e:
print(f"Xatolik: {e}")
finally:
await client.disconnect()
except RPCError as e:
print(Fore.RED + f"Nomer: {phone_number} XATO!:{e}" + Style.RESET_ALL)
continue
def read_phone_numbers_from_csv(csv_file):
with open(csv_file, 'r') as file:
reader = csv.reader(file)
phone_numbers = [row[0] for row in reader]
return phone_numbers
def write_csv_headers(file_path):
with open(file_path, 'w', newline='', encoding='utf-8') as csvfile:
writer = csv.writer(csvfile)
writer.writerow(['Phone Number', 'first_name', 'Date', 'Stars', 'channel_name', 'Transaction ID'])
def write_gift_code_to_csv(file_path, phone_number, first_name, date, stars, channel_name, transaction_id):
with open(file_path, 'a', newline='', encoding='utf-8') as csvfile:
writer = csv.writer(csvfile)
writer.writerow([phone_number, first_name, date, stars, channel_name, transaction_id])
if __name__ == "__main__":
asyncio.run(main())
input("ENTER chiqish...")
elif a == 20:
import os
import csv
import asyncio
from telethon import TelegramClient, functions
from telethon.sessions import StringSession
from colorama import init, Fore
# Инициализация colorama
init(autoreset=True)
# Цветовые константы
lg = Fore.LIGHTGREEN_EX # ярко-зеленый
rs = Fore.RESET # сброс цвета
g = Fore.GREEN # зеленый
b = Fore.BLUE # синий
r = Fore.RED # красный
cy = Fore.CYAN # циановый
ye = Fore.YELLOW # желтый
grey = Fore.LIGHTBLACK_EX # серый
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = './sessions'
def read_phones_from_csv(file_path):
phones = []
with open(file_path, newline='') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
if row:
phones.append(row[0])
return phones
async def manage_authorizations(phone, index):
session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone}.session')
if not os.path.exists(session_file):
print(f"{r}{index}||| {phone} Sessiya topilmadi!")
return
client = None
try:
with open(session_file, 'r') as f:
session_string = f.read().strip()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
await client.connect()
if not await client.is_user_authorized():
print(f"{r}{index}||| {phone} Chiqarib yuborilgan...")
return
auths = await client(functions.account.GetAuthorizationsRequest())
print(f"\n{ye}{index}||| Akkount {phone}: Ro'yxatdan o'tgan:\n")
# --- FAQAT SHU QATOR O'ZGARTIRILDI ---
for idx, auth in enumerate(auths.authorizations, start=1):
date_active = auth.date_active.strftime('%Y-%m-%d %H:%M:%S')
# Ilova nomini olish (agar mavjud bo'lmasa, bo'sh string bo'ladi)
app_name = auth.app_name or ""
# Qurilma va ilova nomini birga chiqarish
print(f"{b}{idx}. Qurilma: {auth.device_model} ({app_name}) (Kirgan vaqti {date_active})")
# ------------------------------------
# Запрашиваем у пользователя выбор устройств для УДАЛЕНИЯ
to_delete = []
while not to_delete:
print(f"{Fore.RED}O'tqazib yuborish uchun '0' ni bosing")
choice = input(f"{cy}O'chirmoqchi bolgan qurilmala raqamini tanlang (masalan: 1,2): ").strip()
if choice == '0':
print(f"{r}Keyingi akkount {phone}")
break
try:
indices = [int(i.strip()) for i in choice.split(',') if i.strip().isdigit()]
to_delete = [auths.authorizations[i-1] for i in indices if 1 <= i <= len(auths.authorizations)]
except (ValueError, IndexError):
print(f"{r}Notog'ri raqam kirittingiz.")
# Удаляем выбранные устройства
for auth in to_delete:
await client(functions.account.ResetAuthorizationRequest(hash=auth.hash))
print(f"{g}{index}||| O'chirildi: {auth.device_model}")
except Exception as e:
print(f"{r}Xatolik {phone}: {e}")
finally:
if client and client.is_connected():
await client.disconnect()
async def main():
phones = read_phones_from_csv('phone.csv')
for idx, phone in enumerate(phones, start=1):
await manage_authorizations(phone, idx)
print(f"\n{lg}Tayyor! Barcha akkountlar ishlandi.")
input("CHiqish uchun ENTER...")
if __name__ == '__main__':
asyncio.run(main())
elif a == 21:
import os
import csv
import asyncio
import random
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.errors import RPCError
from telethon.tl import functions
from telethon.tl.types import InputPhoto
from colorama import init, Fore
# === Colorama init ===
init(autoreset=True)
lg, rs, g, b, r, cy, ye, grey = (
Fore.LIGHTGREEN_EX, Fore.RESET, Fore.GREEN, Fore.BLUE,
Fore.RED, Fore.CYAN, Fore.YELLOW, Fore.LIGHTBLACK_EX
)
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESSION_FOLDER = 'sessions'
# === MOBIL QURILMALAR (desktop yo‘q) ===
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# === + bilan yoki +siz raqamlarni qo‘llab-quvvatlash ===
def normalize_phone(phone):
p = phone.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
return p if p.startswith('+') else f'+{p}'
# === CSV dan telefonlarni o‘qish ===
def read_phone_numbers_from_csv(csv_file):
phones = []
if not os.path.exists(csv_file):
print(f"{r}CSV fayl topilmadi: {csv_file}")
return phones
with open(csv_file, 'r', newline='', encoding='utf-8') as f:
reader = csv.reader(f)
for row in reader:
if row:
phones.append(normalize_phone(row[0]))
return phones
# === Eski rasmlarni o‘chirish ===
async def delete_all_photos(client):
photos = await client.get_profile_photos('me')
if not photos:
print(f"{grey}Akkountda rasm topilmadi.")
return
ids = [
InputPhoto(id=p.id, access_hash=p.access_hash, file_reference=p.file_reference)
for p in photos
]
try:
result = await client(functions.photos.DeletePhotosRequest(id=ids))
print(f"{g}Profildan o‘chirildi {len(result)} ta eski rasm.")
except RPCError as e:
print(f"{r}Rasm o‘chirishda xatolik: {e}")
# === Asosiy ish jarayoni ===
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
if not phone_numbers:
print(f"{r}phone.csv bo‘sh yoki topilmadi!")
return
for phone in phone_numbers:
print(f"{ye}Akkount ishga tushurildi: {phone}")
session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone}.session')
if not os.path.exists(session_file):
print(f"{r}Sessiya topilmadi: {session_file}")
continue
try:
with open(session_file, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
await client.connect()
if not await client.is_user_authorized():
print(f"{r}Akkount {phone} avtorizatsiyadan chiqib ketgan.")
await client.disconnect()
continue
await delete_all_photos(client)
except RPCError as e:
print(f"{r}RPC Xatolik {phone}: {e}")
except Exception as e:
print(f"{r}Umumiy xato {phone}: {e}")
finally:
await client.disconnect()
print(f"\n{lg}Tayyor! Barcha eski rasmlar o‘chirildi.")
input("CHIQISH uchun ENTER bosing...")
if __name__ == '__main__':
asyncio.run(main())
elif a == 22:
import csv
import os
import time
import random
import string
from telethon.sync import TelegramClient
from telethon.sessions import StringSession
from telethon.errors import (
PhoneNumberInvalidError,
SessionPasswordNeededError,
PhoneCodeInvalidError,
FloodWaitError,
PhoneNumberBannedError
)
from telethon.tl.types import MessageEntityTextUrl
API_ID = 253798
HashID = 'd806c9ed3eb74a233d58cb4a072a68f0'
# --- YANGI: realistik 2024-2025 qurilmalar + helper ---
RANDOM_DEVICES = [
# ==== Android flagman/upper-mid ====
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-S926B (Galaxy S24+)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A356B (Galaxy A35)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14T Pro', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
# ==== Huawei (Harmony) ====
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
LANG_POOL = ['en','uz']
def get_random_device_params():
"""
Realistik qurilma parametrlari + til kodlari.
Istasangiz, system_version oxiriga qo'shimcha identifikator ham qo'shsa bo'ladi.
"""
d = random.choice(RANDOM_DEVICES).copy()
# (ixtiyoriy) Androidlar uchun “sdk …” suffix qo'shish o‘xshashlik uchun:
if 'Android' in d['system_version']:
# Masalan, ichki SDK agent identifikatori (faqat matn, tekshiruv yo'q)
d['system_version'] += ' | sdk 4.16.3-PYRO17'
lang = random.choice(LANG_POOL)
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': lang,
'system_lang_code': lang
}
def generate_random_email():
names = [
"botir", "malika", "aziza", "javlon", "feruza", "sardor", "shahnoza",
"umar", "anvar", "timur", "kamila", "lola", "islom", "shirin",
"ilya", "sofia", "maksim", "arina", "nargiza",
"alina", "amir", "maruf", "sasha", "vali", "lera", "azamat", "dina",
"adrian", "melissa", "lucas", "hannah", "liam", "noah", "emma", "oliver"
]
domains = [
"gmail.com", "outlook.com", "yahoo.com", "icloud.com",
"zoho.com", "tutanota.com", "proton.me", "gmx.com",
"fastmail.com", "pm.me"
]
name = random.choice(names)
separator = random.choice(["", ".", "_"])
suffix = ''.join(random.choices(string.digits, k=random.randint(2, 4))) if random.random() < 0.7 else random.choice(names[:10])[:3]
domain = random.choice(domains)
return f"{name}{separator}{suffix}@{domain}"
def append_unique_frozen_account(phone_number):
file = 'frozen_accounts.csv'
try:
with open(file, 'r', encoding='utf-8') as f:
existing = [row[0] for row in csv.reader(f)]
except FileNotFoundError:
existing = []
if phone_number not in existing:
with open(file, 'a', encoding='utf-8', newline='') as f:
csv.writer(f).writerow([phone_number])
def remove_from_csv(phone_number, filename):
try:
# Fayl mavjudligini tekshirish
if not os.path.exists(filename):
return
with open(filename, 'r', encoding='utf-8') as f:
lines = f.readlines()
with open(filename, 'w', encoding='utf-8') as f:
for line in lines:
# Raqamni to'liq mos kelish bo'yicha tekshirish
if phone_number != line.strip().split(',')[0]:
f.write(line)
except Exception as e:
print(f"XATOLIK {filename}: {e}")
def add_to_csv(phone_number, filename):
try:
with open(filename, 'r', encoding='utf-8') as f:
existing = [row[0] for row in csv.reader(f)]
except FileNotFoundError:
existing = []
if phone_number not in existing:
with open(filename, 'a', encoding='utf-8', newline='') as f:
csv.writer(f).writerow([phone_number])
def process_account(phone_number, from_file):
session_file = f'sessions/telethon_{phone_number}.session'
if not os.path.exists(session_file):
print(f"❌ SESSIYA TOPILMADI: {phone_number}")
return
try:
device_params = get_random_device_params()
with open(session_file, 'r') as f:
session_string = f.read().strip()
client = TelegramClient(StringSession(session_string), API_ID, HashID, **device_params)
client.connect()
if not client.is_user_authorized():
print(f"⚠️ {phone_number}: Sessiya yaroqsiz yoki avtorizatsiyadan o'tmagan.")
client.disconnect()
return
input_peer = client.get_entity('spambot')
client.send_message(input_peer, "/start")
time.sleep(2)
msg = client.get_messages(input_peer, limit=1)[0]
text = msg.text.lower()
if "blocked for violations" in text or "account is blocked" in text:
print(f"⛔ MUZLATILGAN → {phone_number}")
if from_file == "phone":
append_unique_frozen_account(phone_number)
remove_from_csv(phone_number, "phone.csv")
print("📥 O'TQAZILDI frozen_accounts.csv ga")
client.disconnect()
return
elif from_file == "frozen":
initial_responses = ["This is a mistake", "My account was hacked"]
random_initial_response = random.choice(initial_responses)
client.send_message(input_peer, random_initial_response)
print(f"INFO: Dastlabki javob yuborildi: '{random_initial_response}'")
time.sleep(2)
response = client.get_messages(input_peer, limit=1)[0]
resp_text = response.text.lower()
if "you've already submitted a complaint recently" in resp_text:
print(f"⚠️ {phone_number}: Ariza oldin jonatilgan.!")
append_unique_frozen_account(phone_number)
client.disconnect()
return
if "would you like to submit a complaint" in resp_text:
client.send_message(input_peer, "Yes")
time.sleep(2)
me = client.get_me()
complaint_templates = [
f"Hey Telegram team 👋 my account (+{phone_number}) seems restricted for some reason. I honestly don’t know why — I just use Telegram to chat with friends. Could you please review it when you can? Thanks 🙏\n\n— {me.first_name}",
f"Hello dear Telegram Support,\nI noticed my account (+{phone_number}) got frozen. Maybe there was a mistake? I’ve been using it for normal chats and work stuff only. Please check it out whenever possible. Thanks a lot!\n\nRegards,\n{me.first_name}",
f"Hi Telegram,\nMy account +{phone_number} got limited today and I’m not sure why 😕 I always try to follow the rules. Could you please have a look at it and maybe remove the restriction?\n\nThank you,\n{me.first_name}",
f"Dear Telegram Team,\nI’m writing because my number +{phone_number} has been restricted. I think there’s been some misunderstanding. I’m an active Telegram user, and this app is really important for me. Please help me restore my access 🙏\n\nSincerely,\n{me.first_name}",
f"Hey guys, my Telegram (+{phone_number}) got blocked suddenly. I didn’t spam or do anything bad. Maybe I was reported by mistake? Please review it for me. I really appreciate your help ❤️\n\nThanks,\n{me.first_name}",
f"Hi,\nI just found out my Telegram number +{phone_number} has some kind of limitation. I’m not a spammer — I only talk to friends and join small groups. Please help me fix this if possible!\n\nBest regards,\n{me.first_name}",
f"Hello Telegram Support,\nCould you please check my account +{phone_number}? It says it’s restricted, but I didn’t break any rules. Maybe it was flagged by mistake. I’d be grateful if you can review it.\n\nKind regards,\n{me.first_name}",
f"Dear Support,\nMy Telegram number +{phone_number} seems frozen. I think it’s some automated error — I’ve always used it respectfully. Can you please look into it and unlock it?\n\nThank you so much,\n{me.first_name}",
f"Hey, my account +{phone_number} got limited today. I didn’t do anything unusual — I just use Telegram for chatting and channels. Please double-check and remove this limit if possible 🙏\n\nCheers,\n{me.first_name}",
f"Hi Telegram team,\nMy account +{phone_number} shows a restriction notice. Maybe it’s an error or false report. Please check it once again. I really rely on Telegram daily for messages and news.\n\nThanks in advance,\n{me.first_name}"
]
random_complaint = random.choice(complaint_templates)
client.send_message(input_peer, random_complaint)
time.sleep(2)
client.send_message(input_peer, me.first_name)
time.sleep(2)
client.send_message(input_peer, generate_random_email())
time.sleep(2)
# --- BU YERDA ASOSIY O'ZGARISH ---
# 1. Ro'yxatdan o'tgan yil uchun variantlar
registration_years = ["2024", "2023", "2022", "2025"]
# 2. Telegram haqida qayerdan eshitgani haqida variantlar
how_found_tg = [
"My friends told me about it a long time ago",
"I saw people using it on Instagram and decided to try",
"I found it while looking for a private messenger in Play Store",
"A coworker added me to a Telegram group for work",
"Heard about it from my cousin, he said it's safer than others",
"I saw it mentioned in a tech blog about secure apps",
"Someone invited me to join a study group on Telegram",
"I was using WhatsApp before but switched because of privacy",
"I saw it trending on social networks and got curious",
"A friend sent me a link to a Telegram channel"
]
# 3. Foydalanish maqsadi haqida variantlar
usage_purpose = [
"Mostly for chatting with friends and family",
"I use it to follow channels about tech and news",
"To stay in touch with people from work and school",
"For reading updates and sharing photos with friends",
"I’m in a few hobby groups, mostly cars and gadgets",
"I use it daily to keep in touch and read interesting posts",
"For personal messages and some group discussions",
"Mainly to read news channels and talk to my close friends",
"I follow some local communities and use it to learn things",
"It’s just my main messenger now — I use it for everything"
]
# Tasodifiy javoblarni yuborish
random_year = random.choice(registration_years)
client.send_message(input_peer, random_year)
print(f"INFO: Yil yuborildi: '{random_year}'")
time.sleep(2)
random_found_source = random.choice(how_found_tg)
client.send_message(input_peer, random_found_source)
print(f"INFO: Manba yuborildi: '{random_found_source}'")
time.sleep(2)
random_purpose = random.choice(usage_purpose)
client.send_message(input_peer, random_purpose)
print(f"INFO: Maqsad yuborildi: '{random_purpose}'")
time.sleep(2)
# -------------------------------------------------
client.send_message(input_peer, "Confirm")
time.sleep(2)
msg2 = client.get_messages(input_peer, limit=1)[0]
if msg2.entities:
for entity in msg2.entities:
if isinstance(entity, MessageEntityTextUrl):
link = entity.url
print(f"🔗 CloudFlare: {link}")
os.system(f'start "" "{link}"')
input("➡ ENTER BOSING DAVOM ETISH UCHUN...")
break
client.send_message(input_peer, "Done")
print(f"✅ ARIZA JO'NATILDI: {phone_number}")
elif ("no limits are currently applied" in text or "good news" in text or "ваш аккаунт свободен" in text or "xushxabarimiz bor" in text):
print(f"✅ AKOUNT YAXSHI XOLATDA ⇨ {phone_number}")
client.send_message(input_peer, "Cool, thanks")
if from_file == "frozen":
remove_from_csv(phone_number, "frozen_accounts.csv")
add_to_csv(phone_number, "phone.csv")
print("🔁 QAYTARILDI phone.csv ga")
else:
print(f"⚠ VAQTINCHA CHEKLANGAN: {phone_number}")
client.disconnect()
except PhoneNumberBannedError:
print(f"🚫 {phone_number}: TO'LIQ BAN QILINGAN (PhoneNumberBannedError)")
append_unique_frozen_account(phone_number)
if from_file == "phone":
remove_from_csv(phone_number, "phone.csv")
return
except Exception as e:
print(f"❗ XATOLIK {phone_number}: {e}")
if 'client' in locals() and client.is_connected():
client.disconnect()
except PhoneNumberBannedError:
print(f"🚫 {phone_number}: TO'LIQ BAN QILINGAN (PhoneNumberBannedError)")
append_unique_frozen_account(phone_number)
if from_file == "phone":
remove_from_csv(phone_number, "phone.csv")
return
except Exception as e:
print(f"❗ XATOLIK {phone_number}: {e}")
if 'client' in locals() and client.is_connected():
client.disconnect()
def main():
# 'sessions' papkasi mavjudligini tekshirish
if not os.path.exists('sessions'):
os.makedirs('sessions')
print("📥 START phone.csv...")
if os.path.exists("phone.csv"):
with open("phone.csv", 'r', encoding='utf-8') as f:
# Fayldan o'qiyotganda bo'sh qatorlarni o'tkazib yuborish
phone_list = [row[0] for row in csv.reader(f) if row]
for phone in phone_list:
process_account(phone, from_file="phone")
print("\n🧊 START frozen_accounts.csv...")
if os.path.exists("frozen_accounts.csv"):
with open("frozen_accounts.csv", 'r', encoding='utf-8') as f:
frozen_list = [row[0] for row in csv.reader(f) if row]
for phone in frozen_list:
process_account(phone, from_file="frozen")
print("\n✅ TUGALLANDI.")
input("ENTER CHIQISH UCHUN...")
if __name__ == "__main__":
main()
elif a == 23:
import os
import random
import time
import csv
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.tl.functions.account import UpdateProfileRequest
from telethon.errors import FloodWaitError, RPCError
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# ---- REAL MOBIL QURILMALAR (desktop yo‘q) ----
RANDOM_DEVICES = [
# Android 2024–2025
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
# HarmonyOS
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
# ozgina “SDK imzo” qo‘shamiz (xohlasangiz olib tashlaysiz)
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# 🔹 BIO randomlari
random_bios = [
"Hayot go'zal! 🌟",
"Telegramda yangiman 😎",
"Kod yozishni yaxshi ko'raman 👨💻",
"Bugun yaxshi kayfiyatda 😊",
"Sayohat qilishga oshiqaman ✈️",
"O‘rganish – bu kuch! 📚",
"Har kuni yangi imkoniyat! 🔥",
"O'yin emas – bu hayot 🎮",
"Kulish – eng yaxshi davo 😄",
"Yirik orzular – katta natija!",
"Hayot – bu sarguzasht! 🚀",
"Qo'rqma, boshlang!",
"Bugungi ish, ertangi natija!",
"Kechalarni yorituvchi fikrlar ✨",
"Faqat oldinga! 💪",
"Men bunday tug'ilganman! 😎",
"Kichik qadamlar – katta muvaffaqiyatlar!",
"Sukut bu donolik belgisi.",
"Men kelajak uchun ishlayman.",
"Boshlash uchun hech qachon kech emas 🌱",
"Qoralama bugungi, kelajak — toza sahifa 📝",
"Fikrlarim tezroq ishlaydi, Internetdan ham.",
"Hayot bu kod – men uni yozyapman.",
"Asl men – hozirgi men. 🎯",
"Men texnologiyani nafas olaman 🤖",
"Dunyo bilan ulashadigan hikoyalarim bor.",
"Salom dunyo! 👋",
"Do’stlik uchun ochiqman 🤝",
"Shunchaki men – o’zgacha uslubda.",
"Tilim 🔥, qalbim 🚀",
"Sodda, ammo chuqur.",
"Optimizm – mening oldingi ishim 😁",
"Kofe, kod, ishlash, takrorlash ☕👨💻",
"Sekin bo‘lsa ham, oldinga yuraman.",
"O'zingga ishongin – bu boshlanishi.",
"Hech kimga o'xshamayman — va bu zo’r! 💎",
"Dunyo bo'ylab virtual sayohachi 🧭",
"Yorqin fikrlar qora fonlarda porlaydi 🌓",
"Kod yozish – bu mening sheʼriyatim.",
"Bugun o'zgacha bo'lishga qaror qildim.",
"Jarayonni sev – natija o‘z-o‘zidan keladi."
]
# phone.csv o‘qish (+ bilan/siz mos)
def read_phone_numbers_from_csv(csv_file):
phone_numbers = []
with open(csv_file, 'r') as f:
reader = csv.reader(f)
for row in reader:
if row:
raw = row[0].strip()
if not raw:
continue
# normalize: +998... yoki 998...
p = raw.replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
if not p.startswith('+'):
p = '+' + p
phone_numbers.append(p)
return phone_numbers
def generate_random_bio():
return random.choice(random_bios)
async def change_profile_bio(client, bio):
await client(UpdateProfileRequest(about=bio))
async def main():
phone_numbers = read_phone_numbers_from_csv('phone.csv')
for phone_number in phone_numbers:
# sessions/telethon_+998... yoki +siz yozilgan bo‘lishi mumkin — + belgisini fayl nomidan olib tashlaymiz
safe_name = phone_number.replace('+', '')
session_file = f'sessions/telethon_{safe_name}.session'
try:
with open(session_file, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
except FileNotFoundError:
print(f"❌ Session fayl topilmadi: {phone_number}")
continue
device_params = get_device_params()
client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"🚫 Akount chiqarilgan: {phone_number}")
await client.disconnect()
continue
bio = generate_random_bio()
try:
await change_profile_bio(client, bio)
print(f"✅ [{phone_number}] Bio o‘zgartirildi: \"{bio}\"\n")
except FloodWaitError as e:
print(f"⏳ FloodWait! Kuting {e.seconds} sekund... ({phone_number})")
# async kutish — event loopni to‘smasin
import asyncio
await asyncio.sleep(e.seconds + 2)
except RPCError as e:
print(f"⚠️ RPC xato: {phone_number}: {str(e)}")
except Exception as e:
print(f"❗️ Xatolik: [{phone_number}]: {str(e)}")
finally:
await client.disconnect()
print("✅ Barcha Bio-lar o'zgartirildi!")
input("CHiqish uchun ENTER bosing...")
if __name__ == "__main__":
import asyncio
# Windows 3.12 da loop siyosati uchun foydali bo‘lishi mumkin:
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
asyncio.run(main())
elif a == 24:
import os
import random
import time
import csv
import requests
from telethon import TelegramClient
from telethon.sessions import StringSession
from telethon.errors import FloodWaitError, RPCError
from telethon.tl.functions.stories import SendStoryRequest, GetPeerStoriesRequest, DeleteStoriesRequest
from telethon.tl import types
import asyncio
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
# === MOBIL QURILMA FINGERPRINTLARI ===
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def get_device_params():
d = random.choice(RANDOM_DEVICES).copy()
if 'Android' in d['system_version']:
d['system_version'] += ' | sdk 4.16.3-PYRO17'
return {
'device_model': d['device_model'],
'system_version': d['system_version'],
'app_version': d['app_version'],
'lang_code': 'en',
'system_lang_code': 'en',
}
# === FUNKSIYALAR ===
def read_phone_numbers_from_csv(csv_file):
numbers = []
if not os.path.exists(csv_file):
print(f"❌ Fayl topilmadi: {csv_file}")
return numbers
with open(csv_file, 'r') as f:
for row in csv.reader(f):
if row and row[0].strip():
numbers.append(row[0].strip())
return numbers
def download_random_image(save_path):
url = "https://picsum.photos/1080/1920"
try:
print(f"🖼️ '{save_path}' uchun rasm yuklanmoqda...")
response = requests.get(url, timeout=15)
response.raise_for_status()
with open(save_path, 'wb') as f:
f.write(response.content)
return save_path
except Exception as e:
print(f"❗️ Rasm yuklanmadi: {e}")
return None
RANDOM_CAPTIONS = [
"Hayot go'zal! 🌟", "Telegramda yangiman 😎", "Bugun yaxshi kayfiyatda 😊",
"Sayohat qilishga oshiqaman ✈️", "O‘rganish – bu kuch! 📚",
"Har kuni yangi imkoniyat! 🔥", "Kulish – eng yaxshi davo 😄",
"Yirik orzular – katta natija!", "Hayot – bu sarguzasht! 🚀", "Salom dunyo! 👋"
]
def random_caption():
return random.choice(RANDOM_CAPTIONS)
# === STORIES O‘RNATISH ===
async def send_story(client):
PIN_STORY = False
NO_FORWARDS = False
PRIVACY_RULE = types.InputPrivacyValueAllowAll()
MAX_NON_PREMIUM = 1
me = await client.get_me()
is_premium = me.premium
stories = await client(GetPeerStoriesRequest(peer='me'))
count = len(stories.stories.stories) if hasattr(stories, 'stories') and hasattr(stories.stories, 'stories') else 0
print(f" - Status: {'Premium' if is_premium else 'Oddiy'}, aktiv: {count}")
if not is_premium and count >= MAX_NON_PREMIUM:
print("⚠️ Oddiy akkaunt uchun story limiti to‘lgan.")
return
filename = f"story_{me.id}.jpg"
path = download_random_image(filename)
if not path:
print("❗️ Rasm topilmadi.")
return
try:
file = await client.upload_file(path)
media = types.InputMediaUploadedPhoto(file=file)
await client(SendStoryRequest(
peer='me',
media=media,
caption=random_caption(),
privacy_rules=[PRIVACY_RULE],
pinned=PIN_STORY,
noforwards=NO_FORWARDS
))
print("✅ Story muvaffaqiyatli joylandi!")
finally:
if os.path.exists(path):
os.remove(path)
# === STORIES O‘CHIRISH ===
async def delete_stories(client):
try:
stories = await client(GetPeerStoriesRequest(peer='me'))
ids = []
if hasattr(stories, 'stories') and hasattr(stories.stories, 'stories'):
ids = [s.id for s in stories.stories.stories]
if not ids:
print("✅ O‘chirish uchun aktiv story yo‘q.")
return
await client(DeleteStoriesRequest(peer='me', id=ids))
print(f"🗑️ {len(ids)} ta story o‘chirildi.")
except Exception as e:
print(f"❗️ O‘chirishda xato: {e}")
# === ASOSIY JARAYON ===
async def process_accounts(action):
phones = read_phone_numbers_from_csv('phone.csv')
if not phones:
print("❌ phone.csv bo‘sh!")
return
print(f"\nJami {len(phones)} ta akkaunt topildi.\n")
for idx, phone in enumerate(phones, 1):
print(f"{idx}/{len(phones)} → {phone}")
session_file = f'sessions/telethon_{phone}.session'
if not os.path.exists(session_file):
print(" ❌ Sessiya topilmadi.")
continue
try:
with open(session_file, 'r', encoding='utf-8') as f:
session = f.read().strip()
client = TelegramClient(StringSession(session), API_ID, API_HASH, **get_device_params())
await client.connect()
if not await client.is_user_authorized():
print(" 🚫 Akkaunt avtorizatsiyadan chiqqan.")
await client.disconnect()
continue
if action == 1:
await send_story(client)
else:
await delete_stories(client)
except FloodWaitError as e:
print(f"⏳ FloodWait: {e.seconds} sek kutamiz...")
await asyncio.sleep(e.seconds + 3)
except Exception as e:
print(f"❗️ Xato: {e}")
finally:
if client.is_connected():
await client.disconnect()
print(" 🔌 Ulanish uzildi.\n")
print("✅ Barcha akkauntlar bilan ish yakunlandi.")
input("ENTER chiqish...")
# === BOSHLASH ===
if __name__ == "__main__":
k = int(input("[1] Stories o‘rnatish \n[2] Storiesni o‘chirish\n\nTANLANG: "))
if os.name == 'nt':
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(process_accounts(k))
elif a == 25:
import sys, subprocess, importlib
from importlib import metadata
def telethon_show_version(prefix=""):
"""O‘rnatilgan (disk) va import qilingan versiyani ko‘rsatish."""
try:
installed = metadata.version("telethon")
except metadata.PackageNotFoundError:
installed = "o‘rnatilmagan"
imported = None
if "telethon" in sys.modules:
try:
imported = getattr(sys.modules["telethon"], "__version__", None)
except Exception:
imported = "aniqlanmadi"
print(f"{lg}{prefix}Telethon (disk): {installed}{w}")
if imported is not None:
print(f"{lg}{prefix}Telethon (import): {imported}{w}")
def upgrade_telethon_quiet(min_version: str | None = None) -> bool:
"""
Telethon'ni jim (quiet) rejimda yangilaydi.
Pip chiqishi ko‘rsatilmaydi; faqat HAQIQATDA o‘zgarish bo‘lsa xabar beradi.
"""
def parse(v: str | None):
if not v: return ()
return tuple(int(x) for x in str(v).split(".") if x.isdigit())
try:
installed_before = metadata.version("telethon")
except metadata.PackageNotFoundError:
installed_before = None
imported_before = None
if "telethon" in sys.modules:
try:
imported_before = getattr(sys.modules["telethon"], "__version__", None)
except Exception:
imported_before = None
if min_version and installed_before and parse(installed_before) >= parse(min_version):
print(f"{ye}Telethon allaqachon minimal versiyada yoki undan yuqori (>= {min_version}).{w}")
return False
# pip: mutlaqo jim
try:
subprocess.run(
[sys.executable, "-m", "pip", "install", "--upgrade", "telethon", "-q", "--disable-pip-version-check"],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False
)
except Exception:
pass
try:
installed_after = metadata.version("telethon")
except metadata.PackageNotFoundError:
installed_after = installed_before
if installed_after == installed_before:
print(f"{ye}Yangilanish topilmadi (hozirgi: {installed_after}).{w}")
return False
# Diskdagi versiya o‘zgardi — modulni reload qilib ko‘ramiz
try:
if "telethon" in sys.modules:
importlib.invalidate_caches()
importlib.reload(sys.modules["telethon"])
else:
import telethon # noqa: F401
imported_after = getattr(sys.modules["telethon"], "__version__", None)
except Exception:
imported_after = imported_before
print(f"{lg}[NEW] Telethon versiyasi o‘rnatildi: {installed_after}{w}")
if imported_after != installed_after:
print(f"{ye}Eslatma: yangi versiyadan foydalanish uchun skriptni qayta ishga tushiring.{w}")
return True
def telethon_upgrade_menu_action():
print(f"{ye}Telethon versiyasini tekshiryapmiz...{w}")
telethon_show_version(prefix="[OLD] ")
changed = upgrade_telethon_quiet(min_version=None) # xohlasang: "1.42.0"
if changed:
telethon_show_version(prefix="[AFTER] ")
input(f"{lg}Tugadi. Davom etish uchun ENTER...{w}")
telethon_upgrade_menu_action()
continue
elif a == 26:
import sys, subprocess, os, csv, time
from telethon import TelegramClient
from telethon.sessions import StringSession, SQLiteSession
from telethon.errors import SessionPasswordNeededError
from telethon.errors.rpcerrorlist import (
AuthTokenExpiredError, AuthTokenInvalidError, AuthTokenAlreadyAcceptedError
)
# === QR-CODE MODULINI TEKSHIRISH / O'RNATISH (jim) ===
try:
from qrcode import QRCode
except ImportError:
print(f"{ye}qrcode moduli topilmadi. O‘rnatilmoqda...{w}")
subprocess.run(
[sys.executable, "-m", "pip", "install", "qrcode", "-q", "--disable-pip-version-check"],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
)
try:
from qrcode import QRCode
print(f"{lg}qrcode muvaffaqiyatli o‘rnatildi.{w}")
except Exception as e:
print(f"{r}qrcode ni import qilishda xato: {e}{w}")
input("ENTER...")
continue
# === Sozlamalar ===
QR_REFRESH_SEC = 30 # QR’ni qayta chizish oralig‘i (token tugashidan oldin)
WAIT_CHUNK = 25 # wait() ni bo'laklab kutish (sekund)
# === Yordamchi funksiyalar ===
def normalize_phone(s: str) -> str:
if not s: return ''
s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
return s[1:] if s.startswith('+') else s
def display_qr_ascii(data: str):
qr = QRCode(border=1)
qr.add_data(data)
qr.print_ascii(invert=True)
def save_sqlite_from_client(client: TelegramClient, sqlite_path: str):
"""StringSession bilan avtorizatsiyalangan client'dan SQLite .session yaratadi."""
base = client.session
sess = SQLiteSession(sqlite_path)
try:
sess.set_dc(base.dc_id, base.server_address, base.port)
except AttributeError:
sess.set_dc(getattr(base, 'dc_id', 2),
getattr(base, 'server_address', '149.154.167.50'),
getattr(base, 'port', 443))
sess.auth_key = getattr(base, 'auth_key', None)
sess.takeout_id = getattr(base, 'takeout_id', None)
try:
sess.user = getattr(base, 'user', None)
except Exception:
pass
sess.save()
# Bloklovchi wrapperlar: coroutine'larni to‘g‘ri kutish uchun
def qr_wait_blocking(client: TelegramClient, qr_login, timeout: int) -> bool:
return client.loop.run_until_complete(qr_login.wait(timeout))
def qr_recreate_blocking(client: TelegramClient, qr_login) -> None:
return client.loop.run_until_complete(qr_login.recreate())
# --- Yangi: 2FA parolini 3 martagacha urinish bilan kiritish ---
def sign_in_with_password_retries(client: TelegramClient, label: str, tries: int = 3) -> bool:
for attempt in range(1, tries + 1):
pwd = input(f"{ye}2FA parolni kiriting ({label}) [urinish {attempt}/{tries}]: {w}")
try:
client.sign_in(password=pwd)
return True
except Exception as e:
print(f"{r}Parol qabul qilinmadi: {e}{w}")
print(f"{r}{label}: 2FA paroli {tries} urinishda ham tasdiqlanmadi. Akkaunt tashlab o‘tiladi.{w}")
return False
# === Telefonlarni o‘qish ===
phones = []
if not os.path.exists('phone.csv'):
print(f"{r}XATO: phone.csv topilmadi!{w}"); input(); continue
with open('phone.csv', 'r', encoding='utf-8') as f:
for row in csv.reader(f):
if not row: continue
raw = row[0].strip()
if not raw: continue
clean = normalize_phone(raw)
e164_phone = raw if raw.startswith('+') else f'+{clean}'
phones.append({'raw': raw, 'clean': clean, 'e164': e164_phone})
if not phones:
print(f"{r}phone.csv bo‘sh.{w}"); input(); continue
os.makedirs('sessions', exist_ok=True)
print(f"{lg}QR orqali ro‘yxatdan o‘tkazish boshlanadi. Har safar bitta akount!{w}")
print(f"{ye}QR chiqqanda Telegram orqali skanerlab tasdiqlang.{w}\n")
# === Akountlar ketma-ket (navbat bilan) — keyingisi faqat oldingisi tugagach ===
for idx, p in enumerate(phones, start=1):
raw, clean, e164_phone = p['raw'], p['clean'], p['e164']
str_path = f'sessions/telethon_{clean}.session'
sql_path = f'sessions/{clean}_SQLite.session'
# Agar allaqachon ro‘yxatdan o‘tgan bo‘lsa — tashlab o‘tamiz
if os.path.exists(str_path) and os.path.exists(sql_path):
print(f"{ye}[{idx}] {raw}: allaqachon ro‘yxatdan o‘tgan. O‘tkazib yuborildi.{w}")
continue
print(f"{lg}[{idx}] {raw}: QR login tayyorlanmoqda...{w}")
# 1) StringSession bilan QR login
str_client = TelegramClient(StringSession(), API_ID, HASHID)
str_client.connect()
try:
qr_login = str_client.qr_login()
except Exception as e:
print(f"{r}[{raw}] QR login yaratib bo‘lmadi: {e}{w}")
str_client.disconnect()
continue
authed = False
last_draw = 0.0
# — faqat shu akount tugaguncha shu yerda turamiz (keyingisi boshlanmaydi) —
while not authed:
now = time.time()
# QR'ni periodik qayta chizish (token muddati tugashidan oldin)
if now - last_draw >= QR_REFRESH_SEC:
print(f"{w}\n{ye}Skaner qiling (QR har {QR_REFRESH_SEC}s yangilanadi). Akkaunt: {raw}{w}")
# mobil kamera bilan bevosita ham ochish uchun:
print(qr_login.url)
# terminalda ASCII QR:
try:
display_qr_ascii(qr_login.url)
except Exception:
pass
last_draw = now
try:
# Muhim: wait() korutina — bloklab kutamiz
authed = qr_wait_blocking(str_client, qr_login, WAIT_CHUNK)
except (AuthTokenExpiredError, AuthTokenInvalidError):
# Token muddati tugadi/invalid — sokin yangilaymiz
try:
qr_recreate_blocking(str_client, qr_login)
last_draw = 0.0 # qayta chizamiz
continue
except Exception as e:
# Ko‘pincha 2FA yoqilganida ExportLoginToken bloklanadi
print(f"{ye}QR token yangilanmadi (ehtimol 2FA). 2FA tekshiruviga o‘tyapmiz...{w}")
# ↓↓↓ FALLBACK: parol yoki kod bilan kirish
try:
# 3 urinish bilan parol
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
except Exception:
pass
try:
str_client.send_code_request(e164_phone)
code = input(f"{ye}{raw} uchun Telegram yuborgan kod: {w}").strip()
try:
str_client.sign_in(e164_phone, code)
authed = True
break
except SessionPasswordNeededError:
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
else:
print(f"{r}[{raw}] 2FA paroli tasdiqlanmadi, akount tashlab o‘tamiz.{w}")
break
except Exception as e3:
print(f"{r}[{raw}] Kod/parol bilan kirish ham muvaffaqiyatsiz: {e3}{w}")
break
except AuthTokenAlreadyAcceptedError:
authed = True
break
except SessionPasswordNeededError:
# Server QR o‘rniga darrov parol talab qildi
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
else:
# Parol xato bo‘lsa – kodga tushamiz
try:
str_client.send_code_request(e164_phone)
code = input(f"{ye}{raw} uchun Telegram yuborgan kod: {w}").strip()
try:
str_client.sign_in(e164_phone, code)
authed = True
break
except SessionPasswordNeededError:
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
else:
print(f"{r}[{raw}] 2FA paroli tasdiqlanmadi, akount tashlab o‘tamiz.{w}")
break
except Exception as e3:
print(f"{r}[{raw}] Kod/parol bilan kirish ham muvaffaqiyatsiz: {e3}{w}")
break
except Exception:
# Har qanday boshqa xatoda ham yana bir bor QR’ni yangilab ko‘ramiz,
# bo‘lmasa 2FA fallback
try:
qr_recreate_blocking(str_client, qr_login)
last_draw = 0.0
continue
except Exception:
print(f"{ye}QR yangilashda muammo, 2FA fallback...{w}")
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
try:
str_client.send_code_request(e164_phone)
code = input(f"{ye}{raw} uchun Telegram kodi: {w}").strip()
try:
str_client.sign_in(e164_phone, code)
authed = True
break
except SessionPasswordNeededError:
if sign_in_with_password_retries(str_client, raw, 3):
authed = True
break
else:
print(f"{r}[{raw}] 2FA paroli tasdiqlanmadi, akount tashlab o‘tamiz.{w}")
break
except Exception as e3:
print(f"{r}[{raw}] Kirish imkoni bo‘lmadi: {e3}{w}")
break
if not authed:
print(f"{r}[{raw}] Kirish amalga oshmadi. Keyingisiga o‘tamiz.{w}")
str_client.disconnect()
continue
# 2) StringSession ni saqlash
try:
str_session_str = str_client.session.save()
with open(str_path, 'w', encoding='utf-8') as sf:
sf.write(str_session_str)
print(f"{lg}[{raw}] StringSession saqlandi: {str_path}{w}")
except Exception as e:
print(f"{r}[{raw}] StringSession saqlashda xato: {e}{w}")
str_client.disconnect()
continue
# 3) SQLite session’ga ko‘chirish
try:
save_sqlite_from_client(str_client, sql_path)
print(f"{lg}[{raw}] SQLite session saqlandi: {sql_path}{w}")
except Exception as e:
print(f"{r}[{raw}] SQLite saqlashda xato: {e}{w}")
# 4) Tugatamiz — keyingi akount faqat shundan keyin boshlanadi
str_client.disconnect()
print(f"{lg}[{raw}] Ro‘yxatdan o‘tish yakunlandi.{w}\n")
input(f"{lg}Barcha akountlar uchun QR jarayon tugadi. ENTER...{w}")
continue
elif a == 27:
import os
import csv
import asyncio
import random
from typing import List, Tuple
from telethon import TelegramClient, functions, types # ⬅️ birthday uchun
from telethon.sessions import StringSession
from telethon.errors import (
FloodWaitError, UserPrivacyRestrictedError, ChatWriteForbiddenError,
PhoneNumberBannedError, RPCError
)
from telethon.tl.types import User, Channel, Chat
from telethon.tl.functions.contacts import ImportContactsRequest
from telethon.tl.types import InputPhoneContact
# ====== API ======
API_ID = 253798
API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'
SESS_DIR = 'sessions'
PHONE_CSV = 'phone.csv'
# ====== Qurilma fingerprintlari (realistik) ======
RANDOM_DEVICES = [
{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Google Pixel 8 Pro', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},
{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},
]
def dev_params():
d = random.choice(RANDOM_DEVICES).copy()
d['system_version'] += ' | sdk 4.16.3-PYRO17'
d['lang_code'] = 'en'
d['system_lang_code'] = 'en'
return d
# ====== “Insoniy” xabarlar ======
SAVOLLAR = [
"Salom, qalesan?", "Assalomu alaykum! Bugun qanday kun?", "Nima yangiliklar?",
"Bugun nimalar qilding?", "Ishlar qalay?", "Qayerdansan o‘zi?",
"Bugungi rejalaring qanday?", "Hozir nima bilan bandsan?", "Kun qanday oʻtmoqda?",
"Yaqinda qiziqarli narsa bo‘ldimi?", "Tavsiyangiz bormi yaqin atrofga borish uchun?",
"Qaysi filmni oxirgi ko‘rding va qanday?", "Sevimli musiqangiz nima hozirlar?",
"Qaysi dastur yoki ilova bilan ishlayapsiz?", "Kichik yordam bera olasizmi: maslahat beringchi?",
"Qiziq: ertaga nimani rejalashtirdingiz?", "Hobbilaring nima? Bo‘lishib yuboring.",
"Kofe yoki choy? 😊", "Ishda yangi loyiha bormi?", "Kechqurun nima qilmoqchisiz?",
"Qanday dasturlash tili eng yoqadi?", "Sayohatga chiqmoqchi boʻlsang, qayerga borarding?",
"Kamera orqali suratlar ko‘rishga qiziqasizmi?", "Bugun kayfiyatingizga 1 dan 10 gacha baho bering?",
"Eng yaxshi dam olish kuningiz qanday o‘tadi?"
]
JAVOBLAR = [
"Yaxshi, rahmat! O'zingchi? 😊", "Hammasi joyida — ishlayapman hozir.",
"Kechki payt choy ichamiz, keyin gaplashamiz.", "Ajoyib, yaqinda yangi loyiha boshladim.",
"Hozir biroz bandman, keyin yozaman.", "Zo‘r, rahmat! Bugun yaxshi kayfiyat.",
"Men ham xuddi shunday — ishlar serob.", "Qiziq savol! Men film ko‘rishni afzal ko‘raman.",
"Ha, sayohat juda yoqadi!", "Kofe > choy, albatta ☕", "O‘ylab ko‘raman, rahmat.",
"Bugun biroz dam oldim, yaxshi boʻldi.", "Kod yozish — mening hobbiym.",
"Hozir onlayn, 10 daqiqadan keyin gaplashsak?", "Menga lo-fi yoqadi, tavsiya qilaman!",
"Super — men ham xuddi shunday qilaman!", "Rahmat, foydali maslahat.",
"Uyda kitob o‘qiyapman — 'Atomic Habits' tavsiya.", "Ajoyib g‘oya — sinab ko‘raman.",
"Tushundim, keyin bog‘lanamiz.", "Bu juda kulgili 😂", "Har kuni kichik qadamlar muhim.",
"Dam olishda tabiat — eng zo‘r.", "Ok, keyinroq batafsil yozaman.", "10/10 — samarali kun bo‘ldi!"
]
READ_LIMIT_PER_CHAT = (5, 12)
DIALOG_ROUNDS = (1, 2)
DM_SLEEP = (2.0, 5.0)
READ_SLEEP = (1.0, 2.5)
# ====== Helpers ======
def normalize_phone(s: str) -> str:
if not s:
return ''
s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
return s[1:] if s.startswith('+') else s
def to_e164(clean: str) -> str:
return f'+{clean}'
def read_phones(path: str) -> List[str]:
phones = []
if not os.path.exists(path):
print(f"[XATO] {path} topilmadi.")
return phones
with open(path, 'r', encoding='utf-8') as f:
for row in csv.reader(f):
if not row: continue
raw = row[0].strip()
if not raw: continue
clean = normalize_phone(raw)
phones.append(clean)
return phones
async def safe_sleep(a: float, b: float):
await asyncio.sleep(random.uniform(a, b))
def is_dialog_a_chat(entity) -> bool:
return isinstance(entity, Channel) or isinstance(entity, Chat)
# ====== Chatlarda “ko‘rish” ======
async def read_some_messages(client: TelegramClient, dialog, count: int):
try:
await client.get_messages(dialog.entity, limit=count)
for _ in range(min(3, count)):
await safe_sleep(*READ_SLEEP)
await safe_sleep(0.5, 1.2)
except FloodWaitError as e:
print(f" └─ FloodWait: {e.seconds}s (ko‘rishda), kutamiz...")
await asyncio.sleep(e.seconds)
except Exception as e:
print(f" └─ Ko‘rishda xato: {e}")
# >>> Qarama-qarshi akkauntni kontaktga import qilish
async def ensure_contact(client: TelegramClient, peer_phone_e164: str, first: str = "User", last: str = "") -> bool:
try:
contact = InputPhoneContact(
client_id=random.randrange(10**9, 10**10),
phone=peer_phone_e164,
first_name=first or "User",
last_name=last or ""
)
await client(ImportContactsRequest([contact]))
return True
except FloodWaitError as e:
print(f" └─ ImportContacts FloodWait: {e.seconds}s — kutamiz...")
await asyncio.sleep(e.seconds)
return False
except Exception as e:
print(f" └─ Kontakt import xatosi ({peer_phone_e164}): {e}")
return False
# ====== RANDOM BIRTHDAY va uni o‘rnatish ======
def random_birthday() -> types.Birthday:
year = random.randint(1986, 2005)
month = random.randint(1, 12)
day = random.randint(1, 28 if month == 2 else 30) # soddalashtirilgan
return types.Birthday(day=day, month=month, year=year)
async def set_random_birthday(client: TelegramClient):
try:
bd = random_birthday()
await client(functions.account.UpdateBirthdayRequest(birthday=bd))
except Exception as e:
print(f" └─ Birthday o‘rnatishda xato: {e}")
# ====== DM yozish (kontakt import bilan) ======
async def dm_exchange(a: TelegramClient, b: TelegramClient, a_user: User, b_user: User,
a_phone_e164: str, b_phone_e164: str, rounds: int):
a_ok = await ensure_contact(a, b_phone_e164, first=b_user.first_name or "User", last=b_user.last_name or "")
b_ok = await ensure_contact(b, a_phone_e164, first=a_user.first_name or "User", last=a_user.last_name or "")
if not (a_ok and b_ok):
return
a_id = a_user.id
b_id = b_user.id
for _ in range(rounds):
# A -> B
try:
b_peer = await a.get_input_entity(b_id)
q = random.choice(SAVOLLAR)
await a.send_message(b_peer, q)
await safe_sleep(*DM_SLEEP)
except UserPrivacyRestrictedError:
return
except (ChatWriteForbiddenError, RPCError):
return
except FloodWaitError as e:
print(f" └─ FloodWait A->B: {e.seconds}s, kutamiz...")
await asyncio.sleep(e.seconds)
return
except Exception:
return
# B -> A
try:
a_peer = await b.get_input_entity(a_id)
r = random.choice([random.choice(JAVOBLAR), "Ha, tushunarli.", "Zo‘r!"])
await b.send_message(a_peer, r)
await safe_sleep(*DM_SLEEP)
except UserPrivacyRestrictedError:
return
except FloodWaitError as e:
print(f" └─ FloodWait B->A: {e.seconds}s, kutamiz...")
await asyncio.sleep(e.seconds)
return
except Exception:
return
# ====== Client tayyorlash ======
async def prepare_client(clean_phone: str):
str_path = os.path.join(SESS_DIR, f"telethon_{clean_phone}.session")
if not os.path.exists(str_path):
print(f"[{clean_phone}] session topilmadi — tashlab o‘tamiz.")
return None, None
with open(str_path, 'r', encoding='utf-8') as f:
session_string = f.read().strip()
params = dev_params()
client = TelegramClient(
StringSession(session_string),
API_ID, API_HASH,
device_model=params['device_model'],
system_version=params['system_version'],
app_version=params['app_version'],
lang_code=params['lang_code'],
system_lang_code=params['system_lang_code']
)
try:
await client.connect()
if not await client.is_user_authorized():
print(f"[{clean_phone}] avtorizatsiya yo‘q — tashlab o‘tamiz.")
await client.disconnect()
return None, None
me = await client.get_me()
return client, me
except PhoneNumberBannedError:
print(f"[{clean_phone}] BAN — tashlab o‘tamiz.")
return None, None
except Exception as e:
print(f"[{clean_phone}] ulanish xatosi: {e}")
try:
await client.disconnect()
except:
pass
return None, None
# ====== “O‘z chatlarini ko‘rish” bosqichi ======
async def view_own_chats(client: TelegramClient, me):
try:
dialogs = []
async for d in client.iter_dialogs():
if d.is_user:
continue
if d.entity and is_dialog_a_chat(d.entity):
dialogs.append(d)
if not dialogs:
print(" └─ A’zo bo‘lgan chatlar topilmadi.")
return
sample = random.sample(dialogs, k=min(2, len(dialogs)))
for d in sample:
title = getattr(d.entity, 'title', 'Chat')
print(f" └─ Ko‘rish: {title}")
to_read = random.randint(*READ_LIMIT_PER_CHAT)
await read_some_messages(client, d, to_read)
except Exception as e:
print(f" └─ Dialoglarni olishda xato: {e}")
# ====== DM orkestratsiya ======
async def dm_everyone(clients_info: List[Tuple[TelegramClient, User, str]]):
pairs = []
for i in range(0, len(clients_info) - 1, 2):
pairs.append((clients_info[i], clients_info[i+1]))
if not pairs:
print("DM uchun juftlik topilmadi (akkauntlar soni kam).")
return
for (c1, u1, p1), (c2, u2, p2) in pairs:
if u1.id == u2.id:
continue
print(f" └─ DM: {u1.first_name or u1.id} ↔ {u2.first_name or u2.id}")
rounds = random.randint(*DIALOG_ROUNDS)
try:
await dm_exchange(c1, c2, u1, u2, p1, p2, rounds)
except Exception as e:
print(f" └─ DM juftlik xatosi: {e}")
await safe_sleep(0.8, 1.4)
# ====== MAIN ======
async def main():
if os.name == 'nt':
try:
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
except Exception:
pass
phones_clean = read_phones(PHONE_CSV)
if not phones_clean:
print("phone.csv bo‘sh yoki topilmadi.")
return
os.makedirs(SESS_DIR, exist_ok=True)
# 1) Klientlarni tayyorlash
clients_info: List[Tuple[TelegramClient, User, str]] = []
for clean in phones_clean:
client, me = await prepare_client(clean)
if client and me:
e164 = to_e164(clean)
print(f"[{clean}] ulandi: {me.first_name or me.id}")
clients_info.append((client, me, e164))
await safe_sleep(0.4, 1.2)
if not clients_info:
print("Ishlaydigan akkaunt topilmadi.")
return
# 2) Har biri o‘z chatlaridan 2 tasini ko‘rib chiqadi
print("\n— Chatlarda ko‘rish bosqichi —")
for client, me, _ in clients_info:
print(f" [{me.first_name or me.id}] chatlarini ko‘rish:")
await view_own_chats(client, me)
await safe_sleep(0.8, 1.2)
# 3) HAR BIR akkauntga random birthday o‘rnatamiz
print("\n— Profil (birthday) o‘rnatish —")
for client, me, _ in clients_info:
print(f" [{me.first_name or me.id}] tug‘ilgan kuni o‘rnatilmoqda...")
await set_random_birthday(client)
await safe_sleep(0.6, 1.0)
# 4) O‘zaro DM (kontakt import bilan)
print("\n— O‘zaro DM bosqichi —")
await dm_everyone(clients_info)
# 5) Yopish
print("\nYakunlandi...")
for client, _, _ in clients_info:
try:
await client.disconnect()
except:
pass
input("ENTER — chiqish...")
if __name__ == '__main__':
asyncio.run(main())