Upload 14 files

.env

@@ -6,10 +6,9 @@ API_HASH=51225833a1b50c15c6c39071ea567e48
 # Use negative ID for supergroups: e.g. -1001234567890
 CHANNEL_ID=-1003739341703
 
-# MongoDB Atlas connection string
-# Get this from: Atlas → Connect → Drivers → Python
-MONGODB_URI=mongodb+srv://nitinbhujwa:nitinbhujwa@tgstorage.thhklhw.mongodb.net/?appName=tgstorage
-MONGO_DB_NAME=tgstorage
+# Supabase (get from: Supabase Dashboard → Settings → API)
+SUPABASE_URL=https://geslknqmelmaoowdkmwv.supabase.co
+SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imdlc2xrbnFtZWxtYW9vd2RrbXd2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTIzMjAwMzMsImV4cCI6MjA2Nzg5NjAzM30.k2JhLyjZ5F6W1vwwGX2yqPf-1Q8vm6nQyV8Zhqfqtfc
 
 # API authentication key for this server
 ADMIN_API_KEY=

.gitignore

@@ -1,3 +0,0 @@
-.env
-__pycache__
-.gitignore

Dockerfile

@@ -1,35 +1,35 @@
-# Use an official Python runtime as a parent image
-FROM python:3.11-slim
-
-# Set environment variables
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
-
-# Set the working directory in the container
-WORKDIR /app
-
-# Install system dependencies required for some Python packages
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    gcc \
-    python3-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first to leverage Docker cache
-COPY requirements.txt .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt 
-
-# Create a non-root user and switch to it
-RUN groupadd -r appuser && useradd -r -g appuser appuser
-RUN chown -R appuser:appuser /app
-USER appuser
-
-# Copy the rest of the application
-COPY --chown=appuser:appuser . .
-
-# Expose the port the app runs on
-EXPOSE 8082
-
-# Command to run the application
-CMD ["gunicorn", "main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8082"]
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies required for some Python packages
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt 
+
+# Create a non-root user and switch to it
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Copy the rest of the application
+COPY --chown=appuser:appuser . .
+
+# Expose the port the app runs on
+EXPOSE 8082
+
+# Command to run the application
+CMD ["gunicorn", "main:app", "-w", "4", "--bind", "0.0.0.0:8082"]

db.py

@@ -1,42 +1,59 @@
 """
-db.py — Async MongoDB Atlas metadata store using Motor.
-Collection: tgstorage.files
+db.py — Supabase (PostgreSQL) metadata store.
+Table: files
+
+Before first run, create the table in Supabase SQL Editor:
+
+    CREATE TABLE IF NOT EXISTS files (
+        id          UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+        file_id     TEXT UNIQUE NOT NULL,
+        filename    TEXT NOT NULL,
+        mime_type   TEXT NOT NULL,
+        size_bytes  BIGINT NOT NULL,
+        tg_message_id BIGINT NOT NULL,
+        tg_file_id  TEXT,
+        public_url  TEXT NOT NULL,
+        custom_path TEXT UNIQUE,
+        uploaded_at TIMESTAMPTZ DEFAULT now()
+    );
 """
 
 import os
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
-from motor.motor_asyncio import AsyncIOMotorClient
-from pymongo import DESCENDING
+from supabase import create_client, Client
 
-MONGO_URI = os.getenv("MONGODB_URI", "mongodb://localhost:27017")
-DB_NAME   = os.getenv("MONGO_DB_NAME", "tgstorage")
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
 
-_client: Optional[AsyncIOMotorClient] = None
+_supabase: Optional[Client] = None
 
+TABLE = "files"
 
-def _get_collection():
-    global _client
-    if _client is None:
-        _client = AsyncIOMotorClient(MONGO_URI)
-    return _client[DB_NAME]["files"]
 
+def _get_client() -> Client:
+    global _supabase
+    if _supabase is None:
+        if not SUPABASE_URL or not SUPABASE_KEY:
+            raise RuntimeError(
+                "SUPABASE_URL and SUPABASE_KEY must be set in environment / .env"
+            )
+        _supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+    return _supabase
 
-async def init_db():
-    """Ensure indexes exist."""
-    col = _get_collection()
-    await col.create_index("file_id", unique=True)
-    await col.create_index([("uploaded_at", DESCENDING)])
-    # sparse=True so documents without custom_path don't conflict
-    await col.create_index("custom_path", unique=True, sparse=True)
+
+def init_db():
+    """Verify Supabase connection by performing a lightweight query."""
+    client = _get_client()
+    client.table(TABLE).select("file_id").limit(1).execute()
 
 
 # ──────────────────────────────────────────────────
 #  CRUD
 # ──────────────────────────────────────────────────
 
-async def save_file_record(
+def save_file_record(
     *,
     file_id: str,
     filename: str,
@@ -47,8 +64,8 @@ async def save_file_record(
     public_url: str,
     custom_path: str | None = None,
 ):
-    col = _get_collection()
-    doc = {
+    client = _get_client()
+    row = {
         "file_id":       file_id,
         "filename":      filename,
         "mime_type":     mime_type,
@@ -56,39 +73,63 @@ async def save_file_record(
         "tg_message_id": tg_message_id,
         "tg_file_id":    tg_file_id,
         "public_url":    public_url,
-        "uploaded_at":   datetime.utcnow().isoformat(),
+        "uploaded_at":   datetime.now(timezone.utc).isoformat(),
     }
     if custom_path:
-        doc["custom_path"] = custom_path
-    await col.insert_one(doc)
-
-
-async def get_file_record(file_id: str) -> dict | None:
-    col = _get_collection()
-    return await col.find_one({"file_id": file_id}, {"_id": 0})
-
-
-async def get_file_by_custom_path(custom_path: str) -> dict | None:
-    col = _get_collection()
-    return await col.find_one({"custom_path": custom_path}, {"_id": 0})
-
-
-async def list_file_records(limit: int = 50, offset: int = 0) -> list[dict]:
-    col = _get_collection()
-    cursor = (
-        col.find({}, {"_id": 0})
-           .sort("uploaded_at", DESCENDING)
-           .skip(offset)
-           .limit(limit)
+        row["custom_path"] = custom_path
+    client.table(TABLE).insert(row).execute()
+
+
+def get_file_record(file_id: str) -> dict | None:
+    client = _get_client()
+    resp = (
+        client.table(TABLE)
+        .select("*")
+        .eq("file_id", file_id)
+        .limit(1)
+        .execute()
+    )
+    if resp.data:
+        return resp.data[0]
+    return None
+
+
+def get_file_by_custom_path(custom_path: str) -> dict | None:
+    client = _get_client()
+    resp = (
+        client.table(TABLE)
+        .select("*")
+        .eq("custom_path", custom_path)
+        .limit(1)
+        .execute()
     )
-    return await cursor.to_list(length=limit)
+    if resp.data:
+        return resp.data[0]
+    return None
+
+
+def list_file_records(limit: int = 50, offset: int = 0) -> list[dict]:
+    client = _get_client()
+    resp = (
+        client.table(TABLE)
+        .select("*")
+        .order("uploaded_at", desc=True)
+        .range(offset, offset + limit - 1)
+        .execute()
+    )
+    return resp.data or []
 
 
-async def delete_file_record(file_id: str):
-    col = _get_collection()
-    await col.delete_one({"file_id": file_id})
+def delete_file_record(file_id: str):
+    client = _get_client()
+    client.table(TABLE).delete().eq("file_id", file_id).execute()
 
 
-async def count_files() -> int:
-    col = _get_collection()
-    return await col.count_documents({})
+def count_files() -> int:
+    client = _get_client()
+    resp = (
+        client.table(TABLE)
+        .select("file_id", count="exact")
+        .execute()
+    )
+    return resp.count or 0

main.py

@@ -4,32 +4,29 @@ TG Storage API — Store & retrieve files via Telegram as a backend.
 Endpoints:
   GET    /                        — Frontend UI
   POST   /upload                  — Upload a file (optional custom_path)
-  GET    /cdn/{path}              — Public CDN URL — works with:
+  GET    /cdn/<path>              — Public CDN URL — works with:
                                       /cdn/<file_id>
                                       /cdn/<custom_path>        e.g. /cdn/logo.png
                                       /cdn/<folder/name.ext>   e.g. /cdn/images/avatar.jpg
-  GET    /file/{file_id}          — Download (auth required, forces attachment)
+  GET    /file/<file_id>          — Download (auth required, forces attachment)
   GET    /files                   — List all stored files
-  DELETE /file/{file_id}          — Delete a file record
+  DELETE /file/<file_id>          — Delete a file record
   GET    /health                  — Health check
 """
 
 import os
-import io
 import re
 import uuid
 import logging
 import mimetypes
-from contextlib import asynccontextmanager
-from datetime import datetime
-from typing import Optional
+import atexit
+from datetime import datetime, timezone
 from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
-from fastapi import FastAPI, UploadFile, File, Form, Header, HTTPException, Depends, Query, Request
-from fastapi.responses import StreamingResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
+from flask import Flask, request, jsonify, Response, abort, send_file
+from flask_cors import CORS
 
 from db import (
     init_db, save_file_record,
@@ -38,32 +35,11 @@ from db import (
 )
 from tg import upload_to_telegram, download_from_telegram, init_bot_pool, close_http
 
-# ──────────────────────────────────────────────────
-#  Lifespan
-# ──────────────────────────────────────────────────
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    await init_db()        # connect MongoDB Atlas + ensure indexes
-    await init_bot_pool()  # verify tokens.txt & build bot pool
-    yield
-    await close_http()     # drain httpx connection pool
-
 # ──────────────────────────────────────────────────
 #  App
 # ──────────────────────────────────────────────────
-app = FastAPI(
-    title="TG Storage API",
-    description="Infinite file storage powered by Telegram",
-    version="4.0.0",
-    lifespan=lifespan,
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app = Flask(__name__)
+CORS(app)
 
 ADMIN_API_KEY = os.getenv("ADMIN_API_KEY", "changeme")
 BASE_URL      = os.getenv("BASE_URL", "http://localhost:8082").rstrip("/")
@@ -71,57 +47,62 @@ BASE_URL      = os.getenv("BASE_URL", "http://localhost:8082").rstrip("/")
 _HERE         = Path(__file__).parent
 FRONTEND_PATH = _HERE / "frontend.html"
 
-# Allowed characters in a custom path segment:
-# alphanumeric, hyphen, underscore, dot, forward slash
+# Allowed characters in a custom path segment
 _CUSTOM_PATH_RE = re.compile(r'^[a-zA-Z0-9._\-/]+$')
 
+# ──────────────────────────────────────────────────
+#  Startup / Shutdown
+# ──────────────────────────────────────────────────
+_initialized = False
+
+def _startup():
+    global _initialized
+    if _initialized:
+        return
+    init_db()          # connect Supabase + verify table exists
+    init_bot_pool()    # verify tokens.txt & build bot pool
+    _initialized = True
+
+atexit.register(close_http)  # drain httpx connection pool on exit
+
 
 # ──────────────────────────────────────────────────
 #  Helpers
 # ──────────────────────────────────────────────────
-async def require_api_key(x_api_key: str = Header(..., description="Your API key")):
-    if x_api_key != ADMIN_API_KEY:
-        raise HTTPException(status_code=401, detail="Invalid or missing API key")
-    return x_api_key
+def require_api_key():
+    key = request.headers.get("X-API-Key", "")
+    if key != ADMIN_API_KEY:
+        abort(401, description="Invalid or missing API key")
 
 
 def _sanitize_custom_path(raw: str) -> str:
-    """
-    Normalise and validate a custom path.
-    - Strip leading/trailing slashes and whitespace
-    - Reject empty, path-traversal attempts, or illegal characters
-    """
     path = raw.strip().strip("/")
     if not path:
-        raise HTTPException(status_code=400, detail="custom_path cannot be empty after stripping slashes.")
+        abort(400, description="custom_path cannot be empty after stripping slashes.")
     if ".." in path:
-        raise HTTPException(status_code=400, detail="custom_path must not contain '..'")
+        abort(400, description="custom_path must not contain '..'")
     if not _CUSTOM_PATH_RE.match(path):
-        raise HTTPException(
-            status_code=400,
-            detail="custom_path may only contain letters, digits, hyphens, underscores, dots, and slashes."
-        )
+        abort(400, description="custom_path may only contain letters, digits, hyphens, underscores, dots, and slashes.")
     return path
 
 
 def _build_public_url(identifier: str) -> str:
-    """identifier is either a file_id UUID or a normalised custom_path."""
     return f"{BASE_URL}/cdn/{identifier}"
 
 
-async def _stream_record(record: dict) -> StreamingResponse:
-    """Download from Telegram and stream to client."""
+def _make_stream_response(record: dict, disposition: str = "inline") -> Response:
+    """Download from Telegram and return to client."""
     try:
-        data: bytes = await download_from_telegram(record["tg_message_id"], record["tg_file_id"])
+        data: bytes = download_from_telegram(record["tg_message_id"], record["tg_file_id"])
     except Exception as exc:
         logger.exception("Telegram download error")
-        raise HTTPException(status_code=502, detail=str(exc))
+        abort(502, description=str(exc))
 
-    return StreamingResponse(
-        io.BytesIO(data),
-        media_type=record["mime_type"],
+    return Response(
+        data,
+        mimetype=record["mime_type"],
         headers={
-            "Content-Disposition": f'inline; filename="{record["filename"]}"',
+            "Content-Disposition": f'{disposition}; filename="{record["filename"]}"',
             "Content-Length":      str(len(data)),
             "Cache-Control":       "public, max-age=31536000, immutable",
         },
@@ -132,100 +113,87 @@ async def _stream_record(record: dict) -> StreamingResponse:
 #  Routes
 # ──────────────────────────────────────────────────
 
-@app.get("/", include_in_schema=False)
-async def frontend():
+@app.route("/")
+def frontend():
     if FRONTEND_PATH.exists():
-        return HTMLResponse(FRONTEND_PATH.read_text(encoding="utf-8"))
-    return HTMLResponse("<h2>frontend.html not found</h2>", status_code=404)
+        return Response(FRONTEND_PATH.read_text(encoding="utf-8"), mimetype="text/html")
+    return Response("<h2>frontend.html not found</h2>", status=404, mimetype="text/html")
 
 
-@app.get("/health", tags=["System"])
-async def health():
-    total = await count_files()
-    return {"status": "ok", "timestamp": datetime.utcnow().isoformat(),
-            "total_files": total, "base_url": BASE_URL}
+@app.route("/health")
+def health():
+    _startup()
+    total = count_files()
+    return jsonify({
+        "status": "ok",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "total_files": total,
+        "base_url": BASE_URL,
+    })
 
 
 # ── CDN — public, no auth ─────────────────────────────────────────────
-@app.get(
-    "/cdn/{path:path}",
-    tags=["CDN"],
-    summary="Public shareable URL — supports UUID file_id or any custom path",
-)
-async def cdn_file(path: str):
-    """
-    Resolve priority:
-      1. Exact match on custom_path  (e.g. /cdn/images/logo.png)
-      2. Exact match on file_id UUID (e.g. /cdn/550e8400-...)
-    """
+@app.route("/cdn/<path:path>")
+def cdn_file(path: str):
+    _startup()
     # 1 — custom path lookup
-    record = await get_file_by_custom_path(path)
+    record = get_file_by_custom_path(path)
 
     # 2 — fall back to file_id lookup
     if not record:
-        record = await get_file_record(path)
+        record = get_file_record(path)
 
     if not record:
-        raise HTTPException(
-            status_code=404,
-            detail=f"No file found for path '{path}'. "
-                   f"Provide a valid file_id or a custom_path assigned at upload."
-        )
+        return jsonify({
+            "detail": f"No file found for path '{path}'. "
+                      f"Provide a valid file_id or a custom_path assigned at upload."
+        }), 404
 
-    return await _stream_record(record)
+    return _make_stream_response(record)
 
 
 # ── Upload ────────────────────────────────────────────────────────────
-@app.post(
-    "/upload",
-    tags=["Files"],
-    summary="Upload a file. Optionally assign a custom CDN path.",
-)
-async def upload_file(
-    file: UploadFile = File(...),
-    custom_path: Optional[str] = Form(
-        default=None,
-        description=(
-            "Optional vanity path for the CDN URL. "
-            "Examples: 'logo.png', 'images/avatar.jpg', 'docs/readme.md'. "
-            "Must be unique. Leave blank to use the auto-generated file_id."
-        ),
-    ),
-    _: str = Depends(require_api_key),
-):
-    content = await file.read()
+@app.route("/upload", methods=["POST"])
+def upload_file_route():
+    _startup()
+    require_api_key()
+
+    if "file" not in request.files:
+        return jsonify({"detail": "No file provided."}), 400
+
+    file = request.files["file"]
+    content = file.read()
     if not content:
-        raise HTTPException(status_code=400, detail="Empty file.")
+        return jsonify({"detail": "Empty file."}), 400
 
     filename  = file.filename or f"upload_{uuid.uuid4().hex}"
     mime_type = file.content_type or mimetypes.guess_type(filename)[0] or "application/octet-stream"
     size      = len(content)
 
     # Validate + normalise custom_path if provided
-    clean_custom_path: str | None = None
-    if custom_path and custom_path.strip():
-        clean_custom_path = _sanitize_custom_path(custom_path)
-        # Check uniqueness before hitting Telegram
-        existing = await get_file_by_custom_path(clean_custom_path)
+    clean_custom_path = None
+    custom_path_raw = request.form.get("custom_path", "")
+    if custom_path_raw and custom_path_raw.strip():
+        clean_custom_path = _sanitize_custom_path(custom_path_raw)
+        existing = get_file_by_custom_path(clean_custom_path)
         if existing:
-            raise HTTPException(
-                status_code=409,
-                detail=f"custom_path '{clean_custom_path}' is already taken by file_id={existing['file_id']}."
-            )
+            return jsonify({
+                "detail": f"custom_path '{clean_custom_path}' is already taken by file_id={existing['file_id']}."
+            }), 409
 
     # Upload bytes to Telegram
     try:
-        tg_message_id, tg_file_id = await upload_to_telegram(content, filename, mime_type)
+        tg_message_id, tg_file_id = upload_to_telegram(content, filename, mime_type)
     except Exception as exc:
         logger.exception("Telegram upload error")
-        raise HTTPException(status_code=502, detail=str(exc))
+        return jsonify({"detail": str(exc)}), 502
 
     # Build URLs
     file_id    = str(uuid.uuid4())
     cdn_key    = clean_custom_path if clean_custom_path else file_id
     public_url = _build_public_url(cdn_key)
 
-    await save_file_record(
+    save_file_record(
         file_id=file_id,
         filename=filename,
         mime_type=mime_type,
@@ -238,7 +206,7 @@ async def upload_file(
 
     logger.info(f"Uploaded {filename!r} → {public_url}")
 
-    return {
+    return jsonify({
         "file_id":     file_id,
         "filename":    filename,
         "mime_type":   mime_type,
@@ -247,26 +215,29 @@ async def upload_file(
         "public_url":  public_url,
         "cdn_url_by_id":   _build_public_url(file_id),
         "cdn_url_by_path": _build_public_url(clean_custom_path) if clean_custom_path else None,
-        "uploaded_at": datetime.utcnow().isoformat(),
-    }
+        "uploaded_at": datetime.now(timezone.utc).isoformat(),
+    })
 
 
 # ── Authenticated download ────────────────────────────────────────────
-@app.get("/file/{file_id}", tags=["Files"], summary="Download (auth required, forces attachment)")
-async def download_file(file_id: str, _: str = Depends(require_api_key)):
-    record = await get_file_record(file_id)
+@app.route("/file/<file_id>", methods=["GET"])
+def download_file_route(file_id: str):
+    _startup()
+    require_api_key()
+
+    record = get_file_record(file_id)
     if not record:
-        raise HTTPException(status_code=404, detail="File not found.")
+        return jsonify({"detail": "File not found."}), 404
 
     try:
-        data: bytes = await download_from_telegram(record["tg_message_id"], record["tg_file_id"])
+        data: bytes = download_from_telegram(record["tg_message_id"], record["tg_file_id"])
     except Exception as exc:
         logger.exception("Download error")
-        raise HTTPException(status_code=502, detail=str(exc))
+        return jsonify({"detail": str(exc)}), 502
 
-    return StreamingResponse(
-        io.BytesIO(data),
-        media_type=record["mime_type"],
+    return Response(
+        data,
+        mimetype=record["mime_type"],
         headers={
             "Content-Disposition": f'attachment; filename="{record["filename"]}"',
             "Content-Length":      str(len(data)),
@@ -275,22 +246,29 @@ async def download_file(file_id: str, _: str = Depends(require_api_key)):
 
 
 # ── List ──────────────────────────────────────────────────────────────
-@app.get("/files", tags=["Files"], summary="List all stored files")
-async def list_files(
-    limit:  int = Query(50, ge=1, le=500),
-    offset: int = Query(0, ge=0),
-    _: str = Depends(require_api_key),
-):
-    records = await list_file_records(limit=limit, offset=offset)
-    total   = await count_files()
-    return {"total": total, "limit": limit, "offset": offset, "files": records}
+@app.route("/files")
+def list_files_route():
+    _startup()
+    require_api_key()
+
+    limit  = request.args.get("limit", 50, type=int)
+    offset = request.args.get("offset", 0, type=int)
+    limit  = max(1, min(limit, 500))
+    offset = max(0, offset)
+
+    records = list_file_records(limit=limit, offset=offset)
+    total   = count_files()
+    return jsonify({"total": total, "limit": limit, "offset": offset, "files": records})
 
 
 # ── Delete ────────────────────────────────────────────────────────────
-@app.delete("/file/{file_id}", tags=["Files"], summary="Delete a file record")
-async def delete_file(file_id: str, _: str = Depends(require_api_key)):
-    record = await get_file_record(file_id)
+@app.route("/file/<file_id>", methods=["DELETE"])
+def delete_file_route(file_id: str):
+    _startup()
+    require_api_key()
+
+    record = get_file_record(file_id)
     if not record:
-        raise HTTPException(status_code=404, detail="File not found.")
-    await delete_file_record(file_id)
-    return {"deleted": True, "file_id": file_id}
+        return jsonify({"detail": "File not found."}), 404
+    delete_file_record(file_id)
+    return jsonify({"deleted": True, "file_id": file_id})

requirements.txt

@@ -1,8 +1,6 @@
-fastapi>=0.111.0
-uvicorn[standard]>=0.29.0
-python-multipart>=0.0.9
+flask>=3.0.0
+flask-cors>=4.0.0
 httpx>=0.27.0
-motor>=3.4.0
-pymongo>=4.7.0
+supabase>=2.0.0
 python-dotenv>=1.0.1
-gunicorn
+gunicorn

server.py

@@ -1,27 +1,19 @@
 """
-server.py — Entry point. Loads .env then starts Uvicorn.
+server.py — Entry point. Loads .env then starts Flask.
 
 Run:
     python server.py
-or directly:
-    uvicorn main:app --host 0.0.0.0 --port 8082
 """
 
-import sys
-import uvicorn
 from dotenv import load_dotenv
 
 load_dotenv()  # load .env before importing app so env vars are available
 
-if __name__ == "__main__":
-    # reload=True causes a multiprocessing crash on Python 3.13 + Windows.
-    # Use reload only on Python < 3.13, otherwise run without it.
-    py313_or_above = sys.version_info >= (3, 13)
+from main import app
 
-    uvicorn.run(
-        "main:app",
+if __name__ == "__main__":
+    app.run(
         host="0.0.0.0",
         port=8082,
-        reload=not py313_or_above,   # disabled on 3.13+ Windows to avoid BufferFlags crash
-        log_level="info",
+        debug=True,
     )

tg.py

@@ -8,7 +8,7 @@ Bot pool:
   • Round-robins uploads across all healthy bots to spread rate-limit load.
 
 Upload flow:
-  sendDocument  →  returns message_id + file_id  →  stored in MongoDB.
+  sendDocument  →  returns message_id + file_id  →  stored in Supabase.
 
 Download flow (two-stage):
   1. getFile(file_id)          →  get a temporary download path from Telegram.
@@ -34,30 +34,28 @@ TG_API  = "https://api.telegram.org/bot{token}/{method}"
 TG_FILE = "https://api.telegram.org/file/bot{token}/{file_path}"
 
 # Telegram hard limit for getFile downloads via Bot API is 20 MB.
-# Files larger than this must be sent as separate parts (chunking) or
-# via a Telegram client (MTProto). We warn but still attempt.
 TG_MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024  # 20 MB
 
 TIMEOUT = httpx.Timeout(connect=10.0, read=120.0, write=120.0, pool=10.0)
 
 
 # ──────────────────────────────────────────────────────────────────────
-#  Shared async HTTP client (one per process)
+#  Shared sync HTTP client (one per process)
 # ──────────────────────────────────────────────────────────────────────
-_http: httpx.AsyncClient | None = None
+_http: httpx.Client | None = None
 
-def _client() -> httpx.AsyncClient:
+def _client() -> httpx.Client:
     global _http
     if _http is None or _http.is_closed:
-        _http = httpx.AsyncClient(timeout=TIMEOUT, follow_redirects=True)
+        _http = httpx.Client(timeout=TIMEOUT, follow_redirects=True)
     return _http
 
 
-async def close_http():
+def close_http():
     """Call on app shutdown to cleanly drain the connection pool."""
     global _http
     if _http and not _http.is_closed:
-        await _http.aclose()
+        _http.close()
         _http = None
 
 
@@ -80,11 +78,11 @@ def _tokens_path() -> Path:
     )
 
 
-async def _verify_token(token: str) -> dict | None:
+def _verify_token(token: str) -> dict | None:
     """Call getMe to validate a token. Returns bot info dict or None."""
     url = TG_API.format(token=token, method="getMe")
     try:
-        r = await _client().get(url)
+        r = _client().get(url)
         data = r.json()
         if data.get("ok"):
             bot = data["result"]
@@ -95,7 +93,7 @@ async def _verify_token(token: str) -> dict | None:
     return None
 
 
-async def init_bot_pool():
+def init_bot_pool():
     """
     Read tokens.txt, verify each token with getMe(), build the round-robin pool.
     Raises RuntimeError if no healthy bots are found.
@@ -114,7 +112,7 @@ async def init_bot_pool():
 
     healthy = []
     for token in raw_tokens:
-        info = await _verify_token(token)
+        info = _verify_token(token)
         if info:
             logger.info(f"✓ Bot ready: @{info['username']} (id={info['id']})")
             healthy.append(info)
@@ -158,13 +156,13 @@ def _get_channel_id() -> int:
 #  Low-level API helpers
 # ──────────────────────────────────────────────────────────────────────
 
-async def _api(token: str, method: str, **kwargs) -> dict:
+def _api(token: str, method: str, **kwargs) -> dict:
     """
     POST to a Bot API method with JSON body.
     Raises RuntimeError on non-ok responses.
     """
     url = TG_API.format(token=token, method=method)
-    r = await _client().post(url, **kwargs)
+    r = _client().post(url, **kwargs)
     data = r.json()
     if not data.get("ok"):
         raise RuntimeError(
@@ -178,7 +176,7 @@ async def _api(token: str, method: str, **kwargs) -> dict:
 #  Upload
 # ──────────────────────────────────────────────────────────────────────
 
-async def upload_to_telegram(
+def upload_to_telegram(
     content: bytes,
     filename: str,
     mime_type: str,
@@ -197,7 +195,7 @@ async def upload_to_telegram(
     }
 
     try:
-        msg = await _api(
+        msg = _api(
             bot["token"], "sendDocument",
             data=payload,
             files=files,
@@ -221,7 +219,7 @@ async def upload_to_telegram(
 #  Download
 # ──────────────────────────────────────────────────────────────────────
 
-async def download_from_telegram(
+def download_from_telegram(
     tg_message_id: int,
     tg_file_id: str | None,
 ) -> bytes:
@@ -242,7 +240,7 @@ async def download_from_telegram(
 
     if tg_file_id:
         try:
-            result    = await _api(bot["token"], "getFile", json={"file_id": tg_file_id})
+            result    = _api(bot["token"], "getFile", json={"file_id": tg_file_id})
             file_path = result.get("file_path")
         except RuntimeError as e:
             logger.warning(f"getFile failed for file_id {tg_file_id[:24]}…, trying message fallback. ({e})")
@@ -250,7 +248,7 @@ async def download_from_telegram(
     # ── Stage 2: message fallback if file_id is stale ───────────────
     if not file_path:
         try:
-            fwd = await _api(bot["token"], "forwardMessage", json={
+            fwd = _api(bot["token"], "forwardMessage", json={
                 "chat_id":      channel_id,
                 "from_chat_id": channel_id,
                 "message_id":   tg_message_id,
@@ -265,7 +263,7 @@ async def download_from_telegram(
         if not doc:
             raise ValueError(f"Message {tg_message_id} contains no document.")
 
-        result    = await _api(bot["token"], "getFile", json={"file_id": doc["file_id"]})
+        result    = _api(bot["token"], "getFile", json={"file_id": doc["file_id"]})
         file_path = result.get("file_path")
 
     if not file_path:
@@ -273,7 +271,7 @@ async def download_from_telegram(
 
     # ── Stage 3: download bytes ──────────────────────────────────────
     url = TG_FILE.format(token=bot["token"], file_path=file_path)
-    r   = await _client().get(url)
+    r   = _client().get(url)
 
     if r.status_code != 200:
         raise RuntimeError(f"File download failed: HTTP {r.status_code} from Telegram CDN.")