soropy 1.0.0__py3-none-any.whl

soropy/__init__.py

@@ -0,0 +1,86 @@
+"""
+SoroPy - Professional Soroush Plus Web Client Library
+=====================================================
+
+A comprehensive, production-grade Python library for automating
+Soroush Plus (splus.ir) web messenger.
+
+Features:
+    - Multi-account simultaneous sessions
+    - Headless browser support
+    - Auto-reply with rule engine and duplicate prevention
+    - Chat extraction, messaging, channel posting
+    - Contact management
+    - Persistent session management
+    - Thread-safe design
+
+Basic Usage:
+    >>> from soropy import SoroushClient
+    >>> client = SoroushClient("+989123456789")
+    >>> client.login()
+    >>> chats = client.get_chats()
+    >>> client.send_message("علی", "سلام!")
+    >>> client.close()
+
+Multi-Account:
+    >>> from soropy import MultiAccountManager
+    >>> manager = MultiAccountManager()
+    >>> manager.add_account("+989123456789")
+    >>> manager.add_account("+989187654321")
+    >>> manager.login_all()
+"""
+
+__version__ = "1.0.0"
+__author__ = "SoroPy Team"
+__license__ = "MIT"
+
+from soropy.client import SoroushClient
+from soropy.auto_reply import AutoReplyEngine, ReplyRule
+from soropy.types import (
+    ChatInfo,
+    ContactInfo,
+    MessageInfo,
+    UnreadChat,
+    SendResult,
+    LoginStatus,
+)
+from soropy.exceptions import (
+    SoroPyError,
+    LoginError,
+    SessionError,
+    ChatError,
+    MessageError,
+    ContactError,
+    ChannelError,
+    BrowserError,
+    TimeoutError as SoroPyTimeoutError,
+)
+from soropy.session import SessionManager
+from soropy.message_tracker import MessageTracker
+
+# Multi-account manager
+from soropy.multi import MultiAccountManager
+
+__all__ = [
+    "SoroushClient",
+    "MultiAccountManager",
+    "AutoReplyEngine",
+    "ReplyRule",
+    "ChatInfo",
+    "ContactInfo",
+    "MessageInfo",
+    "UnreadChat",
+    "SendResult",
+    "LoginStatus",
+    "SessionManager",
+    "MessageTracker",
+    "SoroPyError",
+    "LoginError",
+    "SessionError",
+    "ChatError",
+    "MessageError",
+    "ContactError",
+    "ChannelError",
+    "BrowserError",
+    "SoroPyTimeoutError",
+]

soropy/auth.py

@@ -0,0 +1,194 @@
+"""
+Authentication flow: phone entry → verification code → chat page wait.
+"""
+
+import time
+from typing import Optional, Callable
+
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+from soropy import constants as C
+from soropy.utils import (
+    get_logger,
+    wait_and_find,
+    safe_click,
+    safe_type,
+    wait_page_load,
+)
+from soropy.types import LoginStatus
+from soropy.exceptions import LoginError
+
+logger = get_logger("soropy.auth")
+
+
+class Authenticator:
+    """Encapsulates the multi-step Soroush Plus login process."""
+
+    def __init__(self, driver: WebDriver):
+        self._driver = driver
+
+    # ── public ─────────────────────────────────────────
+
+    def is_logged_in(self) -> bool:
+        """Check whether the current page shows the chat list."""
+        time.sleep(3)
+        wait_page_load(self._driver, C.PAGE_LOAD_TIMEOUT)
+        for sel in C.SEL_LOGGED_IN_INDICATORS:
+            try:
+                if self._driver.find_elements(By.CSS_SELECTOR, sel):
+                    logger.info("Already logged in (matched %s)", sel)
+                    return True
+            except Exception:
+                continue
+        return False
+
+    def login(
+        self,
+        phone: str,
+        code_callback: Optional[Callable[[], str]] = None,
+    ) -> LoginStatus:
+        """
+        Run the full login flow.
+
+        Parameters
+        ----------
+        phone : str
+            Normalised phone number (e.g. "+989123456789").
+        code_callback : callable, optional
+            A function that returns the verification code string.
+            Defaults to ``input()`` prompt.
+
+        Returns
+        -------
+        LoginStatus
+        """
+        self._driver.get(C.SPLUS_WEB_URL)
+        logger.info("Navigated to %s", C.SPLUS_WEB_URL)
+        wait_page_load(self._driver, 15)
+
+        if self.is_logged_in():
+            return LoginStatus.ALREADY_LOGGED_IN
+
+        time.sleep(2)
+        self._dismiss_popup()
+        time.sleep(1)
+
+        if not self._enter_phone(phone):
+            raise LoginError("Could not enter phone number")
+
+        if not self._click_next():
+            raise LoginError("Could not click 'next' button")
+
+        time.sleep(3)
+
+        if code_callback is None:
+            code_callback = lambda: input("🔑 Enter verification code: ")
+
+        code = code_callback()
+        if not self._enter_code(code):
+            raise LoginError("Could not enter verification code")
+
+        if not self._wait_for_chat_page():
+            raise LoginError("Chat page did not load after login")
+
+        return LoginStatus.SUCCESS
+
+    # ── steps ──────────────────────────────────────────
+
+    def _dismiss_popup(self) -> bool:
+        logger.debug("Checking for popup...")
+        for xpath in C.XPATH_DISMISS_POPUP_VARIANTS:
+            try:
+                el = WebDriverWait(self._driver, 5).until(
+                    EC.element_to_be_clickable((By.XPATH, xpath))
+                )
+                safe_click(self._driver, el)
+                logger.info("Popup dismissed")
+                time.sleep(1)
+                return True
+            except Exception:
+                continue
+        logger.debug("No popup found")
+        return False
+
+    def _enter_phone(self, phone: str) -> bool:
+        logger.info("Entering phone: %s", phone)
+        wait_page_load(self._driver)
+
+        inp = wait_and_find(
+            self._driver, By.CSS_SELECTOR, C.SEL_PHONE_INPUT,
+            timeout=10, clickable=True,
+        )
+        if not inp:
+            return False
+
+        inp.click()
+        time.sleep(0.2)
+        inp.send_keys(Keys.CONTROL + "a")
+        time.sleep(0.1)
+        inp.send_keys(Keys.DELETE)
+        time.sleep(0.2)
+
+        for ch in phone:
+            inp.send_keys(ch)
+            time.sleep(0.05)
+
+        time.sleep(0.5)
+        actual = inp.get_attribute("value")
+        logger.debug("Phone field value: %s", actual)
+        return True
+
+    def _click_next(self) -> bool:
+        logger.info("Clicking 'next'...")
+        time.sleep(1)
+        btn = wait_and_find(
+            self._driver, By.XPATH, C.XPATH_NEXT_BUTTON,
+            timeout=10, clickable=True,
+        )
+        if btn and safe_click(self._driver, btn):
+            logger.info("'Next' clicked")
+            return True
+        return False
+
+    def _enter_code(self, code: str) -> bool:
+        logger.info("Entering verification code")
+        wait_page_load(self._driver)
+
+        code_input = None
+        for by, val in [
+            (By.ID, C.SEL_CODE_INPUT_ID),
+            (By.CSS_SELECTOR, C.SEL_CODE_INPUT_ARIA),
+            (By.CSS_SELECTOR, C.SEL_CODE_INPUT_NUMERIC),
+        ]:
+            code_input = wait_and_find(self._driver, by, val, timeout=10, clickable=True)
+            if code_input:
+                break
+
+        if not code_input:
+            return False
+
+        safe_type(self._driver, code_input, code)
+        logger.info("Code entered – waiting for automatic redirect")
+        return True
+
+    def _wait_for_chat_page(self) -> bool:
+        logger.info("Waiting for chat page...")
+        start = time.time()
+        while time.time() - start < C.LOGIN_WAIT:
+            try:
+                found = self._driver.find_elements(
+                    By.CSS_SELECTOR,
+                    "[class*='chatlist'], [class*='dialog'], [class*='folders-tabs']",
+                )
+                if found:
+                    elapsed = int(time.time() - start)
+                    logger.info("Chat page loaded (%ds)", elapsed)
+                    return True
+            except Exception:
+                pass
+            time.sleep(1)
+        return True  # optimistic – some indicators may not match

soropy/auto_reply.py

@@ -0,0 +1,158 @@
+"""
+Auto-reply engine with rule matching and duplicate prevention.
+"""
+
+import time
+import threading
+from typing import List, Optional, Dict, Callable
+from dataclasses import dataclass, field
+
+from soropy.utils import get_logger
+from soropy.message_tracker import MessageTracker
+
+logger = get_logger("soropy.auto_reply")
+
+
+@dataclass
+class ReplyRule:
+    """A single keyword → response mapping."""
+    keyword: str
+    response: str
+    case_sensitive: bool = False
+    exact_match: bool = False
+    priority: int = 0  # higher = matched first
+
+    def matches(self, text: str) -> bool:
+        if self.case_sensitive:
+            src, kw = text.strip(), self.keyword
+        else:
+            src, kw = text.strip().lower(), self.keyword.lower()
+
+        if self.exact_match:
+            return src == kw
+        return kw in src
+
+
+class AutoReplyEngine:
+    """
+    Rule-based auto-reply engine with duplicate message tracking.
+
+    Usage:
+        engine = AutoReplyEngine()
+        engine.add_rule("سلام", "علیک سلام")
+        engine.default_reply = "پیامت دریافت شد"
+
+        reply = engine.get_reply("سلام دوست من", "علی")
+        # → "علیک سلام"
+
+        # Won't return a reply for the same message twice:
+        reply2 = engine.get_reply("سلام دوست من", "علی")
+        # → None  (already replied)
+    """
+
+    def __init__(
+        self,
+        tracker: Optional[MessageTracker] = None,
+        default_reply: str = "پیامت دریافت شد",
+        default_prefix: str = "جواب",
+    ):
+        self._rules: List[ReplyRule] = []
+        self._tracker = tracker or MessageTracker()
+        self.default_reply = default_reply
+        self.default_prefix = default_prefix
+        self._lock = threading.Lock()
+
+    # ── Rule management ────────────────────────────────
+
+    def add_rule(
+        self,
+        keyword: str,
+        response: str,
+        case_sensitive: bool = False,
+        exact_match: bool = False,
+        priority: int = 0,
+    ) -> None:
+        """Add a reply rule."""
+        rule = ReplyRule(
+            keyword=keyword,
+            response=response,
+            case_sensitive=case_sensitive,
+            exact_match=exact_match,
+            priority=priority,
+        )
+        with self._lock:
+            self._rules.append(rule)
+            # Keep sorted by priority descending
+            self._rules.sort(key=lambda r: r.priority, reverse=True)
+        logger.debug("Rule added: '%s' → '%s'", keyword, response)
+
+    def remove_rule(self, keyword: str) -> bool:
+        """Remove the first rule matching *keyword*."""
+        with self._lock:
+            for i, rule in enumerate(self._rules):
+                if rule.keyword == keyword:
+                    self._rules.pop(i)
+                    return True
+        return False
+
+    def clear_rules(self) -> None:
+        """Remove all rules."""
+        with self._lock:
+            self._rules.clear()
+
+    @property
+    def rules(self) -> List[ReplyRule]:
+        with self._lock:
+            return list(self._rules)
+
+    def load_rules_from_dict(self, mapping: Dict[str, str]) -> None:
+        """Bulk-load keyword→response pairs from a dict."""
+        for kw, resp in mapping.items():
+            self.add_rule(kw, resp)
+
+    # ── Reply generation ───────────────────────────────
+
+    def get_reply(
+        self,
+        message_text: str,
+        chat_name: str,
+        msg_index: int = 1,
+        skip_duplicate_check: bool = False,
+    ) -> Optional[str]:
+        """
+        Determine the reply for *message_text* from *chat_name*.
+
+        Returns None if the message has already been replied to
+        (unless skip_duplicate_check is True).
+        """
+        text = message_text.strip()
+        if not text:
+            return None
+
+        # Duplicate check
+        if not skip_duplicate_check and self._tracker.is_replied(chat_name, text):
+            logger.debug("Duplicate detected, skipping: %s / %s", chat_name, text[:30])
+            return None
+
+        # Match rules
+        with self._lock:
+            for rule in self._rules:
+                if rule.matches(text):
+                    return rule.response
+
+        # Default
+        return f"{self.default_prefix} {msg_index}"
+
+    def mark_replied(self, chat_name: str, message_text: str) -> None:
+        """Record that we replied to this message (prevents duplicates)."""
+        self._tracker.mark_replied(chat_name, message_text)
+
+    # ── Tracker access ─────────────────────────────────
+
+    @property
+    def tracker(self) -> MessageTracker:
+        return self._tracker
+
+    def prune_old_entries(self) -> int:
+        """Remove expired tracker entries."""
+        return self._tracker.prune()

soropy/browser.py

@@ -0,0 +1,129 @@
+"""
+Browser (Chrome/Chromium) lifecycle management.
+
+Handles driver creation with anti-detection, headless mode,
+custom profiles, and teardown.
+"""
+
+import os
+from typing import Optional
+
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+
+from soropy.session import SessionManager
+from soropy.utils import get_logger
+from soropy.exceptions import BrowserError
+
+logger = get_logger("soropy.browser")
+
+
+class BrowserManager:
+    """Creates and manages a Selenium Chrome WebDriver."""
+
+    def __init__(
+        self,
+        phone: Optional[str] = None,
+        headless: bool = False,
+        session_manager: Optional[SessionManager] = None,
+        window_size: str = "1300,900",
+        extra_args: Optional[list] = None,
+        chrome_binary: Optional[str] = None,
+        chromedriver_path: Optional[str] = None,
+    ):
+        self._phone = phone
+        self._headless = headless
+        self._session_mgr = session_manager or SessionManager()
+        self._window_size = window_size
+        self._extra_args = extra_args or []
+        self._chrome_binary = chrome_binary
+        self._chromedriver_path = chromedriver_path
+        self._driver: Optional[webdriver.Chrome] = None
+
+    @property
+    def driver(self) -> webdriver.Chrome:
+        if self._driver is None:
+            raise BrowserError("Browser not started. Call start() first.")
+        return self._driver
+
+    @property
+    def is_running(self) -> bool:
+        if self._driver is None:
+            return False
+        try:
+            # If the browser window is closed this will throw
+            _ = self._driver.title
+            return True
+        except Exception:
+            return False
+
+    def start(self) -> webdriver.Chrome:
+        """Launch Chrome and return the WebDriver."""
+        options = Options()
+
+        # ── Anti-detection ────────────────────────────
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        options.add_argument("--disable-blink-features=AutomationControlled")
+        options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        options.add_experimental_option("useAutomationExtension", False)
+        options.add_argument(f"--window-size={self._window_size}")
+
+        # ── Headless ──────────────────────────────────
+        if self._headless:
+            options.add_argument("--headless=new")
+            options.add_argument("--disable-gpu")
+            options.add_argument("--no-first-run")
+            options.add_argument("--no-default-browser-check")
+            logger.info("Headless mode enabled")
+
+        # ── Session profile ───────────────────────────
+        if self._phone:
+            profile_path = self._session_mgr.get_path(self._phone)
+            options.add_argument(f"--user-data-dir={profile_path}")
+            logger.info("Session profile: %s", profile_path)
+
+        # ── Custom binary ─────────────────────────────
+        if self._chrome_binary:
+            options.binary_location = self._chrome_binary
+
+        # ── Extra args ────────────────────────────────
+        for arg in self._extra_args:
+            options.add_argument(arg)
+
+        # ── Service ───────────────────────────────────
+        service_kwargs = {}
+        if self._chromedriver_path:
+            service_kwargs["executable_path"] = self._chromedriver_path
+        service = Service(**service_kwargs)
+
+        try:
+            self._driver = webdriver.Chrome(service=service, options=options)
+            if not self._headless:
+                self._driver.maximize_window()
+
+            # Remove webdriver flag
+            self._driver.execute_script(
+                "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+            )
+            logger.info("Browser started successfully")
+            return self._driver
+        except Exception as e:
+            raise BrowserError(f"Failed to start Chrome: {e}")
+
+    def stop(self) -> None:
+        """Quit the browser."""
+        if self._driver:
+            try:
+                self._driver.quit()
+                logger.info("Browser stopped")
+            except Exception:
+                pass
+            finally:
+                self._driver = None
+
+    def restart(self) -> webdriver.Chrome:
+        """Stop and re-start."""
+        self.stop()
+        return self.start()