ElectronRA 1.0.1__tar.gz

electron-1.0.0/Electron.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: Electron
+Version: 1.0.0
+Summary: A powerful Python library for Rubika bots
+Author: Your Name
+Requires-Python: >=3.7
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

electron-1.0.0/Electron.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+setup.py
+Electron.egg-info/PKG-INFO
+Electron.egg-info/SOURCES.txt
+Electron.egg-info/dependency_links.txt
+Electron.egg-info/requires.txt
+Electron.egg-info/top_level.txt
+electron/__init__.py
+electron/bot.py
+electron/client.py
+electron/filters.py
+electron/handlers.py
+electron/real_client.py
+electron/types.py
+electron/methods/__init__.py

electron-1.0.0/Electron.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

electron-1.0.0/Electron.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp>=3.8.0
+requests>=2.28.0

electron-1.0.0/Electron.egg-info/top_level.txt

@@ -0,0 +1 @@
+electron

electron-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: Electron
+Version: 1.0.0
+Summary: A powerful Python library for Rubika bots
+Author: Your Name
+Requires-Python: >=3.7
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

electron-1.0.0/README.md

@@ -0,0 +1,59 @@
+# Electron
+
+Powerful Python library for Rubika bots - Dual Mode (Bot + Self)
+
+## Features
+
+- Dual Mode - Bot Token & Self Session
+- Async/Await - High performance
+- Simple decorator-based API
+- Advanced handler system
+- Fully independent
+
+## Install
+
+```bash
+pip install Electron
+from electron import Bot
+
+# Bot mode
+bot = Bot(token="YOUR_TOKEN")
+# OR Self mode
+bot = Bot(session="my_account")
+
+@bot.on_command("start")
+async def start(message):
+    await message.reply("Hello!")
+
+bot.run()
+
+### ۲. آپدیت setup.py:
+
+```bash
+cat > setup.py << 'ENDOFFILE'
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="Electron",
+    version="1.0.0",
+    author="Your Name",
+    author_email="your@email.com",
+    description="Powerful Python library for Rubika bots - Dual Mode",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/Electron",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "aiohttp>=3.8.0",
+        "requests>=2.28.0",
+    ],
+)

electron-1.0.0/electron/__init__.py

@@ -0,0 +1,16 @@
+"""
+Electron - کتابخونه قدرتمند پایتون برای ساخت ربات‌های روبیکا
+پشتیبانی از Bot Token و Self Session
+"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+
+from .bot import Bot
+from .types import Message, Chat, User, MessageType
+from .handlers import (
+    Handler, MessageHandler, CommandHandler,
+    PhotoHandler, VideoHandler, VoiceHandler
+)
+from .filters import Filters
+from .client import create_client, BotClient, SelfClient

electron-1.0.0/electron/bot.py

@@ -0,0 +1,171 @@
+import asyncio
+import logging
+from typing import Optional, Callable, List, Dict, Any, Union
+from .client import create_client, BotClient, SelfClient, BaseClient
+from .types import Message, Chat, User, MessageType
+from .handlers import (
+    Handler, MessageHandler, CommandHandler, 
+    PhotoHandler, VideoHandler, VoiceHandler, DocumentHandler
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Bot:
+    def __init__(self, token: str = None, session: str = None, parse_mode: str = None):
+        if not token and not session:
+            raise ValueError("Either 'token' or 'session' must be provided!")
+        
+        self.client: BaseClient = create_client(token=token, session=session)
+        self.token = token
+        self.session_name = session
+        self.handlers: List[Handler] = []
+        self._running = False
+        self._me = None
+        self.parse_mode = parse_mode
+        
+        self.is_bot = token is not None
+        self.is_self = session is not None
+        
+        if self.is_bot:
+            logger.info("Bot mode: Ready")
+        else:
+            logger.info("Self mode: Ready")
+    
+    @property
+    async def me(self) -> Dict:
+        if not self._me:
+            self._me = await self.client.get_me()
+        return self._me
+    
+    @property
+    def mode(self) -> str:
+        return "bot" if self.is_bot else "self"
+    
+    def on_message(self, callback: Callable = None):
+        def decorator(func):
+            handler = MessageHandler(func)
+            self.handlers.append(handler)
+            return func
+        if callback:
+            return decorator(callback)
+        return decorator
+    
+    def on_command(self, command: str, prefix: str = "/"):
+        def decorator(func):
+            handler = CommandHandler(command, func, prefix)
+            self.handlers.append(handler)
+            return func
+        return decorator
+    
+    def on_photo(self, callback: Callable = None):
+        def decorator(func):
+            handler = PhotoHandler(func)
+            self.handlers.append(handler)
+            return func
+        if callback:
+            return decorator(callback)
+        return decorator
+    
+    def on_video(self, callback: Callable = None):
+        def decorator(func):
+            handler = VideoHandler(func)
+            self.handlers.append(handler)
+            return func
+        if callback:
+            return decorator(callback)
+        return decorator
+    
+    def on_voice(self, callback: Callable = None):
+        def decorator(func):
+            handler = VoiceHandler(func)
+            self.handlers.append(handler)
+            return func
+        if callback:
+            return decorator(callback)
+        return decorator
+    
+    def on_document(self, callback: Callable = None):
+        def decorator(func):
+            handler = DocumentHandler(func)
+            self.handlers.append(handler)
+            return func
+        if callback:
+            return decorator(callback)
+        return decorator
+    
+    async def _process_update(self, update: Dict):
+        try:
+            message = Message(
+                message_id=update.get("message_id", ""),
+                chat=Chat(**update.get("chat", {})),
+                from_user=User(**update.get("from", {})) if update.get("from") else None,
+                text=update.get("text"),
+                message_type=MessageType(update.get("message_type", "text")),
+                date=update.get("date"),
+                _client=self.client
+            )
+            
+            for handler in self.handlers:
+                try:
+                    if await handler.check(message):
+                        await handler.execute(message)
+                except Exception as e:
+                    logger.error(f"Handler error: {e}")
+                    
+        except Exception as e:
+            logger.error(f"Update error: {e}")
+    
+    async def start(self, poll_interval: float = 1.0):
+        self._running = True
+        logger.info(f"Electron starting in {self.mode} mode...")
+        
+        try:
+            await self.client.connect()
+            me = await self.me
+            logger.info(f"Connected as: {me}")
+        except Exception as e:
+            logger.error(f"Connection failed: {e}")
+            return
+        
+        logger.info(f"Listening for updates...")
+        
+        while self._running:
+            try:
+                updates = await self.client.get_updates()
+                for update in updates:
+                    await self._process_update(update)
+                await asyncio.sleep(poll_interval)
+            except Exception as e:
+                logger.error(f"Polling error: {e}")
+                await asyncio.sleep(5)
+    
+    def stop(self):
+        self._running = False
+        asyncio.create_task(self.client.close())
+        logger.info("Bot stopped")
+    
+    def run(self):
+        try:
+            print("=" * 40)
+            print(f"  Electron v1.0.0 - {self.mode.upper()}")
+            print("=" * 40)
+            asyncio.run(self.start())
+        except KeyboardInterrupt:
+            logger.info("Goodbye!")
+    
+    async def send_message(self, chat_id: str, text: str, reply_to: str = None, **kwargs):
+        return await self.client.send_message(chat_id, text, reply_to)
+    
+    async def reply_to(self, message: Message, text: str):
+        return await self.send_message(
+            chat_id=message.chat.chat_id,
+            text=text,
+            reply_to=message.message_id
+        )
+    
+    def add_handler(self, handler: Handler):
+        self.handlers.append(handler)
+    
+    def clear_handlers(self):
+        self.handlers.clear()

electron-1.0.0/electron/client.py

@@ -0,0 +1,225 @@
+"""
+کلاینت اصلی Electron
+پشتیبانی از دو حالت: Bot Token و User Session
+"""
+import asyncio
+import aiohttp
+import json
+import logging
+from typing import Optional, Dict, Any, List, Union
+
+logger = logging.getLogger(__name__)
+
+class BaseClient:
+    """کلاس پایه برای هر دو نوع کلاینت"""
+    
+    HEADERS = {
+        "user-agent": "okhttp/3.12.1",
+        "content-type": "application/json",
+    }
+    
+    def __init__(self):
+        self.session = None
+        self.api_url = None
+        self.connected = False
+        self.auth_token = None
+        self.is_bot = False
+        self.is_self = False
+        
+    async def _get_dcs(self) -> str:
+        """دریافت آدرس سرور روبیکا"""
+        urls = [
+            "https://getdcs.rubika.ir/",
+            "https://d3.im/",
+        ]
+        
+        for url in urls:
+            try:
+                connector = aiohttp.TCPConnector(ssl=False)
+                async with aiohttp.ClientSession(connector=connector, headers=self.HEADERS) as session:
+                    async with session.post(url, json={
+                        "api_version": "5",
+                        "method": "getDcs"
+                    }, ssl=False, timeout=10) as resp:
+                        data = await resp.json()
+                        if data and "data" in data:
+                            dcs = data["data"]
+                            api_url = (dcs.get("messenger_url") or 
+                                      dcs.get("api_url") or 
+                                      dcs.get("url"))
+                            if api_url:
+                                return api_url.rstrip("/")
+            except:
+                continue
+        
+        return "https://messengerg2c31.iranlms.ir"
+    
+    async def connect(self) -> bool:
+        """اتصال به روبیکا"""
+        self.api_url = await self._get_dcs()
+        
+        connector = aiohttp.TCPConnector(ssl=False)
+        self.session = aiohttp.ClientSession(
+            connector=connector,
+            headers=self.HEADERS,
+            timeout=aiohttp.ClientTimeout(total=30)
+        )
+        
+        self.connected = True
+        logger.info(f"✅ Connected to: {self.api_url}")
+        return True
+    
+    async def send_request(self, method: str, data: dict = None) -> dict:
+        """ارسال درخواست به API"""
+        if not self.connected:
+            await self.connect()
+        
+        payload = {
+            "api_version": "5",
+            "method": method,
+            "data": data or {}
+        }
+        
+        # اضافه کردن auth_token اگه bot باشه
+        if self.is_bot and self.auth_token:
+            payload["auth"] = self.auth_token
+        
+        try:
+            async with self.session.post(self.api_url, json=payload, ssl=False) as resp:
+                text = await resp.text()
+                try:
+                    return json.loads(text)
+                except:
+                    return {}
+        except Exception as e:
+            logger.error(f"Request error: {e}")
+            return {}
+    
+    async def close(self):
+        if self.session:
+            await self.session.close()
+            self.connected = False
+
+
+class BotClient(BaseClient):
+    """کلاینت ربات (Bot Token)"""
+    
+    def __init__(self, token: str):
+        super().__init__()
+        self.auth_token = token
+        self.is_bot = True
+        self.is_self = False
+    
+    async def get_me(self) -> dict:
+        result = await self.send_request("getUserInfo", {})
+        return result.get("data", {})
+    
+    async def send_message(self, chat_id: str, text: str, reply_to: str = None) -> dict:
+        data = {
+            "object_guid": chat_id,
+            "text": text,
+            "rnd": str(int(asyncio.get_event_loop().time() * 1000))
+        }
+        if reply_to:
+            data["reply_to_message_id"] = reply_to
+        return await self.send_request("sendMessage", data)
+    
+    async def get_updates(self) -> list:
+        result = await self.send_request("getChatsUpdates", {"state": 0})
+        return result.get("data", []) if isinstance(result, dict) else []
+
+
+class SelfClient(BaseClient):
+    """کلاینت سلف (User Session)"""
+    
+    def __init__(self, session_name: str = "self_bot"):
+        super().__init__()
+        self.session_name = session_name
+        self.is_bot = False
+        self.is_self = True
+        self.auth_info = None  # auth, guid, private_key
+        
+    def load_session(self) -> bool:
+        """لود کردن سشن از فایل"""
+        try:
+            with open(f"{self.session_name}.session", "r") as f:
+                data = json.load(f)
+                self.auth_info = data
+                return True
+        except FileNotFoundError:
+            logger.warning(f"Session {self.session_name}.session not found")
+            return False
+    
+    def save_session(self):
+        """ذخیره سشن تو فایل"""
+        if self.auth_info:
+            with open(f"{self.session_name}.session", "w") as f:
+                json.dump(self.auth_info, f)
+            logger.info(f"Session saved: {self.session_name}.session")
+    
+    async def login(self, phone: str = None, code: str = None) -> bool:
+        """ورود با شماره موبایل"""
+        if phone and not code:
+            # ارسال کد
+            result = await self.send_request("sendCode", {
+                "phone_number": phone
+            })
+            logger.info(f"Code sent: {result}")
+            return True
+        
+        elif phone and code:
+            # تایید کد
+            result = await self.send_request("signIn", {
+                "phone_number": phone,
+                "phone_code_hash": "",  
+                "phone_code": code
+            })
+            if result and "data" in result:
+                self.auth_info = result["data"]
+                self.save_session()
+                return True
+        
+        return False
+    
+    async def get_me(self) -> dict:
+        result = await self.send_request("getUserInfo", {})
+        return result.get("data", {})
+    
+    async def send_message(self, chat_id: str, text: str, reply_to: str = None) -> dict:
+        data = {
+            "object_guid": chat_id,
+            "text": text,
+            "rnd": str(int(asyncio.get_event_loop().time() * 1000))
+        }
+        if reply_to:
+            data["reply_to_message_id"] = reply_to
+        return await self.send_request("sendMessage", data)
+    
+    async def get_updates(self) -> list:
+        result = await self.send_request("getChatsUpdates", {"state": 0})
+        return result.get("data", []) if isinstance(result, dict) else []
+
+
+def create_client(token: str = None, session: str = None) -> BaseClient:
+    """
+    ساخت کلاینت مناسب بر اساس نوع ورودی
+    
+    Args:
+        token: توکن ربات
+        session: نام فایل سشن
+        
+    Returns:
+        BotClient یا SelfClient
+    """
+    if token:
+        logger.info("??? Bot mode activated")
+        return BotClient(token)
+    elif session:
+        client = SelfClient(session)
+        if client.load_session():
+            logger.info("??? Self mode activated (session loaded)")
+        else:
+            logger.info("??? Self mode activated (new session)")
+        return client
+    else:
+        raise ValueError("Either token or session must be provided")

electron-1.0.0/electron/filters.py

@@ -0,0 +1,32 @@
+from typing import List, Callable
+from .types import Message, MessageType
+
+class Filters:
+    @staticmethod
+    def text(message: Message) -> bool:
+        return message.message_type == MessageType.TEXT
+    
+    @staticmethod
+    def photo(message: Message) -> bool:
+        return message.message_type == MessageType.PHOTO
+    
+    @staticmethod
+    def video(message: Message) -> bool:
+        return message.message_type == MessageType.VIDEO
+    
+    @staticmethod
+    def voice(message: Message) -> bool:
+        return message.message_type == MessageType.VOICE
+    
+    @staticmethod
+    def reply(message: Message) -> bool:
+        return message.reply_to_message is not None
+    
+    @staticmethod
+    def command(commands: List[str]) -> Callable:
+        def filter_func(message: Message) -> bool:
+            if not message.text or not message.text.startswith('/'):
+                return False
+            cmd = message.text.split()[0][1:]
+            return cmd in commands
+        return filter_func

electron-1.0.0/electron/handlers.py

@@ -0,0 +1,62 @@
+from typing import Callable, Any
+from .types import Message, MessageType
+import re
+import asyncio
+
+class Handler:
+    def __init__(self, callback: Callable, **filters):
+        self.callback = callback
+        self.filters = filters
+    
+    async def check(self, message: Message) -> bool:
+        return True
+    
+    async def execute(self, message: Message) -> Any:
+        if asyncio.iscoroutinefunction(self.callback):
+            return await self.callback(message)
+        return self.callback(message)
+
+class MessageHandler(Handler):
+    async def check(self, message: Message) -> bool:
+        return message.message_type == MessageType.TEXT and message.text is not None
+
+class CommandHandler(Handler):
+    def __init__(self, command: str, callback: Callable, prefix: str = "/"):
+        super().__init__(callback)
+        self.command = command
+        self.prefix = prefix
+    
+    async def check(self, message: Message) -> bool:
+        if message.text and message.text.startswith(self.prefix):
+            command_part = message.text.split()[0][len(self.prefix):]
+            return command_part.lower() == self.command.lower()
+        return False
+
+class RegexHandler(Handler):
+    def __init__(self, pattern: str, callback: Callable):
+        super().__init__(callback)
+        self.pattern = re.compile(pattern)
+    
+    async def check(self, message: Message) -> bool:
+        return bool(message.text and self.pattern.search(message.text))
+    
+    async def execute(self, message: Message) -> Any:
+        match = self.pattern.search(message.text)
+        message.match = match
+        return await super().execute(message)
+
+class PhotoHandler(Handler):
+    async def check(self, message: Message) -> bool:
+        return message.message_type == MessageType.PHOTO
+
+class VideoHandler(Handler):
+    async def check(self, message: Message) -> bool:
+        return message.message_type == MessageType.VIDEO
+
+class VoiceHandler(Handler):
+    async def check(self, message: Message) -> bool:
+        return message.message_type == MessageType.VOICE
+
+class DocumentHandler(Handler):
+    async def check(self, message: Message) -> bool:
+        return message.message_type == MessageType.DOCUMENT

electron-1.0.0/electron/real_client.py

@@ -0,0 +1,121 @@
+"""
+کلاینت واقعی Electron با استفاده از aiohttp
+مستقل و قدرتمند - بدون وابستگی به rubpy
+"""
+import asyncio
+import aiohttp
+import json
+import logging
+from typing import Optional, Dict, Any, List
+
+logger = logging.getLogger(__name__)
+
+class RealRubikaClient:
+    """کلاینت واقعی روبیکا با aiohttp"""
+    
+    HEADERS = {
+        "origin": "https://m.rubika.ir",
+        "referer": "https://m.rubika.ir/",
+        "content-type": "application/json",
+        "connection": "keep-alive",
+        "user-agent": "okhttp/3.12.1"
+    }
+    
+    def __init__(self, auth_token: str):
+        self.auth_token = auth_token
+        self.session = None
+        self.api_url = "https://messenger.rubika.ir/"
+        self.connected = False
+        
+    async def connect(self):
+        """اتصال به روبیکا"""
+        connector = aiohttp.TCPConnector(verify_ssl=False)
+        self.session = aiohttp.ClientSession(
+            connector=connector,
+            headers=self.HEADERS,
+            timeout=aiohttp.ClientTimeout(total=30)
+        )
+        
+        # تست اتصال
+        try:
+            async with self.session.get(
+                "https://messenger.rubika.ir/",
+                ssl=False
+            ) as resp:
+                if resp.status == 200:
+                    self.connected = True
+                    logger.info("✅ به روبیکا متصل شد!")
+                    return True
+        except Exception as e:
+            logger.error(f"❌ خطای اتصال: {e}")
+            
+        return False
+    
+    async def send_request(self, method: str, data: dict) -> dict:
+        """ارسال درخواست به API"""
+        if not self.connected:
+            await self.connect()
+            
+        url = f"{self.api_url}api/{method}"
+        
+        payload = {
+            "api_version": "5",
+            "auth": self.auth_token,
+            "data": data,
+            "method": method
+        }
+        
+        try:
+            async with self.session.post(url, json=payload, ssl=False) as resp:
+                result = await resp.json()
+                return result.get("data", {})
+        except Exception as e:
+            logger.error(f"Request error: {e}")
+            return {}
+    
+    async def get_me(self) -> dict:
+        return await self.send_request("getUserInfo", {})
+    
+    async def send_message(self, chat_id: str, text: str, reply_to: str = None) -> dict:
+        data = {
+            "object_guid": chat_id,
+            "text": text
+        }
+        if reply_to:
+            data["reply_to_message_id"] = reply_to
+            
+        return await self.send_request("sendMessage", data)
+    
+    async def get_updates(self, limit: int = 10) -> list:
+        result = await self.send_request("getChatsUpdates", {
+            "state": 0
+        })
+        return result if isinstance(result, list) else []
+    
+    async def close(self):
+        if self.session:
+            await self.session.close()
+            self.connected = False
+
+# تست
+async def test():
+    TOKEN = "BHBAHF0PYXRCYQWUDIGELJPUNRCEXXBUYLMQHJFILWKMEOYWXACICRLKKZZRIMVB"
+    
+    client = RealRubikaClient(TOKEN)
+    
+    print("??? Connecting...")
+    if await client.connect():
+        print("✅ Connected!")
+        
+        print("\n??? Testing get_me...")
+        me = await client.get_me()
+        print(f"Result: {me}")
+        
+        print("\n??? Testing get_updates...")
+        updates = await client.get_updates()
+        print(f"Updates: {len(updates)} found")
+        
+        await client.close()
+
+if __name__ == "__main__":
+    asyncio.run(test())

electron-1.0.0/electron/types.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+from enum import Enum
+
+class MessageType(Enum):
+    TEXT = "text"
+    PHOTO = "photo"
+    VIDEO = "video"
+    VOICE = "voice"
+    DOCUMENT = "document"
+    STICKER = "sticker"
+
+@dataclass
+class User:
+    user_id: str
+    username: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    phone: Optional[str] = None
+    bio: Optional[str] = None
+    
+    @property
+    def full_name(self) -> str:
+        if self.first_name and self.last_name:
+            return f"{self.first_name} {self.last_name}"
+        return self.first_name or self.username or "Unknown"
+
+@dataclass
+class Chat:
+    chat_id: str
+    type: str = "private"
+    title: Optional[str] = None
+    username: Optional[str] = None
+    members_count: Optional[int] = None
+
+@dataclass
+class Message:
+    message_id: str
+    chat: Chat
+    from_user: Optional[User] = None
+    text: Optional[str] = None
+    message_type: MessageType = MessageType.TEXT
+    reply_to_message: Optional['Message'] = None
+    file_id: Optional[str] = None
+    caption: Optional[str] = None
+    date: Optional[int] = None
+    _client: Any = None
+    
+    def reply(self, text: str, **kwargs):
+        if self._client:
+            return self._client.send_message(
+                chat_id=self.chat.chat_id,
+                text=text,
+                reply_to_message_id=self.message_id,
+                **kwargs
+            )
+        raise ValueError("Client not set")
+    
+    def delete(self):
+        if self._client:
+            return self._client.delete_message(
+                chat_id=self.chat.chat_id,
+                message_id=self.message_id
+            )
+        raise ValueError("Client not set")
+    
+    def edit(self, new_text: str):
+        if self._client:
+            return self._client.edit_message(
+                chat_id=self.chat.chat_id,
+                message_id=self.message_id,
+                text=new_text
+            )
+        raise ValueError("Client not set")

electron-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.backends._legacy:_Backend"

electron-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

electron-1.0.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="Electron",
+    version="1.0.0",
+    author="Your Name",
+    description="A powerful Python library for Rubika bots",
+    packages=find_packages(),
+    install_requires=[
+        "aiohttp>=3.8.0",
+        "requests>=2.28.0",
+    ],
+    python_requires=">=3.7",
+)