rubkey 1.0.2__py3-none-any.whl

rubkey/__init__.py

@@ -0,0 +1,7 @@
+from .bot import Bot as Rubkey
+from .types import Message
+from .keyboards import Keypad, KeyButton
+
+__version__ = "1.0.2"
+__author__ = "taha ansarianpour"
+__all__ = ["Rubkey", "Message", "Keypad", "KeyButton"]

rubkey/bot.py

@@ -0,0 +1,221 @@
+import requests
+import json
+import time
+import threading
+import os
+from .types import Message
+
+class Bot:
+    def __init__(self, token, session_file=None):
+        self.token = token
+        self.api_url = f"https://botapi.rubika.ir/v3/{token}"
+        self.handlers = {}
+        self.button_handlers = {}
+        self.default_handler = None
+        self._running = False
+        self.session_file = session_file
+        self.offset = None
+        self.ADMIN_ID = None
+        self.ADMIN_PASSWORD = None
+        self.admin_handlers = {}
+        self.admin_button_handlers = {}
+        self.admin_default_handler = None
+        self.admin_verified = set()
+        if session_file:
+            self.session_file = session_file if session_file.endswith('.rubkey') else f"{session_file}.rubkey"
+            self._load_offset()
+    def _api(self, method, data=None):
+        if data is None:
+            data = {}
+        try:
+            r = requests.post(f"{self.api_url}/{method}", json=data, timeout=30)
+            if r.status_code == 200 and r.text.strip():
+                return r.json()
+        except Exception as e:
+            print(f"API Error: {e}")
+        return {}
+    def _load_offset(self):
+        if self.session_file and os.path.exists(self.session_file):
+            try:
+                with open(self.session_file, "r") as f:
+                    data = f.read().strip()
+                    self.offset = data if data else None
+            except:
+                pass
+    def _save_offset(self):
+        if self.session_file and self.offset:
+            try:
+                with open(self.session_file, "w") as f:
+                    f.write(str(self.offset))
+            except:
+                pass
+    def _is_admin(self, msg):
+        if self.ADMIN_ID:
+            if msg.sender_id == self.ADMIN_ID or msg.chat_id == self.ADMIN_ID:
+                return True
+        if self.ADMIN_PASSWORD:
+            if msg.sender_id in self.admin_verified:
+                return True
+        return False
+    def get_updates(self, limit=10):
+        body = {"limit": limit}
+        if self.offset:
+            body["offset_id"] = self.offset
+        result = self._api("getUpdates", body)
+        data = result.get("data", result)
+        if data.get("next_offset_id"):
+            self.offset = data["next_offset_id"]
+            self._save_offset()
+        updates = []
+        for update in data.get("updates", []):
+            msg_data = update.get("new_message") or update.get("updated_message")
+            if msg_data:
+                msg_data["chat_id"] = update.get("chat_id", "")
+                updates.append(Message(msg_data, bot=self))
+        return updates
+    def poll_updates(self, limit=10, sleep=1):
+        print("Please wait...")
+        if self.offset:
+            while True:
+                result = self._api("getUpdates", {"limit": 50, "offset_id": self.offset})
+                data = result.get("data", result)
+                updates = data.get("updates", [])
+                if not updates:
+                    break
+                if data.get("next_offset_id"):
+                    self.offset = data["next_offset_id"]
+                else:
+                    break
+        else:
+            result = self._api("getUpdates", {"limit": 1})
+            data = result.get("data", result)
+            if data.get("next_offset_id"):
+                self.offset = data["next_offset_id"]
+                while True:
+                    result = self._api("getUpdates", {"limit": 50, "offset_id": self.offset})
+                    data = result.get("data", result)
+                    updates = data.get("updates", [])
+                    if not updates:
+                        break
+                    if data.get("next_offset_id"):
+                        self.offset = data["next_offset_id"]
+                    else:
+                        break
+        self._save_offset()
+        print("Rubkey bot run...")
+        self._running = True
+        while self._running:
+            try:
+                updates = self.get_updates(limit=limit)
+                for update in updates:
+                    threading.Thread(target=self._process_message, args=(update._data,), daemon=True).start()
+                time.sleep(sleep)
+            except KeyboardInterrupt:
+                print("\nBot stopped.")
+                break
+            except Exception as e:
+                print(f"Error: {e}")
+                time.sleep(2)
+    def send_message(self, chat_id, text, keypad=None, reply_to=None):
+        data = {"chat_id": chat_id, "text": text}
+        if keypad:
+            data["chat_keypad_type"] = "New"
+            data["chat_keypad"] = keypad.to_dict()
+        if reply_to:
+            data["reply_to_message_id"] = reply_to
+        result = self._api("sendMessage", data)
+        return result.get("data", result)
+    def edit_message(self, chat_id, message_id, text):
+        result = self._api("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
+        return result.get("data", result)
+    def delete_message(self, chat_id, message_id):
+        result = self._api("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
+        return result.get("data", result)
+    def send_poll(self, chat_id, question, options):
+        result = self._api("sendPoll", {"chat_id": chat_id, "question": question, "options": options})
+        return result.get("data", result)
+    def get_chat(self, chat_id):
+        result = self._api("getChat", {"chat_id": chat_id})
+        return result.get("data", result)
+    def get_me(self):
+        result = self._api("getMe", {})
+        return result.get("data", result)
+    def remove_keypad(self, chat_id):
+        result = self._api("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
+        return result.get("data", result)
+    def edit_chat_keypad(self, chat_id, keypad):
+        result = self._api("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": keypad.to_dict()})
+        return result.get("data", result)
+    def set_commands(self, commands):
+        result = self._api("setCommands", {"bot_commands": commands})
+        return result.get("data", result)
+    def delete_commands(self):
+        result = self._api("setCommands", {"bot_commands": []})
+        return result.get("data", result)
+    def command(self, name):
+        def decorator(func):
+            self.handlers[name] = func
+            return func
+        return decorator
+    def on_message(self):
+        def decorator(func):
+            self.default_handler = func
+            return func
+        return decorator
+    def on_button(self, button_id):
+        def decorator(func):
+            self.button_handlers[button_id] = func
+            return func
+        return decorator
+    def admin_command(self, name):
+        def decorator(func):
+            self.admin_handlers[name] = func
+            return func
+        return decorator
+    def admin_on_message(self):
+        def decorator(func):
+            self.admin_default_handler = func
+            return func
+        return decorator
+    def admin_on_button(self, button_id):
+        def decorator(func):
+            self.admin_button_handlers[button_id] = func
+            return func
+        return decorator
+    def _process_message(self, msg_data):
+        msg = Message(msg_data, bot=self)
+        text = (msg.text or "").strip()
+        button_id = msg.button_id
+        if self.ADMIN_PASSWORD and text == self.ADMIN_PASSWORD:
+            self.admin_verified.add(msg.sender_id)
+            return
+        if self._is_admin(msg):
+            if button_id and button_id in self.admin_button_handlers:
+                self.admin_button_handlers[button_id](msg)
+                return
+            if text.startswith("/"):
+                cmd = text[1:].split()[0]
+                if cmd in self.admin_handlers:
+                    self.admin_handlers[cmd](msg)
+                    return
+            if text in self.admin_handlers:
+                self.admin_handlers[text](msg)
+                return
+            if self.admin_default_handler:
+                self.admin_default_handler(msg)
+                return
+        if button_id and button_id in self.button_handlers:
+            self.button_handlers[button_id](msg)
+            return
+        if text.startswith("/"):
+            cmd = text[1:].split()[0]
+            if cmd in self.handlers:
+                self.handlers[cmd](msg)
+                return
+        if text in self.handlers:
+            self.handlers[text](msg)
+            return
+        if self.default_handler:
+            self.default_handler(msg)
+    def run(self):
+        self.poll_updates()

rubkey/keyboards.py

@@ -0,0 +1,26 @@
+class KeyButton:
+    def __init__(self, button_id, text, button_type="Simple"):
+        self.id = button_id
+        self.text = text
+        self.type = button_type
+    
+    def to_dict(self):
+        return {"id": self.id, "type": self.type, "button_text": self.text}
+
+
+class Keypad:
+    def __init__(self, resize=True, one_time=False):
+        self.rows = []
+        self.resize = resize
+        self.one_time = one_time
+    
+    def add_row(self, *buttons):
+        self.rows.append(list(buttons))
+        return self
+    
+    def to_dict(self):
+        return {
+            "rows": [{"buttons": [btn.to_dict() for btn in row]} for row in self.rows],
+            "resize_keyboard": self.resize,
+            "one_time_keyboard": self.one_time
+        }

rubkey/types.py

@@ -0,0 +1,31 @@
+class Message:
+    def __init__(self, data, bot=None):
+        self._data = data
+        self._bot = bot
+        self.chat_id = data.get("chat_id", "")
+        self.text = data.get("text", "")
+        self.message_id = data.get("message_id", "")
+        self.sender_id = data.get("sender_id", "")
+        self.time = data.get("time", 0)
+        self.is_edited = data.get("is_edited", False)
+        self.poll = data.get("poll")
+        self.location = data.get("location")
+        self.contact = data.get("contact_message")
+        self.aux_data = data.get("aux_data", {})
+        self.reply_to_message_id = data.get("reply_to_message_id", "")
+    @property
+    def button_id(self):
+        return self.aux_data.get("button_id", "") if self.aux_data else ""
+    def reply(self, text, keypad=None):
+        if self._bot:
+            result = self._bot.send_message(self.chat_id, text, keypad=keypad, reply_to=self.message_id)
+            result["chat_id"] = self.chat_id
+            return Message(result, bot=self._bot)
+    def edit(self, text):
+        if self._bot:
+            return self._bot.edit_message(self.chat_id, self.message_id, text)
+    def delete(self):
+        if self._bot:
+            return self._bot.delete_message(self.chat_id, self.message_id)
+    def __repr__(self):
+        return f"<Message id={self.message_id} text='{str(self.text)[:30]}'>"

rubkey-1.0.2.dist-info/METADATA

@@ -0,0 +1,400 @@
+Metadata-Version: 2.4
+Name: rubkey
+Version: 1.0.2
+Summary: Rubika Bot API library - Simple and powerful bot framework for Rubika messenger
+Author: taha ansarianpour
+Author-email: codetansarian@gmail.com
+License: MIT
+Keywords: rubika bot rubkey messenger api
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Rubika Bot API Libraryary for Rubika Bot API with all features.
+
+
+Quick Start
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+for update in bot.poll_updates():
+    if update.new_message and update.new_message.text == "/start":
+        bot.send_message(update.chat_id, "Hello!")
+```
+
+Features
+
+· Send text, poll, location, contact, file
+· Inline and chat keypad with all button types (Selection, Calendar, NumberPicker, StringPicker, Textbox, Location, Camera, Gallery, File, Audio, Link, AskMyPhoneNumber, AskMyLocation, Barcode)
+· Metadata for text formatting (Bold, Italic, Mono, Underline, Strike, Spoiler, Link, Mention, Pre, Quote)
+· Group management (ban, unban, delete messages)
+· Polling updates with auto offset management
+· Edit messages and keypads
+· Forward messages
+· Get chat information
+· Upload and send files
+· Webhook support
+· Auto skip old messages on start
+
+Examples
+
+Send simple message
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.send_message("chat_id", "Hello World")
+```
+
+Send message with inline keypad
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad
+from rubkey.enums import ButtonType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+button1 = Button("btn1", "Click Me", ButtonType.SIMPLE)
+button2 = Button("btn2", "Cancel", ButtonType.SIMPLE)
+
+keypad = InlineKeypad().add_row(button1, button2)
+
+bot.send_message("chat_id", "Choose an option:", inline_keypad=keypad)
+```
+
+Send message with metadata formatting
+
+```python
+from rubkey import Rubkey, Metadata, MetadataPart
+from rubkey.enums import MetadataType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+metadata = Metadata()
+metadata.add_part(MetadataPart(MetadataType.BOLD, 0, 5))
+metadata.add_part(MetadataPart(MetadataType.ITALIC, 6, 4))
+
+bot.send_message("chat_id", "Hello Dear User", metadata=metadata)
+```
+
+Send poll
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.send_poll("chat_id", "Do you like Rubkey?", ["Yes", "No", "Maybe"])
+```
+
+Send location
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.send_location("chat_id", "35.6892", "51.3890")
+```
+
+Send contact
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.send_contact("chat_id", "John", "09123456789", "Doe")
+```
+
+Send file
+
+```python
+from rubkey import Rubkey
+from rubkey.enums import FileType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+result = bot.request_send_file(FileType.IMAGE)
+upload_url = result.get("upload_url")
+
+with open("photo.jpg", "rb") as f:
+    files = {"file": f}
+    response = requests.post(upload_url, files=files)
+    file_data = response.json().get("data", {})
+    file_id = file_data.get("file_id")
+
+bot.send_file("chat_id", file_id, "Check this photo!")
+```
+
+Group management
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+bot.ban_chat_member("group_id", "user_id")
+bot.unban_chat_member("group_id", "user_id")
+bot.delete_message("group_id", "message_id")
+```
+
+Edit message
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.edit_message_text("chat_id", "message_id", "New text content")
+```
+
+Forward message
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.forward_message("from_chat_id", "to_chat_id", "message_id")
+```
+
+Set bot commands
+
+```python
+from rubkey import Rubkey, BotCommand
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+commands = [
+    BotCommand("start", "Start the bot"),
+    BotCommand("help", "Get help"),
+    BotCommand("about", "About this bot")
+]
+
+bot.set_commands(commands)
+```
+
+Get updates manually
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+updates = bot.get_updates(limit=10)
+for update in updates:
+    if update.new_message:
+        print(update.new_message.text)
+```
+
+Poll updates continuously
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+for update in bot.poll_updates(limit=10, sleep=1):
+    if update.new_message:
+        msg = update.new_message
+        if msg.text == "/start":
+            bot.send_message(update.chat_id, "Welcome!")
+```
+
+Advanced Examples
+
+Button with selection list
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad
+from rubkey.enums import ButtonType, SelectionType, SelectionSearch, SelectionGet
+from rubkey.keypad import ButtonSelectionItem
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+items = [
+    ButtonSelectionItem("Option 1"),
+    ButtonSelectionItem("Option 2"),
+    ButtonSelectionItem("Option 3")
+]
+
+button = Button("select_btn", "Choose Option", ButtonType.SELECTION)
+button.set_selection(
+    selection_id="menu_1",
+    items=[item.to_dict() for item in items],
+    search_type=SelectionSearch.LOCAL,
+    get_type=SelectionGet.LOCAL,
+    is_multi_selection=False,
+    columns_count="1",
+    title="Select an option"
+)
+
+keypad = InlineKeypad().add_row(button)
+bot.send_message("chat_id", "Please select:", inline_keypad=keypad)
+```
+
+Button with calendar
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad
+from rubkey.enums import ButtonType, CalendarType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+button = Button("date_btn", "Select Date", ButtonType.CALENDAR)
+button.set_calendar(
+    title="Choose a date",
+    default_value="1400-01-01",
+    calendar_type=CalendarType.PERSIAN,
+    min_year="1390",
+    max_year="1410"
+)
+
+keypad = InlineKeypad().add_row(button)
+bot.send_message("chat_id", "Select your birth date:", inline_keypad=keypad)
+```
+
+Button with number picker
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad
+from rubkey.enums import ButtonType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+button = Button("num_btn", "Select Quantity", ButtonType.NUMBER_PICKER)
+button.set_number_picker(
+    title="Choose quantity",
+    min_value=1,
+    max_value=100,
+    default_value=10
+)
+
+keypad = InlineKeypad().add_row(button)
+bot.send_message("chat_id", "How many items?", inline_keypad=keypad)
+```
+
+Button with textbox
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad
+from rubkey.enums import ButtonType, TextboxLineType, TextboxKeypadType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+button = Button("text_btn", "Write Message", ButtonType.TEXTBOX)
+button.set_textbox(
+    title="Enter your message",
+    place_holder="Type here...",
+    default_value="Hello",
+    type_line=TextboxLineType.MULTI_LINE,
+    type_keypad=TextboxKeypadType.STRING
+)
+
+keypad = InlineKeypad().add_row(button)
+bot.send_message("chat_id", "Please write your message:", inline_keypad=keypad)
+```
+
+Button with location picker
+
+```python
+from rubkey import Rubkey, Button, InlineKeypad, Location
+from rubkey.enums import ButtonType, LocationType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+default_location = Location({"latitude": "35.6892", "longitude": "51.3890"})
+
+button = Button("loc_btn", "Select Location", ButtonType.LOCATION)
+button.set_location(
+    title="Pick a location",
+    default_pointer_location=default_location,
+    default_map_location=default_location,
+    location_type=LocationType.PICKER
+)
+
+keypad = InlineKeypad().add_row(button)
+bot.send_message("chat_id", "Please select your location:", inline_keypad=keypad)
+```
+
+Chat keypad (keyboard at bottom)
+
+```python
+from rubkey import Rubkey, Button, ChatKeypad
+from rubkey.enums import ButtonType
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+
+button1 = Button("btn1", "Option A", ButtonType.SIMPLE)
+button2 = Button("btn2", "Option B", ButtonType.SIMPLE)
+button3 = Button("btn3", "Option C", ButtonType.SIMPLE)
+
+keypad = ChatKeypad(resize_keyboard=True, one_time_keyboard=False)
+keypad.add_row(button1, button2).add_row(button3)
+
+bot.send_message("chat_id", "Choose an option:", chat_keypad=keypad, chat_keypad_type="New")
+```
+
+Remove chat keypad
+
+```python
+from rubkey import Rubkey
+
+bot = Rubkey("YOUR_BOT_TOKEN")
+bot.remove_chat_keypad("chat_id")
+```
+
+API Reference
+
+Rubkey Class
+
+Method Description
+get_me() Get bot information
+get_updates(limit=10) Get new updates
+poll_updates(limit=10, sleep=1) Generator for continuous polling
+send_message() Send text message with optional keypad and metadata
+send_poll() Send poll
+send_location() Send location
+send_contact() Send contact
+send_file() Send file
+request_send_file(file_type) Get upload URL for file
+upload_file(upload_url, file_path) Upload file to server
+get_file(file_id) Get file download URL
+get_chat(chat_id) Get chat information
+delete_message(chat_id, message_id) Delete message
+edit_message_text(chat_id, message_id, text) Edit message text
+edit_message_keypad(chat_id, message_id, inline_keypad) Edit message keypad
+forward_message(from_chat_id, to_chat_id, message_id) Forward message
+ban_chat_member(chat_id, user_id) Ban user from group
+unban_chat_member(chat_id, user_id) Unban user from group
+set_commands(commands) Set bot commands
+edit_chat_keypad(chat_id, chat_keypad, chat_keypad_type) Edit chat keypad
+remove_chat_keypad(chat_id) Remove chat keypad
+update_bot_endpoints(url, endpoint_type) Update webhook endpoints
+
+License
+
+MIT License (c) 2026 taha ansarianpour

rubkey-1.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+rubkey/__init__.py,sha256=zjSWohDUvoWdBuSqg5YAeGtEVpXAhYVaSN6cJ0wQO5M,209
+rubkey/bot.py,sha256=Bv41kmwgNEwVEJK3FDHUkTEimFPtG87pbijEAIRB5Ww,8738
+rubkey/keyboards.py,sha256=S86YkTwpkkA040dmOVI9-cuGM5EpMS78Fa4vDQf8r7U,754
+rubkey/types.py,sha256=y4044kKhnazhYmVHjAHmLEpjUZsm-ShHA8w92ZwBB1k,1367
+rubkey-1.0.2.dist-info/licenses/LICENSE,sha256=TCZw423S9jZcqyB0Xwq1zYae0-S9XOSRHLYFutHuORk,1073
+rubkey-1.0.2.dist-info/METADATA,sha256=gtLU-7KmdbC6amSDW9D1nqOMfhBphYSmfLdvwHFrKdM,10101
+rubkey-1.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rubkey-1.0.2.dist-info/top_level.txt,sha256=I4H5GVjU4LRf8wxUkeUqZB2zt2yd1gJ1SqXzxMNv9zw,7
+rubkey-1.0.2.dist-info/RECORD,,

rubkey-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rubkey-1.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 taha ansarianpour
+
+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.

rubkey-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+rubkey