Rubka 7.2.8__py3-none-any.whl

rubka/jobs.py

@@ -0,0 +1,15 @@
+import threading
+import time
+from typing import Callable
+
+class Job:
+    def __init__(self, delay: int, callback: Callable):
+        self.delay = delay
+        self.callback = callback
+        thread = threading.Thread(target=self.run)
+        thread.daemon = True
+        thread.start()
+
+    def run(self):
+        time.sleep(self.delay)
+        self.callback()

rubka/keyboards.py

@@ -0,0 +1,16 @@
+from typing import Dict, List
+
+def create_simple_keyboard(buttons: List[List[str]]) -> Dict:
+    """
+    Create a simple chat keypad (keyboard) structure for Rubika.
+    buttons: List of button rows, each row is a list of button texts.
+    Example:
+    [
+        ["Button1", "Button2"],
+        ["Button3"]
+    ]
+    """
+    keyboard = {"rows": []}
+    for row in buttons:
+        keyboard["rows"].append({"buttons": [{"text": text} for text in row]})
+    return keyboard

rubka/keypad.py

@@ -0,0 +1,298 @@
+from typing import Dict
+
+from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
+
+class InlineBuilder:
+    def __init__(self):
+        self.rows: List[Dict] = []
+
+    def row(self, *buttons: Dict) -> "InlineBuilder":
+        """
+        افزودن یک ردیف دکمه به کیبورد
+        حداقل یک دکمه باید داده شود.
+        """
+        if not buttons:
+            raise ValueError("حداقل یک دکمه باید به row داده شود")
+        self.rows.append({"buttons": list(buttons)})
+        return self
+
+    def button_simple(self, id: str, text: str) -> Dict:
+        return {"id": id, "type": "Simple", "button_text": text}
+
+    def button_selection(self, id: str, text: str, selection: Dict) -> Dict:
+        """
+        selection: dict با فیلدهای:
+         - selection_id (str)
+         - search_type (str) [ButtonSelectionSearchEnum: None, Local, Api]
+         - get_type (str) [ButtonSelectionGetEnum: Local, Api]
+         - items (list of ButtonSelectionItem)
+         - is_multi_selection (bool)
+         - columns_count (str)
+         - title (str)
+        """
+        return {
+            "id": id,
+            "type": "Selection",
+            "button_text": text,
+            "button_selection": selection
+        }
+
+    def button_calendar(self, id: str, title: str, type_: str,
+                        default_value: Optional[str] = None,
+                        min_year: Optional[str] = None,
+                        max_year: Optional[str] = None) -> Dict:
+        """
+        type_: ButtonCalendarTypeEnum = "DatePersian" | "DateGregorian"
+        """
+        calendar = {
+            "title": title,
+            "type": type_,
+        }
+        if default_value:
+            calendar["default_value"] = default_value
+        if min_year:
+            calendar["min_year"] = min_year
+        if max_year:
+            calendar["max_year"] = max_year
+
+        return {
+            "id": id,
+            "type": "Calendar",
+            "button_text": title,
+            "button_calendar": calendar
+        }
+
+    def button_number_picker(self, id: str, title: str, min_value: str, max_value: str,
+                             default_value: Optional[str] = None) -> Dict:
+        picker = {
+            "title": title,
+            "min_value": min_value,
+            "max_value": max_value,
+        }
+        if default_value:
+            picker["default_value"] = default_value
+
+        return {
+            "id": id,
+            "type": "NumberPicker",
+            "button_text": title,
+            "button_number_picker": picker
+        }
+
+    def button_string_picker(self, id: str, title: Optional[str], items: List[str],
+                             default_value: Optional[str] = None) -> Dict:
+        picker = {
+            "items": items
+        }
+        if default_value:
+            picker["default_value"] = default_value
+        if title:
+            picker["title"] = title
+
+        return {
+            "id": id,
+            "type": "StringPicker",
+            "button_text": title if title else "انتخاب",
+            "button_string_picker": picker
+        }
+
+    def button_location(self, id: str, type_: str, location_image_url: str,
+                        default_pointer_location: Optional[Dict] = None,
+                        default_map_location: Optional[Dict] = None,
+                        title: Optional[str] = None) -> Dict:
+        """
+        type_: ButtonLocationTypeEnum = "Picker" | "View"
+        location_image_url: str آدرس عکس دکمه موقعیت
+        default_pointer_location و default_map_location هر کدام دیکشنری Location (latitude, longitude)
+        """
+        loc = {
+            "type": type_,
+            "location_image_url": location_image_url,
+        }
+        if default_pointer_location:
+            loc["default_pointer_location"] = default_pointer_location
+        if default_map_location:
+            loc["default_map_location"] = default_map_location
+        if title:
+            loc["title"] = title
+
+        return {
+            "id": id,
+            "type": "Location",
+            "button_text": title if title else "موقعیت مکانی",
+            "button_location": loc
+        }
+
+    def button_textbox(self, id: str, title: Optional[str], 
+                       type_line: str, type_keypad: str,
+                       place_holder: Optional[str] = None,
+                       default_value: Optional[str] = None) -> Dict:
+        """
+        type_line: ButtonTextboxTypeLineEnum = "SingleLine" | "MultiLine"
+        type_keypad: ButtonTextboxTypeKeypadEnum = "String" | "Number"
+        """
+        textbox = {
+            "type_line": type_line,
+            "type_keypad": type_keypad
+        }
+        if place_holder:
+            textbox["place_holder"] = place_holder
+        if default_value:
+            textbox["default_value"] = default_value
+        if title:
+            textbox["title"] = title
+
+        return {
+            "id": id,
+            "type": "Textbox",
+            "button_text": title if title else "متن",
+            "button_textbox": textbox
+        }
+
+    def button_payment(self, id: str, title: str, amount: int, description: Optional[str] = None) -> Dict:
+        """
+        نمونه‌ای ساده برای دکمه پرداخت (مقدار و توضیح دلخواه)
+        """
+        payment = {
+            "title": title,
+            "amount": amount
+        }
+        if description:
+            payment["description"] = description
+
+        return {
+            "id": id,
+            "type": "Payment",
+            "button_text": title,
+            "button_payment": payment
+        }
+
+    def button_camera_image(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "CameraImage",
+            "button_text": title
+        }
+
+    def button_camera_video(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "CameraVideo",
+            "button_text": title
+        }
+
+    def button_gallery_image(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "GalleryImage",
+            "button_text": title
+        }
+
+    def button_gallery_video(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "GalleryVideo",
+            "button_text": title
+        }
+
+    def button_file(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "File",
+            "button_text": title
+        }
+
+    def button_audio(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "Audio",
+            "button_text": title
+        }
+
+    def button_record_audio(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "RecordAudio",
+            "button_text": title
+        }
+
+    def button_my_phone_number(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "MyPhoneNumber",
+            "button_text": title
+        }
+
+    def button_my_location(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "MyLocation",
+            "button_text": title
+        }
+
+    def button_link(self, id: str, title: str, url: str) -> Dict:
+        return {
+            "id": id,
+            "type": "Link",
+            "button_text": title,
+            "url": url
+        }
+
+    def button_ask_my_phone_number(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "AskMyPhoneNumber",
+            "button_text": title
+        }
+
+    def button_ask_location(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "AskLocation",
+            "button_text": title
+        }
+
+    def button_barcode(self, id: str, title: str) -> Dict:
+        return {
+            "id": id,
+            "type": "Barcode",
+            "button_text": title
+        }
+
+    def build(self) -> Dict:
+        return {"rows": self.rows}
+
+from typing import List, Dict, Optional
+
+class ChatKeypadBuilder:
+    def __init__(self):
+        self.rows: List[Dict[str, List[Dict[str, str]]]] = []
+
+    def row(self, *buttons: Dict[str, str]) -> "ChatKeypadBuilder":
+        """
+        یک ردیف دکمه به کی‌پد اضافه می‌کند.
+        ورودی: چند دیکشنری که نماینده دکمه‌ها هستند.
+        """
+        self.rows.append({"buttons": list(buttons)})
+        return self
+
+    def button(self, id: str, text: str, type: str = "Simple") -> Dict[str, str]:
+        """
+        دیکشنری یک دکمه می‌سازد.
+        """
+        return {"id": id, "type": type, "button_text": text}
+
+    def build(
+        self,
+        resize_keyboard: bool = True,
+        on_time_keyboard: bool = False
+    ) -> Dict[str, object]:
+        """
+        ساختار نهایی chat_keypad را می‌سازد.
+        """
+        return {
+            "rows": self.rows,
+            "resize_keyboard": resize_keyboard,
+            "on_time_keyboard": on_time_keyboard
+        }

rubka/logger.py

@@ -0,0 +1,12 @@
+import logging
+
+logger = logging.getLogger("rubka")
+logger.setLevel(logging.ERROR)
+
+ch = logging.StreamHandler()
+ch.setLevel(logging.ERROR)
+
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+ch.setFormatter(formatter)
+
+logger.addHandler(ch)

rubka/metadata.py

@@ -0,0 +1,114 @@
+import re
+from typing import Any, Dict, List
+import markdownify
+def _normalize_multiline_quote(text: str) -> str:
+    lines = text.splitlines()
+    normalized_lines = []
+    quote_block = []
+
+    for line in lines + [""]:
+        if line.startswith(">"):quote_block.append(line[1:].strip())
+        else:
+            if quote_block:
+                normalized_lines.append("$" + "\n".join(quote_block) + "$")
+                quote_block = []
+            normalized_lines.append(line)
+    return "\n".join(normalized_lines).strip()
+
+class Track_parsed:
+    _PATT = re.compile(
+    r"(?P<pre>```(?P<pre_c>[\s\S]*?)```)"
+    r"|(?P<bold>\*\*(?P<bold_c>.*?)\*\*)"
+    r"|(?P<mono>`(?P<mono_c>.*?)`)"
+    r"|(?P<italic>__(?P<italic_c>.*?)__)"
+    r"|(?P<underline>--(?P<underline_c>.*?)--)"
+    r"|(?P<link>\[(?P<link_text>.*?)\]\((?P<link_url>\S+?)\))"
+    r"|(?P<quote>\$(?P<quote_c>[\s\S]*?)\$)"
+    r"|(?P<quote_md>^>(?P<quote_md_c>.*?)(?:\n|$))"
+    r"|(?P<strike>~~(?P<strike_c>.*?)~~)"
+    r"|(?P<spoiler>\|\|(?P<spoiler_c>.*?)\|\|)",
+    flags=re.DOTALL,
+)
+    _TYPE_MAP = {
+        "pre": "Pre",
+        "bold": "Bold",
+        "mono": "Mono",
+        "italic": "Italic",
+        "underline": "Underline",
+        "strike": "Strike",
+        "spoiler": "Spoiler",
+        "quote": "Quote",
+        "quote_md": "Quote",
+        "link": "Link",
+        "mention": "MentionText",
+    }
+    @staticmethod
+    def _utf16_len_java_style(s: str) -> int:
+        return len(s.encode("utf-16-be")) // 2
+    @staticmethod
+    def _html2md(src: str) -> str:
+        src = re.sub(r'<i>(.*?)</i>', r'||\1||', src, flags=re.DOTALL)
+        src = re.sub(r'<span class="spoiler">(.*?)</span>', r'||\1||', src, flags=re.DOTALL)
+        src = markdownify.markdownify(html=src).strip()
+        src = src.replace("@@SPOILER@@", "||")
+        return src
+    def transcribe(self, src: str, mode: str = "MARKDOWN") -> Dict[str, Any]:
+        if mode and mode.upper() == "HTML":
+            src = self._html2md(src)
+        src = _normalize_multiline_quote(src)
+        payload_parts: List[Dict[str, Any]] = []
+        normalized_text = src
+        byte_offset = 0
+        char_offset = 0
+        matches = list(self._PATT.finditer(src))
+        for m in matches:
+            whole = m.group(0)
+            start, end = m.span()
+            adj_from = self._utf16_len_java_style(src[:start]) - byte_offset
+            adj_char_from = start - char_offset
+            gname = m.lastgroup
+            if not gname:continue
+            if gname == "link":
+                inner = m.group("link_text") or ""
+                link_href = m.group("link_url")
+                if link_href.startswith("u0"):gname = "mention"
+            else:
+                inner = m.group(f"{gname}_c") or ""
+                link_href = None
+            if gname in ["quote", "quote_md", "bold", "italic", "underline", "spoiler", "strike","mention"]:
+                inner_metadata = self.transcribe(inner, mode="MARKDOWN")
+                inner = inner_metadata["text"]
+                if "metadata" in inner_metadata:
+                    for part in inner_metadata["metadata"]["meta_data_parts"]:
+                        part["from_index"] += adj_from
+                        payload_parts.append(part)
+            if inner == "":
+                continue
+            content_utf16_len = self._utf16_len_java_style(inner)
+            part: Dict[str, Any] = {
+                "type": self._TYPE_MAP.get(gname, "Unknown"),
+                "from_index": adj_from,
+                "length": content_utf16_len,
+            }
+            if gname == "mention":
+                part["type"] = "MentionText"
+                part["mention_text_user_id"] = link_href
+            elif link_href:
+                part["type"] = "Link"
+                part["link_url"] = link_href
+            payload_parts.append(part)
+            normalized_text = (
+                normalized_text[:adj_char_from] + inner + normalized_text[end - char_offset :]
+            )
+            byte_offset += self._utf16_len_java_style(whole) - content_utf16_len
+            char_offset += (end - start) - len(inner)
+
+        result: Dict[str, Any] = {"text": normalized_text.strip()}
+        if payload_parts:
+            result["metadata"] = {"meta_data_parts": payload_parts}
+
+        return result
+
+
+    def parse(self, text: str, parse_mode: str = "MARKDOWN") -> Dict[str, Any]:
+        return self.transcribe(text, mode=parse_mode)