sorocore 1.0.0__tar.gz

sorocore-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 آرشا
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sorocore-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include requirements.txt
+include LICENSE
+recursive-include rouba *.py

sorocore-1.0.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: sorocore
+Version: 1.0.0
+Summary: Core library for Soroush Plus
+Author: SoroCore Team
+Author-email: sorocore@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: splusthon>=1.1.4
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SoroCore
+
+**Core library for Soroush Plus**
+
+## نصب
+
+```bash
+pip install sorocore
+```
+
+## مثال
+
+```python
+from sorocore import SoroCoreClient, NewMessage
+import asyncio
+
+client = SoroCoreClient("my_session")
+
+@client.on(NewMessage)
+async def handler(event):
+    if event.text == "س":
+        await event.reply("س")
+
+async def main():
+    await client.start()
+    await client.run_until_disconnected()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## مجوز
+
+MIT

sorocore-1.0.0/README.md

@@ -0,0 +1,34 @@
+# SoroCore
+
+**Core library for Soroush Plus**
+
+## نصب
+
+```bash
+pip install sorocore
+```
+
+## مثال
+
+```python
+from sorocore import SoroCoreClient, NewMessage
+import asyncio
+
+client = SoroCoreClient("my_session")
+
+@client.on(NewMessage)
+async def handler(event):
+    if event.text == "س":
+        await event.reply("س")
+
+async def main():
+    await client.start()
+    await client.run_until_disconnected()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## مجوز
+
+MIT

sorocore-1.0.0/requirements.txt

@@ -0,0 +1 @@
+aiohttp>=3.8.0

sorocore-1.0.0/rouba_backup/__init__.py

@@ -0,0 +1,7 @@
+from .client import RoubaClient
+from .client import NewMessage, MessageEdited, ChatAction
+
+__version__ = "0.9.0"
+__author__ = "Arsha"
+
+__all__ = ["RoubaClient", "NewMessage", "MessageEdited", "ChatAction"]

sorocore-1.0.0/rouba_backup/client.py

@@ -0,0 +1,186 @@
+from splusthon import SoroushClient, events as splus_events
+import asyncio
+import time
+from functools import lru_cache
+
+class RoubaClient:
+    def __init__(self, session_name="my_account"):
+        self._client = SoroushClient(session_name)
+        
+        # تنظیمات سرعت
+        self.poll_interval = 0.1
+        self.min_delay = 0.5
+        self.max_delay = 1
+        self.max_workers = 50
+        self.save_session = False
+        self.auto_reconnect = True
+        self._cache = {}
+        self._cache_time = {}
+        self._cache_ttl = 120
+        self._handlers = []
+    
+    async def start(self):
+        await self._client.start()
+        return self
+    
+    async def stop(self):
+        try:
+            await self._client.stop()
+        except:
+            pass
+    
+    async def send_message(self, chat_id, text):
+        try:
+            return await self._client.send_message(chat_id, text)
+        except Exception as e:
+            print(f"⚠️ خطا در ارسال: {e}")
+            return None
+    
+    async def delete_message(self, chat_id, message_id):
+        return await self._client.delete_messages(chat_id, [message_id])
+    
+    async def get_messages(self, chat_id, limit=100):
+        return await self._client.get_messages(chat_id, limit)
+    
+    async def edit_permissions(self, chat_id, user_id, send_messages=None):
+        return await self._client.edit_permissions(chat_id, user_id, send_messages)
+    
+    async def kick_participant(self, chat_id, user_id):
+        return await self._client.kick_participant(chat_id, user_id)
+    
+    async def leave_chat(self, chat_id):
+        return await self._client.leave_chat(chat_id)
+    
+    async def pin_message(self, chat_id, message_id):
+        return await self._client.pin_message(chat_id, message_id)
+    
+    async def unpin_message(self, chat_id):
+        return await self._client.unpin_message(chat_id)
+    
+    async def get_me(self):
+        if "me" in self._cache:
+            return self._cache["me"]
+        result = await self._client.get_me()
+        self._cache["me"] = result
+        return result
+    
+    @lru_cache(maxsize=128)
+    async def get_entity(self, identifier):
+        return await self._client.get_entity(identifier)
+    
+    async def send_sticker(self, chat_id, sticker):
+        return await self._client.send_file(chat_id, sticker)
+    
+    async def send_photo(self, chat_id, photo, caption=""):
+        return await self._client.send_file(chat_id, photo, caption=caption)
+    
+    async def send_video(self, chat_id, video, caption=""):
+        return await self._client.send_file(chat_id, video, caption=caption)
+    
+    async def send_audio(self, chat_id, audio, caption=""):
+        return await self._client.send_file(chat_id, audio, caption=caption)
+    
+    async def send_document(self, chat_id, document, caption=""):
+        return await self._client.send_file(chat_id, document, caption=caption)
+    
+    async def send_voice(self, chat_id, voice, caption=""):
+        return await self._client.send_file(chat_id, voice, caption=caption)
+    
+    async def get_user_info(self, user_id):
+        return await self.get_entity(user_id)
+    
+    async def send_typing(self, chat_id):
+        return await self._client.send_typing(chat_id)
+    
+    async def download_file(self, file_id, file_path):
+        return await self._client.download_file(file_id, file_path)
+    
+    def on(self, event_type):
+        def decorator(func):
+            if event_type.__name__ == "NewMessage":
+                @self._client.on(splus_events.NewMessage)
+                async def wrapper(event):
+                    rouba_event = NewMessage(
+                        text=event.text or "",
+                        chat_id=event.chat_id or 0,
+                        sender_id=event.sender_id or 0,
+                        is_group=event.is_group or False,
+                        reply_to_msg_id=event.reply_to_msg_id,
+                        message=event.message
+                    )
+                    await func(rouba_event)
+            
+            elif event_type.__name__ == "MessageEdited":
+                @self._client.on(splus_events.MessageEdited)
+                async def wrapper(event):
+                    rouba_event = MessageEdited(
+                        text=event.text or "",
+                        chat_id=event.chat_id or 0,
+                        sender_id=event.sender_id or 0,
+                        message=event.message
+                    )
+                    await func(rouba_event)
+            
+            elif event_type.__name__ == "ChatAction":
+                @self._client.on(splus_events.ChatAction)
+                async def wrapper(event):
+                    rouba_event = ChatAction(
+                        chat_id=event.chat_id or 0,
+                        user_id=event.user_id or 0,
+                        user_joined=event.user_joined or False,
+                        user_left=event.user_left or False
+                    )
+                    await func(rouba_event)
+            
+            return func
+        return decorator
+    
+    async def run_until_disconnected(self):
+        await self._client.run_until_disconnected()
+
+
+class NewMessage:
+    __slots__ = ['text', 'chat_id', 'sender_id', 'is_group', 'reply_to_msg_id', 'message']
+    
+    def __init__(self, text="", chat_id=0, sender_id=0, is_group=False, reply_to_msg_id=None, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.is_group = is_group or False
+        self.reply_to_msg_id = reply_to_msg_id
+        self.message = message
+    
+    async def reply(self, text):
+        if self.message:
+            return await self.message.reply(text)
+        return None
+    
+    async def delete(self):
+        if self.message:
+            return await self.message.delete()
+        return None
+
+
+class MessageEdited:
+    __slots__ = ['text', 'chat_id', 'sender_id', 'message']
+    
+    def __init__(self, text="", chat_id=0, sender_id=0, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.message = message
+    
+    async def delete(self):
+        if self.message:
+            return await self.message.delete()
+        return None
+
+
+class ChatAction:
+    __slots__ = ['chat_id', 'user_id', 'user_joined', 'user_left']
+    
+    def __init__(self, chat_id=0, user_id=0, user_joined=False, user_left=False):
+        self.chat_id = chat_id or 0
+        self.user_id = user_id or 0
+        self.user_joined = user_joined or False
+        self.user_left = user_left or False

sorocore-1.0.0/rouba_backup/client_backup.py

@@ -0,0 +1,274 @@
+from splusthon import SoroushClient, events as splus_events
+import asyncio
+import time
+from functools import lru_cache
+from concurrent.futures import ThreadPoolExecutor
+
+class RoubaClient:
+    def __init__(self, sessionname="myaccount"):
+        self._client = SoroushClient(sessionname)
+        
+        # ====== تنظیمات فوق‌سریع ======
+        self._client.poll_interval = 0.0001
+        self._client.min_delay = 0
+        self._client.max_delay = 0
+        self._client.save_session = False
+        self._client.max_workers = 500
+        
+        self._handlers = []
+        self._cache = {}
+        self._cache_time = {}
+        self._cache_ttl = 60
+        
+        # کش برای get_entity
+        self._entity_cache = {}
+        
+        # صف رویدادها
+        self._event_queue = asyncio.Queue(maxsize=500)
+        self._processing = False
+        
+        # تردپول برای پردازش موازی
+        self._executor = ThreadPoolExecutor(max_workers=20)
+    
+    async def start(self):
+        await self._client.start()
+        # شروع پردازش رویدادها در پس‌زمینه
+        asyncio.create_task(self._process_events())
+        return self
+    
+    async def stop(self):
+        self._processing = False
+        await self._client.stop()
+        self._executor.shutdown(wait=False)
+    
+    async def _process_events(self):
+        """پردازش سریع رویدادها از صف"""
+        self._processing = True
+        while self._processing:
+            try:
+                # گرفتن رویداد از صف با timeout کم
+                event = await asyncio.wait_for(
+                    self._event_queue.get(), 
+                    timeout=0.01
+                )
+                # پردازش در ترد جداگانه
+                loop = asyncio.get_event_loop()
+                loop.run_in_executor(
+                    self._executor,
+                    self._handle_event,
+                    event
+                )
+            except asyncio.TimeoutError:
+                continue
+            except Exception:
+                continue
+    
+    def _handle_event(self, event):
+        """پردازش همزمان رویداد"""
+        try:
+            for event_type, handler in self._handlers:
+                if event_type.__name__ == "NewMessage" and isinstance(event, splus_events.NewMessage):
+                    rouba_event = NewMessage(
+                        text=event.text or "",
+                        chat_id=event.chat_id or 0,
+                        sender_id=event.sender_id or 0,
+                        is_group=event.is_group or False,
+                        reply_to_msg_id=event.reply_to_msg_id,
+                        message=event.message
+                    )
+                    # اجرای هندلر
+                    asyncio.create_task(handler(rouba_event))
+                    
+                elif event_type.__name__ == "MessageEdited" and isinstance(event, splus_events.MessageEdited):
+                    rouba_event = MessageEdited(
+                        text=event.text or "",
+                        chat_id=event.chat_id or 0,
+                        sender_id=event.sender_id or 0,
+                        message=event.message
+                    )
+                    asyncio.create_task(handler(rouba_event))
+                    
+                elif event_type.__name__ == "ChatAction" and isinstance(event, splus_events.ChatAction):
+                    rouba_event = ChatAction(
+                        chat_id=event.chat_id or 0,
+                        user_id=event.user_id or 0,
+                        user_joined=event.user_joined or False,
+                        user_left=event.user_left or False
+                    )
+                    asyncio.create_task(handler(rouba_event))
+        except Exception:
+            pass
+    
+    # ====== متدهای با کش ======
+    async def _get_cache(self, key):
+        if key in self._cache:
+            if time.time() - self._cache_time.get(key, 0) < self._cache_ttl:
+                return self._cache[key]
+        return None
+    
+    async def _set_cache(self, key, value):
+        self._cache[key] = value
+        self._cache_time[key] = time.time()
+    
+    @lru_cache(maxsize=512)
+    async def _get_entity_cached(self, identifier):
+        return await self._client.get_entity(identifier)
+    
+    # ====== متدهای عمومی ======
+    async def send_message(self, chat_id, text):
+        return await self._client.send_message(chat_id, text)
+    
+    async def send_message_fast(self, chat_id, text):
+        """ارسال بدون انتظار برای پاسخ"""
+        asyncio.create_task(self._client.send_message(chat_id, text))
+    
+    async def get_messages(self, chat_id, limit=100):
+        cache_key = f"msgs_{chat_id}_{limit}"
+        cached = await self._get_cache(cache_key)
+        if cached:
+            return cached
+        result = await self._client.get_messages(chat_id, limit)
+        await self._set_cache(cache_key, result)
+        return result
+    
+    async def get_me(self):
+        cached = await self._get_cache('me')
+        if cached:
+            return cached
+        result = await self._client.get_me()
+        await self._set_cache('me', result)
+        return result
+    
+    async def get_entity(self, identifier):
+        # کش ساده
+        cache_key = f"entity_{identifier}"
+        if cache_key in self._entity_cache:
+            return self._entity_cache[cache_key]
+        
+        result = await self._get_entity_cached(str(identifier))
+        self._entity_cache[cache_key] = result
+        return result
+    
+    async def delete_message(self, chat_id, message_id):
+        return await self._client.delete_messages(chat_id, [message_id])
+    
+    async def edit_permissions(self, chat_id, user_id, send_messages=None):
+        return await self._client.edit_permissions(chat_id, user_id, send_messages)
+    
+    async def kick_participant(self, chat_id, user_id):
+        return await self._client.kick_participant(chat_id, user_id)
+    
+    async def leave_chat(self, chat_id):
+        return await self._client.leave_chat(chat_id)
+    
+    async def pin_message(self, chat_id, message_id):
+        return await self._client.pin_message(chat_id, message_id)
+    
+    async def unpin_message(self, chat_id):
+        return await self._client.unpin_message(chat_id)
+    
+    async def send_sticker(self, chat_id, sticker):
+        return await self._client.send_file(chat_id, sticker)
+    
+    async def send_photo(self, chat_id, photo, caption=""):
+        return await self._client.send_file(chat_id, photo, caption=caption)
+    
+    async def send_video(self, chat_id, video, caption=""):
+        return await self._client.send_file(chat_id, video, caption=caption)
+    
+    async def send_audio(self, chat_id, audio, caption=""):
+        return await self._client.send_file(chat_id, audio, caption=caption)
+    
+    async def send_document(self, chat_id, document, caption=""):
+        return await self._client.send_file(chat_id, document, caption=caption)
+    
+    async def send_voice(self, chat_id, voice, caption=""):
+        return await self._client.send_file(chat_id, voice, caption=caption)
+    
+    async def get_user_info(self, user_id):
+        return await self.get_entity(user_id)
+    
+    async def send_typing(self, chat_id):
+        return await self._client.send_typing(chat_id)
+    
+    async def download_file(self, file_id, file_path):
+        return await self._client.download_file(file_id, file_path)
+    
+    # ====== دکوراتور on ======
+    def on(self, event_type):
+        def decorator(func):
+            self._handlers.append((event_type, func))
+            
+            # ثبت در کلاینت اصلی
+            if event_type.__name__ == "NewMessage":
+                @self._client.on(splus_events.NewMessage)
+                async def wrapper(event):
+                    # اضافه به صف برای پردازش سریع
+                    await self._event_queue.put(event)
+                return wrapper
+                
+            elif event_type.__name__ == "MessageEdited":
+                @self._client.on(splus_events.MessageEdited)
+                async def wrapper(event):
+                    await self._event_queue.put(event)
+                return wrapper
+                
+            elif event_type.__name__ == "ChatAction":
+                @self._client.on(splus_events.ChatAction)
+                async def wrapper(event):
+                    await self._event_queue.put(event)
+                return wrapper
+            
+            return func
+        return decorator
+    
+    async def run_until_disconnected(self):
+        await self._client.run_until_disconnected()
+
+
+# ====== کلاس‌های رویداد ======
+class NewMessage:
+    __slots__ = ['text', 'chat_id', 'sender_id', 'is_group', 'reply_to_msg_id', 'message']
+    
+    def __init__(self, text="", chat_id=0, sender_id=0, is_group=False, reply_to_msg_id=None, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.is_group = is_group or False
+        self.reply_to_msg_id = reply_to_msg_id
+        self.message = message
+    
+    async def reply(self, text):
+        if self.message:
+            return await self.message.reply(text)
+        return None
+    
+    async def delete(self):
+        if self.message:
+            return await self.message.delete()
+        return None
+
+
+class MessageEdited:
+    __slots__ = ['text', 'chat_id', 'sender_id', 'message']
+    
+    def __init__(self, text="", chat_id=0, sender_id=0, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.message = message
+    
+    async def delete(self):
+        if self.message:
+            return await self.message.delete()
+        return None
+
+
+class ChatAction:
+    __slots__ = ['chat_id', 'user_id', 'user_joined', 'user_left']
+    
+    def __init__(self, chat_id=0, user_id=0, user_joined=False, user_left=False):
+        self.chat_id = chat_id or 0
+        self.user_id = user_id or 0
+        self.user_joined = user_joined or False
+        self.user_left = user_left or False

sorocore-1.0.0/rouba_backup/events.py

@@ -0,0 +1,3 @@
+from .client import NewMessage, MessageEdited, ChatAction
+
+__all__ = ["NewMessage", "MessageEdited", "ChatAction"]

sorocore-1.0.0/setup.cfg

@@ -0,0 +1,10 @@
+[metadata]
+license_file = LICENSE
+
+[bdist_wheel]
+universal = 1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sorocore-1.0.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="sorocore",
+    version="1.0.0",
+    author="SoroCore Team",
+    author_email="sorocore@gmail.com",
+    description="Core library for Soroush Plus",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=["splusthon>=1.1.4"],
+    python_requires=">=3.6",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+    ],
+)

sorocore-1.0.0/sorocore/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "1.0.0"
+__author__ = "SoroCore Team"
+from .client import SoroCoreClient
+from .events import NewMessage, MessageEdited, ChatAction

sorocore-1.0.0/sorocore/client.py

@@ -0,0 +1,93 @@
+from splusthon import SoroushClient, events as splus_events
+import asyncio
+import os
+import glob
+
+class NewMessage:
+    def __init__(self, text="", chat_id=0, sender_id=0, is_group=False, reply_to_msg_id=None, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.is_group = is_group or False
+        self.reply_to_msg_id = reply_to_msg_id
+        self.message = message
+
+    async def reply(self, text):
+        if self.message:
+            return await self.message.reply(text)
+        return None
+
+class SoroCoreClient:
+    def __init__(self, session_name="my_session"):
+        self.session_name = session_name
+        self._client = None
+        self._handlers = []
+
+    async def start(self):
+        try:
+            for f in glob.glob("*.session"):
+                try:
+                    os.remove(f)
+                except:
+                    pass
+
+            self._client = SoroushClient(self.session_name)
+            self._client.poll_interval = 0.00001
+            self._client.save_session = True
+            self._client.auto_reconnect = True
+
+            print("=" * 40)
+            print("📱 SoroCore - Please enter your phone number")
+            print("=" * 40)
+
+            phone = input("Phone (with +): ").strip()
+
+            if not phone:
+                print("❌ No phone entered!")
+                return await self.start()
+
+            print("📤 Sending code...")
+            await self._client.send_code(phone)
+            print("✅ Code sent!")
+
+            code = input("Enter code: ").strip()
+
+            if not code:
+                print("❌ No code entered!")
+                return await self.start()
+
+            print("🔄 Logging in...")
+            await self._client.sign_in(phone, code)
+            await self._client.start()
+
+            for handler in self._handlers:
+                @self._client.on(splus_events.NewMessage)
+                async def wrapper(event, h=handler):
+                    e = NewMessage(
+                        text=event.text or "",
+                        chat_id=event.chat_id or 0,
+                        sender_id=event.sender_id or 0,
+                        is_group=event.is_group or False,
+                        reply_to_msg_id=getattr(event, "reply_to_msg_id", None),
+                        message=event.message
+                    )
+                    await h(e)
+
+            print("✅ SoroCore Activated!")
+            return self
+
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return await self.start()
+
+    def on(self, event_type):
+        def decorator(func):
+            self._handlers.append(func)
+            return func
+        return decorator
+
+    async def run_until_disconnected(self):
+        try:
+            await self._client.run_until_disconnected()
+        except:
+            pass

sorocore-1.0.0/sorocore/events.py

@@ -0,0 +1,27 @@
+class NewMessage:
+    def __init__(self, text="", chat_id=0, sender_id=0, is_group=False, reply_to_msg_id=None, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.is_group = is_group or False
+        self.reply_to_msg_id = reply_to_msg_id
+        self.message = message
+
+    async def reply(self, text):
+        if self.message:
+            return await self.message.reply(text)
+        return None
+
+class MessageEdited:
+    def __init__(self, text="", chat_id=0, sender_id=0, message=None):
+        self.text = text or ""
+        self.chat_id = chat_id or 0
+        self.sender_id = sender_id or 0
+        self.message = message
+
+class ChatAction:
+    def __init__(self, chat_id=0, user_id=0, user_joined=False, user_left=False):
+        self.chat_id = chat_id or 0
+        self.user_id = user_id or 0
+        self.user_joined = user_joined or False
+        self.user_left = user_left or False

sorocore-1.0.0/sorocore.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: sorocore
+Version: 1.0.0
+Summary: Core library for Soroush Plus
+Author: SoroCore Team
+Author-email: sorocore@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: splusthon>=1.1.4
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SoroCore
+
+**Core library for Soroush Plus**
+
+## نصب
+
+```bash
+pip install sorocore
+```
+
+## مثال
+
+```python
+from sorocore import SoroCoreClient, NewMessage
+import asyncio
+
+client = SoroCoreClient("my_session")
+
+@client.on(NewMessage)
+async def handler(event):
+    if event.text == "س":
+        await event.reply("س")
+
+async def main():
+    await client.start()
+    await client.run_until_disconnected()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## مجوز
+
+MIT

sorocore-1.0.0/sorocore.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.cfg
+setup.py
+rouba_backup/__init__.py
+rouba_backup/client.py
+rouba_backup/client_backup.py
+rouba_backup/events.py
+sorocore/__init__.py
+sorocore/client.py
+sorocore/events.py
+sorocore.egg-info/PKG-INFO
+sorocore.egg-info/SOURCES.txt
+sorocore.egg-info/dependency_links.txt
+sorocore.egg-info/requires.txt
+sorocore.egg-info/top_level.txt

sorocore-1.0.0/sorocore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sorocore-1.0.0/sorocore.egg-info/requires.txt

@@ -0,0 +1 @@
+splusthon>=1.1.4

sorocore-1.0.0/sorocore.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+rouba_backup
+sorocore