# Telegram Botlari - Tam Kaynak ve Kurulum

**Tarih:** 2026-10-23  
**Kapsam:** 10 bot (adi *Hacked By CyberTroll* olarak degistirilmis 3 bot haric)  
**Amac:** Klasor kopyalamadan, bu dosyadaki kodlarla sifirdan kurulum

> Her botun **tam kaynak kodu** kendi bolumunde. Klasoru olustur, kodu `sorgu.py` olarak kaydet, bitti.
> Kodlar calisan sunucudan birebir alindi, hicbir sey degistirilmedi.

---

## Icindekiler

1. [Kurulum ozeti](#1-kurulum-ozeti)
2. [Calisma ortami](#2-calisma-ortami)
3. [Bot listesi ve tokenlar](#3-bot-listesi-ve-tokenlar)
4. [Bot kaynak kodlari](#4-bot-kaynak-kodlari)
   - 1. @betratg_bot
   - 2. @betrayeni_bot
   - 3. @fiksturtc_bot
   - 4. @maximtc_bot
   - 5. @hanedantel_bot
   - 6. @hanedantg_bot
   - 7. @istinyetc_bot
   - 8. @jeweltg_bot
   - 9. @kaletg_bot
   - 10. @meritrc_bot
5. [Yonetim betikleri](#5-yonetim-betikleri)
6. [Webhooklu botlar](#6-webhooklu-botlar)
7. [Guvenlik uyarisi](#7-guvenlik-uyarisi)
8. [Sorun giderme](#8-sorun-giderme)

---

## 1. Kurulum ozeti

```
<ana klasor>\
    Python Telegram - Betra\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Reyna TC\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Fikstur\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Fikstur - Copy\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Istinye Telefon - Kopya\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Hanedan - Kopya\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Istinye TC\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Jewel\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Betra TC - Copy - Copy\
        sorgu.py          <- bu dosyadaki kodu yapistir
    Python Telegram - Merit\
        sorgu.py          <- bu dosyadaki kodu yapistir
    logs\                 <- bos klasor, olustur
    botlar.py
    baslat.py
    supervizor.py
```

**Klasor adlari birebir ayni olmali.** Baslatici betikler `Python Telegram - ` onekine gore tarama yapar.

Klasor adlari bot adlariyla uyusmuyor (tarihsel sebeplerle) - ornegin `Fikstur - Copy` icinde **Maxim** botu var.
Bolum 3'teki tabloya gore eslestirin.

---

## 2. Calisma ortami

```
Python 3.14.2 (Windows x64)
```

```bash
pip install python-telegram-bot==22.8 requests==2.34.2 aiohttp==3.14.3 APScheduler==3.11.3 psutil==7.2.2 mysql-connector-python==9.4.0
```

| Paket | Surum | Not |
|---|---|---|
| python-telegram-bot | 22.8 | |
| requests | 2.34.2 | |
| aiohttp | 3.14.3 | Fikstur ve Fikstur - Copy |
| APScheduler | 3.11.3 | PTB job-queue |
| psutil | 7.2.2 | yonetim betikleri |
| mysql-connector-python | **9.4.0 - yukseltmeyin** | 26.x botlari `ACCESS_VIOLATION` ile cokertiyor |

> Bu 10 botun hicbiri MySQL kullanmiyor, ama yonetim betikleri ayni ortamda calistigi icin listede.

---

## 3. Bot listesi ve tokenlar

| # | Telegram | Bot adi | Klasor | Komutlar | Token |
|---|---|---|---|---|---|
| 1 | `@betratg_bot` | Betra Bot | `Python Telegram - Betra` | /rapor /gunsonu /bakiye | `6756846757:AAFfohn9u1NCiaWzWQuHs4ZOR2uH3qcGHvA` |
| 2 | `@betrayeni_bot` | Betra Bot | `Python Telegram - Reyna TC` | /rapor /kapanis /tc | `8751169273:AAFweyCHWJiYkKGuC8m-fPHgU7lA1_PlrFE` |
| 3 | `@fiksturtc_bot` | Fikstur Bot | `Python Telegram - Fikstur` | /btag /tc | `8905492287:AAHT_pQA583CwhjXA91hIfeh3kdOnwwfBMY` |
| 4 | `@maximtc_bot` | Maxim TC bot | `Python Telegram - Fikstur - Copy` | /btag /tc | `8609624098:AAEceuLTteg36M9gJHZ1vrUbsiA4fzQ5POM` |
| 5 | `@hanedantel_bot` | Hanedan Bot | `Python Telegram - Istinye Telefon - Kopya` | /tel | `8484233300:AAGnbEwSy5bGBB1BJTm83R8zYUr-nUfMyKw` |
| 6 | `@hanedantg_bot` WH | Hanedan Bot | `Python Telegram - Hanedan - Kopya` | /kontrol | `7824807718:AAFp-BCyP2-odXxbug4jy83534QjWf8siNU` |
| 7 | `@istinyetc_bot` WH | GO Bot | `Python Telegram - Istinye TC` | /rapor /kapanis /tc | `7898800936:AAE8cShKlZE3nyQqtMfcLvHcltr8S1OqQYU` |
| 8 | `@jeweltg_bot` | Opera Bot | `Python Telegram - Jewel` | /rapor /gunsonu /tc /ozet | `7465549518:AAF6OEVIV7PY0TkyXwBTkQ2asqPxgxu4-98` |
| 9 | `@kaletg_bot` | Kale Bot | `Python Telegram - Betra TC - Copy - Copy` | /rapor /gunsonu /tc | `8036839379:AAGLgXbKOE570RXxHAzRuZsRhGlx9iIn1BE` |
| 10 | `@meritrc_bot` WH | Merit Bot | `Python Telegram - Merit` | /rapor /gunsonu /tc | `7572062852:AAEM3ruMjheKCkOC9E84ax3rKQSwR26PNKQ` |

`WH` = webhook kurulu, bolum 6'ya bakin

> **Bu dosya canli token icerir.** Paylasilan klasore, e-postaya veya surum kontrolune koymayin.

---

## 4. Bot kaynak kodlari

Her bolumdeki kodu, belirtilen klasorde `sorgu.py` olarak **UTF-8** kodlamayla kaydedin.

---

### 1 - @betratg_bot

**Klasor:** `Python Telegram - Betra`

| | |
|---|---|
| Bot adi | Betra Bot |
| Token | `6756846757:AAFfohn9u1NCiaWzWQuHs4ZOR2uH3qcGHvA` |
| Token satiri | 23 |
| Komutlar | `/rapor` `/gunsonu` `/bakiye` |
| Bagimlilik | `requests`, `telegram`, `telegram.ext` |
| Satir sayisi | 31 |

**Cagirdigi adresler:**

```
https://telegram.betra.app/anasayfa/gunluksorgu
https://telegram.betra.app/anasayfa/rapor_sistemi
https://telegram.betra.app/anasayfa/saatlik_deposit
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import requests


async  def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.betra.app/anasayfa/saatlik_deposit"
    r = requests.get(url)


async  def gunsonu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.betra.app/anasayfa/gunluksorgu"
    r = requests.get(url)

async  def bakiye(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Bakiye kontrollerini sağlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.betra.app/anasayfa/rapor_sistemi"
    r = requests.get(url)
    

app = ApplicationBuilder().token("6756846757:AAFfohn9u1NCiaWzWQuHs4ZOR2uH3qcGHvA").build()

app.add_handler(CommandHandler("rapor", saatlik_deposit))

app.add_handler(CommandHandler("gunsonu", gunsonu))

app.add_handler(CommandHandler("bakiye", bakiye))

app.run_polling()
```

---

### 2 - @betrayeni_bot

**Klasor:** `Python Telegram - Reyna TC`

| | |
|---|---|
| Bot adi | Betra Bot |
| Token | `8751169273:AAFweyCHWJiYkKGuC8m-fPHgU7lA1_PlrFE` |
| Token satiri | 47 |
| Komutlar | `/rapor` `/kapanis` `/tc` |
| Bagimlilik | `requests`, `telegram`, `telegram.ext` |
| Satir sayisi | 63 |

**Cagirdigi adresler:**

```
https://telegram.betra.app/anasayfa/tcsorgu?username={username}
https://telegram.hepbetbonus.app/anasayfa/gunluk_deposit_test
https://telegram.hepbetbonus.app/anasayfa/saatlik_deposit
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    MessageHandler,
    ContextTypes,
    filters
)
import requests

# ———————— Komutlar —————————

async def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey'
    )
    requests.get("https://telegram.hepbetbonus.app/anasayfa/saatlik_deposit")

async def kapanis(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey'
    )
    requests.get("https://telegram.hepbetbonus.app/anasayfa/gunluk_deposit_test")

async def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    # Orijinal TC sorgu mantığı tamamen korundu
    try:
        username = context.args[0]
        if not username:
            raise IndexError
        await update.message.reply_text(f'Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍 {username}')
        requests.get(f"https://telegram.betra.app/anasayfa/tcsorgu?username={username}")
    except (IndexError, ValueError):
        await update.message.reply_text("Kullanım: !tc <kullanıcı adı>")

# — wrapper — 
# Gelen "!tc xyz" metnini parçalar, context.args ayarlar, sonra tc()'yi çağırır.
async def bang_tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    parts = update.message.text.split(maxsplit=1)
    context.args = [parts[1]] if len(parts) > 1 else []
    await tc(update, context)

# ———————— Uygulama Başlatma —————————

if __name__ == "__main__":
    app = ApplicationBuilder() \
        .token("8751169273:AAFweyCHWJiYkKGuC8m-fPHgU7lA1_PlrFE") \
        .build()

    # Slash komutlar hâlâ aynı:
    app.add_handler(CommandHandler("rapor", saatlik_deposit))
    app.add_handler(CommandHandler("kapanis", kapanis))
    app.add_handler(CommandHandler("tc", tc))

    # Yeni: !tc xyz için tek satır handler
    app.add_handler(
        MessageHandler(
            filters.TEXT & filters.Regex(r"^!tc\b"),
            bang_tc
        )
    )

    app.run_polling()
```

---

### 3 - @fiksturtc_bot

**Klasor:** `Python Telegram - Fikstur`

| | |
|---|---|
| Bot adi | Fikstur Bot |
| Token | `8905492287:AAHT_pQA583CwhjXA91hIfeh3kdOnwwfBMY` |
| Token satiri | 79 |
| Komutlar | `/btag` `/tc` |
| Bagimlilik | `aiohttp`, `datetime`, `telegram`, `telegram.ext` |
| Satir sayisi | 82 |

**Cagirdigi adresler:**

```
https://fiksturbetbot.com/anasayfa/btagsorgu
https://fiksturbetbot.com/anasayfa/tcsorgu
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import aiohttp
from datetime import datetime

# === Komut logu (davranisi degistirmez, sadece kaydeder) ===
LOG_FILE = "commands.log"

def log_command(update, command_name):
    try:
        user = update.effective_user
        chat = update.effective_chat
        msg = update.effective_message
        with open(LOG_FILE, "a", encoding="utf-8") as f:
            print(
                f"{datetime.now().isoformat(timespec='seconds')} | "
                f"chat_type={getattr(chat, 'type', '')} | chat_id={getattr(chat, 'id', '')} | "
                f"user_id={getattr(user, 'id', '')} | username={getattr(user, 'username', '')} | "
                f"name={getattr(user, 'first_name', '') or ''} | "
                f"command={command_name} | text={(getattr(msg, 'text', '') or '').strip()}",
                file=f,
            )
    except Exception:
        pass


# /btag <kullanıcı> <btag>
async def btag(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    log_command(update, "btag")
    try:
        if len(context.args) < 2:
            await update.effective_message.reply_text("Kullanım: /btag <kullanıcıadı> <btag>")
            return

        username = context.args[0].strip()
        btag_val = context.args[1].strip()
        if not username or not btag_val:
            await update.effective_message.reply_text("Lütfen geçerli bir kullanıcı adı ve btag girin.")
            return

        # bilgilendirme mesajı
        await update.effective_message.reply_text(
            f"Kullanıcı: {username}\nBtag: {btag_val} sorgulanıyor.. 🔍"
        )

        url = "https://fiksturbetbot.com/anasayfa/btagsorgu"
        async with aiohttp.ClientSession() as session:
            await session.get(url, params={"username": username, "btag": btag_val}, timeout=10)

    except:
        pass  # Hata mesajı gösterilmez

# /tc <kullanıcı>
async def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    log_command(update, "tc")
    try:
        if not context.args:
            await update.effective_message.reply_text("Kullanım: /tc <kullanıcı adı>")
            return

        username = context.args[0].strip()
        if not username:
            await update.effective_message.reply_text("Lütfen geçerli bir değer girin.")
            return

        # bilgilendirme mesajı
        await update.effective_message.reply_text(
            f"Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍 {username}"
        )

        url = "https://fiksturbetbot.com/anasayfa/tcsorgu"
        async with aiohttp.ClientSession() as session:
            await session.get(url, params={"username": username}, timeout=10)

    except:
        pass  # Hata mesajı gösterilmez

# --- BOT ---
app = ApplicationBuilder().token("8905492287:AAHT_pQA583CwhjXA91hIfeh3kdOnwwfBMY").build()
app.add_handler(CommandHandler("btag", btag))
app.add_handler(CommandHandler("tc", tc))
app.run_polling()
```

---

### 4 - @maximtc_bot

**Klasor:** `Python Telegram - Fikstur - Copy`

| | |
|---|---|
| Bot adi | Maxim TC bot |
| Token | `8609624098:AAEceuLTteg36M9gJHZ1vrUbsiA4fzQ5POM` |
| Token satiri | 79 |
| Komutlar | `/btag` `/tc` |
| Bagimlilik | `aiohttp`, `datetime`, `telegram`, `telegram.ext` |
| Satir sayisi | 82 |

**Cagirdigi adresler:**

```
https://maximcasinobot.com/anasayfa/btagsorgu
https://maximcasinobot.com/anasayfa/tcsorgu
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import aiohttp
from datetime import datetime

# === Komut logu (davranisi degistirmez, sadece kaydeder) ===
LOG_FILE = "commands.log"

def log_command(update, command_name):
    try:
        user = update.effective_user
        chat = update.effective_chat
        msg = update.effective_message
        with open(LOG_FILE, "a", encoding="utf-8") as f:
            print(
                f"{datetime.now().isoformat(timespec='seconds')} | "
                f"chat_type={getattr(chat, 'type', '')} | chat_id={getattr(chat, 'id', '')} | "
                f"user_id={getattr(user, 'id', '')} | username={getattr(user, 'username', '')} | "
                f"name={getattr(user, 'first_name', '') or ''} | "
                f"command={command_name} | text={(getattr(msg, 'text', '') or '').strip()}",
                file=f,
            )
    except Exception:
        pass


# /btag <kullanıcı> <btag>
async def btag(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    log_command(update, "btag")
    try:
        if len(context.args) < 2:
            await update.effective_message.reply_text("Kullanım: /btag <kullanıcıadı> <btag>")
            return

        username = context.args[0].strip()
        btag_val = context.args[1].strip()
        if not username or not btag_val:
            await update.effective_message.reply_text("Lütfen geçerli bir kullanıcı adı ve btag girin.")
            return

        # bilgilendirme mesajı
        await update.effective_message.reply_text(
            f"Kullanıcı: {username}\nBtag: {btag_val} sorgulanıyor.. 🔍"
        )

        url = "https://maximcasinobot.com/anasayfa/btagsorgu"
        async with aiohttp.ClientSession() as session:
            await session.get(url, params={"username": username, "btag": btag_val}, timeout=10)

    except:
        pass  # Hata mesajı gösterilmez

# /tc <kullanıcı>
async def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    log_command(update, "tc")
    try:
        if not context.args:
            await update.effective_message.reply_text("Kullanım: /tc <kullanıcı adı>")
            return

        username = context.args[0].strip()
        if not username:
            await update.effective_message.reply_text("Lütfen geçerli bir değer girin.")
            return

        # bilgilendirme mesajı
        await update.effective_message.reply_text(
            f"Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍 {username}"
        )

        url = "https://maximcasinobot.com/anasayfa/tcsorgu"
        async with aiohttp.ClientSession() as session:
            await session.get(url, params={"username": username}, timeout=10)

    except:
        pass  # Hata mesajı gösterilmez

# --- BOT ---
app = ApplicationBuilder().token("8609624098:AAEceuLTteg36M9gJHZ1vrUbsiA4fzQ5POM").build()
app.add_handler(CommandHandler("btag", btag))
app.add_handler(CommandHandler("tc", tc))
app.run_polling()
```

---

### 5 - @hanedantel_bot

**Klasor:** `Python Telegram - Istinye Telefon - Kopya`

| | |
|---|---|
| Bot adi | Hanedan Bot |
| Token | `8484233300:AAGnbEwSy5bGBB1BJTm83R8zYUr-nUfMyKw` |
| Token satiri | 147 |
| Komutlar | `/tel` |
| Bagimlilik | `asyncio`, `logging`, `re`, `requests`, `telegram`, `telegram.ext`, `urllib.parse` |
| Satir sayisi | 152 |

**Cagirdigi adresler:**

```
https://hanedanbet.app/anasayfa/telegramyenibott?username={param}
```

**`sorgu.py` - tam kaynak:**

```python
import logging
import re
import urllib.parse
import requests
import asyncio
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ContextTypes,
)

# Logging ayarları
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

BATCH_SIZE = 50           # 50-50 böl
BATCH_DELAY_SEC = 20     # her batch arası küçük bekleme (gerekirse arttır)

ALLOWED_CHAT_ID = -1003158585338  # /tel komutunun çalışacağı tek grup

def chunk_list(items, size):
    for i in range(0, len(items), size):
        yield items[i:i+size]

async def tel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat_id = update.effective_chat.id

    # SADECE BELİRLİ GRUPTA ÇALIŞSIN
    if chat_id != ALLOWED_CHAT_ID:
        # İstersen tamamen sessiz olsun dersen burayı boş return yapabilirsin
        await context.bot.send_message(
            chat_id=chat_id,
            text="Bu komut sadece yetkili grupta kullanılabilir."
        )
        return

    # 1) Kullanıcı adı argümanları yoksa uyar
    if not context.args:
        await context.bot.send_message(
            chat_id=chat_id,
            text=(
                "Kullanım:\n"
                "/tel kullanıcı1 kullanıcı2 ...\n"
                "veya\n"
                "/tel kullanıcı1,kullanıcı2,..."
            )
        )
        return

    # 2) Argümanları virgül, noktalı virgül veya boşlukla ayır
    raw = " ".join(context.args).strip()
    usernames = [u.strip() for u in re.split(r'[\s,;]+', raw) if u.strip()]
    if not usernames:
        await context.bot.send_message(chat_id=chat_id, text="Lütfen en az bir geçerli kullanıcı adı girin.")
        return

    total = len(usernames)
    await context.bot.send_message(
        chat_id=chat_id,
        text=f"{total} kullanıcı için yatırım bilgileri 50'lik paketler halinde sorgulanıyor.. 🔍"
    )

    # 3) 50-50 böl ve her batch için ayrı istek at
    batch_index = 0
    for batch in chunk_list(usernames, BATCH_SIZE):
        batch_index += 1
        start = (batch_index - 1) * BATCH_SIZE + 1
        end = min(batch_index * BATCH_SIZE, total)

        # Bilgilendirme
        await context.bot.send_message(
            chat_id=chat_id,
            text=f"📦 Paket {batch_index}: {start}-{end} arası kullanıcılar sorgulanıyor..."
        )

        # 4) PHP endpoint'e bu batch'i gönder
        try:
            param = urllib.parse.quote(",".join(batch))
            url = f"https://hanedanbet.app/anasayfa/telegramyenibott?username={param}"

            # Not: requests senkron; handler içinde kısa bloklarımız var, sorun olmaz.
            resp = requests.get(url, timeout=90)
            resp.raise_for_status()

        except Exception as e:
            logger.error("PHP isteğinde hata (batch %s): %s", batch_index, e, exc_info=e)
            await context.bot.send_message(
                chat_id=chat_id,
                text=f"❌ Paket {batch_index} hata verdi: {e}"
            )
            # Sonraki batch'e devam
            await asyncio.sleep(BATCH_DELAY_SEC)
            continue

        # 5) Gelen metni ayır ve gönder
        text = resp.text or ""
        parts = re.split(r'\n*-{3,}\n*', text)  # "---" benzeri ayraçlara göre böl
        sent_any = False
        for part in parts:
            part = part.strip()
            if not part:
                continue
            sent_any = True
            try:
                await context.bot.send_message(
                    chat_id=chat_id,
                    text=part,
                    parse_mode='HTML',
                    disable_web_page_preview=True
                )
            except Exception as send_err:
                logger.warning("Mesaj gönderilirken hata (batch %s): %s", batch_index, send_err, exc_info=send_err)

        if not sent_any:
            # Sunucu bir şey döndürmediyse kısa bilgi geç
            await context.bot.send_message(
                chat_id=chat_id,
                text=f"ℹ️ Paket {batch_index} için sonuç bulunamadı veya boş yanıt geldi."
            )

        # 6) Batch'ler arası ufak bekleme (rate-limit ve GET sınırları için iyi olur)
        await asyncio.sleep(BATCH_DELAY_SEC)

    await context.bot.send_message(
        chat_id=chat_id,
        text="✅ Tüm paketlerin sorgusu tamamlandı."
    )

async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
    logger.error("Yakalanmamış hata:", exc_info=context.error)
    if isinstance(update, Update) and update.effective_chat:
        try:
            await context.bot.send_message(
                chat_id=update.effective_chat.id,
                text="Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin."
            )
        except:
            pass

if __name__ == '__main__':
    app = (
        ApplicationBuilder()
        .token("8484233300:AAGnbEwSy5bGBB1BJTm83R8zYUr-nUfMyKw")
        .build()
    )
    app.add_handler(CommandHandler("tel", tel))
    app.add_error_handler(error_handler)
    app.run_polling()
```

---

### 6 - @hanedantg_bot

**Klasor:** `Python Telegram - Hanedan - Kopya`

| | |
|---|---|
| Bot adi | Hanedan Bot |
| Token | `7824807718:AAFp-BCyP2-odXxbug4jy83534QjWf8siNU` |
| Token satiri | 92 |
| Komutlar | `/kontrol` |
| Bagimlilik | `logging`, `re`, `requests`, `telegram`, `telegram.ext`, `urllib.parse` |
| Satir sayisi | 97 |
| Webhook | `https://hanedanbet.app/kb-tg?key=kb-hanedan-webhook-2026` |

**Cagirdigi adresler:**

```
https://hanedanbet.app/anasayfa/telegramyenibot?username={param}
```

**`sorgu.py` - tam kaynak:**

```python
import logging
import re
import urllib.parse
import requests
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ContextTypes,
)

# Logging ayarları
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

async def kontrol(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat_id = update.effective_chat.id

    # 1) Kullanıcı adı argümanları yoksa uyar
    if not context.args:
        await context.bot.send_message(
            chat_id=chat_id,
            text=(
                "Kullanım:\n"
                "/kontrol kullanıcı1 kullanıcı2 ...\n"
                "veya\n"
                "/kontrol kullanıcı1,kullanıcı2,..."
            )
        )
        return

    # 2) Argümanları virgül, noktalı virgül veya boşlukla ayır
    raw = " ".join(context.args).strip()
    usernames = [u.strip() for u in re.split(r'[\s,;]+', raw) if u.strip()]
    if not usernames:
        await context.bot.send_message(chat_id=chat_id, text="Lütfen en az bir geçerli kullanıcı adı girin.")
        return

    # 3) Bilgilendirme mesajı
    await context.bot.send_message(
        chat_id=chat_id,
        text=f"{len(usernames)} kullanıcı için yatırım bilgileri sorgulanıyor.. 🔍\n" +
             ", ".join(usernames)
    )

    # 4) PHP endpoint'e tek seferde tüm kullanıcıları yolla
    param = urllib.parse.quote(",".join(usernames))
    url = f"https://hanedanbet.app/anasayfa/telegramyenibot?username={param}"

    try:
        resp = requests.get(url, timeout=30)
        resp.raise_for_status()
    except Exception as e:
        logger.error("PHP isteğinde hata", exc_info=e)
        await context.bot.send_message(chat_id=chat_id, text=f"Sunucu hatası: {e}")
        return

    # 5) Gelen metni: "\n\n---\n\n" benzeri ayırıcılardan temiz bir şekilde böl
    parts = re.split(r'\n*-{3,}\n*', resp.text)
    for part in parts:
        part = part.strip()
        if not part:
            continue
        try:
            await context.bot.send_message(
                chat_id=chat_id,
                text=part,
                parse_mode='HTML',
                disable_web_page_preview=True
            )
        except Exception as send_err:
            logger.warning("Mesaj gönderilirken hata: %s", send_err, exc_info=send_err)
            # Burada kullanıcıya tekrar mesaj atmıyoruz, sadece logluyoruz

async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
    logger.error("Yakalanmamış hata:", exc_info=context.error)
    if isinstance(update, Update) and update.effective_chat:
        try:
            await context.bot.send_message(
                chat_id=update.effective_chat.id,
                text="Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin."
            )
        except:
            pass

if __name__ == '__main__':
    app = (
        ApplicationBuilder()
        .token("7824807718:AAFp-BCyP2-odXxbug4jy83534QjWf8siNU")
        .build()
    )
    app.add_handler(CommandHandler("kontrol", kontrol))
    app.add_error_handler(error_handler)
    app.run_polling()
```

---

### 7 - @istinyetc_bot

**Klasor:** `Python Telegram - Istinye TC`

| | |
|---|---|
| Bot adi | GO Bot |
| Token | `7898800936:AAE8cShKlZE3nyQqtMfcLvHcltr8S1OqQYU` |
| Token satiri | 47 |
| Komutlar | `/rapor` `/kapanis` `/tc` |
| Bagimlilik | `requests`, `telegram`, `telegram.ext` |
| Satir sayisi | 63 |
| Webhook | `https://telegram.grandoperabonus.com/smsbot/webhook` |

**Cagirdigi adresler:**

```
https://telegram.istinyecasinoortaklik.com/anasayfa/gunluk_deposit_test
https://telegram.istinyecasinoortaklik.com/anasayfa/saatlik_deposit
https://telegram.istinyecasinoortaklik.com/anasayfa/tcsorgu?username={username}
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    MessageHandler,
    ContextTypes,
    filters
)
import requests

# ———————— Komutlar —————————

async def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey'
    )
    requests.get("https://telegram.istinyecasinoortaklik.com/anasayfa/saatlik_deposit")

async def kapanis(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey'
    )
    requests.get("https://telegram.istinyecasinoortaklik.com/anasayfa/gunluk_deposit_test")

async def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    # Orijinal TC sorgu mantığı tamamen korundu
    try:
        username = context.args[0]
        if not username:
            raise IndexError
        await update.message.reply_text(f'Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍 {username}')
        requests.get(f"https://telegram.istinyecasinoortaklik.com/anasayfa/tcsorgu?username={username}")
    except (IndexError, ValueError):
        await update.message.reply_text("Kullanım: !tc <kullanıcı adı>")

# — wrapper — 
# Gelen "!tc xyz" metnini parçalar, context.args ayarlar, sonra tc()'yi çağırır.
async def bang_tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    parts = update.message.text.split(maxsplit=1)
    context.args = [parts[1]] if len(parts) > 1 else []
    await tc(update, context)

# ———————— Uygulama Başlatma —————————

if __name__ == "__main__":
    app = ApplicationBuilder() \
        .token("7898800936:AAE8cShKlZE3nyQqtMfcLvHcltr8S1OqQYU") \
        .build()

    # Slash komutlar hâlâ aynı:
    app.add_handler(CommandHandler("rapor", saatlik_deposit))
    app.add_handler(CommandHandler("kapanis", kapanis))
    app.add_handler(CommandHandler("tc", tc))

    # Yeni: !tc xyz için tek satır handler
    app.add_handler(
        MessageHandler(
            filters.TEXT & filters.Regex(r"^!tc\b"),
            bang_tc
        )
    )

    app.run_polling()
```

---

### 8 - @jeweltg_bot

**Klasor:** `Python Telegram - Jewel`

| | |
|---|---|
| Bot adi | Opera Bot |
| Token | `7465549518:AAF6OEVIV7PY0TkyXwBTkQ2asqPxgxu4-98` |
| Token satiri | 125 |
| Komutlar | `/rapor` `/gunsonu` `/tc` `/ozet` |
| Bagimlilik | `asyncio`, `datetime`, `pathlib`, `requests`, `telegram`, `telegram.ext`, `time` |
| Satir sayisi | 131 |

**Cagirdigi adresler:**

```
https://telegram.grandoperabonus.com/anasayfa/gunluksorgu
https://telegram.grandoperabonus.com/anasayfa/saatlik_deposit
https://telegram.grandoperabonus.com/anasayfa/tcsorgu?username=
https://telegram.grandoperabonus.com/anasayfa/uye_ozet?username=
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import asyncio
import time
import requests
from datetime import datetime
from pathlib import Path

# === Basit TXT log ayarı ===
LOG_FILE = "commands.log"

def is_group(update: Update) -> bool:
    chat = update.effective_chat
    return bool(chat and chat.type in ("group", "supergroup"))

def log_command(update: Update, command_name: str, handled: bool):
    user = update.effective_user
    chat = update.effective_chat
    msg  = update.effective_message

    ts = datetime.now().isoformat(timespec="seconds")
    line = (
        f"{ts} | handled={int(handled)} | "
        f"chat_type={getattr(chat, 'type', '')} | chat_id={getattr(chat, 'id', '')} | "
        f"user_id={getattr(user, 'id', '')} | username={getattr(user, 'username', '')} | "
        f"name={(getattr(user, 'first_name', '') or '')} {(getattr(user, 'last_name', '') or '')} | "
        f"command={command_name} | text={(getattr(msg, 'text', '') or '').strip()}\n"
    )
    Path(LOG_FILE).parent.mkdir(parents=True, exist_ok=True)
    with open(LOG_FILE, "a", encoding="utf-8") as f:
        f.write(line)


def log_site(command_name, durum, saniye):
    try:
        with open(LOG_FILE, "a", encoding="utf-8") as f:
            print(
                f"{datetime.now().isoformat(timespec='seconds')} | SITE | "
                f"command={command_name} | sonuc={durum} | sure={saniye:.1f}s",
                file=f,
            )
    except Exception:
        pass

# === Komutlar ===
async def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    # Sadece gruplarda çalıştır
    if not is_group(update):
        log_command(update, "rapor", handled=False)
        return

    log_command(update, "rapor", handled=True)
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.grandoperabonus.com/anasayfa/saatlik_deposit"
    _t0 = time.monotonic()
    try:
        _r = await asyncio.to_thread(requests.get, url, timeout=120)
        log_site("saatlik_deposit", "HTTP " + str(_r.status_code), time.monotonic() - _t0)
    except Exception as _e:
        log_site("saatlik_deposit", type(_e).__name__, time.monotonic() - _t0)
        raise

async def gunsonu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    if not is_group(update):
        log_command(update, "gunsonu", handled=False)
        return

    log_command(update, "gunsonu", handled=True)
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.grandoperabonus.com/anasayfa/gunluksorgu"
    _t0 = time.monotonic()
    try:
        _r = await asyncio.to_thread(requests.get, url, timeout=120)
        log_site("gunsonu", "HTTP " + str(_r.status_code), time.monotonic() - _t0)
    except Exception as _e:
        log_site("gunsonu", type(_e).__name__, time.monotonic() - _t0)
        raise

async def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    if not is_group(update):
        log_command(update, "tc", handled=False)
        return

    # Buraya gelindiyse grup: logla ve devam et
    log_command(update, "tc", handled=True)

    try:
        username = context.args[0]
        await update.message.reply_text(f'Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍 {username}')
        url = "https://telegram.grandoperabonus.com/anasayfa/tcsorgu?username=" + username
        _t0 = time.monotonic()
        try:
            _r = await asyncio.to_thread(requests.get, url, timeout=120)
            log_site("tc", "HTTP " + str(_r.status_code), time.monotonic() - _t0)
        except Exception as _e:
            log_site("tc", type(_e).__name__, time.monotonic() - _t0)
            raise
    except (IndexError, ValueError):
        await update.effective_message.reply_text("Kullanım: /tc <kullanıcı adı>")


async def ozet(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    if not is_group(update):
        log_command(update, "ozet", handled=False)
        return

    # Buraya gelindiyse grup: logla ve devam et
    log_command(update, "ozet", handled=True)

    try:
        username = context.args[0]
        await update.message.reply_text(f'Kullanıcı için bilgiler sorgulanıyor.. 🔍 {username}')
        url = "https://telegram.grandoperabonus.com/anasayfa/uye_ozet?username=" + username
        _t0 = time.monotonic()
        try:
            _r = await asyncio.to_thread(requests.get, url, timeout=120)
            log_site("ozet", "HTTP " + str(_r.status_code), time.monotonic() - _t0)
        except Exception as _e:
            log_site("ozet", type(_e).__name__, time.monotonic() - _t0)
            raise
    except (IndexError, ValueError):
        await update.effective_message.reply_text("Kullanım: /ozet <kullanıcı adı>")

# === Bot setup ===
app = ApplicationBuilder().token("7465549518:AAF6OEVIV7PY0TkyXwBTkQ2asqPxgxu4-98").build()

app.add_handler(CommandHandler("rapor", saatlik_deposit))
app.add_handler(CommandHandler("gunsonu", gunsonu))
app.add_handler(CommandHandler("tc", tc))
app.add_handler(CommandHandler("ozet", ozet))
app.run_polling()
```

---

### 9 - @kaletg_bot

**Klasor:** `Python Telegram - Betra TC - Copy - Copy`

| | |
|---|---|
| Bot adi | Kale Bot |
| Token | `8036839379:AAGLgXbKOE570RXxHAzRuZsRhGlx9iIn1BE` |
| Token satiri | 36 |
| Komutlar | `/rapor` `/gunsonu` `/tc` |
| Bagimlilik | `requests`, `telegram`, `telegram.ext` |
| Satir sayisi | 44 |

**Cagirdigi adresler:**

```
https://telegram.grandoperabonus.com/anasayfa/gunluksorgu
https://telegram.kalebonus.com/anasayfa/saatlik_deposit
https://telegram.kalebonus.com/anasayfa/tcsorgu?username=
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import requests


async  def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.kalebonus.com/anasayfa/saatlik_deposit"
    r = requests.get(url)


async  def gunsonu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://telegram.grandoperabonus.com/anasayfa/gunluksorgu"
    r = requests.get(url)

    
async  def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    print("hello")
    """Add a job to the queue."""
    chat_id = update.effective_message.chat_id
    try:
        # args[0] should contain the time for the timer in seconds
        username = len(context.args[0])
        if username <= 0:
            await update.effective_message.reply_text("Lütfen geçerli bir değer girin.")
            return
        await update.message.reply_text(f'Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍'+str(context.args[0]))
        url = "https://telegram.kalebonus.com/anasayfa/tcsorgu?username="+str(context.args[0])
        r = requests.get(url)
        

    except (IndexError, ValueError):
        await update.effective_message.reply_text("Kullanım: /tc <kullanıcı adı>")

app = ApplicationBuilder().token("8036839379:AAGLgXbKOE570RXxHAzRuZsRhGlx9iIn1BE").build()

app.add_handler(CommandHandler("rapor", saatlik_deposit))

app.add_handler(CommandHandler("gunsonu", gunsonu))

app.add_handler(CommandHandler("tc", tc))

app.run_polling()
```

---

### 10 - @meritrc_bot

**Klasor:** `Python Telegram - Merit`

| | |
|---|---|
| Bot adi | Merit Bot |
| Token | `7572062852:AAEM3ruMjheKCkOC9E84ax3rKQSwR26PNKQ` |
| Token satiri | 36 |
| Komutlar | `/rapor` `/gunsonu` `/tc` |
| Bagimlilik | `requests`, `telegram`, `telegram.ext` |
| Satir sayisi | 44 |
| Webhook | `https://redlabonus.click/anasayfa/telegram_tc` |

**Cagirdigi adresler:**

```
https://tc.democu.online/telegram.php?daily=yes
https://tc.democu.online/telegram.php?gunsonu=yes
https://tc.democu.online/telegram.php?username=
```

**`sorgu.py` - tam kaynak:**

```python
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
import requests


async  def saatlik_deposit(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://tc.democu.online/telegram.php?daily=yes"
    r = requests.get(url)


async  def gunsonu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Raporunuzu hazırlıyorum, lütfen bekleyin {update.effective_user.first_name} Bey')
    url = "https://tc.democu.online/telegram.php?gunsonu=yes"
    r = requests.get(url)

    
async  def tc(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    print("hello")
    """Add a job to the queue."""
    chat_id = update.effective_message.chat_id
    try:
        # args[0] should contain the time for the timer in seconds
        username = len(context.args[0])
        if username <= 0:
            await update.effective_message.reply_text("Lütfen geçerli bir değer girin.")
            return
        await update.message.reply_text(f'Kullanıcı için TC Kimlik bilgileri sorgulanıyor.. 🔍'+str(context.args[0]))
        url = "https://tc.democu.online/telegram.php?username="+str(context.args[0])
        r = requests.get(url)
        

    except (IndexError, ValueError):
        await update.effective_message.reply_text("Kullanım: /tc <kullanıcı adı>")

app = ApplicationBuilder().token("7572062852:AAEM3ruMjheKCkOC9E84ax3rKQSwR26PNKQ").build()

app.add_handler(CommandHandler("rapor", saatlik_deposit))

app.add_handler(CommandHandler("gunsonu", gunsonu))

app.add_handler(CommandHandler("tc", tc))

app.run_polling()
```

---

## 5. Yonetim betikleri

Bu uc dosya **ana klasorun kokune** konur (bot klasorlerinin icine degil).

Her birinde su iki yolu yeni sunucuya gore guncelleyin:

```python
BASE_DIR   = r"<yeni yol>\Telegram Botlari"
PYTHON_EXE = r"<yeni python yolu>\python.exe"
```

### `botlar.py`

Tum botlari kapatip bastan baslatir. En basit yontem.

```python
import os, time, subprocess
from datetime import datetime
from pathlib import Path
import psutil  # pip install psutil

# === AYARLAR ===
BASE_DIR = r"C:\xampp\htdocs\Telegram Botları"
PYTHON_EXE = r"C:\Users\admin\AppData\Local\Programs\Python\Python314\python.exe"
STARTUP_CHECK_SECONDS = 5
ONLY_PREFIX = True  # yalnız "Python Telegram - " ile başlayanları tara (False yaparsan tüm klasörler)

base = Path(BASE_DIR)
logs_dir = base / "logs"
logs_dir.mkdir(exist_ok=True)

def name_ok(p: Path) -> bool:
    return (p.name.casefold().startswith("python telegram - ")) if ONLY_PREFIX else True

def is_running_for(workdir: Path) -> bool:
    w = str(workdir.resolve())
    for proc in psutil.process_iter(["pid", "cmdline", "cwd"]):
        try:
            cmd = " ".join(proc.info.get("cmdline") or [])
            cwd = str(proc.info.get("cwd") or "")
            if "sorgu.py" in cmd.casefold() and (w == cwd or w in cmd):
                return True
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    return False

# --- 1) Çalışan tüm sorgu.py'leri kapat ---
to_terminate = []
for proc in psutil.process_iter(["pid", "cmdline"]):
    try:
        cmd = " ".join(proc.info["cmdline"]) if proc.info["cmdline"] else ""
        if "sorgu.py" in cmd.casefold():
            print(f"🔴 Kapatılıyor: PID {proc.pid} | {cmd}")
            try:
                proc.terminate()
                to_terminate.append(proc)
            except psutil.AccessDenied:
                pass
    except (psutil.NoSuchProcess, psutil.AccessDenied):
        continue

if to_terminate:
    try:
        gone, alive = psutil.wait_procs(to_terminate, timeout=3)
        for p in alive:
            try:
                p.kill()
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
    except Exception:
        pass
time.sleep(2)

# --- 2) Hedefleri topla (KOPYA/DENEME DAHİL) ---
targets, missing_sorgu = [], []
for entry in base.iterdir():
    if not entry.is_dir(): 
        continue
    if not name_ok(entry):
        continue
    files_lower = [f.name.lower() for f in entry.iterdir() if f.is_file()]
    if "sorgu.py" in files_lower:
        targets.append(entry / "sorgu.py")
    else:
        missing_sorgu.append(entry.name)

print(f"\n🔎 Bulunan bot klasörü (sorgu.py olan): {len(targets)} adet")
if missing_sorgu:
    print("⚠️  Aşağıdaki klasörlerde 'sorgu.py' bulunamadı (bu yüzden başlatılmadı):")
    for n in sorted(missing_sorgu, key=str.casefold):
        print("   -", n)

# --- 3) Başlat ---
procs = []
CREATE_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)

for sorgu in sorted(targets, key=lambda p: p.parent.name.casefold()):
    workdir = sorgu.parent.resolve()
    if is_running_for(workdir):
        print(f"⏭  Atlama: {workdir.name} (zaten çalışıyor)")
        continue

    stamp = datetime.now().strftime('%Y%m%d-%H%M%S')
    log_file = logs_dir / f"{workdir.name}_{stamp}.log"
    log_fh = open(log_file, "w", buffering=1, encoding="utf-8", errors="ignore")

    print(f"▶ Başlatılıyor: {workdir.name}")
    try:
        p = subprocess.Popen(
            [PYTHON_EXE, "sorgu.py"],
            cwd=str(workdir),
            stdout=log_fh,
            stderr=log_fh,
            creationflags=CREATE_NO_WINDOW,
        )
        procs.append((p, log_fh, log_file, workdir))
    except Exception as e:
        print(f"‼️  Başlatılamadı: {workdir} -> {e}")
        log_fh.close()

# --- 4) Sağlık kontrolü ---
time.sleep(STARTUP_CHECK_SECONDS)
alive_count = 0
for p, log_fh, log_file, workdir in procs:
    if p.poll() is not None:
        log_fh.flush(); log_fh.close()
        reason = "Bilinmiyor"
        try:
            text = Path(log_file).read_text(encoding="utf-8", errors="ignore")
            if any(s in text for s in ["InvalidToken", "Unauthorized"]): reason = "Geçersiz TOKEN"
            elif "FileNotFoundError" in text: reason = "Eksik dosya/relative path"
            elif "ModuleNotFoundError" in text: reason = "Eksik paket (pip install ...)"
            elif "requests.exceptions" in text or "ConnectionError" in text: reason = "Ağ hatası"
        except Exception:
            pass
        print(f"✖ KAPANDI: {workdir.name} | Neden: {reason} | Log: {log_file}")
    else:
        alive_count += 1
        print(f"✔ ÇALIŞIYOR: {workdir.name} | Log: {log_file}")

print(f"\nÖzet: {alive_count}/{len(procs)} bot aktif. (Kopya/Deneme dahil hepsi tarandı)")
```

### `baslat.py`

Akilli baslatici: her botu baslatmadan once Telegram'a sorar (token gecerli mi, baskasi ayni tokeni cekiyor mu). Olu tokenli botlari bosuna acmaz.

```python
"""Akilli baslatici.

botlar.py'den farki: bir botu baslatmadan ONCE Telegram'a soruyor.
  - token gecersiz mi?            -> baslatma, raporla
  - baska bir kurulum mu cekiyor? -> baslatma, raporla
  - temiz mi?                     -> baslat

Olu tokenli botlar bosuna CPU/log yakmaz. Cakisanlar varsayilan olarak yine
baslatilir (karsi kurulum cevap vermiyor; kapali tutmak hizmeti sifirlar).
"""
import concurrent.futures as cf
import json
import os
import re
import subprocess
import sys
import time
import urllib.error
import urllib.request
from datetime import datetime
from pathlib import Path

import psutil

BASE_DIR = Path(r"C:\xampp\htdocs\Telegram Botları")
PYTHON_EXE = r"C:\Users\admin\AppData\Local\Programs\Python\Python314\python.exe"
ONLY_PREFIX = "python telegram - "
PROBE_TIMEOUT = 6          # cakisma testi icin long-poll suresi (sn)
SETTLE_SECONDS = 12        # kill sonrasi Telegram'in eski long-poll'u birakmasi icin
STARTUP_CHECK_SECONDS = 10
CREATE_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)

TOKEN_RE = re.compile(r"[0-9]{8,10}:[A-Za-z0-9_-]{30,}")

logs_dir = BASE_DIR / "logs"
logs_dir.mkdir(exist_ok=True)


def api(token, method, query=""):
    """(http_kodu, json_govde) dondurur. Ag hatasinda (None, {...})."""
    url = f"https://api.telegram.org/bot{token}/{method}{query}"
    try:
        with urllib.request.urlopen(url, timeout=PROBE_TIMEOUT + 25) as r:
            return r.status, json.load(r)
    except urllib.error.HTTPError as e:
        try:
            return e.code, json.loads(e.read())
        except Exception:
            return e.code, {}
    except Exception as e:
        return None, {"description": f"ag hatasi: {type(e).__name__}: {e}"}


def token_of(folder: Path):
    m = TOKEN_RE.search((folder / "sorgu.py").read_text(encoding="utf-8", errors="ignore"))
    return m.group(0) if m else None


def teshis(folder: Path):
    """Bir botu siniflandirir -> (durum, aciklama)."""
    token = token_of(folder)
    if not token:
        return "TOKENSIZ", "sorgu.py icinde token bulunamadi"

    code, body = api(token, "getMe")
    if code == 401:
        return "GECERSIZ_TOKEN", "401 Unauthorized - bot silinmis veya token yenilenmis"
    if code != 200:
        return "ULASILAMADI", f"getMe -> {code} {body.get('description', '')}"
    username = "@" + body.get("result", {}).get("username", "?")

    # Cakisma testi: bu bot su an kapali oldugu icin 409 gelirse
    # istegi sonlandiran taraf BASKA bir kurulumdur.
    code, body = api(token, "getUpdates", f"?timeout={PROBE_TIMEOUT}&limit=1&offset=-1")
    if code == 409:
        return "CAKISMA", f"{username} - baska bir kurulum ayni tokeni cekiyor"
    if code != 200:
        return "ULASILAMADI", f"{username} - getUpdates -> {code} {body.get('description', '')}"
    return "TEMIZ", username


# --- 1) Calisan her seyi durdur ---
oldurulen = []
for proc in psutil.process_iter(["pid", "cmdline"]):
    try:
        if "sorgu.py" in " ".join(proc.info["cmdline"] or []).lower():
            proc.kill()
            oldurulen.append(proc)
    except (psutil.NoSuchProcess, psutil.AccessDenied):
        continue
if oldurulen:
    psutil.wait_procs(oldurulen, timeout=5)
print(f"Durdurulan process: {len(oldurulen)}")
print(f"Telegram tarafi temizlensin diye {SETTLE_SECONDS} sn bekleniyor...")
time.sleep(SETTLE_SECONDS)

# --- 2) Hedefleri bul ---
hedefler = sorted(
    (d for d in BASE_DIR.iterdir()
     if d.is_dir() and d.name.casefold().startswith(ONLY_PREFIX) and (d / "sorgu.py").is_file()),
    key=lambda p: p.name.casefold(),
)
print(f"Bulunan bot klasoru: {len(hedefler)}")
print("Telegram'a soruluyor (token gecerli mi / baskasi cekiyor mu)...\n")

# --- 3) Paralel teshis ---
sonuc = {}
with cf.ThreadPoolExecutor(max_workers=8) as ex:
    for folder, (durum, aciklama) in zip(hedefler, ex.map(teshis, hedefler)):
        sonuc[folder] = (durum, aciklama)
        print(f"  {durum:<15} {folder.name[len(ONLY_PREFIX):]:<38} {aciklama}")

# --- 4) Baslat ---
# CAKISMA durumundakiler de varsayilan olarak baslatilir: karsi kurulum gelen
# komutlara cevap VERMIYOR, dolayisiyla botu kapali tutmak hizmeti %50'den %0'a
# dusurur. Sadece temizleri istersen: --cakisanlari-atla
CAKISANLARI_ATLA = "--cakisanlari-atla" in sys.argv
kabul = {"TEMIZ"} if CAKISANLARI_ATLA else {"TEMIZ", "CAKISMA"}
baslatilacak = [f for f in hedefler if sonuc[f][0] in kabul]
print("")
print(f"Baslatiliyor: {len(baslatilacak)} bot"
      + ("" if CAKISANLARI_ATLA else "  (cakisanlar dahil - mesajlarin ~yarisi kaybolur)"))

procs = []
for folder in baslatilacak:
    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
    log_file = logs_dir / f"{folder.name}_{stamp}.log"
    fh = open(log_file, "w", buffering=1, encoding="utf-8", errors="ignore")
    p = subprocess.Popen([PYTHON_EXE, "sorgu.py"], cwd=str(folder),
                         stdout=fh, stderr=fh, creationflags=CREATE_NO_WINDOW)
    procs.append((p, fh, log_file, folder))

# --- 5) Saglik kontrolu ---
time.sleep(STARTUP_CHECK_SECONDS)
ayakta, dusen = [], []
for p, fh, log_file, folder in procs:
    kisa = folder.name[len(ONLY_PREFIX):]
    if p.poll() is None:
        ayakta.append(kisa)
        continue
    fh.flush(); fh.close()
    metin = log_file.read_text(encoding="utf-8", errors="ignore")
    if "mysql.connector" in metin:
        satir = next((l for l in reversed(metin.splitlines()) if "mysql.connector.errors" in l), "MySQL hatasi")
        neden = satir.strip()[:110]
    elif "ModuleNotFoundError" in metin:
        neden = next((l for l in metin.splitlines() if "ModuleNotFoundError" in l), "").strip()[:110]
    elif "FileNotFoundError" in metin:
        neden = "Eksik dosya / yanlis yol"
    else:
        neden = (metin.strip().splitlines() or ["bilinmiyor"])[-1][:110]
    dusen.append((kisa, neden, log_file.name))

# --- 6) Ozet ---
def grup(d):
    return [f.name[len(ONLY_PREFIX):] for f in hedefler if sonuc[f][0] == d]

print("\n" + "=" * 78)
print(f"CALISIYOR                     : {len(ayakta)}")
for n in ayakta:
    print("   +", n)

if dusen:
    print(f"\nBASLADI AMA COKTU             : {len(dusen)}")
    for n, neden, lg in dusen:
        print(f"   x {n}\n       {neden}\n       log: {lg}")

cakisma_basligi = ("BASKA KURULUM CEKIYOR (baslatilmadi)" if CAKISANLARI_ATLA
                   else "BASKA KURULUM CEKIYOR (calisiyor ama ~yarisi kayip)")
for durum, baslik in [
    ("CAKISMA", cakisma_basligi),
    ("GECERSIZ_TOKEN", "TOKEN GECERSIZ (baslatilmadi)"),
    ("ULASILAMADI", "ULASILAMADI (baslatilmadi)"),
    ("TOKENSIZ", "TOKEN BULUNAMADI (baslatilmadi)"),
]:
    isimler = grup(durum)
    if isimler:
        print(f"\n{baslik:<30}: {len(isimler)}")
        for n in isimler:
            print("   -", n)

print("=" * 78)
print(f"Ozet: {len(ayakta)}/{len(hedefler)} bot aktif.")
```

### `supervizor.py`

Surekli calisir, 30 saniyede bir dusen botu yeniden baslatir. Ag kesintilerine karsi asil koruma budur.

```python
"""Tum Telegram botlari icin supervizor.

Neden: ag/DNS kesintisinde PTB birkac deneme sonrasi pes ediyor ve surec
kapaniyor. Ag duzelse bile botlar kendiliginden geri gelmiyor.

Bu betik 30 saniyede bir bakar, dusen botu yeniden baslatir, olaylari
supervizor_durum.log dosyasina yazar.

Olu tokenli botlar aninda cokecegi icin "sorunlu" isaretlenir ve
30 dakikada bir denenir - surekli yeniden baslatma dongusune girilmez.

Tek kopya calisir (kilit dosyasi). Baslatilan botlar DETACHED_PROCESS ile
acilir, yani supervizor olse bile botlar yasamaya devam eder.
"""
import datetime
import os
import subprocess
import time

import psutil

BASE = r"C:\xampp\htdocs\Telegram Botları"
PY_EXE = r"C:\Users\admin\AppData\Local\Programs\Python\Python314\python.exe"
ONEK = "Python Telegram - "
LOG = os.path.join(BASE, "supervizor_durum.log")
KILIT = os.path.join(BASE, "supervizor.kilit")

KONTROL = 30              # saniye: ne siklikla bakilacak
HIZLI_OLUM = 60           # bu sureden once olurse "basarisiz" sayilir
MAX_HIZLI_OLUM = 3        # bu kadar ust uste basarisiz olursa karantinaya
KARANTINA = 1800          # saniye: karantinadaki bot bu araliklarla denenir

DETACHED = 0x00000008 | 0x00000200   # DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP


def kayit(s):
    satir = "%s  %s" % (datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), s)
    try:
        with open(LOG, "a", encoding="utf-8") as f:
            f.write(satir + "\n")
    except Exception:
        pass


def hedefler():
    try:
        return sorted(d for d in os.listdir(BASE)
                      if d.startswith(ONEK) and os.path.isfile(os.path.join(BASE, d, "sorgu.py")))
    except Exception:
        return []


def calisanlar():
    out = {}
    for p in psutil.process_iter(["pid", "cmdline"]):
        try:
            cl = p.info["cmdline"] or []
            if cl and os.path.basename(cl[-1]).lower() == "sorgu.py":
                out[os.path.basename(p.cwd())] = p.pid
        except Exception:
            pass
    return out


def baslat(klasor):
    damga = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    lf = os.path.join(BASE, "logs", "%s_%s.log" % (klasor, damga))
    fh = open(lf, "w", buffering=1, encoding="utf-8", errors="ignore")
    p = subprocess.Popen([PY_EXE, "sorgu.py"], cwd=os.path.join(BASE, klasor),
                         stdout=fh, stderr=subprocess.STDOUT,
                         creationflags=DETACHED, close_fds=True)
    return p.pid, os.path.basename(lf)


# --- tek kopya kontrolu ---
if os.path.exists(KILIT):
    try:
        eski = int(open(KILIT, encoding="utf-8").read().strip())
        if psutil.pid_exists(eski):
            p = psutil.Process(eski)
            if "supervizor.py" in " ".join(p.cmdline() or []):
                kayit("zaten calisan supervizor var (PID %d) - cikiliyor" % eski)
                raise SystemExit(0)
    except SystemExit:
        raise
    except Exception:
        pass
with open(KILIT, "w", encoding="utf-8") as f:
    f.write(str(os.getpid()))

kayit("=" * 60)
kayit("supervizor basladi (PID %d) - %d sn'de bir kontrol" % (os.getpid(), KONTROL))

basladi_at = {}     # klasor -> baslatma zamani
basarisiz = {}      # klasor -> ust uste hizli olum sayisi
karantina_at = {}   # klasor -> karantinaya alinma zamani

while True:
    try:
        simdi = time.time()
        acik = calisanlar()
        for k in hedefler():
            if k in acik:
                if basladi_at.get(k) and simdi - basladi_at[k] > HIZLI_OLUM:
                    basarisiz[k] = 0          # uzun sure yasadi, sayac sifirlanir
                continue

            # dusmus
            if k in basladi_at:
                omur = simdi - basladi_at.pop(k)
                if omur < HIZLI_OLUM:
                    basarisiz[k] = basarisiz.get(k, 0) + 1
                    kayit("OLDU  %-34s %.0f sn yasadi (ust uste %d)" % (k[len(ONEK):], omur, basarisiz[k]))
                else:
                    basarisiz[k] = 0
                    kayit("OLDU  %-34s %.0f dakika yasadi" % (k[len(ONEK):], omur / 60))

            if basarisiz.get(k, 0) >= MAX_HIZLI_OLUM:
                if simdi - karantina_at.get(k, 0) < KARANTINA:
                    continue
                karantina_at[k] = simdi
                kayit("karantina denemesi: %s" % k[len(ONEK):])

            try:
                pid, lf = baslat(k)
                basladi_at[k] = simdi
                kayit("baslatildi  %-34s PID %-7s log=%s" % (k[len(ONEK):], pid, lf))
            except Exception as e:
                kayit("BASLATILAMADI %s -> %s: %s" % (k[len(ONEK):], type(e).__name__, e))
    except Exception as e:
        kayit("supervizor dongu hatasi: %s: %s" % (type(e).__name__, e))
    time.sleep(KONTROL)
```

---

## 6. Webhooklu botlar

Telegram'da bir bot **ya webhook ya polling** kullanir, ikisi ayni anda olmaz.
Asagidaki 3 bota webhook kurulu - ana sunucuda `sorgu.py` ile (polling) baslatirsaniz calismazlar.

| Telegram | Klasor | Webhook adresi |
|---|---|---|
| `@hanedantg_bot` | `Python Telegram - Hanedan - Kopya` | `https://hanedanbet.app/kb-tg?key=kb-hanedan-webhook-2026` |
| `@istinyetc_bot` | `Python Telegram - Istinye TC` | `https://telegram.grandoperabonus.com/smsbot/webhook` |
| `@meritrc_bot` | `Python Telegram - Merit` | `https://redlabonus.click/anasayfa/telegram_tc` |

Iki secenek:

**A) Webhook kalsin** - bu botlari ana sunucuda calistirmayin. Klasor adinin basina `KAPALI - ` ekleyin, baslatici atlar.

**B) Polling'e donun** - once webhook'u silin:

```bash
curl "https://api.telegram.org/bot<TOKEN>/deleteWebhook"
```

Bu, webhook'un bagli oldugu entegrasyonu kirar. Once o tarafin hala kullanilip kullanilmadigini dogrulayin.

---

## 7. Guvenlik uyarisi

Tasinmayan 3 botun (`@casinoburadafs_bot`, `@casinoburadatg_bot`, `@showbahistg_bot`) adi **"Hacked By CyberTroll"** olarak degistirilmis.
Bot adini yalnizca BotFather uzerinden, **botun sahibi hesap** degistirebilir.

Ayni donemdeki tutarli bulgular:

- 2026-08-14 12:39:56'dan itibaren 20 botta surekli `409 Conflict` - baska bir kurulum ayni tokenlari cekiyordu. Yerel sunucudaki tum surecler durdurulup dogrulandi, kaynak bu makine degildi.
- Yeni olusturulan `@grandtc_bot` **18 saat icinde** ele gecirildi ve gruplara spam atti.
- `@istinyetc_bot`'tan silinen webhook kendiliginden **yeniden kuruldu**.

**Tasimadan once sirayla:**

1. Telegram -> Ayarlar -> Cihazlar -> **diger tum oturumlari sonlandir**
2. **Iki Asamali Dogrulama**'yi ac
3. BotFather'da 10 botun tamamini **`/revoke`** et
4. Yeni tokenlari `sorgu.py` dosyalarina yaz (her botun token satiri bolum 4'te)
5. **Sitelerdeki bot token ayarlarini da guncelle**

> 5. madde kritik: botlarin hepsi *"istek at, sonucu site gondersin"* deseniyle calisiyor.
> Sitedeki token eski kalirsa komut calisir ama **sonuc mesaji gruba ulasmaz**.

**Eski sunucuyu kapatin.** Iki kurulum ayni tokeni cekerse Telegram `409 Conflict` verir ve mesajlarin yarisi kaybolur.

---

## 8. Sorun giderme

| Belirti | Sebep | Cozum |
|---|---|---|
| `409 Conflict: terminated by other getUpdates` | Ayni tokeni baska kurulum cekiyor | Digerini kapatin veya `/revoke` |
| `401 Unauthorized` / `InvalidToken` | Token revoke edilmis | BotFather'dan yeni token |
| `getaddrinfo failed` | DNS/ag kesintisi | `supervizor.py` otomatik toparlar |
| Traceback yok, exit `3221225477` | mysql-connector C eklentisi cokmesi | `use_pure: True`, 9.4.0'da kalin |
| `UnicodeEncodeError: 'charmap'` | Log dosyasi cp1252 acilmis | `FileHandler(..., encoding="utf-8")` |
| `BadRequest: Message is too long` | Sitenin HTML hata sayfasi gonderilmeye calisiliyor | Cevabi 4096 karaktere kirpin |
| Bot ayakta ama istek atmiyor | PTB polling dongusu sessizce olmus | Yeniden baslatin; supervizor yakalar |
| Komut geliyor, cevap yok | Sitedeki bot tokeni eski | Site ayarini guncelleyin |
| Grupta hic cevap yok | Bot gruptan cikarilmis / yonetici degil | Ekleyin ve yonetici yapin |

**Test ederken:**

- Hicbir botta `/start` handler'i **yok** - cevap gelmez, bolum 3'teki gercek komutlari kullanin.
- `@jeweltg_bot` **sadece gruplarda** calisir, ozel mesajda sessiz kalir.

