PySPlus 0.5__py3-none-any.whl → 0.6__py3-none-any.whl

pysplus/Client.py

@@ -5,12 +5,25 @@ from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.chrome.options import Options
 from webdriver_manager.chrome import ChromeDriverManager
+from selenium.webdriver.common.action_chains import ActionChains
+import time
 from bs4 import BeautifulSoup
 from .colors import *
 from .async_sync import *
-from typing import Optional,Literal
-from traceback import format_exc
-import time,os,json,asyncio,logging,pickle
+from typing import (
+    Optional,
+    Literal
+)
+import time
+import os
+import json
+import logging
+import pickle
+import re
+import base64
+import inspect
+from .props import props
+from .Update import Update
 
 logging.getLogger('selenium').setLevel(logging.WARNING)
 logging.getLogger('urllib3').setLevel(logging.WARNING)
@@ -25,11 +38,14 @@ class Client:
         display_welcome=True,
         user_agent: Optional[str] = None,
         time_out: Optional[int] = 60,
-        number_phone: Optional[str] = None
+        number_phone: Optional[str] = None,
+        viewing_browser: Optional[bool] = False
     ):
         self.number_phone = number_phone
         name = name_session + ".pysplus"
         self.name_cookies = name_session + "_cookies.pkl"
+        self.viewing_browser = viewing_browser
+        self.splus_url = "https://web.splus.ir"
         if os.path.isfile(name):
             with open(name, "r", encoding="utf-8") as file:
                 text_json_py_slpus_session = json.load(file)
@@ -72,17 +88,20 @@ class Client:
                     print(f"{Colors.GREEN}{k}{Colors.RESET}", end="\r")
                     time.sleep(0.07)
                 cprint("",Colors.WHITE)
+
     def check_phone_number(self,number:str) -> bool:
         if len(number)!=10:
             return False
         if not number.startswith("9"):
             return False
         return True
+
     @async_to_sync
     async def login(self) -> bool:
         """لاگین / login"""
         chrome_options = Options()
-        chrome_options.add_argument("--headless")
+        if not self.viewing_browser:
+            chrome_options.add_argument("--headless")
         chrome_options.add_argument("--start-maximized")
         chrome_options.add_argument("--disable-notifications")
         chrome_options.add_argument("--lang=fa")
@@ -91,7 +110,7 @@ class Client:
         self.driver = webdriver.Chrome(service=service, options=chrome_options)
         wait = WebDriverWait(self.driver, 30)
         try:
-            self.driver.get("https://web.splus.ir")
+            self.driver.get(self.splus_url)
             wait.until(lambda d: d.execute_script("return document.readyState") == "complete")
             time.sleep(1)
             is_open_cookies = False
@@ -140,15 +159,16 @@ class Client:
                 pickle.dump(self.driver.get_cookies(), file)
             return True
         except Exception as e:
-            print("/*-+123456789*-+")
-            print(format_exc())
-            print("123456789*-+")
             self.driver.save_screenshot("error_screenshot.png")
             print("ERROR :")
             print(e)
             print("ERROR SAVED : error_screenshot.png")
             return False
 
+    @async_to_sync
+    async def get_url_opened(self) -> str:
+        return self.driver.current_url
+
     @async_to_sync
     async def get_type_chat_id(
         self,
@@ -167,8 +187,12 @@ class Client:
         return None
 
     @async_to_sync
-    async def get_chat_ids(self) -> list:
+    async def get_chat_ids(self) -> props:
         """گرفتن چت آیدی ها / getting chat ids"""
+        url_opened = await self.get_url_opened()
+        if not url_opened == self.splus_url+"/":
+            self.driver.get(self.splus_url)
+        self.code_html = self.driver.page_source
         soup = BeautifulSoup(self.code_html, "html.parser")
         root = soup.select_one(
             "body > #UiLoader > div.Transition.full-height > "
@@ -186,42 +210,182 @@ class Client:
                     if a!=None:
                         chat = str(a["href"]).replace("#","")
                         chats.append(chat)
-        return chats
+        return props(chats)
 
     @async_to_sync
-    async def get_chats(self) -> list:
+    async def get_chats(self) -> props:
         """گرفتن چت ها / getting chats"""
-        soup = BeautifulSoup(self.code_html, "html.parser")
-        root = soup.select_one(
-            "body > #UiLoader > div.Transition.full-height > "
-            "#Main.left-column-shown.left-column-open > "
-            "#LeftColumn > #LeftColumn-main > div.Transition > "
-            "div.ChatFolders.not-open.not-shown > div.Transition > "
-            "div.chat-list.custom-scroll > div[style*='position: relative']"
-        )
-        chats_ = []
-        chats = []
-        if root:
-            divs = root.find_all("div", recursive=True)
-            for div in divs:
-                anchors = div.find_all("a", href=True)
-                for a in anchors:
-                    if a!=None:
-                        chat = str(a["href"]).replace("#","")
-                        chats_.append(chat)
-        for chat in chats_:
-            type_chat = await self.get_type_chat_id(chat)
-            chats.append({
-                "chat_id":chat,
-                "type_chat":type_chat
-            })
-        return chats
+        try:
+            url_opened = await self.get_url_opened()
+            if not url_opened == self.splus_url+"/":
+                self.driver.get(self.splus_url)
+        except Exception:
+            pass
+        try:
+            WebDriverWait(self.driver, 10).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, "div.chat-list.custom-scroll"))
+            )
+        except Exception:
+            pass
+        items = self.driver.find_elements(By.CSS_SELECTOR, "div.ListItem.Chat")
+        def js_avatar_src(el):
+            js = r"""
+            return (function(root){
+                // تلاش از <img>
+                var img = root.querySelector('img.Avatar__media, img.avatar-media, .Avatar img, .avatar img, picture img');
+                var src = '';
+                if (img){
+                    src = img.getAttribute('src') || img.currentSrc || img.getAttribute('data-src') || '';
+                    if (!src){
+                        var ss = img.getAttribute('srcset') || '';
+                        if (ss){
+                            src = ss.split(',')[0].trim().split(' ')[0].trim();
+                        }
+                    }
+                }
+                // اگر نبود، از background-image روی .Avatar
+                if (!src){
+                    var av = root.querySelector('.Avatar, .avatar, .avatar-badge-wrapper');
+                    if (av){
+                        var st = getComputedStyle(av);
+                        var bg = (st && st.backgroundImage) || '';
+                        if (bg && bg.startsWith('url(')){
+                            src = bg.slice(4, -1).replace(/^["']|["']$/g,'');
+                        }
+                    }
+                }
+                return src || '';
+            })(arguments[0]);
+            """
+            try:
+                return (self.driver.execute_script(js, el) or "").strip()
+            except Exception:
+                return ""
+        results = []
+        default_icon_hint = "/person_icon."
+        for el in items:
+            try:
+                try:
+                    self.driver.execute_script("arguments[0].scrollIntoView({block:'nearest'});", el)
+                except Exception:
+                    pass
+                chat_id = ""
+                try:
+                    a = el.find_element(By.CSS_SELECTOR, "a.ListItem-button")
+                    href = (a.get_attribute("href") or "")
+                    m = re.search(r"#(\d+)", href)
+                    if m: chat_id = m.group(1)
+                except Exception:
+                    pass
+                if not chat_id:
+                    try:
+                        peer = el.find_element(By.CSS_SELECTOR, "[data-peer-id]")
+                        chat_id = (peer.get_attribute("data-peer-id") or "").strip()
+                    except Exception:
+                        chat_id = ""
+                try:
+                    name = el.find_element(By.CSS_SELECTOR, "h3.fullName").text.strip()
+                except Exception:
+                    name = ""
+                try:
+                    time_txt = el.find_element(By.CSS_SELECTOR, "span.time").text.strip()
+                except Exception:
+                    time_txt = ""
+                last_message = ""
+                try:
+                    sub_html = self.driver.execute_script(
+                        "var x=arguments[0].querySelector('.subtitle, p.last-message'); return x? x.innerHTML: '';",
+                        el
+                    ) or ""
+                    soup = BeautifulSoup(sub_html, "html.parser")
+                    for sp in soup.select("span.Spoiler__content"):
+                        sp_text = sp.get_text()
+                        sp.replace_with(f"||{sp_text}||")
+                    last_message = soup.get_text(" ", strip=True)
+                except Exception:
+                    try:
+                        last_message = el.find_element(By.CSS_SELECTOR, ".subtitle, p.last-message").text.strip()
+                    except Exception:
+                        last_message = ""
+                avatar_src = js_avatar_src(el)
+                if avatar_src and default_icon_hint in avatar_src:
+                    try:
+                        WebDriverWait(self.driver, 0.7).until(
+                            lambda d: (("blob:" in js_avatar_src(el)) or (default_icon_hint not in js_avatar_src(el)))
+                        )
+                        avatar_src = js_avatar_src(el)
+                    except Exception:
+                        if default_icon_hint in (avatar_src or ""):
+                            avatar_src = None
+                        if not str(avatar_src).startswith("blob:"):
+                            avatar_src = None
+                type_chat = await self.get_type_chat_id(chat_id)
+                results.append({
+                    "chat_id": chat_id,
+                    "name": name,
+                    "last_message": {
+                        "text":last_message,
+                        "time":time_txt
+                    },
+                    "avatar_src": avatar_src,
+                    "type_chat":type_chat
+                })
+            except Exception as e:
+                try:
+                    print("get_chats avatar parse error : ", e)
+                except:
+                    pass
+        return props(results)
+
+    @async_to_sync
+    async def download_blob_image(self, blob_url: str, dest_path: str) -> bool:
+        """download avatar / دانلود آواتور"""
+        try:
+            js = """
+            var url = arguments[0];
+            var cb  = arguments[arguments.length - 1];
+            try {
+                var img = new Image();
+                img.crossOrigin = 'anonymous';
+                img.onload = function(){
+                    try {
+                        var canvas = document.createElement('canvas');
+                        canvas.width  = this.naturalWidth  || this.width  || 0;
+                        canvas.height = this.naturalHeight || this.height || 0;
+                        var ctx = canvas.getContext('2d');
+                        ctx.drawImage(this, 0, 0);
+                        var data = canvas.toDataURL('image/png').split(',')[1];
+                        cb(data);
+                    } catch(e) { cb(null); }
+                };
+                img.onerror = function(){ cb(null); };
+                img.src = url;
+            } catch(e) { cb(null); }
+            """
+            b64 = self.driver.execute_async_script(js, blob_url)
+            if not b64:
+                return False
+            data = base64.b64decode(b64)
+            with open(dest_path, "wb") as f:
+                f.write(data)
+            return True
+        except Exception as e:
+            try:
+                print("download_blob_image error : ", e)
+            except:
+                pass
+            return False
 
     @async_to_sync
     async def open_chat(self, chat_id: str) -> bool:
         """opening chat / باز کردن چت"""
         try:
-            self.driver.get("https://web.splus.ir")
+            current = await self.get_url_opened()
+            if current == f"{self.splus_url}/#{chat_id}":
+                print(f"✅ Chat {chat_id} opened.")
+                return True
+            if not current == self.splus_url+"/":
+                self.driver.get(self.splus_url)
             WebDriverWait(self.driver, 60).until(
                 EC.presence_of_element_located((By.CSS_SELECTOR, "div.chat-list, div[role='main']"))
             )
@@ -240,10 +404,12 @@ class Client:
             return False
 
     @async_to_sync
-    async def send_text(self, chat_id: str, text: str) -> bool:
+    async def send_text(self, chat_id: str, text: str,reply_message_id: Optional[str]) -> bool:
         """ارسال متن / sending text"""
         try:
             await self.open_chat(chat_id)
+            if reply_message_id:
+                await self.context_click_message(reply_message_id, menu_text="پاسخ")
             WebDriverWait(self.driver, 25).until(
                 EC.presence_of_element_located((By.CSS_SELECTOR, "div[contenteditable='true']"))
             )
@@ -264,4 +430,410 @@ class Client:
         except Exception as e:
             print(f"❌ Error in send_text : {e}")
             self.driver.save_screenshot("send_text_error.png")
-            return False
+            return False
+
+    @async_to_sync
+    async def get_chat(
+        self,
+        chat_id
+    ) -> props:
+        """getting messages chat / گرفتن پیام های چت"""
+        opening = await self.open_chat(chat_id)
+        type_chat = await self.get_type_chat_id(chat_id)
+        peer_name = None
+        peer_status = None
+        peer_avatar = None
+        peer_verified = False
+        if not opening:
+            return props(
+                {
+                    "messages":[],
+                    "chat":{
+                        "name": peer_name,
+                        "avatar_src": peer_avatar,
+                        "last_seen": peer_status,
+                        "verified": peer_verified,
+                        "type": type_chat
+                    }
+                }
+            )
+        try:
+            header_el = WebDriverWait(self.driver, 5).until(
+                lambda d: d.find_element(By.CSS_SELECTOR, ".ChatInfo")
+            )
+            header_html = self.driver.execute_script("return arguments[0].outerHTML;", header_el)
+            hsoup = BeautifulSoup(header_html, "html.parser")
+            name_tag = hsoup.select_one(".fullName, .title h3, .info h3")
+            if name_tag:
+                peer_name = name_tag.get_text(strip=True)
+            status_tag = hsoup.select_one(".user-status, .status, .info .status")
+            if status_tag:
+                peer_status = status_tag.get_text(" ", strip=True)
+            if hsoup.select_one("svg.VerifiedIcon"):
+                peer_verified = True
+            try:
+                avatar_src = self.driver.execute_script("""
+                    var root = arguments[0];
+                    var img = root.querySelector('.Avatar__media, .avatar-media, .Avatar img, .avatar img, picture img');
+                    if (img) {
+                        var s = img.getAttribute('src') || img.currentSrc || img.getAttribute('data-src') || '';
+                        if (s) return s;
+                    }
+                    var av = root.querySelector('.Avatar, .avatar, .Avatar.size-medium, .Avatar.size-large');
+                    if (av) {
+                        var st = getComputedStyle(av);
+                        var bg = st && st.backgroundImage || '';
+                        if (bg && bg.indexOf('url(') === 0) {
+                            return bg.slice(4, -1).replace(/^['"]|['"]$/g,'');
+                        }
+                    }
+                    return '';
+                """, header_el) or ""
+                peer_avatar = avatar_src or None
+            except Exception:
+                peer_avatar = None
+        except Exception:
+            pass
+        try:
+            WebDriverWait(self.driver, 20).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, ".messages-container"))
+            )
+        except Exception:
+            pass
+        try:
+            WebDriverWait(self.driver, 15).until(
+                EC.presence_of_all_elements_located((By.CSS_SELECTOR, ".Message, .message-list-item"))
+            )
+        except Exception:
+            pass
+        try:
+            script_scroll = """
+            (function(){
+                var el = document.querySelector('.messages-container');
+                if(!el) return false;
+                el.scrollTop = el.scrollHeight;
+                return true;
+            })();
+            """
+            for _ in range(3):
+                try:
+                    self.driver.execute_script(script_scroll)
+                    time.sleep(0.35)
+                except Exception:
+                    break
+        except Exception:
+            pass
+        time.sleep(0.5)
+        try:
+            container_el = self.driver.find_element(By.CSS_SELECTOR, ".messages-container")
+            html_fragment = self.driver.execute_script("return arguments[0].innerHTML;", container_el)
+            html_string = f'<div class="messages-container">{html_fragment}</div>'
+        except Exception:
+            html_string = self.driver.page_source
+        def normalize_lines(text):
+            lines = [ln.strip() for ln in text.splitlines()]
+            lines = [ln for ln in lines if ln]
+            return "\n".join(lines)
+        def extract_text_from_textcontent(text_div):
+            if text_div is None:
+                return ""
+            for meta in text_div.select(".MessageMeta"):
+                meta.extract()
+            raw = text_div.get_text("\n", strip=True)
+            return normalize_lines(raw)
+        def _persian_digits_to_ascii(s: str) -> str:
+            if not s:
+                return s
+            persian_offset = {ord(c): ord('0') + i for i, c in enumerate("۰۱۲۳۴۵۶۷۸۹")}
+            arabic_offset = {ord(c): ord('0') + i for i, c in enumerate("٠١٢٣٤٥٦٧٨٩")}
+            table = {}
+            table.update(persian_offset)
+            table.update(arabic_offset)
+            return s.translate(table)
+        def parse_message_tag(msg_tag, sticky_text=None):
+            time_span = msg_tag.select_one(".message-time")
+            time_sent = None
+            full_date = None
+            if time_span:
+                title = time_span.get("title") or ""
+                title = title.strip()
+                if title:
+                    title_ascii = _persian_digits_to_ascii(title)
+                    if "،" in title_ascii:
+                        parts = [p.strip() for p in title_ascii.split("،") if p.strip()]
+                    else:
+                        parts = [p.strip() for p in title_ascii.split(",") if p.strip()]
+                    if len(parts) >= 2:
+                        date_part = "، ".join(parts[:-1]) if len(parts) > 2 else parts[0]
+                        time_part = parts[-1]
+                        full_date = title_ascii
+                        time_sent = time_part
+                    else:
+                        full_date = title_ascii
+                        import re
+                        m = re.search(r'(\d{1,2}[:\:\uFF1A]\d{2}(?::\d{2})?)', title_ascii)
+                        if m:
+                            time_sent = m.group(1).replace("\uFF1A", ":")
+                else:
+                    txt = time_span.get_text(strip=True)
+                    txt_ascii = _persian_digits_to_ascii(txt)
+                    if ":" in txt_ascii:
+                        parts = txt_ascii.split(":")
+                        if len(parts) == 2:
+                            time_sent = f"{parts[0].zfill(2)}:{parts[1].zfill(2)}:00"
+                        else:
+                            time_sent = txt_ascii
+                    else:
+                        time_sent = txt_ascii
+            text_div = msg_tag.select_one(".text-content")
+            if text_div is None:
+                text_div = msg_tag.select_one(".content-inner")
+            cleaned = extract_text_from_textcontent(text_div)
+            classes = msg_tag.get("class", []) or []
+            own_flag = False
+            if "own" in classes:
+                own_flag = True
+            if msg_tag.select_one(".with-outgoing-icon") or msg_tag.select_one(".MessageOutgoingStatus") or msg_tag.select_one(".MessageOutgoingStatus .icon-message-succeeded"):
+                own_flag = True
+            summary = cleaned.replace("\n", " ")
+            if len(summary) > 160:
+                summary = summary[:157].rstrip() + "..."
+            return {
+                "message_id": msg_tag.get("id").replace("message", "") if msg_tag.get("id") else None,
+                "day": sticky_text,
+                "date": full_date,
+                "time": time_sent,
+                "is_me": bool(own_flag),
+                "text": cleaned,
+                "summary": summary,
+                "classes": classes
+            }
+
+        soup = BeautifulSoup(html_string, "html.parser")
+        container = soup.select_one(".messages-container") or soup
+        sticky_current = None
+        collected = []
+        seen_ids = set()
+        for d in container.find_all("div", recursive=True):
+            d_classes = d.get("class") or []
+            if "sticky-date" in d_classes:
+                txt = d.get_text(" ", strip=True)
+                sticky_current = txt if txt else sticky_current
+                continue
+            is_msg = False
+            for token in ("Message", "message-list-item"):
+                if token in d_classes:
+                    is_msg = True
+                    break
+            if is_msg:
+                mid = d.get("id")
+                if mid and mid in seen_ids:
+                    continue
+                parsed = parse_message_tag(d, sticky_text=sticky_current)
+                collected.append(parsed)
+                if mid:
+                    seen_ids.add(mid)
+        collected.reverse()
+        return props(
+            {
+                "messages":collected,
+                "chat":{
+                    "name": peer_name,
+                    "avatar_src": peer_avatar,
+                    "last_seen": peer_status,
+                    "verified": peer_verified,
+                    "type": type_chat
+                }
+            }
+        )
+
+    def _dispatch_js_contextmenu(self, el):
+        js = """
+        var el = arguments[0];
+        var ev = document.createEvent('MouseEvent');
+        ev.initMouseEvent('contextmenu', true, true, window, 1, 0,0,0,0, false, false, false, false, 2, null);
+        el.dispatchEvent(ev);
+        return true;
+        """
+        try:
+            return self.driver.execute_script(js, el)
+        except Exception:
+            return False
+
+    @async_to_sync
+    async def context_click_message(
+        self,
+        message_id: str,
+        menu_selector: Optional[str] = None,
+        menu_text: Optional[str] = None,
+        timeout: int = 8
+    ) -> bool:
+        try:
+            mid = str(message_id)
+            if not mid.startswith("message"):
+                mid = "message" + mid
+            msg_el = WebDriverWait(self.driver, 5).until(
+                lambda d: d.find_element(By.ID, mid)
+            )
+            try:
+                self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", msg_el)
+            except Exception:
+                pass
+            time.sleep(0.12)
+            try:
+                ac = ActionChains(self.driver)
+                ac.move_to_element(msg_el).context_click(msg_el).perform()
+            except Exception:
+                self._dispatch_js_contextmenu(msg_el)
+            wait = WebDriverWait(self.driver, timeout)
+            if menu_selector:
+                item = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, menu_selector)))
+                item.click()
+                return True
+            if menu_text:
+                xpaths = [
+                    f"//button[normalize-space()='{menu_text}']",
+                    f"//div[normalize-space()='{menu_text}']",
+                    f"//a[normalize-space()='{menu_text}']",
+                    f"//*[normalize-space()='{menu_text}']"
+                ]
+                for xp in xpaths:
+                    try:
+                        el = wait.until(EC.element_to_be_clickable((By.XPATH, xp)))
+                        el.click()
+                        return True
+                    except Exception:
+                        continue
+                return False
+            return True
+        except Exception as e:
+            try:
+                self.driver.save_screenshot("context_click_error.png")
+            except:
+                pass
+            return False
+
+    @async_to_sync
+    async def click_confirm(
+        self,
+        confirm_selector: Optional[str] = None,
+        confirm_text: Optional[str] = None,
+        timeout: int = 6,
+        take_screenshot_on_fail: bool = True
+    ) -> bool:
+        try:
+            wait = WebDriverWait(self.driver, timeout)
+            if confirm_selector:
+                try:
+                    btn = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, confirm_selector)))
+                    btn.click()
+                    return True
+                except Exception:
+                    pass
+            candidate_texts = []
+            if confirm_text:
+                candidate_texts.append(confirm_text)
+            candidate_texts += ["حذف", "حذف پیام", "حذف گفتگو", "بله", "تایید", "OK", "Yes", "Delete", "Confirm"]
+            xpaths = []
+            for t in candidate_texts:
+                xpaths.extend([
+                    f"//button[normalize-space()='{t}']",
+                    f"//a[normalize-space()='{t}']",
+                    f"//div[normalize-space()='{t}']",
+                    f"//span[normalize-space()='{t}']",
+                    f"//*[@role='button' and normalize-space()='{t}']"
+                ])
+            for xp in xpaths:
+                try:
+                    el = wait.until(EC.element_to_be_clickable((By.XPATH, xp)))
+                    el.click()
+                    return True
+                except Exception:
+                    continue
+            try:
+                buttons = self.driver.find_elements(By.TAG_NAME, "button")
+                low_candidates = [t.lower() for t in candidate_texts]
+                for b in buttons:
+                    try:
+                        txt = (b.text or "").strip().lower()
+                        if not txt:
+                            val = b.get_attribute("value") or ""
+                            txt = val.strip().lower()
+                        for cand in low_candidates:
+                            if cand and cand in txt:
+                                try:
+                                    b.click()
+                                    return True
+                                except:
+                                    try:
+                                        self.driver.execute_script("arguments[0].click();", b)
+                                        return True
+                                    except:
+                                        pass
+                    except Exception:
+                        continue
+            except Exception:
+                pass
+            if take_screenshot_on_fail:
+                try:
+                    self.driver.save_screenshot("confirm_click_failed.png")
+                except:
+                    pass
+            return False
+        except Exception:
+            try:
+                self.driver.save_screenshot("confirm_click_error.png")
+            except:
+                pass
+            return False
+
+    @async_to_sync
+    async def delete_message(self,message_id:str,chat_id:str) -> bool:
+        """delete message / حذف پیام"""
+        opening = await self.open_chat(chat_id)
+        if opening:
+            try:
+                click_right = await self.context_click_message(message_id, menu_text="حذف")
+                if click_right:
+                    delete = await self.click_confirm(confirm_text="حذف")
+                    if delete:
+                        return True
+                return False
+            except:
+                raise ValueError("Invalid Acsses")
+        else:
+            return False
+
+    @async_to_sync
+    async def pin_message(self,message_id:str,chat_id:str) -> bool:
+        """pining message / سنجاق پیام"""
+        type_chat = await self.get_type_chat_id(chat_id)
+        if type_chat in ["Group","Channel"]:
+            await self.open_chat(chat_id)
+            try:
+                click_right = await self.context_click_message(message_id, menu_text="سنجاق کردن")
+                if click_right:
+                    pining = await self.click_confirm(confirm_text="سنجاق کردن")
+                    if pining:
+                        return True
+                return False
+            except:
+                raise ValueError("Invalid Acsses")
+        raise ValueError("group and channel can pining message")
+
+    @async_to_sync
+    async def unpin_message(self,message_id:str,chat_id:str) -> bool:
+        """unpining message / برداشتن سنجاق پیام"""
+        type_chat = await self.get_type_chat_id(chat_id)
+        if type_chat in ["Group","Channel"]:
+            await self.open_chat(chat_id)
+            try:
+                click_right = await self.context_click_message(message_id, menu_text="برداشتن سنجاق")
+                if click_right:
+                    return True
+                return False
+            except:
+                raise ValueError("Invalid Acsses")
+        raise ValueError("group and channel can pining message")
+
+

pysplus/Update.py

@@ -0,0 +1,7 @@
+import json
+
+class Update:
+    def __init__(self,data):
+        self._data_ = data
+    def __str__(self) -> str:
+        return json.dumps(self._data_,indent=4,ensure_ascii=False)

pysplus/props.py

@@ -0,0 +1,44 @@
+import json
+
+class props:
+    def __init__(self,data):
+        self._data_ = data
+    def __getattr__(self, name):
+        return self.find_prop(keys=name)
+    def __getitem__(self, key):
+        return self._data_[key]
+    def __lts__(self, update: list, *args, **kwargs):
+        for index, element in enumerate(update):
+            if isinstance(element, list):
+                update[index] = self.__lts__(update=element)
+            elif isinstance(element, dict):
+                update[index] = props(data=element)
+            else:
+                update[index] = element
+        return update
+    def find_prop(self, keys, data_=None, *args, **kwargs):
+        if data_ is None:
+            data_ = self._data_
+        if not isinstance(keys, list):
+            keys = [keys]
+        if isinstance(data_, dict):
+            for key in keys:
+                try:
+                    update = data_[key]
+                    if isinstance(update, dict):
+                        update = props(data=update)
+                    elif isinstance(update, list):
+                        update = self.__lts__(update=update)
+                    return update
+                except KeyError:
+                    pass
+            data_ = data_.values()
+        for value in data_:
+            if isinstance(value, (dict, list)):
+                try:
+                    return self.find_prop(keys=keys, data_=value)
+                except AttributeError:
+                    return None
+        return None
+    def __str__(self) -> str:
+        return json.dumps(self._data_,indent=4,ensure_ascii=False)

{pysplus-0.5.dist-info → pysplus-0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySPlus
-Version: 0.5
+Version: 0.6
 Summary: the library SPlus platform for bots.
 Home-page: https://github.com/OandONE/SPlus
 Author: seyyed mohamad hosein moosavi raja(01)
@@ -11,6 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: selenium==4.29.0
 Requires-Dist: webdriver_manager==4.0.2
 Requires-Dist: bs4==0.0.2
+Requires-Dist: pytz
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

pysplus-0.6.dist-info/RECORD

@@ -0,0 +1,10 @@
+pysplus/Client.py,sha256=NOef2SKn1FQNKEHIk4cx4TUDfh-mRMI81zjai_UGBRk,35602
+pysplus/Update.py,sha256=4mUzfYwICFsPKCwJ3T_cvqDB07Sr9okIF0Ib5Vuu-QA,185
+pysplus/__init__.py,sha256=D6b12F-lYPY38W7ymcNtCgUQb7tu79scbEcbDjIRR5c,97
+pysplus/async_sync.py,sha256=d9VSE7_A7zgOI8BAlZoxfm8LdkdWxyZdpgAEOrRpQcg,489
+pysplus/colors.py,sha256=SwcpovYEff7gDHMtWZAjYnVSbvhqSiHXlAoa4eSJ9RM,556
+pysplus/props.py,sha256=BN171ElaDSjRn1pfIQ2zkVTUS_0MBLrZn-EiNOw12tM,1644
+pysplus-0.6.dist-info/METADATA,sha256=vVRKPDrM8bmGC42uanMlLA5QI0WYA0BN8AluUoPNVHk,875
+pysplus-0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pysplus-0.6.dist-info/top_level.txt,sha256=h2PKSbKoDxAHsNE8pxuQY8VllsI-4KQW_Udcd7DKQkA,8
+pysplus-0.6.dist-info/RECORD,,

pysplus-0.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-pysplus/Client.py,sha256=QuNKFuDiSaysh93_0wfXKsY_PGCg1sEqYGdvuTLQRaU,11552
-pysplus/__init__.py,sha256=D6b12F-lYPY38W7ymcNtCgUQb7tu79scbEcbDjIRR5c,97
-pysplus/async_sync.py,sha256=d9VSE7_A7zgOI8BAlZoxfm8LdkdWxyZdpgAEOrRpQcg,489
-pysplus/colors.py,sha256=SwcpovYEff7gDHMtWZAjYnVSbvhqSiHXlAoa4eSJ9RM,556
-pysplus-0.5.dist-info/METADATA,sha256=yqXKWChLEIVeFXJR5-l4anNFJyA2z8pjHVmT2EVM0Sc,854
-pysplus-0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pysplus-0.5.dist-info/top_level.txt,sha256=h2PKSbKoDxAHsNE8pxuQY8VllsI-4KQW_Udcd7DKQkA,8
-pysplus-0.5.dist-info/RECORD,,