bot-framework 0.1.3__py3-none-any.whl

bot_framework/protocols/i_message_handler.py

@@ -0,0 +1,16 @@
+from typing import (
+    Protocol,
+    runtime_checkable,
+)
+
+from bot_framework.entities.bot_message import BotMessage
+
+
+@runtime_checkable
+class IMessageHandler(Protocol):
+    allowed_roles: set[str] | None
+
+    def handle(
+        self,
+        message: BotMessage,
+    ) -> bool | None: ...

bot_framework/protocols/i_message_handler_registry.py

@@ -0,0 +1,14 @@
+from collections.abc import Callable
+from typing import Protocol
+
+from bot_framework.protocols.i_message_handler import IMessageHandler
+
+
+class IMessageHandlerRegistry(Protocol):
+    def register(
+        self,
+        handler: IMessageHandler,
+        commands: list[str] | None = None,
+        content_types: list[str] | None = None,
+        func: Callable[..., bool] | None = None,
+    ) -> None: ...

bot_framework/protocols/i_message_replacer.py

@@ -0,0 +1,17 @@
+from typing import Protocol
+
+from bot_framework.entities.bot_message import BotMessage
+from bot_framework.entities.keyboard import Keyboard
+from bot_framework.entities.parse_mode import ParseMode
+
+
+class IMessageReplacer(Protocol):
+    def replace(
+        self,
+        chat_id: int,
+        message_id: int,
+        text: str,
+        parse_mode: ParseMode = ParseMode.HTML,
+        keyboard: Keyboard | None = None,
+        flow_name: str | None = None,
+    ) -> BotMessage: ...

bot_framework/protocols/i_message_sender.py

@@ -0,0 +1,31 @@
+from typing import Protocol
+
+from bot_framework.entities.bot_message import BotMessage
+from bot_framework.entities.keyboard import Keyboard
+from bot_framework.entities.parse_mode import ParseMode
+
+
+class IMessageSender(Protocol):
+    def send(
+        self,
+        chat_id: int,
+        text: str,
+        parse_mode: ParseMode = ParseMode.HTML,
+        keyboard: Keyboard | None = None,
+        flow_name: str | None = None,
+    ) -> BotMessage: ...
+
+    def send_markdown_as_html(
+        self,
+        chat_id: int,
+        text: str,
+        keyboard: Keyboard | None = None,
+        flow_name: str | None = None,
+    ) -> BotMessage: ...
+
+    def send_document(
+        self,
+        chat_id: int,
+        document: bytes,
+        filename: str,
+    ) -> BotMessage: ...

bot_framework/protocols/i_message_service.py

@@ -0,0 +1,16 @@
+from typing import Protocol
+
+from bot_framework.protocols.i_message_deleter import IMessageDeleter
+from bot_framework.protocols.i_message_replacer import IMessageReplacer
+from bot_framework.protocols.i_message_sender import IMessageSender
+from bot_framework.protocols.i_notify_replacer import INotifyReplacer
+
+
+class IMessageService(
+    IMessageSender,
+    IMessageReplacer,
+    IMessageDeleter,
+    INotifyReplacer,
+    Protocol,
+):
+    pass

bot_framework/protocols/i_next_step_handler_registrar.py

@@ -0,0 +1,12 @@
+from typing import Protocol
+
+from bot_framework.entities.bot_message import BotMessage
+from bot_framework.protocols.i_message_handler import IMessageHandler
+
+
+class INextStepHandlerRegistrar(Protocol):
+    def register(
+        self,
+        message: BotMessage,
+        handler: IMessageHandler,
+    ) -> None: ...

bot_framework/protocols/i_notify_replacer.py

@@ -0,0 +1,17 @@
+from typing import Protocol
+
+from bot_framework.entities.bot_message import BotMessage
+from bot_framework.entities.keyboard import Keyboard
+from bot_framework.entities.parse_mode import ParseMode
+
+
+class INotifyReplacer(Protocol):
+    def notify_replace(
+        self,
+        chat_id: int,
+        message_id: int,
+        text: str,
+        parse_mode: ParseMode = ParseMode.HTML,
+        keyboard: Keyboard | None = None,
+        flow_name: str | None = None,
+    ) -> BotMessage: ...

bot_framework/protocols/i_remaining_time_formatter.py

@@ -0,0 +1,6 @@
+from datetime import datetime
+from typing import Protocol
+
+
+class IRemainingTimeFormatter(Protocol):
+    def format(self, expires_at: datetime, language_code: str) -> str: ...

bot_framework/role_management/__init__.py

@@ -0,0 +1,13 @@
+from bot_framework.role_management.entities import Role, RoleName, User, UserRole
+from bot_framework.role_management.repos import RoleRepo
+from bot_framework.role_management.repos.protocols import IRoleRepo, IUserRepo
+
+__all__ = [
+    "User",
+    "Role",
+    "UserRole",
+    "RoleName",
+    "RoleRepo",
+    "IRoleRepo",
+    "IUserRepo",
+]

bot_framework/role_management/entities/__init__.py

@@ -0,0 +1,10 @@
+from bot_framework.entities import Role, RoleName, User
+
+from .user_role import UserRole
+
+__all__ = [
+    "User",
+    "Role",
+    "UserRole",
+    "RoleName",
+]

bot_framework/role_management/entities/user_role.py

@@ -0,0 +1,13 @@
+from datetime import datetime
+
+from pydantic import (
+    BaseModel, ConfigDict, Field,
+)
+
+
+class UserRole(BaseModel):
+    user_id: int
+    role_id: int
+    assigned_at: datetime = Field(default_factory=datetime.now)
+
+    model_config = ConfigDict(from_attributes=True)

bot_framework/role_management/repos/__init__.py

@@ -0,0 +1,5 @@
+from .role_repo import RoleRepo
+
+__all__ = [
+    "RoleRepo",
+]

bot_framework/role_management/repos/protocols/__init__.py

@@ -0,0 +1,7 @@
+from .i_role_repo import IRoleRepo
+from .i_user_repo import IUserRepo
+
+__all__ = [
+    "IUserRepo",
+    "IRoleRepo",
+]

bot_framework/role_management/repos/protocols/i_role_repo.py

@@ -0,0 +1,30 @@
+from typing import Protocol
+
+from bot_framework.base_protocols import (
+    GetAllProtocol,
+    ReadProtocol,
+)
+from bot_framework.entities.role import Role
+
+
+class IRoleRepo(
+    GetAllProtocol,
+    ReadProtocol,
+    Protocol,
+):
+    def get_user_roles(
+        self,
+        user_id: int,
+    ) -> list[Role]: ...
+
+    def assign_role(
+        self,
+        user_id: int,
+        role_id: int,
+    ) -> None: ...
+
+    def assign_role_by_name(
+        self,
+        user_id: int,
+        role_name: str,
+    ) -> None: ...

bot_framework/role_management/repos/protocols/i_user_repo.py

@@ -0,0 +1,24 @@
+from typing import Protocol
+
+from bot_framework.base_protocols import (
+    CreateProtocol,
+    DeleteProtocol,
+    GetByNameProtocol,
+    ReadProtocol,
+    UpdateProtocol,
+)
+from bot_framework.entities.user import User
+
+
+class IUserRepo(
+    GetByNameProtocol,
+    CreateProtocol,
+    DeleteProtocol,
+    ReadProtocol,
+    UpdateProtocol,
+    Protocol,
+):
+    def get_by_role_name(
+        self,
+        role_name: str,
+    ) -> list[User]: ...

bot_framework/role_management/repos/role_repo.py

@@ -0,0 +1,103 @@
+import psycopg
+from psycopg.rows import class_row
+
+from bot_framework.entities.role import Role
+from bot_framework.role_management.repos.protocols.i_role_repo import IRoleRepo
+
+
+class RoleRepo(IRoleRepo):
+    def __init__(
+        self,
+        database_url: str,
+    ):
+        self.database_url = database_url
+
+    def get_all(self) -> list[Role]:
+        with psycopg.connect(self.database_url) as conn:
+            with conn.cursor(row_factory=class_row(Role)) as cur:
+                cur.execute(
+                    "SELECT * FROM roles WHERE is_active = TRUE ORDER BY name",
+                )
+                return cur.fetchall()
+
+    def find_by_id(
+        self,
+        id: int,
+    ) -> Role | None:
+        with psycopg.connect(self.database_url) as conn:
+            with conn.cursor(row_factory=class_row(Role)) as cur:
+                cur.execute(
+                    "SELECT * FROM roles WHERE id = %(role_id)s AND is_active = TRUE",
+                    {
+                        "role_id": id,
+                    },
+                )
+                return cur.fetchone()
+
+    def get_by_id(
+        self,
+        id: int,
+    ) -> Role:
+        role = self.find_by_id(id)
+        if not role:
+            raise ValueError(f"Role with id {id} not found")
+        return role
+
+    def get_user_roles(
+        self,
+        user_id: int,
+    ) -> list[Role]:
+        with psycopg.connect(self.database_url) as conn:
+            with conn.cursor(row_factory=class_row(Role)) as cur:
+                cur.execute(
+                    """
+                    SELECT r.*
+                    FROM user_roles ur
+                    JOIN roles r ON ur.role_id = r.id
+                    WHERE ur.user_id = %(user_id)s AND r.is_active = TRUE
+                    """,
+                    {
+                        "user_id": user_id,
+                    },
+                )
+                return cur.fetchall()
+
+    def assign_role(
+        self,
+        user_id: int,
+        role_id: int,
+    ) -> None:
+        with psycopg.connect(self.database_url) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO user_roles (user_id, role_id)
+                    VALUES (%(user_id)s, %(role_id)s)
+                    ON CONFLICT (user_id, role_id) DO NOTHING
+                    """,
+                    {
+                        "user_id": user_id,
+                        "role_id": role_id,
+                    },
+                )
+
+    def assign_role_by_name(
+        self,
+        user_id: int,
+        role_name: str,
+    ) -> None:
+        with psycopg.connect(self.database_url) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    INSERT INTO user_roles (user_id, role_id)
+                    SELECT %(user_id)s, r.id
+                    FROM roles r
+                    WHERE r.name = %(role_name)s AND r.is_active = TRUE
+                    ON CONFLICT (user_id, role_id) DO NOTHING
+                    """,
+                    {
+                        "user_id": user_id,
+                        "role_name": role_name,
+                    },
+                )

bot_framework/role_management/services/__init__.py

@@ -0,0 +1 @@
+__all__ = []

bot_framework/role_management/services/protocols/__init__.py

@@ -0,0 +1 @@
+__all__ = []

bot_framework/services/__init__.py

@@ -0,0 +1,9 @@
+from .card_field_formatter import CardFieldFormatter
+from .display_width_calculator import DisplayWidthCalculator
+from .remaining_time_formatter import RemainingTimeFormatter
+
+__all__ = [
+    "CardFieldFormatter",
+    "DisplayWidthCalculator",
+    "RemainingTimeFormatter",
+]

bot_framework/services/card_field_formatter.py

@@ -0,0 +1,43 @@
+from bot_framework.protocols import ICardFieldFormatter, IDisplayWidthCalculator
+from bot_framework.services.display_width_calculator import DisplayWidthCalculator
+
+
+class CardFieldFormatter(ICardFieldFormatter):
+    def __init__(
+        self,
+        line_length: int = 43,
+        display_width_calculator: IDisplayWidthCalculator | None = None,
+    ):
+        self.line_length = line_length
+        self._display_width_calculator = display_width_calculator or DisplayWidthCalculator()
+
+    def display_width(self, text: str) -> int:
+        return self._display_width_calculator.calculate(text)
+
+    def generate_field_lines(self, label: str, value: str) -> list[str]:
+        label_width = self.display_width(label)
+        value_width = self.display_width(value)
+
+        if value_width + label_width + 3 <= self.line_length:
+            dots_count = self.line_length - 2 - label_width - value_width
+            dots = "." * max(1, dots_count)
+            return [f"{label} {dots} {value}"]
+
+        lines = [f"{label}:"]
+        if value_width <= self.line_length:
+            lines.append(value)
+        else:
+            words = value.split()
+            current_line = ""
+            for word in words:
+                if not current_line:
+                    current_line = word
+                elif self.display_width(current_line) + self.display_width(word) + 1 <= self.line_length:
+                    current_line += " " + word
+                else:
+                    lines.append(current_line)
+                    current_line = word
+            if current_line:
+                lines.append(current_line)
+
+        return lines

bot_framework/services/display_width_calculator.py

@@ -0,0 +1,45 @@
+import unicodedata
+
+from bot_framework.protocols import IDisplayWidthCalculator
+
+
+class DisplayWidthCalculator(IDisplayWidthCalculator):
+    def calculate(self, text: str) -> int:
+        width = 0
+        i = 0
+        chars = list(text)
+        while i < len(chars):
+            char = chars[i]
+            code_point = ord(char)
+
+            if 0x1F1E6 <= code_point <= 0x1F1FF:
+                if i + 1 < len(chars):
+                    next_code = ord(chars[i + 1])
+                    if 0x1F1E6 <= next_code <= 0x1F1FF:
+                        width += 3
+                        i += 2
+                        continue
+                width += 1
+                i += 1
+                continue
+
+            if self._is_emoji(code_point):
+                width += 3
+                i += 1
+                continue
+
+            ea_width = unicodedata.east_asian_width(char)
+            if ea_width in ("W", "F"):
+                width += 2
+            else:
+                width += 1
+            i += 1
+
+        return width
+
+    def _is_emoji(self, code_point: int) -> bool:
+        return (
+            0x1F300 <= code_point <= 0x1F9FF
+            or 0x2600 <= code_point <= 0x26FF
+            or 0x2700 <= code_point <= 0x27BF
+        )

bot_framework/services/remaining_time_formatter.py

@@ -0,0 +1,31 @@
+from datetime import UTC, datetime
+
+from bot_framework.language_management.repos.protocols.i_phrase_repo import IPhraseRepo
+from bot_framework.protocols import IRemainingTimeFormatter
+
+
+class RemainingTimeFormatter(IRemainingTimeFormatter):
+    def __init__(self, phrase_repo: IPhraseRepo) -> None:
+        self._phrase_repo = phrase_repo
+
+    def format(self, expires_at: datetime, language_code: str) -> str:
+        if expires_at.tzinfo is None:
+            expires_at = expires_at.replace(tzinfo=UTC)
+
+        remaining = expires_at - datetime.now(UTC)
+        total_minutes = max(0, int(remaining.total_seconds() // 60))
+        hours = total_minutes // 60
+        minutes = total_minutes % 60
+
+        hours_suffix = self._phrase_repo.get_phrase(
+            key="shared.time.hours_short",
+            language_code=language_code,
+        )
+        minutes_suffix = self._phrase_repo.get_phrase(
+            key="shared.time.minutes_short",
+            language_code=language_code,
+        )
+
+        if hours > 0:
+            return f"{hours}{hours_suffix} {minutes}{minutes_suffix}"
+        return f"{minutes}{minutes_suffix}"

bot_framework/telegram/__init__.py

@@ -0,0 +1,56 @@
+from .middleware import EnsureUserMiddleware, IMiddleware
+from .protocols import (
+    ICallbackHandler,
+    ICallbackHandlerRegistry,
+    IEnsureUserExists,
+    IFlowRouter,
+    IMarkdownEscaper,
+    IMarkdownToHtmlConverter,
+    IMessageHandler,
+    IMessageHandlerRegistry,
+    IMessageSender,
+    INextStepHandlerRegistrar,
+)
+from .services import (
+    CallbackAnswerer,
+    CallbackHandlerRegistry,
+    CloseCallbackHandler,
+    EnsureUserExists,
+    MarkdownEscaper,
+    MarkdownToHtmlConverter,
+    MessageHandlerRegistry,
+    NextStepHandlerRegistrar,
+    TelegramMessageCore,
+    TelegramMessageDeleter,
+    TelegramMessageReplacer,
+    TelegramMessageSender,
+    TelegramNotifyReplacer,
+)
+
+__all__ = [
+    "CallbackAnswerer",
+    "CallbackHandlerRegistry",
+    "CloseCallbackHandler",
+    "EnsureUserExists",
+    "EnsureUserMiddleware",
+    "ICallbackHandler",
+    "ICallbackHandlerRegistry",
+    "IEnsureUserExists",
+    "IFlowRouter",
+    "IMarkdownEscaper",
+    "IMarkdownToHtmlConverter",
+    "IMessageHandler",
+    "IMessageHandlerRegistry",
+    "IMessageSender",
+    "IMiddleware",
+    "INextStepHandlerRegistrar",
+    "MarkdownEscaper",
+    "MarkdownToHtmlConverter",
+    "MessageHandlerRegistry",
+    "NextStepHandlerRegistrar",
+    "TelegramMessageCore",
+    "TelegramMessageDeleter",
+    "TelegramMessageReplacer",
+    "TelegramMessageSender",
+    "TelegramNotifyReplacer",
+]

bot_framework/telegram/middleware/__init__.py

@@ -0,0 +1,4 @@
+from .ensure_user_middleware import EnsureUserMiddleware
+from .i_middleware import IMiddleware
+
+__all__ = ["EnsureUserMiddleware", "IMiddleware"]

bot_framework/telegram/middleware/ensure_user_middleware.py

@@ -0,0 +1,46 @@
+from telebot.types import CallbackQuery, Message, User as TelegramUser
+
+from bot_framework.entities.bot_user import BotUser
+from bot_framework.protocols import IEnsureUserExists
+from bot_framework.telegram.middleware.i_middleware import IMiddleware
+
+
+class EnsureUserMiddleware(IMiddleware):
+    update_types = ["message", "callback_query"]
+
+    def __init__(self, ensure_user_exists: IEnsureUserExists):
+        super().__init__()
+        self.ensure_user_exists = ensure_user_exists
+        self.update_sensitive = False
+
+    def pre_process(
+        self,
+        message: Message | CallbackQuery,
+        data: dict[str, object],
+    ) -> None:
+        telegram_user = message.from_user
+        if not telegram_user:
+            return
+        bot_user = self._to_bot_user(telegram_user)
+        self.ensure_user_exists.execute(user=bot_user)
+
+    def _to_bot_user(self, telegram_user: TelegramUser) -> BotUser:
+        bot_user = BotUser(
+            id=telegram_user.id,
+            username=telegram_user.username,
+            first_name=telegram_user.first_name,
+            last_name=telegram_user.last_name,
+            language_code=telegram_user.language_code or "en",
+            is_bot=telegram_user.is_bot,
+            is_premium=telegram_user.is_premium or False,
+        )
+        bot_user.set_original(telegram_user)
+        return bot_user
+
+    def post_process(
+        self,
+        message: Message | CallbackQuery,
+        data: dict[str, object],
+        exception: Exception | None,
+    ) -> None:
+        pass

bot_framework/telegram/middleware/i_middleware.py

@@ -0,0 +1,7 @@
+from telebot import TeleBot
+from telebot.handler_backends import BaseMiddleware
+
+
+class IMiddleware(BaseMiddleware):
+    def register(self, bot: TeleBot) -> None:
+        bot.setup_middleware(self)

bot_framework/telegram/protocols/__init__.py

@@ -0,0 +1,36 @@
+from bot_framework.protocols import (
+    ICallbackAnswerer,
+    ICallbackHandler,
+    ICallbackHandlerRegistry,
+    IEnsureUserExists,
+    IFlowRouter,
+    IMarkdownToHtmlConverter,
+    IMessageDeleter,
+    IMessageHandler,
+    IMessageHandlerRegistry,
+    IMessageReplacer,
+    IMessageSender,
+    IMessageService,
+    INextStepHandlerRegistrar,
+    INotifyReplacer,
+)
+
+from .i_markdown_escaper import IMarkdownEscaper
+
+__all__ = [
+    "ICallbackAnswerer",
+    "ICallbackHandler",
+    "ICallbackHandlerRegistry",
+    "IEnsureUserExists",
+    "IFlowRouter",
+    "IMarkdownEscaper",
+    "IMarkdownToHtmlConverter",
+    "IMessageDeleter",
+    "IMessageHandler",
+    "IMessageHandlerRegistry",
+    "IMessageReplacer",
+    "IMessageSender",
+    "IMessageService",
+    "INextStepHandlerRegistrar",
+    "INotifyReplacer",
+]

bot_framework/telegram/protocols/i_markdown_escaper.py

@@ -0,0 +1,5 @@
+from typing import Protocol
+
+
+class IMarkdownEscaper(Protocol):
+    def escape(self, text: str) -> str: ...