CliRemote 1.7.14__tar.gz → 1.8.0__tar.gz

{cliremote-1.7.14 → cliremote-1.8.0}/CliRemote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CliRemote
-Version: 1.7.14
+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.14 → cliremote-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CliRemote
-Version: 1.7.14
+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.14 → cliremote-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "CliRemote"
-version = "1.7.14"
+version = "1.8.0"
 description = "Remote client framework for Telegram automation using Pyrogram"
 readme = "README.md"
 license = {text = "MIT"}

cliremote-1.8.0/remote/precise_engine.py

@@ -0,0 +1,102 @@
+# antispam_core/precise_engine.py
+import asyncio
+import time
+from dataclasses import dataclass
+
+@dataclass
+class TickerStats:
+    last_target_ns: int = 0
+    last_wakeup_ns: int = 0
+    last_jitter_ns: int = 0  # wakeup - target (>= 0)
+
+class HiPrecisionTicker:
+    """
+    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.
+    """
+
+    __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_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; next sleep schedules from current time + period."""
+        self.next_target_ns = None
+        self.stats = TickerStats()

{cliremote-1.7.14 → cliremote-1.8.0}/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:

{cliremote-1.7.14 → cliremote-1.8.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="CliRemote",
-    version="1.7.14", 
+    version="1.8.0", 
     author="MrAhmadiRad",
     author_email="mohammadahmadirad69@gmail.com",
     description="A precise, async-safe, Telegram automation core (Python 3.8+)",

cliremote-1.7.14/remote/precise_engine.py

@@ -1,45 +0,0 @@
-# antispam_core/precise_engine.py
-import asyncio
-import time
-
-class PreciseTicker:
-    """
-    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().
-    """
-    def __init__(self, interval: float):
-        if interval <= 0:
-            raise ValueError("interval must be > 0")
-        self.interval = float(interval)
-        self.next_tick = None
-
-    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)
-
-    def reset(self):
-        """Reset baseline so next sleep schedules from current time."""
-        self.next_tick = None