Upload 5 files

Dockerfile

@@ -0,0 +1,27 @@
+# ---- Base image ----
+FROM python:3.11-slim
+
+# ---- System deps (kecil saja) ----
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl && \
+    rm -rf /var/lib/apt/lists/*
+
+# ---- Workdir ----
+WORKDIR /app
+
+# ---- Python deps (pakai cache layer) ----
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ---- App source ----
+COPY . .
+
+# ---- Port dari HF (jangan hardcode) ----
+ENV PORT=7860
+EXPOSE 7860
+
+# (opsional tapi berguna) supaya log realtime
+ENV PYTHONUNBUFFERED=1
+
+# ---- Run FastAPI (Telethon start di startup event) ----
+CMD ["bash", "-lc", "uvicorn server:app --host 0.0.0.0 --port ${PORT}"]

README.md

@@ -0,0 +1,9 @@
+---
+title: Telegram scrapping text
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# My Awesome Telegram Bot
+Ini adalah bot yang meneruskan pesan dari beberapa channel.

botsignal.py

@@ -0,0 +1,300 @@
+import asyncio
+import os
+import re
+import io
+import hashlib
+from collections import deque
+from mimetypes import guess_extension
+from typing import List, Optional
+
+import nest_asyncio
+nest_asyncio.apply()
+
+from rapidfuzz import fuzz
+from telethon import TelegramClient, events
+from telethon.sessions import StringSession, MemorySession
+
+
+# ========= Configuration via Environment =========
+API_ID = int(os.environ.get("API_ID", "0"))
+API_HASH = os.environ.get("API_HASH", "")
+STRING_SESSION = os.environ.get("STRING_SESSION", "")
+
+# Sumber & target (boleh pakai @username, id, atau link t.me)
+SOURCE_CHATS = [
+    "https://t.me/PEPE_Calls28",
+    "https://t.me/Tanjirocall",
+    "https://t.me/ChinaPumpCommunity",
+    "https://t.me/Milagrosdegencalls",
+    "https://t.me/GM_Degencalls",
+]
+TARGET_CHAT = os.environ.get("TARGET_CHAT", "https://t.me/MidasTouchsignall")
+
+# Kata kunci topik; simple relevansi supaya tidak semua pesan dikirim
+THEME_KEYWORDS = [
+    "call", "signal", "entry", "buy", "sell", "tp", "sl",
+    "pump", "spot", "futures", "setup",
+    "pepe", "bnb", "eth", "btc", "sol", "meme",
+]
+KEYWORD_WEIGHT = 1.0
+FUZZ_WEIGHT = 0.6
+RELEVANCE_THRESHOLD = float(os.environ.get("RELEVANCE_THRESHOLD", "1.0"))
+
+# Filter pengecualian: jika ada frasa ini (case-insensitive) -> skip
+EXCLUDE_PHRASES = [
+    "achievement unlocked",
+]
+
+# Media handling
+INCLUDE_MEDIA = os.environ.get("INCLUDE_MEDIA", "1") == "1"
+MAX_MEDIA_MB = float(os.environ.get("MAX_MEDIA_MB", "12"))
+SKIP_STICKERS = os.environ.get("SKIP_STICKERS", "1") == "1"
+ALLOW_GIFS_VIDEOS = os.environ.get("ALLOW_GIFS_VIDEOS", "0") == "1"
+
+# History backfill saat startup
+INITIAL_BACKFILL = int(os.environ.get("INITIAL_BACKFILL", "20"))
+
+# Dedup buffer
+DEDUP_BUFFER_SIZE = int(os.environ.get("DEDUP_BUFFER_SIZE", "800"))
+
+
+# ========= Client bootstrap =========
+def build_client() -> TelegramClient:
+    if STRING_SESSION:
+        print(">> Using StringSession (persistent).")
+        return TelegramClient(StringSession(STRING_SESSION), API_ID, API_HASH)
+    print(">> Using MemorySession (login tiap run).")
+    return TelegramClient(MemorySession(), API_ID, API_HASH)
+
+client = build_client()
+recent_hashes: deque[str] = deque(maxlen=DEDUP_BUFFER_SIZE)
+
+
+# ========= Utilities =========
+def debug_log(reason: str, content: str = "") -> None:
+    short = (content or "").replace("\n", " ")[:160]
+    print(f"[DEBUG] {reason}: {short}")
+
+def normalize_for_filter(text: str) -> str:
+    if not text:
+        return ""
+    # Hilangkan quote >..., rapikan whitespace
+    s = re.sub(r"(?m)^>.*$", "", text)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+def score_relevance(text: str, keywords: List[str]) -> float:
+    """Skor sederhana: exact keyword + fuzzy ratio rata-rata top 3."""
+    if not text:
+        return 0.0
+    t = text.lower()
+
+    # exact hits
+    exact_hits = 0
+    for kw in keywords:
+        if kw in t or re.search(rf"\b{re.escape(kw)}\b", t):
+            exact_hits += 1
+    exact_score = exact_hits * KEYWORD_WEIGHT
+
+    # fuzzy hits (ambil 3 nilai tertinggi)
+    fuzz_scores = sorted((fuzz.partial_ratio(kw, t) / 100.0 for kw in keywords), reverse=True)[:3]
+    fuzzy_score = (sum(fuzz_scores) / max(1, len(fuzz_scores))) * FUZZ_WEIGHT if fuzz_scores else 0.0
+
+    return exact_score + fuzzy_score
+
+def hash_for_dedup(text: str, msg) -> str:
+    """Gabungkan teks dan sid media agar tidak double post."""
+    parts = [text or ""]
+    if getattr(msg, "id", None) is not None:
+        # id unik per chat; cukup bagus untuk dedup dalam window pendek
+        parts.append(str(msg.id))
+    doc = getattr(msg, "document", None)
+    if doc and getattr(doc, "id", None) is not None:
+        parts.append(f"doc:{doc.id}")
+    if getattr(msg, "photo", None) is not None:
+        # Telegram photo punya id juga
+        ph = msg.photo
+        ph_id = getattr(ph, "id", None)
+        if ph_id is not None:
+            parts.append(f"photo:{ph_id}")
+    raw = "|".join(parts).encode("utf-8", errors="ignore")
+    return hashlib.sha1(raw).hexdigest()
+
+def is_image_message(msg) -> bool:
+    """True jika pesan mengandung foto atau dokumen gambar yang boleh."""
+    if getattr(msg, "photo", None) is not None:
+        return True
+    doc = getattr(msg, "document", None)
+    if doc and getattr(doc, "mime_type", None):
+        mt = (doc.mime_type or "").lower()
+        if mt.startswith("image/"):
+            if SKIP_STICKERS and ("webp" in mt or "sticker" in mt):
+                return False
+            return True
+        if not ALLOW_GIFS_VIDEOS:
+            return False
+        if mt in ("video/mp4", "image/gif"):
+            return True
+    return False
+
+def media_too_big(msg) -> bool:
+    doc = getattr(msg, "document", None)
+    if doc and getattr(doc, "size", None):
+        return (doc.size or 0) > MAX_MEDIA_MB * 1024 * 1024
+    return False
+
+
+# ========= Core actions =========
+async def send_as_is(msg) -> None:
+    """Forward konten 'apa adanya' ke TARGET_CHAT, dengan media bila sesuai."""
+    orig_text = msg.message or (getattr(msg, "raw_text", None) or "")
+
+    if INCLUDE_MEDIA and is_image_message(msg) and not media_too_big(msg):
+        try:
+            # Jika pesan berupa photo asli
+            if getattr(msg, "photo", None):
+                await client.send_file(
+                    TARGET_CHAT,
+                    msg.photo,
+                    caption=orig_text,
+                    caption_entities=getattr(msg, "entities", None),
+                    force_document=False,
+                )
+                return
+
+            # Jika berupa document image/gif/video
+            doc = getattr(msg, "document", None)
+            if doc:
+                data = await client.download_media(msg, file=bytes)
+                if data:
+                    bio = io.BytesIO(data)
+                    # Tentukan ekstensi file dari mime
+                    ext = ".jpg"
+                    mt = (getattr(doc, "mime_type", "") or "").lower()
+                    if mt:
+                        ext_guess = guess_extension(mt) or ".jpg"
+                        if ext_guess == ".jpe":
+                            ext_guess = ".jpg"
+                        ext = ext_guess
+                    bio.name = f"media{ext}"
+                    await client.send_file(
+                        TARGET_CHAT,
+                        bio,
+                        caption=orig_text,
+                        caption_entities=getattr(msg, "entities", None),
+                        force_document=False,
+                    )
+                    return
+        except Exception as e:
+            debug_log("Gagal kirim sebagai media, fallback ke text", str(e))
+
+    # Fallback: text saja
+    await client.send_message(
+        TARGET_CHAT,
+        orig_text,
+        formatting_entities=getattr(msg, "entities", None),
+        link_preview=True,
+    )
+
+async def process_message(msg, source_name: str) -> None:
+    """Filter, dedup, relevansi, lalu kirim."""
+    orig_text = msg.message or (getattr(msg, "raw_text", None) or "")
+    text_norm = normalize_for_filter(orig_text).lower()
+
+    # Pengecualian eksplisit
+    for phrase in EXCLUDE_PHRASES:
+        if phrase.lower() in text_norm:
+            debug_log("Dilewati karena EXCLUDE_PHRASES", orig_text)
+            return
+
+    # Dedup
+    h = hash_for_dedup(text_norm, msg)
+    if h in recent_hashes:
+        debug_log("Duplikat, dilewati", orig_text)
+        return
+    recent_hashes.append(h)
+
+    # Relevansi
+    score = score_relevance(text_norm, THEME_KEYWORDS)
+    debug_log(f"Skor relevansi={score:.2f}", orig_text)
+    if score < RELEVANCE_THRESHOLD:
+        return
+
+    await send_as_is(msg)
+    debug_log("Dikirim ke target", orig_text)
+
+async def backfill_history(entity, limit: int) -> None:
+    """Tarik pesan lama dari suatu source untuk diproses (opsional)."""
+    if limit <= 0:
+        return
+    print(f"[Backfill] Tarik {limit} pesan terakhir dari {entity} ...")
+    async for m in client.iter_messages(entity, limit=limit):
+        try:
+            await process_message(m, source_name=str(entity))
+        except Exception as e:
+            debug_log("Error saat memproses backfill", str(e))
+
+
+# ========= Event handlers =========
+@client.on(events.NewMessage(chats=SOURCE_CHATS))
+async def on_new_message(event):
+    try:
+        await process_message(event.message, source_name=str(event.chat_id))
+    except Exception as e:
+        print("Process error:", e)
+
+
+# ========= Entry points =========
+async def start_bot_background() -> None:
+    """
+    Dipanggil dari server FastAPI (server.py).
+    Menjalankan client + backfill tapi tidak memblokir event loop web-server.
+    """
+    await client.start()
+
+    # resolve semua sources
+    resolved_sources = []
+    for src in SOURCE_CHATS:
+        try:
+            ent = await client.get_entity(src)
+            resolved_sources.append(ent)
+        except Exception as e:
+            print(f"Gagal resolve sumber {src}: {e}")
+
+    for ent in resolved_sources:
+        try:
+            await backfill_history(ent, INITIAL_BACKFILL)
+        except Exception as e:
+            print(f"Backfill gagal untuk {ent}: {e}")
+
+    print("Kurator berjalan (background task). Menunggu pesan baru...")
+    # Jangan blokir: jalankan client sampai disconnect sebagai task terpisah
+    asyncio.create_task(client.run_until_disconnected())
+
+
+async def app_main() -> None:
+    """
+    Jalur eksekusi legacy: biar bisa `python botsignal.py`
+    (blok hingga disconnect).
+    """
+    await client.start()
+
+    resolved_sources = []
+    for src in SOURCE_CHATS:
+        try:
+            ent = await client.get_entity(src)
+            resolved_sources.append(ent)
+        except Exception as e:
+            print(f"Gagal resolve sumber {src}: {e}")
+
+    for ent in resolved_sources:
+        await backfill_history(ent, INITIAL_BACKFILL)
+
+    print("Kurator berjalan. Menunggu pesan baru... (Stop dengan interrupt).")
+    await client.run_until_disconnected()
+
+
+if __name__ == "__main__":
+
+    nest_asyncio.apply()
+    asyncio.run(app_main())

requirements.txt

@@ -0,0 +1,5 @@
+telethon
+rapidfuzz
+nest-asyncio
+fastapi
+uvicorn[standard]

server.py

@@ -0,0 +1,20 @@
+import os
+import asyncio
+from fastapi import FastAPI
+from botsignal import start_bot_background
+
+app = FastAPI(title="Telegram Curator Health")
+
+@app.on_event("startup")
+async def startup():
+  
+    await start_bot_background()
+
+@app.get("/")
+async def root():
+    return {"status": "ok"}
+
+@app.get("/health")
+async def health():
+   
+    return {"healthy": True}