Delete app

app/cf_api.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-import httpx
-from typing import Any, Dict, Optional
-
-class CFClient:
-    def __init__(self, worker1_url: str, worker2_url: str, bot_backend_key: str, hf_api_key: str):
-        self.w1 = worker1_url.rstrip("/")
-        self.w2 = worker2_url.rstrip("/")
-        self.bot_backend_key = bot_backend_key
-        self.hf_api_key = hf_api_key
-        self._client = httpx.AsyncClient(timeout=httpx.Timeout(60.0, read=120.0))
-
-    async def close(self):
-        await self._client.aclose()
-
-    # ---------- Worker2 (HF-only) ----------
-    async def is_allowed(self, tg_id: str) -> bool:
-        r = await self._client.post(
-            f"{self.w2}/api/is_allowed",
-            headers={"Authorization": f"Bearer {self.hf_api_key}"},
-            json={"tg_id": tg_id},
-        )
-        if r.status_code != 200:
-            return False
-        j = r.json()
-        return bool(j.get("allowed", False))
-
-    async def allow_user(self, tg_id: str) -> Dict[str, Any]:
-        return await self._post_w2("/api/allow_user", {"tg_id": tg_id})
-
-    async def disallow_user(self, tg_id: str) -> Dict[str, Any]:
-        return await self._post_w2("/api/disallow_user", {"tg_id": tg_id})
-
-    async def list_profiles_w2(self, tg_id: str) -> Dict[str, Any]:
-        return await self._post_w2("/api/list_profiles", {"tg_id": tg_id})
-
-    async def pick_profile(self, tg_id: str, channel_id: str, rotate_after: int) -> Dict[str, Any]:
-        return await self._post_w2("/api/pick_profile", {"tg_id": tg_id, "channel_id": channel_id, "rotate_after": rotate_after})
-
-    async def access_token(self, tg_id: str, profile_id: str) -> Dict[str, Any]:
-        return await self._post_w2("/api/access_token", {"tg_id": tg_id, "profile_id": profile_id})
-
-    async def record_upload(self, tg_id: str, profile_id: str) -> Dict[str, Any]:
-        return await self._post_w2("/api/record_upload", {"tg_id": tg_id, "profile_id": profile_id})
-
-    async def stats_today(self) -> Dict[str, Any]:
-        return await self._post_w2("/api/stats_today", {})
-
-    async def log_error(self, tg_id: str, profile_id: str, where: str, err: str) -> None:
-        try:
-            await self._post_w2("/api/log_error", {"tg_id": tg_id, "profile_id": profile_id, "where": where, "err": err})
-        except Exception:
-            pass
-
-    async def _post_w2(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
-        r = await self._client.post(
-            f"{self.w2}{path}",
-            headers={"Authorization": f"Bearer {self.hf_api_key}"},
-            json=body,
-        )
-        try:
-            return r.json()
-        except Exception:
-            return {"ok": False, "err": f"bad_json_{r.status_code}"}
-
-    # ---------- Worker1 (BOT backend key) ----------
-    async def profile_add(self, tg_id: str, client_id: str, client_secret: str, label: str = "main", ttl_sec: int = 600) -> Dict[str, Any]:
-        r = await self._client.post(
-            f"{self.w1}/api/profile/add",
-            headers={"Authorization": f"Bearer {self.bot_backend_key}"},
-            json={"tg_id": tg_id, "client_id": client_id, "client_secret": client_secret, "label": label, "ttl_sec": ttl_sec},
-        )
-        try:
-            return r.json()
-        except Exception:
-            return {"ok": False, "err": f"bad_json_{r.status_code}"}
-
-    async def profile_list_w1(self, tg_id: str) -> Dict[str, Any]:
-        r = await self._client.post(
-            f"{self.w1}/api/profile/list",
-            headers={"Authorization": f"Bearer {self.bot_backend_key}"},
-            json={"tg_id": tg_id},
-        )
-        try:
-            return r.json()
-        except Exception:
-            return {"ok": False, "err": f"bad_json_{r.status_code}"}
-
-    async def profile_set_default(self, tg_id: str, profile_id: str) -> Dict[str, Any]:
-        r = await self._client.post(
-            f"{self.w1}/api/profile/set_default",
-            headers={"Authorization": f"Bearer {self.bot_backend_key}"},
-            json={"tg_id": tg_id, "profile_id": profile_id},
-        )
-        try:
-            return r.json()
-        except Exception:
-            return {"ok": False, "err": f"bad_json_{r.status_code}"}
-
-    async def profile_remove(self, tg_id: str, profile_id: str) -> Dict[str, Any]:
-        r = await self._client.post(
-            f"{self.w1}/api/profile/remove",
-            headers={"Authorization": f"Bearer {self.bot_backend_key}"},
-            json={"tg_id": tg_id, "profile_id": profile_id},
-        )
-        try:
-            return r.json()
-        except Exception:
-            return {"ok": False, "err": f"bad_json_{r.status_code}"}

app/config.py

@@ -1,38 +0,0 @@
-import os
-from dataclasses import dataclass
-
-@dataclass(frozen=True)
-class Config:
-    # Telegram
-    BOT_TOKEN: str
-    API_ID: int
-    API_HASH: str
-    OWNER_ID: int
-
-    # Workers
-    WORKER1_URL: str
-    WORKER2_URL: str
-    BOT_BACKEND_KEY: str
-    HF_API_KEY: str
-
-    # Optional
-    BOT_USERNAME: str = ""
-
-def _must(name: str) -> str:
-    v = os.getenv(name, "").strip()
-    if not v:
-        raise RuntimeError(f"Missing env: {name}")
-    return v
-
-def load_config() -> Config:
-    return Config(
-        BOT_TOKEN=_must("BOT_TOKEN"),
-        API_ID=int(_must("API_ID")),
-        API_HASH=_must("API_HASH"),
-        OWNER_ID=int(_must("OWNER_ID")),
-        WORKER1_URL=_must("WORKER1_URL").rstrip("/"),
-        WORKER2_URL=_must("WORKER2_URL").rstrip("/"),
-        BOT_BACKEND_KEY=_must("BOT_BACKEND_KEY"),
-        HF_API_KEY=_must("HF_API_KEY"),
-        BOT_USERNAME=os.getenv("BOT_USERNAME", "").strip(),
-    )

app/main.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from contextlib import asynccontextmanager
-from fastapi import FastAPI
-
-from app.config import load_config
-from app.cf_api import CFClient
-from bot.client import build_bot
-from bot.handlers import register_handlers
-
-cfg = load_config()
-cf = CFClient(cfg.WORKER1_URL, cfg.WORKER2_URL, cfg.BOT_BACKEND_KEY, cfg.HF_API_KEY)
-bot = build_bot(cfg)
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # start bot
-    await register_handlers(bot, cfg, cf)
-    await bot.start()
-    yield
-    # stop bot
-    await bot.stop()
-    await cf.close()
-
-app = FastAPI(lifespan=lifespan)
-
-@app.get("/")
-async def root():
-    return {
-        "ok": True,
-        "service": "yt-uploader-bot",
-        "bot_username": cfg.BOT_USERNAME,
-    }
-
-@app.get("/health")
-async def health():
-    return {"ok": True}

app/progress.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-import time
-
-def human_bytes(n: float) -> str:
-    for unit in ["B", "KB", "MB", "GB", "TB"]:
-        if n < 1024:
-            return f"{n:.1f}{unit}"
-        n /= 1024
-    return f"{n:.1f}PB"
-
-def fmt_eta(sec: float) -> str:
-    sec = max(0, int(sec))
-    if sec < 60:
-        return f"{sec}s"
-    m = sec // 60
-    s = sec % 60
-    if m < 60:
-        return f"{m}m {s}s"
-    h = m // 60
-    m = m % 60
-    return f"{h}h {m}m"
-
-class RateProgress:
-    def __init__(self, total: int, edit_every: float = 2.5):
-        self.total = max(1, total)
-        self.edit_every = edit_every
-        self.t0 = time.time()
-        self.last_edit = 0.0
-        self.last_bytes = 0
-        self.last_t = self.t0
-
-    def snapshot(self, done: int) -> dict:
-        now = time.time()
-        done = max(0, min(done, self.total))
-        dt = max(1e-6, now - self.last_t)
-        dbytes = done - self.last_bytes
-        speed = dbytes / dt  # B/s
-        elapsed = now - self.t0
-        pct = (done / self.total) * 100.0
-        remaining = self.total - done
-        eta = remaining / speed if speed > 1 else float("inf")
-        return {
-            "pct": pct,
-            "done": done,
-            "total": self.total,
-            "speed": speed,
-            "eta": eta,
-            "elapsed": elapsed,
-            "now": now
-        }
-
-    def should_edit(self, now: float) -> bool:
-        return (now - self.last_edit) >= self.edit_every
-
-    def mark_edit(self, done: int, now: float):
-        self.last_edit = now
-        self.last_bytes = done
-        self.last_t = now

app/settings.py

@@ -1,24 +0,0 @@
-# Settings that you can edit safely WITHOUT touching .env
-
-# Upload rotation: per profile per UTC day limit
-ROTATE_AFTER_PER_PROFILE = 30  # change anytime
-
-# Default upload privacy (bulk-friendly)
-DEFAULT_PRIVACY = "private"  # private | unlisted | public
-
-# Default title mode for new videos
-# "caption" (if exists else filename) | "filename"
-DEFAULT_TITLE_MODE = "caption"
-
-# YouTube resumable upload chunk size (bytes)
-# 8MB is safe; bigger may speed up but more risk on unstable net
-YOUTUBE_CHUNK_SIZE = 8 * 1024 * 1024
-
-# Bot rate-limit for progress edits (seconds)
-PROGRESS_EDIT_EVERY_SEC = 2.5
-
-# Max concurrent uploads per bot (avoid HF overload)
-MAX_CONCURRENT_UPLOADS = 1
-
-# Local temp dir
-TMP_DIR = "/tmp/ytbot"

app/state.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass, field
-from typing import Dict, Optional, Any
-import asyncio
-import secrets
-import time
-
-@dataclass
-class UploadJob:
-    upload_id: str
-    user_id: int
-    chat_id: int
-    src_msg_id: int
-    file_type: str  # "video" | "document"
-    tg_file_id: str
-    file_name: str
-    caption: str
-
-    privacy: str = "private"
-    title_mode: str = "caption"  # caption | filename | custom
-    custom_title: str = ""
-
-    status_msg_id: Optional[int] = None
-    created_at: float = field(default_factory=time.time)
-
-class MemoryState:
-    def __init__(self):
-        self.uploads: Dict[str, UploadJob] = {}
-        self.waiting_client_id: Dict[int, bool] = {}
-        self.waiting_client_secret: Dict[int, str] = {}  # user_id -> client_id
-        self.waiting_custom_title: Dict[int, str] = {}   # user_id -> upload_id
-        self.auto_mode: Dict[int, bool] = {}             # user_id -> bool
-        self.sem = asyncio.Semaphore(1)  # overwritten by settings at runtime
-
-    def new_upload_id(self) -> str:
-        return secrets.token_urlsafe(8)[:10]
-
-STATE = MemoryState()

app/youtube_api.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-import os
-import json
-import httpx
-from typing import Optional, Callable, Dict, Any
-from app.progress import RateProgress, human_bytes, fmt_eta
-
-YT_INIT_URL = "https://www.googleapis.com/upload/youtube/v3/videos"
-YT_PARTS = "snippet,status"
-
-def _clean_title(s: str) -> str:
-    s = (s or "").strip()
-    if not s:
-        return "Untitled"
-    # YouTube title limit is 100 chars
-    return s[:100]
-
-async def youtube_resumable_upload(
-    access_token: str,
-    file_path: str,
-    title: str,
-    description: str,
-    privacy: str,
-    chunk_size: int,
-    progress_cb: Optional[Callable[[int, int, float, float], Any]] = None,
-    http: Optional[httpx.AsyncClient] = None,
-) -> Dict[str, Any]:
-    """
-    progress_cb(done, total, speed_bps, eta_sec)
-    """
-    total = os.path.getsize(file_path)
-    title = _clean_title(title)
-    description = (description or "").strip()
-    privacy = privacy if privacy in ("private", "unlisted", "public") else "private"
-
-    close_http = False
-    if http is None:
-        http = httpx.AsyncClient(timeout=None)
-        close_http = True
-
-    try:
-        # 1) Initiate resumable session
-        meta = {
-            "snippet": {"title": title, "description": description},
-            "status": {"privacyStatus": privacy},
-        }
-        init_headers = {
-            "Authorization": f"Bearer {access_token}",
-            "Content-Type": "application/json; charset=UTF-8",
-            "X-Upload-Content-Type": "video/*",
-            "X-Upload-Content-Length": str(total),
-        }
-        init_params = {"uploadType": "resumable", "part": YT_PARTS}
-        init_resp = await http.post(YT_INIT_URL, headers=init_headers, params=init_params, content=json.dumps(meta))
-        if init_resp.status_code not in (200, 201):
-            return {"ok": False, "err": f"init_failed:{init_resp.status_code}:{init_resp.text[:200]}"}
-
-        upload_url = init_resp.headers.get("Location")
-        if not upload_url:
-            return {"ok": False, "err": "no_upload_location"}
-
-        # 2) Upload chunks
-        rp = RateProgress(total=total, edit_every=0.0)
-        done = 0
-
-        with open(file_path, "rb") as f:
-            while done < total:
-                chunk = f.read(chunk_size)
-                if not chunk:
-                    break
-                start = done
-                end = done + len(chunk) - 1
-                headers = {
-                    "Authorization": f"Bearer {access_token}",
-                    "Content-Length": str(len(chunk)),
-                    "Content-Range": f"bytes {start}-{end}/{total}",
-                }
-
-                put_resp = await http.put(upload_url, headers=headers, content=chunk)
-
-                # 308 = Resume Incomplete
-                if put_resp.status_code == 308:
-                    done = end + 1
-                elif put_resp.status_code in (200, 201):
-                    # finished
-                    j = put_resp.json()
-                    vid = j.get("id")
-                    return {"ok": True, "video_id": vid, "raw": j}
-                else:
-                    return {"ok": False, "err": f"upload_failed:{put_resp.status_code}:{put_resp.text[:200]}"}
-
-                snap = rp.snapshot(done)
-                if progress_cb:
-                    progress_cb(done, total, snap["speed"], snap["eta"])
-
-        return {"ok": False, "err": "upload_incomplete"}
-    finally:
-        if close_http:
-            await http.aclose()