CliRemote 1.7.13__py3-none-any.whl → 1.8.0__py3-none-any.whl

{cliremote-1.7.13.dist-info → cliremote-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CliRemote
-Version: 1.7.13
+Version: 1.8.0
 Summary: Remote client framework for Telegram automation using Pyrogram
 Home-page: https://github.com/MohammadAhmadi-R/CliRemote
 Author: MrAhmadiRad

{cliremote-1.7.13.dist-info → cliremote-1.8.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-cliremote-1.7.13.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+cliremote-1.8.0.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
 remote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 remote/account_manager.py,sha256=TepnGIoE2hU-j_NmU5ByoS-JrboE0w3A1bYmQoQX5h8,15176
 remote/account_viewer.py,sha256=j46KSjbgrBmBi7UxFeJ5tCwHIe0QvCvphkirGIbB2oo,5192
-remote/admin_manager.py,sha256=JXxZ6dEF5xXUcNmLmxuFAAUE7EyHDf0sLutTQYnTlHY,7392
+remote/admin_manager.py,sha256=fTtwWwlr9Kq7QGZ_gNJVa2JNVnnUEkByo4L1toUf5Ys,7422
 remote/analytics_manager.py,sha256=6jPvwt_ELA4RMbQdD8W_ltfAoaSgILnEkOAp6HZAqsU,7382
 remote/batch_manager.py,sha256=jVGhYVwHMKJd7f7JxcWjKlwr03dq0RaGD1KdkyYdb00,1051
 remote/block_manager.py,sha256=R7UaQigr-hTRtjxjG3OvJdKhvp0mDpLaESp3Of1AYhs,5692
@@ -22,18 +22,18 @@ remote/joiner.py,sha256=CXTQ-l6CysqZSkYP1GUV1LM1qlh5wD4jBj_og_FVW1I,7773
 remote/leave_controller.py,sha256=TIShgxCMiKyBn9ZdQZYm6Kf89GgDaoPCRH7pxqq9FC8,1167
 remote/lefter.py,sha256=jxZmkl3NIe1c-WeVES8WBX21hW-eocfxfePvxddHdi0,6090
 remote/mention_manager.py,sha256=I75ezmVZM0lYrgk8OQ2p-VETLLwM5FiW83tiBgbQ1CY,3257
-remote/precise_engine.py,sha256=39FjbHPirH_IXnkbvlEiyu7O0636_0btlRwIS8oiKxA,1562
+remote/precise_engine.py,sha256=EP-QMWj4YRXqh7IUckAQzHTARi-iFr-7WcspM9IHvrA,4092
 remote/profile_info.py,sha256=Us5mz6sdV_5-5wRx6F3S6rtj2m6vaP_HOrCBLgHXpD4,1992
 remote/profile_media.py,sha256=lD_uIb0U3jeH_dpa4SNbF0wr1DQiQ5OfbTCOubcm9Us,2264
 remote/profile_privacy.py,sha256=LrRZbbqhaYdl4JzBMJrl-D-N8y1AG2LR1DDzv-tmlV0,2298
-remote/spammer.py,sha256=ywrqWyxsVfVVLaryPhgdOTT8IQVB2EO3eA3gmYQ3bvw,13176
+remote/spammer.py,sha256=lKALyfX3hInsJmR6qVb5xxAdM-GkW2s42e6gqTyIo1k,11820
 remote/speed_manager.py,sha256=fIWSQAP9qW8AHZtMZq0MrC4_nvxcTFU1SBU75kpRzB8,1115
 remote/stop_manager.py,sha256=UXzKJTblEyQqCjp7fenvQ51Q96Unx05WeOiuFMdj25M,1151
 remote/text_manager.py,sha256=C2wNSXPSCDu8NSD3RsfbKmUQMWOYd1B5N4tzy-Jsriw,2195
 remote/username_manager.py,sha256=nMNdke-2FIv86xR1Y6rR-43oUoQu_3Khw8wEo54noXI,3388
 remote/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 remote/utils/sqlite_utils.py,sha256=5i0oUXsBgKC_8qHZPJ-Gyhp9D1TwqKHVvuZRIhKpS6w,1260
-cliremote-1.7.13.dist-info/METADATA,sha256=AGkWN4uIhUNz55bPpKmv6t31CJvf53AS2l3uuMsjlJg,1203
-cliremote-1.7.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cliremote-1.7.13.dist-info/top_level.txt,sha256=yBZidJ6zCix_a2ubGlYaewvlzBFXWbckQt20dudxJ1E,7
-cliremote-1.7.13.dist-info/RECORD,,
+cliremote-1.8.0.dist-info/METADATA,sha256=I8rSH5Tx0v5tXy0EFk3ty1_cz0Yo4e_3UH2zGlRNX_U,1202
+cliremote-1.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cliremote-1.8.0.dist-info/top_level.txt,sha256=yBZidJ6zCix_a2ubGlYaewvlzBFXWbckQt20dudxJ1E,7
+cliremote-1.8.0.dist-info/RECORD,,

remote/admin_manager.py

@@ -4,8 +4,8 @@ import os
 import sys
 import logging
 from pathlib import Path
-from pyrogram import filters
-from .config import OWNER_ID
+from pyrogram import filters 
+from . import config  
 
 # =============================
 # تنظیم logger فایل
@@ -53,8 +53,8 @@ def load_admins() -> list[int]:
     بارگذاری لیست ادمین‌ها از فایل.
     همیشه OWNER_ID را هم به لیست اضافه می‌کند.
     """
-    logger.debug(f"Loading admins from file: {ADMINS_FILE} | OWNER_ID: {OWNER_ID}")
-    s = set(OWNER_ID)
+    logger.debug(f"Loading admins from file: {ADMINS_FILE} | OWNER_ID: {config.OWNER_ID}")
+    s = set(config.OWNER_ID)
     try:
         if os.path.exists(ADMINS_FILE):
             with open(ADMINS_FILE, "r", encoding="utf-8") as f:
@@ -98,7 +98,7 @@ admin_filter = filters.create(
     lambda _, __, m: bool(getattr(m, "from_user", None)) and int(m.from_user.id) in ADMINS
 )
 owner_filter = filters.create(
-    lambda _, __, m: bool(getattr(m, "from_user", None)) and int(m.from_user.id) in OWNER_ID
+    lambda _, __, m: bool(getattr(m, "from_user", None)) and int(m.from_user.id) in config.OWNER_ID
 )
 
 # =============================
@@ -119,7 +119,7 @@ async def add_admin_cmd(message):
         uid = int(parts[1])
         logger.debug(f"add_admin_cmd: parsed target uid={uid}")
 
-        if uid in OWNER_ID:
+        if uid in config.OWNER_ID:
             logger.info(f"add_admin_cmd: uid={uid} is OWNER; skip append")
             await message.reply("ادمین اصلی از قبل وجود دارد")
             return
@@ -151,7 +151,7 @@ async def del_admin_cmd(message):
         uid = int(parts[1])
         logger.debug(f"del_admin_cmd: parsed target uid={uid}")
 
-        if uid in OWNER_ID:
+        if uid in config.OWNER_ID:
             logger.info(f"del_admin_cmd: attempt to remove OWNER uid={uid} blocked")
             await message.reply("❌ امکان حذف ادمین اصلی وجود ندارد")
             return

remote/precise_engine.py

@@ -1,45 +1,102 @@
 # antispam_core/precise_engine.py
 import asyncio
 import time
+from dataclasses import dataclass
 
-class PreciseTicker:
+@dataclass
+class TickerStats:
+    last_target_ns: int = 0
+    last_wakeup_ns: int = 0
+    last_jitter_ns: int = 0  # wakeup - target (>= 0)
+
+class HiPrecisionTicker:
     """
-    A drift-free ticker.
-    Usage:
-      ticker = PreciseTicker(interval=1.0)
-      while running:
-          # do work
-          await ticker.sleep()
-    Behavior:
-      - Ensures interval spacing between wakes without accumulating drift.
-      - If the work took longer than the interval, it schedules next wake as now + interval
-        (so it doesn't try to "catch up" by sleeping negative amounts).
-      - On first use, it sets the baseline relative to time.perf_counter().
+    Drift-free asyncio ticker with hybrid coarse-sleep + fine spin.
+    - Absolute scheduling: next_target = prev_target + period (no cumulative drift).
+    - Coarse sleep via asyncio, then busy-wait for final microseconds.
+    - Uses time.perf_counter_ns() (monotonic, high-resolution).
+
+    Notes:
+      * Sub-microsecond accuracy is NOT realistic on general OS with Python.
+      * 'spin' burns CPU on the running core; keep margins reasonable.
+      * Tune margins for your hardware/OS.
+
+    Args:
+      interval_sec: desired period in seconds (float).
+      sleep_margin_ns: if remaining > (sleep_margin + spin_margin), we await asyncio.sleep.
+      spin_margin_ns: final window to busy-wait (e.g., 50-200 µs).
+
+    Stats:
+      .stats.last_jitter_ns gives (actual_wakeup - scheduled_target) in ns.
     """
-    def __init__(self, interval: float):
-        if interval <= 0:
-            raise ValueError("interval must be > 0")
-        self.interval = float(interval)
-        self.next_tick = None
+
+    __slots__ = (
+        "period_ns", "sleep_margin_ns", "spin_margin_ns",
+        "next_target_ns", "stats"
+    )
+
+    def __init__(self,
+                 interval_sec: float,
+                 sleep_margin_ns: int = 200_000,   # 200 µs
+                 spin_margin_ns: int  = 50_000):   # 50 µs
+        if interval_sec <= 0:
+            raise ValueError("interval_sec must be > 0")
+        self.period_ns = int(interval_sec * 1e9)
+        if self.period_ns <= 1_000:  # sanity: <1 µs period is nonsense for Python
+            raise ValueError("interval too small for Python environment")
+        if sleep_margin_ns < 0 or spin_margin_ns < 0:
+            raise ValueError("margins must be non-negative")
+        self.sleep_margin_ns = int(sleep_margin_ns)
+        self.spin_margin_ns  = int(spin_margin_ns)
+        self.next_target_ns: int | None = None
+        self.stats = TickerStats()
 
     async def sleep(self):
-        now = time.perf_counter()
-        if self.next_tick is None:
-            # first tick: schedule next at now + interval
-            self.next_tick = now + self.interval
-
-        delay = self.next_tick - now
-
-        if delay > 0:
-            # normal case: wait remaining time
-            await asyncio.sleep(delay)
-            # advance to next slot
-            self.next_tick += self.interval
-        else:
-            # work took longer than interval; reset baseline to now + interval
-            self.next_tick = now + self.interval
-            # don't sleep now (we are already late)
+        now = time.perf_counter_ns()
+
+        # First use: schedule at now + period (absolute target)
+        if self.next_target_ns is None:
+            self.next_target_ns = now + self.period_ns
+
+        remaining = self.next_target_ns - now
+
+        if remaining <= 0:
+            # We're already late: skip sleeping, jump target forward
+            # so we don't try to "catch up" with negative sleeps.
+            self.stats.last_target_ns = self.next_target_ns
+            self.stats.last_wakeup_ns = now
+            self.stats.last_jitter_ns = now - self.next_target_ns
+            self.next_target_ns = now + self.period_ns
+            return
+
+        # Coarse sleep: leave 'spin_margin_ns' to finish in busy-wait.
+        # Also keep a 'sleep_margin_ns' cushion to reduce overshoot risk.
+        coarse_threshold = self.sleep_margin_ns + self.spin_margin_ns
+        if remaining > coarse_threshold:
+            # target - spin_margin => leave that much for spinning
+            coarse_sleep_ns = remaining - self.spin_margin_ns
+            # asyncio.sleep takes seconds
+            await asyncio.sleep(coarse_sleep_ns / 1e9)
+
+        # Fine spin until target
+        target = self.next_target_ns
+        while True:
+            now = time.perf_counter_ns()
+            if now >= target:
+                break
+            # Tight spin: do nothing. If you see high CPU, you can insert
+            # a minimal pause on some platforms via time.sleep(0) sporadically,
+            # but that will hurt accuracy.
+
+        # Record stats
+        self.stats.last_target_ns = target
+        self.stats.last_wakeup_ns = now
+        self.stats.last_jitter_ns = now - target  # >= 0
+
+        # Advance absolute target by exactly one period (no drift accumulation)
+        self.next_target_ns = target + self.period_ns
 
     def reset(self):
-        """Reset baseline so next sleep schedules from current time."""
-        self.next_tick = None
+        """Reset baseline; next sleep schedules from current time + period."""
+        self.next_target_ns = None
+        self.stats = TickerStats()

remote/spammer.py

@@ -30,7 +30,7 @@ if not any(
 # ============================================================
 # ✅ پیکربندی ایمن و پارامترهای پیش‌فرض
 # ============================================================
-MAX_RETRIES = 2                # تلاش مجدد حداکثر برای هر ارسال
+MAX_RETRIES = 3                # تلاش مجدد حداکثر برای هر ارسال
 BASE_BACKOFF = 1.5             # ضریب بک‌آف برای retries (s)
 FLOOD_COOLDOWN_CAP = 3600     # حداکثر زمان cooldown برای FloodWait (s)
 
@@ -45,23 +45,6 @@ if not hasattr(client_manager, "client_locks"):
 # ============================================================
 # 🧰 توابع کمکی
 # ============================================================
-def is_in_cooldown(phone: str) -> bool:
-    ts = _account_cooldowns.get(phone)
-    if not ts:
-        return False
-    return ts > asyncio.get_event_loop().time()
-
-def set_cooldown(phone: str, seconds: float):
-    resume = asyncio.get_event_loop().time() + seconds
-    _account_cooldowns[phone] = resume
-    logger.info(f"{phone}: ⏳ Put on cooldown for {seconds:.1f}s (resume @ {resume:.1f})")
-
-def clear_expired_cooldowns():
-    now = asyncio.get_event_loop().time()
-    expired = [p for p, t in _account_cooldowns.items() if t <= now]
-    for p in expired:
-        _account_cooldowns.pop(p, None)
-        logger.info(f"{p}: ✅ Cooldown expired")
 
 async def _attempt_send(cli, acc_phone: str, target: str, text: str):
     """Try to send once, raising exceptions up to caller to handle specialized behavior."""
@@ -82,10 +65,6 @@ async def safe_send(acc_phone: str, spam_config: dict, text: str, remove_client_
     بازگشت: True اگر ارسال موفق باشد، False در غیر این صورت.
     """
     try:
-        # اگر اکانت در cooldown است، زود بازگردان False (بدون تلاش)
-        if is_in_cooldown(acc_phone):
-            logger.info(f"{acc_phone}: ⚠️ Skipping send because account is in cooldown.")
-            return False
 
         cli = await client_manager.get_or_start_client(acc_phone)
         if not cli:
@@ -122,8 +101,7 @@ async def safe_send(acc_phone: str, spam_config: dict, text: str, remove_client_
                     wait = e.value if hasattr(e, "value") else getattr(e, "x", 0)
                     # حداقل و حداکثر را منطقی حفظ کن
                     wait = max(1, min(wait, FLOOD_COOLDOWN_CAP))
-                    logger.warning(f"{acc_phone}: ⏰ FloodWait {wait}s (code:{getattr(e, 'value', 'n/a')})")
-                    set_cooldown(acc_phone, wait)
+                    logger.warning(f"{acc_phone}: ⏰ FloodWait {wait}s (code:{getattr(e, 'value', 'n/a')})") 
                     # صبر در این تابع به اندازهٔ wait ضروری نیست — cooldown کافی است.
                     return False
 
@@ -189,8 +167,7 @@ async def run_spammer(spam_config: dict, get_spam_texts, make_mention_html, remo
 
     try:
         while spam_config.get("run", False):
-            # cleanup expired cooldowns
-            clear_expired_cooldowns()
+            # cleanup expired cooldowns 
 
             # refresh active accounts (live snapshot)
             active_accounts: Set[str] = set(client_manager.get_active_accounts())
@@ -200,12 +177,8 @@ async def run_spammer(spam_config: dict, get_spam_texts, make_mention_html, remo
                 continue
 
             # filter out accounts currently in cooldown
-            acc_list = sorted([a for a in active_accounts if not is_in_cooldown(a)])
-            if not acc_list:
-                # همه در cooldown هستند — کمی صبر کن و ادامه بده
-                logger.info("تمام اکانت‌ها در cooldown هستند؛ کمی صبر می‌کنیم...")
-                await asyncio.sleep(min(5, base_delay))
-                continue
+            acc_list = sorted([a for a in active_accounts])
+            
 
             texts = get_spam_texts()
             if not texts: