Spaces:
Running
Running
| """Uptime / ping / resource numbers for /status and /stats. | |
| Inside a container psutil reports the *host's* CPU and RAM, so the cgroup files | |
| are read first and psutil is only the fallback. | |
| """ | |
| from __future__ import annotations | |
| import asyncio | |
| import os | |
| import platform | |
| import shutil | |
| import time | |
| from typing import Any, List, Optional, Tuple | |
| import psutil | |
| from . import __version__ | |
| from .fasttransfer import BIG_FILE_THRESHOLD | |
| from .utils import clip, esc, human_size, human_uptime | |
| START_TIME = time.time() | |
| CGROUP_ROOT = "/sys/fs/cgroup" | |
| _NET_BASE = psutil.net_io_counters() | |
| def _read(path: str) -> Optional[str]: | |
| try: | |
| with open(path, "r", encoding="utf-8") as fh: | |
| return fh.read().strip() | |
| except OSError: | |
| return None | |
| def parse_cpu_max(text: Optional[str]) -> Optional[float]: | |
| """cgroup v2 ``cpu.max`` -> number of cores, ``None`` when unlimited.""" | |
| if not text: | |
| return None | |
| parts = text.split() | |
| if len(parts) != 2 or parts[0] == "max": | |
| return None | |
| try: | |
| quota, period = int(parts[0]), int(parts[1]) | |
| except ValueError: | |
| return None | |
| return quota / period if quota > 0 and period > 0 else None | |
| def parse_mem_limit(text: Optional[str]) -> Optional[int]: | |
| """cgroup ``memory.max`` / v1 ``limit_in_bytes`` -> bytes, ``None`` when unlimited.""" | |
| if not text or text.strip() == "max": | |
| return None | |
| try: | |
| value = int(text.strip()) | |
| except ValueError: | |
| return None | |
| return value if value < 2 ** 60 else None | |
| def parse_stat_value(text: Optional[str], key: str) -> Optional[int]: | |
| for line in (text or "").splitlines(): | |
| parts = line.split() | |
| if len(parts) == 2 and parts[0] == key: | |
| try: | |
| return int(parts[1]) | |
| except ValueError: | |
| return None | |
| return None | |
| def cpu_cores() -> float: | |
| quota = parse_cpu_max(_read(f"{CGROUP_ROOT}/cpu.max")) | |
| return quota if quota else float(psutil.cpu_count() or 1) | |
| def _cgroup_cpu_usec() -> Optional[int]: | |
| return parse_stat_value(_read(f"{CGROUP_ROOT}/cpu.stat"), "usage_usec") | |
| async def cpu_percent(interval: float = 0.5) -> float: | |
| """CPU use of this container as a percentage of its own limit.""" | |
| first = _cgroup_cpu_usec() | |
| if first is None: | |
| return psutil.cpu_percent(interval=None) | |
| t0 = time.monotonic() | |
| await asyncio.sleep(interval) | |
| second = _cgroup_cpu_usec() | |
| elapsed = time.monotonic() - t0 | |
| if second is None or elapsed <= 0: | |
| return psutil.cpu_percent(interval=None) | |
| return max(0.0, min(100.0, (second - first) / (elapsed * 1_000_000) / cpu_cores() * 100)) | |
| def memory_usage() -> Tuple[int, int]: | |
| """(used, total) bytes for this container.""" | |
| current = _read(f"{CGROUP_ROOT}/memory.current") | |
| limit = parse_mem_limit(_read(f"{CGROUP_ROOT}/memory.max")) | |
| if current is None: # cgroup v1 | |
| current = _read(f"{CGROUP_ROOT}/memory/memory.usage_in_bytes") | |
| limit = parse_mem_limit(_read(f"{CGROUP_ROOT}/memory/memory.limit_in_bytes")) | |
| host_total = psutil.virtual_memory().total | |
| if current is None or not current.isdigit(): | |
| vm = psutil.virtual_memory() | |
| return vm.used, vm.total | |
| used = int(current) | |
| inactive = parse_stat_value(_read(f"{CGROUP_ROOT}/memory.stat"), "inactive_file") or 0 | |
| used = max(0, used - inactive) # do not count reclaimable page cache | |
| return used, min(limit, host_total) if limit else host_total | |
| def disk_usage(path: str) -> Tuple[int, int, int]: | |
| os.makedirs(path, exist_ok=True) | |
| du = shutil.disk_usage(path) | |
| return du.used, du.total, du.free | |
| def net_since_start() -> Tuple[int, int]: | |
| now = psutil.net_io_counters() | |
| return max(0, now.bytes_recv - _NET_BASE.bytes_recv), max(0, now.bytes_sent - _NET_BASE.bytes_sent) | |
| def uptime() -> float: | |
| return time.time() - START_TIME | |
| def crypto_backend() -> str: | |
| """What Telethon encrypts and decrypts with: ``cryptg`` or ``libssl`` (both native code, fast), else ``python`` (slow).""" | |
| from telethon.crypto import aes | |
| if aes.cryptg is not None: | |
| return "cryptg" | |
| return "libssl" if aes.libssl.encrypt_ige and aes.libssl.decrypt_ige else "python" | |
| def loop_backend() -> str: | |
| """``uvloop`` when the running event loop is uvloop's, ``asyncio`` for the standard one, ``none`` outside a loop.""" | |
| try: | |
| loop = asyncio.get_running_loop() | |
| except RuntimeError: | |
| return "none" | |
| return "uvloop" if type(loop).__module__.split(".")[0] == "uvloop" else "asyncio" | |
| def speed_checks(parallel: bool, connections: int, stream: Optional[bool] = None) -> List[Tuple[str, str, bool]]: | |
| """``(short name, detail, fine)`` for the things transfer speed depends on; ``stream`` (when given) adds the streaming rename.""" | |
| crypto, loop = crypto_backend(), loop_backend() | |
| if crypto == "cryptg": | |
| encryption = ("cryptg", "cryptg", True) | |
| elif crypto == "libssl": | |
| encryption = ("libssl", "libssl (cryptg is not installed)", True) | |
| else: | |
| encryption = ("slow Python crypto", "pure Python, slow: cryptg is missing", False) | |
| event_loop = ("uvloop", "uvloop", True) if loop == "uvloop" else ("no uvloop", f"{loop} loop: uvloop is not running", False) | |
| transfers = (f"parallel ×{connections}", f"on, {connections} connections", True) if parallel else ("parallel off", "off (FAST_TRANSFER=0)", False) | |
| checks = [encryption, event_loop, transfers] | |
| if stream is not None: | |
| if not parallel: | |
| checks.append(("no streaming", "off: it needs the parallel transfer", False)) | |
| elif stream: | |
| checks.append(("streaming", "on: big files are uploaded while they download", True)) | |
| else: | |
| checks.append(("no streaming", "off (STREAM_RENAME=0)", False)) | |
| return checks | |
| def speed_summary(parallel: bool, connections: int, stream: Optional[bool] = None) -> str: | |
| """One line for the start-up notice: ``cryptg ✅ · uvloop ✅ · parallel ×8 ✅ · streaming ✅``.""" | |
| return " · ".join(f"{short} {'✅' if fine else '⚠️'}" for short, _detail, fine in speed_checks(parallel, connections, stream)) | |
| def format_speed(parallel: bool, connections: int, stats: Any, stream: Optional[bool] = None) -> str: | |
| """The Speed section of /status: what is switched on, and how the transfers since the start went.""" | |
| labels = ("🔐 Encryption", "🔁 Event loop", "🚀 Parallel transfer", "⬇⬆ Streaming rename") | |
| lines = ["⚡ <b>Speed</b>"] | |
| for label, (_short, detail, fine) in zip(labels, speed_checks(parallel, connections, stream)): | |
| lines.append(f"{label}: {esc(detail)} {'✅' if fine else '⚠️'}") | |
| small = f"{BIG_FILE_THRESHOLD // 2 ** 20} MB" | |
| lines.append(f"⬇ <b>Downloads:</b> {stats.fast_down} parallel · {stats.standard_down} standard") | |
| lines.append(f"⬆ <b>Uploads:</b> {stats.fast_up} parallel · {stats.small_up} up to {small} · {stats.standard_up} standard") | |
| if stream is not None: | |
| lines.append(f"⬇⬆ <b>Streamed renames:</b> {stats.streamed}") | |
| if stats.fallbacks: | |
| lines.append( | |
| f"⚠️ The parallel transfer failed {stats.fallbacks}× and the standard, slower one took over. " | |
| f"Last: <code>{esc(clip(stats.last_fallback, 160))}</code>" | |
| ) | |
| if stats.stream_fallbacks: | |
| lines.append( | |
| f"⚠️ Streaming failed {stats.stream_fallbacks}× and those files were saved first and then uploaded. " | |
| f"Last: <code>{esc(clip(stats.last_stream_fallback, 160))}</code>" | |
| ) | |
| return "\n".join(lines) | |
| def format_status(ping_ms: Optional[float], dc_id: Optional[int], telethon_version: str, speed: str = "") -> str: | |
| ping = f"{ping_ms:.0f} ms" if ping_ms is not None else "n/a" | |
| dc = f" (DC {dc_id})" if dc_id else "" | |
| return ( | |
| "🟢 <b>Bot status</b>\n\n" | |
| f"⏱ <b>Uptime:</b> {human_uptime(uptime())}\n" | |
| f"🏓 <b>Ping:</b> {ping}{dc}\n" | |
| f"🤖 <b>Version:</b> v{__version__}\n" | |
| f"🐍 Python {platform.python_version()} · Telethon {telethon_version}" | |
| + (f"\n\n{speed}" if speed else "") | |
| ) | |
| async def format_stats(users: int, files: int, total_bytes: int, running: int, waiting: int, temp_dir: str) -> str: | |
| cpu = await cpu_percent() | |
| used, total = memory_usage() | |
| d_used, d_total, d_free = disk_usage(temp_dir) | |
| rx, tx = net_since_start() | |
| rss = psutil.Process().memory_info().rss | |
| ram_pct = used / total * 100 if total else 0.0 | |
| disk_pct = d_used / d_total * 100 if d_total else 0.0 | |
| return ( | |
| "📊 <b>System stats</b>\n\n" | |
| f"👥 <b>Users:</b> {users}\n" | |
| f"📁 <b>Files renamed:</b> {files} ({human_size(total_bytes)})\n" | |
| f"🧵 <b>Queue:</b> {running} running · {waiting} waiting\n\n" | |
| f"🖥 <b>CPU:</b> {cpu:.1f}% of {cpu_cores():g} core(s)\n" | |
| f"🧠 <b>RAM:</b> {human_size(used)} / {human_size(total)} ({ram_pct:.1f}%) · bot {human_size(rss)}\n" | |
| f"💾 <b>Disk:</b> {human_size(d_used)} / {human_size(d_total)} ({disk_pct:.1f}%) · {human_size(d_free)} free\n" | |
| f"🌐 <b>Network since start:</b> ↓ {human_size(rx)} · ↑ {human_size(tx)}" | |
| ) | |