jims-telegram 0.1.0.dev4__py3-none-any.whl

jims_telegram/__init__.py

@@ -0,0 +1,270 @@
+import asyncio
+import uuid
+from contextlib import suppress
+from typing import Any, Awaitable, overload
+
+from aiogram import Bot, Dispatcher, F
+from aiogram.filters import CommandStart
+from aiogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message
+from jims_core.app import JimsApp
+from jims_core.schema import Pipeline
+from jims_core.thread.thread_context import StatusUpdater
+from jims_core.thread.thread_controller import ThreadController
+from jims_core.util import uuid7
+from loguru import logger
+from opentelemetry import trace
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing_extensions import TypedDict
+
+from jims_telegram.md2tgmd import escape
+
+tracer = trace.get_tracer("jims_tui")
+
+
+class TelegramSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="TELEGRAM_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    bot_token: str
+
+
+settings = TelegramSettings()  # type: ignore
+
+uuid_namespace = uuid.UUID("00000000-0000-0000-0000-000000000000")
+
+
+def uuid_from_int(value: int) -> uuid.UUID:
+    if not 0 <= value < 2**64:
+        raise ValueError(f"Integer value must be between 0 and 2^64-1, got {value}")
+
+    # Convert the integer to bytes in big-endian order
+    name = value.to_bytes(8, byteorder="big")
+
+    # Generate a version 5 UUID
+    return uuid.uuid5(uuid_namespace, name)
+
+
+class TelegramStatusUpdater(StatusUpdater):
+    def __init__(self, bot: Bot, chat_id: int) -> None:
+        self.bot = bot
+        self.chat_id = chat_id
+
+    async def update_status(self, status: str) -> None:
+        await self.bot.send_chat_action(
+            chat_id=self.chat_id,
+            action="typing",
+        )
+        logger.debug(f"Status updated to: {status}")
+
+
+class TelegramButton(TypedDict):
+    text: str
+    id: str
+
+
+class TelegramController:
+    def __init__(
+        self,
+        app: JimsApp,
+    ) -> None:
+        self.app = app
+        self.bot = Bot(token=settings.bot_token)
+
+        self.dispatcher = Dispatcher()
+
+        self.dispatcher.message.register(self.command_start, CommandStart())
+        self.dispatcher.message.register(self.handle_message)
+        self.dispatcher.callback_query.register(self.handle_callback, F.data.startswith("btn:"))
+
+    @overload
+    @classmethod
+    async def create(cls, app: JimsApp) -> "TelegramController":
+        ...
+
+    @overload
+    @classmethod
+    async def create(cls, app: Awaitable[JimsApp]) -> "TelegramController":
+        ...
+
+    @classmethod
+    async def create(cls, app: JimsApp | Awaitable[JimsApp]) -> "TelegramController":
+        if isinstance(app, Awaitable):
+            app = await app
+        return cls(app)
+
+    async def _run_pipeline(self, ctl: ThreadController, chat_id: Any, pipeline: Pipeline) -> None:
+        ctx = await ctl.make_context()
+        ctx = ctx.with_status_updater(TelegramStatusUpdater(self.bot, chat_id))
+
+        async def status_updater():
+            try:
+                while True:
+                    await ctx.update_agent_status("thinking")
+                    await asyncio.sleep(5)
+            except asyncio.CancelledError:
+                pass
+
+        updater_task = asyncio.create_task(status_updater())
+
+        try:
+            events = await ctl.run_pipeline_with_context(pipeline, ctx)
+        finally:
+            updater_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await updater_task
+
+        for event in events:
+            if event.event_type == "comm.assistant_message":
+                await self.bot.send_message(
+                    chat_id=chat_id,
+                    text=escape(event.event_data["content"]),
+                    parse_mode="MarkdownV2",
+                )
+            elif event.event_type == "comm.assistant_buttons":
+                buttons = event.event_data.get("buttons", [])
+                reply_markup = self._build_inline_keyboard(buttons)
+                await self.bot.send_message(
+                    chat_id=chat_id,
+                    text=escape(event.event_data.get("content", "")),
+                    parse_mode="MarkdownV2",
+                    reply_markup=reply_markup,
+                )
+
+    async def command_start(self, message: Message) -> None:
+        logger.debug(f"Received command start from {message.chat.id}")
+        if not message.from_user:  # messages sent on behalf of chats, channels, or by tg
+            logger.error("from_user.id not found in message")
+            return
+
+        from_id = message.from_user.id  # type: ignore[union-attr]
+
+        thread_id = uuid7()
+        ctl = await self.app.new_thread(
+            contact_id=f"telegram:{from_id}",
+            thread_id=thread_id,
+            thread_config={
+                "interface": "telegram",
+                "telegram_chat_id": message.chat.id,
+                "telegram_user_id": from_id,
+                "telegram_user_name": message.from_user.username,  # type: ignore[union-attr]
+            },
+        )
+
+        if message.text:
+            await ctl.store_user_message(
+                event_id=uuid_from_int(message.message_id),
+                content=message.text,
+            )
+
+        if self.app.conversation_start_pipeline is not None:
+            await self._run_pipeline(ctl, message.chat.id, self.app.conversation_start_pipeline)
+
+    async def handle_message(self, message: Message) -> None:
+        with tracer.start_as_current_span("jims_telegram.handle_message"):
+            logger.debug(f"Received message {message.text=} from {message.chat.id=}")
+            if not message.from_user:  # messages sent on behalf of chats, channels, or by tg
+                logger.error("from_user.id not found in message")
+                return
+
+            from_id = message.from_user.id  # type: ignore[union-attr]
+
+            ctl = await ThreadController.latest_thread_from_contact_id(self.app.sessionmaker, f"telegram:{from_id}")
+            if ctl is None:
+                logger.warning(f"Thread with id {message.chat.id} not found, recreating")
+                thread_id = uuid7()
+                ctl = await ThreadController.new_thread(
+                    self.app.sessionmaker,
+                    contact_id=f"telegram:{from_id}",
+                    thread_id=thread_id,
+                    thread_config={
+                        "interface": "telegram",
+                        "telegram_chat_id": message.chat.id,
+                        "telegram_user_id": from_id,
+                        "telegram_user_name": message.from_user.username,  # type: ignore[union-attr]
+                    },
+                )
+
+            if message.text:
+                await ctl.store_user_message(
+                    event_id=uuid_from_int(message.message_id),
+                    content=message.text,
+                )
+
+            await self._run_pipeline(ctl, message.chat.id, self.app.pipeline)
+
+    async def handle_callback(self, callback: CallbackQuery) -> None:
+        if not callback.from_user:
+            return
+        from_id = callback.from_user.id  # type: ignore[union-attr]
+
+        ctl = await ThreadController.latest_thread_from_contact_id(self.app.sessionmaker, f"telegram:{from_id}")
+        if ctl is None:
+            thread_id = uuid7()
+            ctl = await ThreadController.new_thread(
+                self.app.sessionmaker,
+                contact_id=f"telegram:{from_id}",
+                thread_id=thread_id,
+                thread_config={
+                    "interface": "telegram",
+                    "telegram_chat_id": callback.message.chat.id if callback.message else None,
+                    "telegram_user_id": from_id,
+                    "telegram_user_name": callback.message.from_user.username,  # type: ignore[union-attr]
+                },
+            )
+
+        data = callback.data or ""
+        try:
+            await ctl.store_event_dict(
+                event_id=uuid7(),
+                event_type="comm.user_button_click",
+                event_data={
+                    "role": "user",
+                    "content": data,
+                    "message_id": callback.message.message_id if callback.message else None,
+                },
+            )
+        except Exception as e:
+            logger.error(f"Failed to store button click event: {e}")
+
+        with suppress(Exception):
+            await callback.answer()
+
+        chat_id = callback.message.chat.id if callback.message else from_id
+        await self._run_pipeline(ctl, chat_id, self.app.pipeline)
+
+    @staticmethod
+    def _build_inline_keyboard(
+        buttons: list[list[TelegramButton]] | list[TelegramButton] | list[Any],
+    ) -> InlineKeyboardMarkup | None:
+        """
+        Parse buttons dict into keyboard
+        """
+        rows: list[list[InlineKeyboardButton]] = []
+        if buttons and isinstance(buttons, list):
+            # normalize single row form
+            if buttons and all(isinstance(b, dict) for b in buttons):
+                buttons = [buttons]  # type: ignore[assignment]
+            for row in buttons:
+                if not isinstance(row, list):
+                    continue
+                kb_row: list[InlineKeyboardButton] = []
+                for b in row:
+                    if not isinstance(b, dict):
+                        continue
+                    label_v = b.get("text")
+                    if label_v is None:
+                        continue
+                    label = str(label_v)
+                    btn_id = str(b.get("id") or b.get("callback_data") or label)
+                    kb_row.append(InlineKeyboardButton(text=label, callback_data=f"btn:{btn_id}"))
+                if kb_row:
+                    rows.append(kb_row)
+        return InlineKeyboardMarkup(inline_keyboard=rows) if rows else None
+
+    async def run(self):
+        logger.debug("Starting Telegram bot")
+        await self.dispatcher.start_polling(self.bot)

jims_telegram/main.py

@@ -0,0 +1,77 @@
+import asyncio
+
+import click
+from aiohttp import web
+from jims_core.util import (
+    load_jims_app,
+    setup_monitoring_and_tracing_with_sentry,
+    setup_prometheus_metrics,
+    setup_verbose_logging,
+)
+from loguru import logger
+
+from jims_telegram import TelegramController
+
+
+async def healthcheck(host: str = "0.0.0.0", port: int = 8000):
+    async def health(request: web.Request):
+        return web.json_response({"status": "ok"})
+
+    app = web.Application()
+    app.add_routes([web.get("/health", health)])
+    app.add_routes([web.get("/healthz", health)])
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, host, port)
+    await site.start()
+    return runner
+
+
+@click.command()
+@click.option("--app", type=click.STRING, default="app")
+@click.option("--enable-sentry", is_flag=True, help="Enable tracing to Sentry", default=False)
+@click.option("--enable-healthcheck", is_flag=True, help="Enable healthcheck endpoint", default=True)
+@click.option("--healthcheck-port", type=click.INT, default=9000)
+@click.option("--metrics-port", type=click.INT, default=8000)
+@click.option("--verbose", is_flag=True, default=False)
+def cli(
+    app: str,
+    enable_sentry: bool,
+    enable_healthcheck: bool,
+    healthcheck_port: int,
+    metrics_port: int,
+    verbose: bool,
+) -> None:
+    if verbose:
+        setup_verbose_logging()
+
+    setup_prometheus_metrics(port=metrics_port)
+
+    if enable_sentry:
+        setup_monitoring_and_tracing_with_sentry()
+
+    jims_app = load_jims_app(app)
+
+    async def run_telegram_bot():
+        if enable_healthcheck:
+            await healthcheck(port=healthcheck_port)
+
+        telegram_controller = await TelegramController.create(jims_app)
+        await telegram_controller.run()
+
+    try:
+        asyncio.run(run_telegram_bot())
+    except KeyboardInterrupt:
+        logger.info("Bot stopped by user")
+    except Exception as e:
+        logger.error(f"Bot crashed: {e}")
+        exit(1)
+
+
+def main():
+    cli(auto_envvar_prefix="JIMS")
+
+
+if __name__ == "__main__":
+    main()

jims_telegram/md2tgmd.py

@@ -0,0 +1,353 @@
+"""
+conveniently borrowed from https://github.com/yym68686/md2tgmd
+"""
+
+import re
+
+
+def find_all_index(str, pattern):
+    index_list = [0]
+    for match in re.finditer(pattern, str, re.MULTILINE):
+        if match.group(1) is not None:
+            start = match.start(1)
+            end = match.end(1)
+            index_list += [start, end]
+    index_list.append(len(str))
+    return index_list
+
+
+def replace_all(text, pattern, function):
+    poslist = [0]
+    strlist = []
+    originstr = []
+    poslist = find_all_index(text, pattern)
+    for i in range(1, len(poslist[:-1]), 2):
+        start, end = poslist[i : i + 2]
+        strlist.append(function(text[start:end]))
+    for i in range(0, len(poslist), 2):
+        j, k = poslist[i : i + 2]
+        originstr.append(text[j:k])
+    if len(strlist) < len(originstr):
+        strlist.append("")
+    else:
+        originstr.append("")
+    new_list = [item for pair in zip(originstr, strlist) for item in pair]
+    return "".join(new_list)
+
+
+def escapeshape(text):
+    return "▎*" + " ".join(text.split()[1:]) + "*\n\n"
+
+
+def escapeminus(text):
+    return "\\" + text
+
+
+def escapeminus2(text):
+    return r"@+>@"
+
+
+def escapebackquote(text):
+    return r"\`\`"
+
+
+def escapebackquoteincode(text):
+    return r"@->@"
+
+
+def escapeplus(text):
+    return "\\" + text
+
+
+def escape_all_backquote(text):
+    return "\\" + text
+
+
+def dedent_space(text):
+    import textwrap
+
+    return "\n\n" + textwrap.dedent(text).strip() + "\n\n"
+
+
+def split_code(text):
+    split_list = []
+    if len(text) > 2300:
+        split_str_list = text.split("\n\n")
+
+        conversation_len = len(split_str_list)
+        message_index = 1
+        while message_index < conversation_len:
+            if split_str_list[message_index].startswith("    "):
+                split_str_list[message_index - 1] += "\n\n" + split_str_list[message_index]
+                split_str_list.pop(message_index)
+                conversation_len = conversation_len - 1
+            else:
+                message_index = message_index + 1
+
+        split_index = 0
+        for index, _ in enumerate(split_str_list):
+            if len("".join(split_str_list[:index])) < len(text) // 2:
+                split_index += 1
+                continue
+            else:
+                break
+        str1 = "\n\n".join(split_str_list[:split_index])
+        if not str1.strip().endswith("```"):
+            str1 = str1 + "\n```"
+        split_list.append(str1)
+        code_type = text.split("\n")[0]
+        str2 = "\n\n".join(split_str_list[split_index:])
+        str2 = code_type + "\n" + str2
+        if not str2.strip().endswith("```"):
+            str2 = str2 + "\n```"
+        split_list.append(str2)
+    else:
+        split_list.append(text)
+
+    if len(split_list) > 1:
+        split_list = "\n@|@|@|@\n\n".join(split_list)
+    else:
+        split_list = split_list[0]
+    return split_list
+
+
+def find_lines_with_char(s, char, min_count):
+    """
+    Find lines containing a specific character at least min_count times.
+
+    Args:
+        s (str): String to process
+        char (str): Character to count
+        min_count (int): Minimum occurrence count
+
+    Returns:
+        str: String with escaped characters
+    """
+    lines = s.split("\n")  # Split string by lines
+
+    for index, line in enumerate(lines):
+        if re.sub(r"```", "", line).count(char) % 2 != 0 or (
+            not line.strip().startswith("```") and line.count(char) % 2 != 0
+        ):
+            lines[index] = replace_all(lines[index], r"\\`|(`)", escape_all_backquote)
+
+    return "\n".join(lines)
+
+
+def escape(text, flag=0, italic=True):
+    """
+    Convert Markdown to Telegram Markdown format.
+
+    Args:
+        text (str): Input Markdown text
+        flag (int): Processing flag
+        italic (bool): Whether to process italic formatting
+
+    Returns:
+        str: Telegram-formatted markdown
+    """
+    # In all other places characters
+    # _ * [ ] ( ) ~ ` > # + - = | { } . !
+    # must be escaped with the preceding character '\'.
+    text = re.sub(r"\\\[", "@->@", text)
+    text = re.sub(r"\\]", "@<-@", text)
+    text = re.sub(r"\\\(", "@-->@", text)
+    text = re.sub(r"\\\)", "@<--@", text)
+    if flag:
+        text = re.sub(r"\\\\", "@@@", text)
+    text = re.sub(r"\\`", "@<@", text)
+    text = re.sub(r"\\", r"\\\\", text)
+    if flag:
+        text = re.sub(r"@{3}", r"\\\\", text)
+    # _italic_
+    if italic:
+        text = re.sub(r"_(.*?)_", "@@@\\1@@@", text)
+        text = re.sub(r"_", r"\_", text)
+        text = re.sub(r"@{3}(.*?)@{3}", "_\\1_", text)
+    else:
+        text = re.sub(r"_", r"\_", text)
+
+    text = re.sub(r"\*{2}(.*?)\*{2}", "@@@\\1@@@", text)
+    text = re.sub(r"\n{1,2}\*\s", "\n\n• ", text)
+    text = re.sub(r"\*", r"\*", text)
+    text = re.sub(r"@{3}(.*?)@{3}", "*\\1*", text)
+    text = re.sub(r"!?\[(.*?)]\((.*?)\)", "@@@\\1@@@^^^\\2^^^", text)
+    text = re.sub(r"\[", r"\[", text)
+    text = re.sub(r"]", r"\]", text)
+    text = re.sub(r"\(", r"\(", text)
+    text = re.sub(r"\)", r"\)", text)
+    text = re.sub(r"@->@", r"\[", text)
+    text = re.sub(r"@<-@", r"\]", text)
+    text = re.sub(r"@-->@", r"\(", text)
+    text = re.sub(r"@<--@", r"\)", text)
+    text = re.sub(r"@{3}(.*?)@{3}\^{3}(.*?)\^{3}", "[\\1](\\2)", text)
+
+    # ~strikethrough~
+    text = re.sub(r"~{2}(.*?)~{2}", "@@@\\1@@@", text)
+    text = re.sub(r"~", r"\~", text)
+    text = re.sub(r"@{3}(.*?)@{3}", "~\\1~", text)
+
+    text = re.sub(r"\n>\s", "\n@@@ ", text)
+    text = re.sub(r">", r"\>", text)
+    text = re.sub(r"@{3}", ">", text)
+
+    text = replace_all(text, r"(^#+\s.+?\n+)|```[\D\d\s]+?```", escapeshape)
+    text = re.sub(r"#", r"\#", text)
+    text = replace_all(text, r"(\+)|\n[\s]*-\s|```[\D\d\s]+?```|`[\D\d\s]*?`", escapeplus)
+
+    # Numbered lists
+    text = re.sub(r"\n{1,2}(\s*\d{1,2}\.\s)", "\n\n\\1", text)
+
+    # Replace - outside code blocks
+    text = replace_all(text, r"```[\D\d\s]+?```|(-)", escapeminus2)
+    text = re.sub(r"-", "@<+@", text)
+    text = re.sub(r"@\+>@", "-", text)
+
+    text = re.sub(r"\n{1,2}(\s*)-\s", "\n\n\\1• ", text)
+    text = re.sub(r"@<+@", r"\-", text)
+    text = replace_all(text, r"(-)|\n[\s]*-\s|```[\D\d\s]+?```|`[\D\d\s]*?`", escapeminus)
+    text = re.sub(r"```([\D\d\s]+?)```", "@@@\\1@@@", text)
+    # Replace backticks in code blocks
+    text = replace_all(text, r"\@\@\@[\s\d\D]+?\@\@\@|(`)", escapebackquoteincode)
+    text = re.sub(r"`", r"\`", text)
+    text = re.sub(r"@<@", r"\`", text)
+    text = re.sub(r"@->@", "`", text)
+    text = re.sub(r"\s`\\`\s", r" `\\\\\` ", text)
+
+    text = replace_all(text, r"(``)", escapebackquote)
+    text = re.sub(r"@{3}([\D\d\s]+?)@{3}", "```\\1```", text)
+    text = re.sub(r"=", r"\=", text)
+    text = re.sub(r"\|", r"\|", text)
+    # text = re.sub(r"\@\!\@", '||', text)
+    text = re.sub(r"{", r"\{", text)
+    text = re.sub(r"}", r"\}", text)
+    text = re.sub(r"\.", r"\.", text)
+    text = re.sub(r"!", r"\!", text)
+    text = find_lines_with_char(text, "`", 5)
+    text = replace_all(text, r"(\n+\x20*```[\D\d\s]+?```\n+)", dedent_space)
+    return text
+
+
+test_text = r"""
+# title
+
+### `probs.scatter_(1, ind`
+
+**bold**
+```
+# comment
+print(qwer) # ferfe
+ni1
+```
+# bn
+
+
+# b
+
+# Header
+## Subheader
+
+[1.0.0](http://version.com)
+![1.0.0](http://version.com)
+
+- item 1 -
+    - item 1 -
+    - item 1 -
+* item 2 #
+* item 3 ~
+
+1. item 1
+2. item 2
+
+1. item 1
+```python
+
+# comment
+print("1.1\n")_
+\subsubsection{1.1}
+- item 1 -
+```
+2. item 2
+
+sudo apt install package # Install command
+
+\subsubsection{1.1}
+
+And simple text `with-dashes` `with+plus` + some - **symbols**.
+
+    ```
+    print("Hello, World!") -
+    app.listen(PORT, () => {
+        console.log(`Server is running on http://localhost:${PORT}`);
+    });
+    ```
+
+Cxy = abs (Pxy)**2/ (Pxx*Pyy)
+
+`a`a-b-c`n`
+\[ E[X^4] = \int_{-\infty}^{\infty} x^4 f(x) dx \]
+
+`-a----++++`++a-b-c`-n-`
+`[^``]*`a``b-c``d``
+# pattern = r"`[^`]*`-([^`-]*)"``
+w`-a----`ccccc`-n-`bbbb``a
+
+1. Open VSCode terminal: Go to `View` > `Terminal` or use `Ctrl+``
+
+How to write: `line.strip().startswith("```")`?
+
+`View` > `Terminal`
+
+Escape example: `\``
+
+- `Path.open()` method opens the `README.md` file with UTF-8 encoding.
+
+3. `(`
+
+3. Parentheses example: `(`
+
+According to Euler's totient function, for \( n = p_1^{k_1} \times p_2^{k_2} \times \cdots \times p_r^{k_r} \) (where \( p_1, p_2, \ldots, p_r \) are distinct primes):
+
+\[ \varphi(n) = n \left(1 - \frac{1}{p_1}\right) \left(1 - \frac{1}{p_2}\right) \cdots \left(1 - \frac{1}{p_r}\right) \]
+
+Therefore:
+
+\[ \varphi(35) = 35 \left(1 - \frac{1}{5}\right) \left(1 - \frac{1}{7}\right) \]
+
+Calculating step by step:
+
+\[ \varphi(35) = 35 \left(\frac{4}{5}\right) \left(\frac{6}{7}\right) \]
+
+\[ \varphi(35) = 35 \times \frac{24}{35} \]
+
+\[ \varphi(35) = 24 \]
+
+To calculate acceleration \( a \), use the formula:
+
+\[ a = \frac{\Delta v}{\Delta t} \]
+
+Where:
+- \(\Delta v\) is the change in velocity
+- \(\Delta t\) is the change in time
+
+Given:
+- Initial velocity \( v_0 = 0 \) m/s
+- Final velocity \( v = 27.8 \) m/s
+- Time \( \Delta t = 3.85 \) s
+
+Substituting values:
+
+\[ a = \frac{27.8 \, \text{m/s} - 0 \, \text{m/s}}{3.85 \, \text{s}} \]
+
+Calculating:
+
+\[ a = \frac{27.8}{3.85} \approx 7.22 \, \text{m/s}^2 \]
+
+Therefore, the car's acceleration is approximately 7.22 m/s².
+
+Thus, Euler's totient function \( \varphi(35) \) equals 24.
+"""
+
+if __name__ == "__main__":
+    test_text_escaped = escape(test_text)
+    print(test_text_escaped)

jims_telegram-0.1.0.dev4.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: jims-telegram
+Version: 0.1.0.dev4
+Summary: Telegram interface for JIMS applications
+Author-email: Andrey Tatarinov <a@tatarinov.co>, Timur Sheydaev <tsheyd@epoch8.co>
+Requires-Python: >=3.12
+Requires-Dist: aiogram>=3.18
+Requires-Dist: aiohttp>=3.11.16
+Requires-Dist: click>=8.0
+Requires-Dist: jims-core
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic-settings>=2.8.1
+Requires-Dist: pydantic>=2.4.1

jims_telegram-0.1.0.dev4.dist-info/RECORD

@@ -0,0 +1,8 @@
+jims_telegram/__init__.py,sha256=0wEcTNYCGnmVcc9n8wfID7vtBfYhmJryrYx-8Sg1qc4,9970
+jims_telegram/main.py,sha256=inu_Nh6W3OxDvlPZbYZZRK7bxHog3Dg_akKfiteKVrQ,2059
+jims_telegram/md2tgmd.py,sha256=xermMXAr8tgbsFp7itxSPPJ0NfEe5A66fwoBxrO-__o,9461
+jims_telegram/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jims_telegram-0.1.0.dev4.dist-info/METADATA,sha256=m4hW97HNPY7glFnRR3aPz3cIqEwE5YHVNBwP55yR3DU,431
+jims_telegram-0.1.0.dev4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jims_telegram-0.1.0.dev4.dist-info/entry_points.txt,sha256=eiEkp0hbAskEaY7YfCcWDXMs9NM_TdCg88UMA6pVx5Y,58
+jims_telegram-0.1.0.dev4.dist-info/RECORD,,

jims_telegram-0.1.0.dev4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

jims_telegram-0.1.0.dev4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jims-telegram = jims_telegram.main:main