hidmart 0.2.0__tar.gz

hidmart-0.2.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: hidmart
+Version: 0.2.0
+Summary: Async Python framework for building token-based bots for Bale Messenger
+Author: HidMart Team
+License: MIT
+Project-URL: Homepage, https://github.com/programmersatlantis-hash/HidMart
+Project-URL: Repository, https://github.com/programmersatlantis-hash/HidMart
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0,>=0.27
+
+# HidMart
+
+<div align="center">
+
+# HidMart
+
+### Async Python Framework for Bale Messenger Bots
+
+[![Python](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python)](https://www.python.org/)
+[![GitHub](https://img.shields.io/badge/GitHub-HidMart-black?logo=github)](https://github.com/programmersatlantis-hash/HidMart)
+[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/programmersatlantis-hash/HidMart)
+
+</div>
+
+---
+
+## Installation
+
+Install the latest version of **HidMart** directly from GitHub.
+
+### Install with pip
+
+```bash
+pip install https://github.com/programmersatlantis-hash/HidMart/archive/main.zip --force-reinstall

hidmart-0.2.0/README.md

@@ -0,0 +1,24 @@
+# HidMart
+
+<div align="center">
+
+# HidMart
+
+### Async Python Framework for Bale Messenger Bots
+
+[![Python](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python)](https://www.python.org/)
+[![GitHub](https://img.shields.io/badge/GitHub-HidMart-black?logo=github)](https://github.com/programmersatlantis-hash/HidMart)
+[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/programmersatlantis-hash/HidMart)
+
+</div>
+
+---
+
+## Installation
+
+Install the latest version of **HidMart** directly from GitHub.
+
+### Install with pip
+
+```bash
+pip install https://github.com/programmersatlantis-hash/HidMart/archive/main.zip --force-reinstall

hidmart-0.2.0/hidmart/__init__.py

@@ -0,0 +1,29 @@
+from .bot import Bot
+
+from .types import (
+    Message,
+    User,
+    Chat,
+)
+
+from .exceptions import (
+    HidMartError,
+    APIError,
+    NetworkError,
+    InvalidTokenError,
+)
+
+
+__version__ = "0.2.0"
+
+
+__all__ = [
+    "Bot",
+    "Message",
+    "User",
+    "Chat",
+    "HidMartError",
+    "APIError",
+    "NetworkError",
+    "InvalidTokenError",
+]

hidmart-0.2.0/hidmart/bot.py

@@ -0,0 +1,425 @@
+import asyncio
+import logging
+
+from .client import BaleClient
+from .types import Message
+from .handlers import (
+    CommandHandler,
+    MessageHandler,
+    TextHandler,
+)
+
+
+logger = logging.getLogger("hidmart")
+
+
+class Bot:
+
+    def __init__(
+        self,
+        token: str,
+        poll_interval: float = 1.0,
+        timeout: int = 25,
+    ):
+
+        if not token:
+            raise ValueError(
+                "Bot token is required"
+            )
+
+        self.token = token
+
+        self.poll_interval = poll_interval
+        self.timeout = timeout
+
+        self.client = BaleClient(
+            token
+        )
+
+        self.handlers = []
+
+        self.running = False
+
+        self.offset = None
+
+        self.me = None
+
+    # -------------------------
+    # Handlers
+    # -------------------------
+
+    def on_command(self, *commands):
+
+        if not commands:
+            raise ValueError(
+                "At least one command is required"
+            )
+
+        def decorator(callback):
+
+            for command in commands:
+
+                self.handlers.append(
+                    CommandHandler(
+                        command,
+                        callback,
+                    )
+                )
+
+            return callback
+
+        return decorator
+
+    def on_message(self):
+
+        def decorator(callback):
+
+            self.handlers.append(
+                MessageHandler(
+                    callback
+                )
+            )
+
+            return callback
+
+        return decorator
+
+    def on_text(self, text):
+
+        def decorator(callback):
+
+            self.handlers.append(
+                TextHandler(
+                    text,
+                    callback,
+                )
+            )
+
+            return callback
+
+        return decorator
+
+    # -------------------------
+    # API methods
+    # -------------------------
+
+    async def send_message(
+        self,
+        chat_id,
+        text,
+        **kwargs,
+    ):
+
+        return await self.client.send_message(
+            chat_id,
+            text,
+            **kwargs,
+        )
+
+    async def send_photo(
+        self,
+        chat_id,
+        photo,
+        caption=None,
+        **kwargs,
+    ):
+
+        return await self.client.send_photo(
+            chat_id,
+            photo,
+            caption,
+            **kwargs,
+        )
+
+    async def send_video(
+        self,
+        chat_id,
+        video,
+        caption=None,
+        **kwargs,
+    ):
+
+        return await self.client.send_video(
+            chat_id,
+            video,
+            caption,
+            **kwargs,
+        )
+
+    async def send_audio(
+        self,
+        chat_id,
+        audio,
+        caption=None,
+        **kwargs,
+    ):
+
+        return await self.client.send_audio(
+            chat_id,
+            audio,
+            caption,
+            **kwargs,
+        )
+
+    async def send_document(
+        self,
+        chat_id,
+        document,
+        caption=None,
+        **kwargs,
+    ):
+
+        return await self.client.send_document(
+            chat_id,
+            document,
+            caption,
+            **kwargs,
+        )
+
+    async def send_voice(
+        self,
+        chat_id,
+        voice,
+        caption=None,
+        **kwargs,
+    ):
+
+        return await self.client.send_voice(
+            chat_id,
+            voice,
+            caption,
+            **kwargs,
+        )
+
+    async def send_location(
+        self,
+        chat_id,
+        latitude,
+        longitude,
+        **kwargs,
+    ):
+
+        return await self.client.send_location(
+            chat_id,
+            latitude,
+            longitude,
+            **kwargs,
+        )
+
+    async def edit_message_text(
+        self,
+        chat_id,
+        message_id,
+        text,
+        **kwargs,
+    ):
+
+        return await self.client.edit_message_text(
+            chat_id,
+            message_id,
+            text,
+            **kwargs,
+        )
+
+    async def delete_message(
+        self,
+        chat_id,
+        message_id,
+    ):
+
+        return await self.client.delete_message(
+            chat_id,
+            message_id,
+        )
+
+    async def get_me(self):
+
+        self.me = await self.client.get_me()
+
+        return self.me
+
+    async def get_chat(self, chat_id):
+
+        return await self.client.get_chat(
+            chat_id
+        )
+
+    async def get_chat_member(
+        self,
+        chat_id,
+        user_id,
+    ):
+
+        return await self.client.get_chat_member(
+            chat_id,
+            user_id,
+        )
+
+    async def get_updates(
+        self,
+        offset=None,
+        timeout=None,
+        limit=None,
+    ):
+
+        if timeout is None:
+            timeout = self.timeout
+
+        return await self.client.get_updates(
+            offset=offset,
+            timeout=timeout,
+            limit=limit,
+        )
+
+    # -------------------------
+    # Update processing
+    # -------------------------
+
+    async def process_update(
+        self,
+        update,
+    ):
+
+        if not isinstance(update, dict):
+            return
+
+        message_data = update.get(
+            "message"
+        )
+
+        if not message_data:
+            return
+
+        message = Message.from_dict(
+            message_data,
+            bot=self,
+        )
+
+        for handler in self.handlers:
+
+            try:
+
+                if hasattr(
+                    handler,
+                    "matches",
+                ):
+
+                    if not handler.matches(
+                        message
+                    ):
+                        continue
+
+                await handler.run(
+                    message
+                )
+
+            except Exception:
+
+                logger.exception(
+                    "Handler error"
+                )
+
+    # -------------------------
+    # Polling
+    # -------------------------
+
+    async def polling(self):
+
+        self.running = True
+
+        logger.info(
+            "HidMart polling started"
+        )
+
+        while self.running:
+
+            try:
+
+                updates = await self.get_updates(
+                    offset=self.offset
+                )
+
+                if not updates:
+
+                    await asyncio.sleep(
+                        self.poll_interval
+                    )
+
+                    continue
+
+                for update in updates:
+
+                    update_id = update.get(
+                        "update_id"
+                    )
+
+                    if update_id is not None:
+
+                        self.offset = (
+                            update_id + 1
+                        )
+
+                    await self.process_update(
+                        update
+                    )
+
+            except asyncio.CancelledError:
+
+                break
+
+            except Exception:
+
+                logger.exception(
+                    "Polling error"
+                )
+
+                await asyncio.sleep(
+                    3
+                )
+
+        logger.info(
+            "HidMart polling stopped"
+        )
+
+    async def start(self):
+
+        self.running = True
+
+        self.me = await self.get_me()
+
+        logger.info(
+            "Bot started: %s",
+            self.me,
+        )
+
+        await self.polling()
+
+    async def stop(self):
+
+        self.running = False
+
+        await self.client.close()
+
+    async def _run(self):
+
+        try:
+
+            await self.start()
+
+        finally:
+
+            await self.client.close()
+
+    def run(self):
+
+        try:
+
+            asyncio.run(
+                self._run()
+            )
+
+        except KeyboardInterrupt:
+
+            logger.info(
+                "HidMart stopped by user"
+            )

hidmart-0.2.0/hidmart/client.py

@@ -0,0 +1,357 @@
+import asyncio
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .exceptions import (
+    APIError,
+    NetworkError,
+    InvalidTokenError,
+)
+
+
+class BaleClient:
+    """
+    Low-level asynchronous client for Bale Bot API.
+    """
+
+    def __init__(
+        self,
+        token: str,
+        base_url: str = "https://tapi.bale.ai",
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        if not token:
+            raise ValueError("Bot token is required")
+
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+        self.http = httpx.AsyncClient(
+            timeout=httpx.Timeout(timeout)
+        )
+
+    def _url(self, method: str) -> str:
+        return f"{self.base_url}/bot{self.token}/{method}"
+
+    async def call(
+        self,
+        method: str,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """
+        Call a Bale Bot API method.
+        """
+
+        payload = data or {}
+
+        last_error = None
+
+        for attempt in range(self.max_retries + 1):
+
+            try:
+                response = await self.http.post(
+                    self._url(method),
+                    json=payload,
+                )
+
+                response.raise_for_status()
+
+                try:
+                    result = response.json()
+                except ValueError as exc:
+                    raise APIError(
+                        "Invalid JSON response from Bale API"
+                    ) from exc
+
+                if not result.get("ok", False):
+
+                    error_code = result.get("error_code")
+                    description = result.get(
+                        "description",
+                        "Bale API request failed",
+                    )
+
+                    if error_code == 401:
+                        raise InvalidTokenError(
+                            description
+                        )
+
+                    raise APIError(
+                        description=description,
+                        error_code=error_code,
+                    )
+
+                return result.get("result")
+
+            except InvalidTokenError:
+                raise
+
+            except APIError:
+                raise
+
+            except httpx.HTTPStatusError as exc:
+                last_error = exc
+
+                if attempt >= self.max_retries:
+                    raise NetworkError(
+                        f"HTTP error: {exc.response.status_code}"
+                    ) from exc
+
+            except httpx.RequestError as exc:
+                last_error = exc
+
+                if attempt >= self.max_retries:
+                    raise NetworkError(
+                        f"Network error: {exc}"
+                    ) from exc
+
+            except httpx.HTTPError as exc:
+                last_error = exc
+
+                if attempt >= self.max_retries:
+                    raise NetworkError(
+                        f"HTTP error: {exc}"
+                    ) from exc
+
+            if attempt < self.max_retries:
+                await asyncio.sleep(2 ** attempt)
+
+        raise NetworkError(
+            f"Request failed: {last_error}"
+        )
+
+    async def get_me(self):
+        return await self.call("getMe")
+
+    async def get_updates(
+        self,
+        offset: Optional[int] = None,
+        timeout: int = 25,
+        limit: Optional[int] = None,
+    ):
+        data = {
+            "timeout": timeout,
+        }
+
+        if offset is not None:
+            data["offset"] = offset
+
+        if limit is not None:
+            data["limit"] = limit
+
+        return await self.call(
+            "getUpdates",
+            data,
+        )
+
+    async def send_message(
+        self,
+        chat_id,
+        text: str,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "text": text,
+        }
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendMessage",
+            data,
+        )
+
+    async def send_photo(
+        self,
+        chat_id,
+        photo,
+        caption: Optional[str] = None,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "photo": photo,
+        }
+
+        if caption is not None:
+            data["caption"] = caption
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendPhoto",
+            data,
+        )
+
+    async def send_video(
+        self,
+        chat_id,
+        video,
+        caption: Optional[str] = None,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "video": video,
+        }
+
+        if caption is not None:
+            data["caption"] = caption
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendVideo",
+            data,
+        )
+
+    async def send_audio(
+        self,
+        chat_id,
+        audio,
+        caption: Optional[str] = None,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "audio": audio,
+        }
+
+        if caption is not None:
+            data["caption"] = caption
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendAudio",
+            data,
+        )
+
+    async def send_document(
+        self,
+        chat_id,
+        document,
+        caption: Optional[str] = None,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "document": document,
+        }
+
+        if caption is not None:
+            data["caption"] = caption
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendDocument",
+            data,
+        )
+
+    async def send_voice(
+        self,
+        chat_id,
+        voice,
+        caption: Optional[str] = None,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "voice": voice,
+        }
+
+        if caption is not None:
+            data["caption"] = caption
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendVoice",
+            data,
+        )
+
+    async def send_location(
+        self,
+        chat_id,
+        latitude: float,
+        longitude: float,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude,
+        }
+
+        data.update(kwargs)
+
+        return await self.call(
+            "sendLocation",
+            data,
+        )
+
+    async def edit_message_text(
+        self,
+        chat_id,
+        message_id,
+        text: str,
+        **kwargs,
+    ):
+        data = {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "text": text,
+        }
+
+        data.update(kwargs)
+
+        return await self.call(
+            "editMessageText",
+            data,
+        )
+
+    async def delete_message(
+        self,
+        chat_id,
+        message_id,
+    ):
+        return await self.call(
+            "deleteMessage",
+            {
+                "chat_id": chat_id,
+                "message_id": message_id,
+            },
+        )
+
+    async def get_chat(
+        self,
+        chat_id,
+    ):
+        return await self.call(
+            "getChat",
+            {
+                "chat_id": chat_id,
+            },
+        )
+
+    async def get_chat_member(
+        self,
+        chat_id,
+        user_id,
+    ):
+        return await self.call(
+            "getChatMember",
+            {
+                "chat_id": chat_id,
+                "user_id": user_id,
+            },
+        )
+
+    async def close(self):
+        await self.http.aclose()

hidmart-0.2.0/hidmart/exceptions.py

@@ -0,0 +1,25 @@
+class HidMartError(Exception):
+    """Base exception for HidMart."""
+
+
+class APIError(HidMartError):
+    """Raised when Bale API returns an error."""
+
+    def __init__(self, description=None, error_code=None):
+        self.description = description or "Unknown API error"
+        self.error_code = error_code
+
+        if error_code is not None:
+            message = f"[{error_code}] {self.description}"
+        else:
+            message = self.description
+
+        super().__init__(message)
+
+
+class NetworkError(HidMartError):
+    """Raised when a network request fails."""
+
+
+class InvalidTokenError(HidMartError):
+    """Raised when the bot token is invalid."""

hidmart-0.2.0/hidmart/handlers.py

@@ -0,0 +1,58 @@
+import inspect
+
+
+class Handler:
+
+    def __init__(self, callback):
+        self.callback = callback
+
+    async def run(self, message):
+        result = self.callback(message)
+
+        if inspect.isawaitable(result):
+            await result
+
+
+class CommandHandler(Handler):
+
+    def __init__(self, command, callback):
+        super().__init__(callback)
+
+        self.commands = {
+            command.lstrip("/").lower()
+        }
+
+    def matches(self, message):
+
+        if not message.text:
+            return False
+
+        text = message.text.strip()
+
+        if not text.startswith("/"):
+            return False
+
+        command = text[1:].split()[0].lower()
+
+        return command in self.commands
+
+
+class MessageHandler(Handler):
+
+    def matches(self, message):
+        return bool(message.text)
+
+
+class TextHandler(Handler):
+
+    def __init__(self, text, callback):
+        super().__init__(callback)
+
+        self.text = text
+
+    def matches(self, message):
+
+        if not message.text:
+            return False
+
+        return message.text == self.text

hidmart-0.2.0/hidmart/types.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from typing import Optional, Any, Dict
+
+
+@dataclass
+class User:
+
+    id: int
+
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    username: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+
+        return cls(
+            id=data.get("id"),
+            first_name=data.get("first_name"),
+            last_name=data.get("last_name"),
+            username=data.get("username"),
+        )
+
+    @property
+    def full_name(self):
+
+        parts = []
+
+        if self.first_name:
+            parts.append(self.first_name)
+
+        if self.last_name:
+            parts.append(self.last_name)
+
+        return " ".join(parts)
+
+
+@dataclass
+class Chat:
+
+    id: int
+
+    type: Optional[str] = None
+    title: Optional[str] = None
+    username: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+
+        return cls(
+            id=data.get("id"),
+            type=data.get("type"),
+            title=data.get("title"),
+            username=data.get("username"),
+        )
+
+    @property
+    def is_private(self):
+
+        return self.type == "private"
+
+    @property
+    def is_group(self):
+
+        return self.type in (
+            "group",
+            "supergroup",
+        )
+
+
+@dataclass
+class Message:
+
+    message_id: int
+
+    chat: Chat
+
+    from_user: Optional[User] = None
+
+    text: Optional[str] = None
+
+    raw: Optional[Dict[str, Any]] = None
+
+    bot: Any = None
+
+    @classmethod
+    def from_dict(
+        cls,
+        data: Dict[str, Any],
+        bot=None,
+    ):
+
+        user_data = data.get("from")
+        chat_data = data.get("chat", {})
+
+        return cls(
+            message_id=data.get("message_id"),
+            chat=Chat.from_dict(chat_data),
+            from_user=(
+                User.from_dict(user_data)
+                if user_data
+                else None
+            ),
+            text=data.get("text"),
+            raw=data,
+            bot=bot,
+        )
+
+    @property
+    def id(self):
+
+        return self.message_id
+
+    @property
+    def sender(self):
+
+        return self.from_user
+
+    async def reply(self, text: str, **kwargs):
+
+        return await self.bot.send_message(
+            chat_id=self.chat.id,
+            text=text,
+            **kwargs,
+        )
+
+    async def answer(self, text: str, **kwargs):
+
+        return await self.reply(
+            text,
+            **kwargs,
+        )
+
+    async def delete(self):
+
+        return await self.bot.delete_message(
+            chat_id=self.chat.id,
+            message_id=self.message_id,
+        )

hidmart-0.2.0/hidmart.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: hidmart
+Version: 0.2.0
+Summary: Async Python framework for building token-based bots for Bale Messenger
+Author: HidMart Team
+License: MIT
+Project-URL: Homepage, https://github.com/programmersatlantis-hash/HidMart
+Project-URL: Repository, https://github.com/programmersatlantis-hash/HidMart
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0,>=0.27
+
+# HidMart
+
+<div align="center">
+
+# HidMart
+
+### Async Python Framework for Bale Messenger Bots
+
+[![Python](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python)](https://www.python.org/)
+[![GitHub](https://img.shields.io/badge/GitHub-HidMart-black?logo=github)](https://github.com/programmersatlantis-hash/HidMart)
+[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/programmersatlantis-hash/HidMart)
+
+</div>
+
+---
+
+## Installation
+
+Install the latest version of **HidMart** directly from GitHub.
+
+### Install with pip
+
+```bash
+pip install https://github.com/programmersatlantis-hash/HidMart/archive/main.zip --force-reinstall

hidmart-0.2.0/hidmart.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+hidmart/__init__.py
+hidmart/bot.py
+hidmart/client.py
+hidmart/exceptions.py
+hidmart/handlers.py
+hidmart/types.py
+hidmart.egg-info/PKG-INFO
+hidmart.egg-info/SOURCES.txt
+hidmart.egg-info/dependency_links.txt
+hidmart.egg-info/requires.txt
+hidmart.egg-info/top_level.txt
+tests/test_basic.py

hidmart-0.2.0/hidmart.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hidmart-0.2.0/hidmart.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx<1.0,>=0.27

hidmart-0.2.0/hidmart.egg-info/top_level.txt

@@ -0,0 +1 @@
+hidmart

hidmart-0.2.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hidmart"
+version = "0.2.0"
+description = "Async Python framework for building token-based bots for Bale Messenger"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+
+authors = [
+    {name = "HidMart Team"}
+]
+
+dependencies = [
+    "httpx>=0.27,<1.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/programmersatlantis-hash/HidMart"
+Repository = "https://github.com/programmersatlantis-hash/HidMart"
+
+[tool.setuptools.packages.find]
+include = ["hidmart*"]

hidmart-0.2.0/setup.cfg

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

hidmart-0.2.0/tests/test_basic.py

@@ -0,0 +1,69 @@
+from hidmart import (
+    Bot,
+    Message,
+    User,
+    Chat,
+    APIError,
+    NetworkError,
+)
+
+
+def test_bot_creation():
+
+    bot = Bot(
+        "TEST_TOKEN"
+    )
+
+    assert bot.token == "TEST_TOKEN"
+
+    assert bot.handlers == []
+
+    assert bot.offset is None
+
+
+def test_user():
+
+    user = User(
+        id=123,
+        first_name="Ali",
+        last_name="Test",
+        username="ali",
+    )
+
+    assert user.id == 123
+
+    assert user.username == "ali"
+
+    assert user.full_name == "Ali Test"
+
+
+def test_chat():
+
+    chat = Chat(
+        id=123,
+        type="private",
+    )
+
+    assert chat.id == 123
+
+    assert chat.is_private is True
+
+    assert chat.is_group is False
+
+
+def test_message():
+
+    chat = Chat(
+        id=123,
+        type="private",
+    )
+
+    message = Message(
+        message_id=1,
+        chat=chat,
+        text="Hello",
+    )
+
+    assert message.id == 1
+
+    assert message.text == "Hello"