steeper 0.1.0__py3-none-any.whl

steeper/__init__.py

@@ -0,0 +1,16 @@
+"""Steeper — Telegram bot middleware for the Steeper platform."""
+
+__version__ = "0.1.0"
+
+
+def __getattr__(name: str):
+    if name == "SteeperConfig":
+        from steeper._config import SteeperConfig
+        return SteeperConfig
+    if name == "SteeperClient":
+        from steeper._client import SteeperClient
+        return SteeperClient
+    raise AttributeError(f"module 'steeper' has no attribute {name!r}")
+
+
+__all__ = ["SteeperConfig", "SteeperClient"]

steeper/_client.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+import httpx
+
+from steeper._config import SteeperConfig
+
+logger = logging.getLogger("steeper")
+
+
+class SteeperClient:
+    """Async HTTP client that forwards data to the Steeper backend."""
+
+    def __init__(self, config: SteeperConfig, *, timeout: float = 10.0) -> None:
+        self._config = config
+        self._http = httpx.AsyncClient(timeout=timeout)
+
+    async def forward_update(self, update: dict[str, Any]) -> None:
+        """POST a raw Telegram Update to the Steeper webhook endpoint."""
+        try:
+            resp = await self._http.post(
+                self._config.webhook_url,
+                json=update,
+                headers={
+                    "x-telegram-bot-api-secret-token": self._config.token_hash,
+                },
+            )
+            resp.raise_for_status()
+        except httpx.HTTPError as exc:
+            logger.warning("Steeper webhook failed: %s", exc)
+
+    async def log_bot_message(
+        self,
+        chat_id: int,
+        text: str,
+        message_id: int,
+        date: int | None = None,
+    ) -> None:
+        """POST a bot-sent message to the Steeper bot-message endpoint."""
+        payload = {
+            "chat_id": chat_id,
+            "text": text,
+            "message_id": message_id,
+            "date": date or int(time.time()),
+        }
+        try:
+            resp = await self._http.post(
+                self._config.bot_message_url,
+                json=payload,
+            )
+            resp.raise_for_status()
+        except httpx.HTTPError as exc:
+            logger.warning("Steeper bot-message log failed: %s", exc)
+
+    async def close(self) -> None:
+        await self._http.aclose()

steeper/_config.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class SteeperConfig:
+    """Immutable configuration for the Steeper middleware.
+
+    Args:
+        base_url: Steeper backend URL (e.g. ``http://localhost:8000``).
+        bot_id: UUID of the bot registered in Steeper.
+        bot_token: Raw Telegram bot token from BotFather.
+    """
+
+    base_url: str
+    bot_id: str
+    bot_token: str
+
+    @property
+    def token_hash(self) -> str:
+        """SHA-256 hex digest of the bot token, used by the backend for auth."""
+        return hashlib.sha256(self.bot_token.encode()).hexdigest()
+
+    @property
+    def webhook_url(self) -> str:
+        base = self.base_url.rstrip("/")
+        return f"{base}/v1/communications/webhook/{self.bot_id}"
+
+    @property
+    def bot_message_url(self) -> str:
+        base = self.base_url.rstrip("/")
+        return f"{base}/v1/communications/webhook/{self.token_hash}/bot-message"

steeper/integrations/aiogram.py

@@ -0,0 +1,136 @@
+"""Steeper middleware for **aiogram v3**.
+
+Usage::
+
+    from aiogram import Bot, Dispatcher
+    from steeper.integrations.aiogram import SteeperMiddleware
+
+    bot = Bot(token=BOT_TOKEN)
+    dp = Dispatcher()
+
+    steeper = SteeperMiddleware(
+        base_url="http://localhost:8000",
+        bot_id="<uuid>",
+        bot_token=BOT_TOKEN,
+    )
+    steeper.setup(dp, bot)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Awaitable
+
+from steeper._client import SteeperClient
+from steeper._config import SteeperConfig
+
+logger = logging.getLogger("steeper.aiogram")
+
+try:
+    from aiogram import BaseMiddleware, Bot, Dispatcher
+    from aiogram.types import Update, Message
+except ImportError as _exc:
+    raise ImportError(
+        "aiogram>=3.0 is required for this integration. "
+        "Install it with: pip install steeper[aiogram]"
+    ) from _exc
+
+
+class _IncomingMiddleware(BaseMiddleware):
+    """Outer middleware on ``Update`` — forwards raw updates to Steeper."""
+
+    def __init__(self, client: SteeperClient) -> None:
+        self._client = client
+
+    async def __call__(
+        self,
+        handler: Callable[[Update, dict[str, Any]], Awaitable[Any]],
+        event: Update,
+        data: dict[str, Any],
+    ) -> Any:
+        raw = event.model_dump(mode="json")
+        await self._client.forward_update(raw)
+        return await handler(event, data)
+
+
+class _OutgoingMiddleware(BaseMiddleware):
+    """Outer middleware on ``Message`` (response) — catches bot replies."""
+
+    def __init__(self, client: SteeperClient) -> None:
+        self._client = client
+
+    async def __call__(
+        self,
+        handler: Callable[[Message, dict[str, Any]], Awaitable[Any]],
+        event: Message,
+        data: dict[str, Any],
+    ) -> Any:
+        result = await handler(event, data)
+        if isinstance(result, Message):
+            await self._client.log_bot_message(
+                chat_id=result.chat.id,
+                text=result.text or result.caption or "",
+                message_id=result.message_id,
+                date=int(result.date.timestamp()) if result.date else None,
+            )
+        return result
+
+
+def _wrap_bot_send(bot: Bot, client: SteeperClient) -> None:
+    """Monkey-patch ``Bot.send_message`` to also log to Steeper."""
+    _original_send = bot.send_message
+
+    async def _patched_send(*args: Any, **kwargs: Any) -> Message:
+        result: Message = await _original_send(*args, **kwargs)
+        try:
+            await client.log_bot_message(
+                chat_id=result.chat.id,
+                text=result.text or result.caption or "",
+                message_id=result.message_id,
+                date=int(result.date.timestamp()) if result.date else None,
+            )
+        except Exception:
+            logger.debug("Failed to log outgoing message", exc_info=True)
+        return result
+
+    bot.send_message = _patched_send  # type: ignore[assignment]
+
+
+class SteeperMiddleware:
+    """All-in-one Steeper integration for aiogram v3.
+
+    Call :meth:`setup` to register both incoming and outgoing hooks.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        bot_id: str,
+        bot_token: str,
+        *,
+        timeout: float = 10.0,
+    ) -> None:
+        self._config = SteeperConfig(
+            base_url=base_url,
+            bot_id=bot_id,
+            bot_token=bot_token,
+        )
+        self._client = SteeperClient(self._config, timeout=timeout)
+
+    def setup(self, dp: Dispatcher, bot: Bot) -> None:
+        """Register Steeper on the dispatcher and bot.
+
+        - Incoming updates are forwarded via an outer Update middleware.
+        - Outgoing ``send_message`` calls are patched to log bot replies.
+        """
+        dp.update.outer_middleware(self._incoming)
+        _wrap_bot_send(bot, self._client)
+        logger.info("Steeper middleware registered for aiogram")
+
+    @property
+    def _incoming(self) -> _IncomingMiddleware:
+        return _IncomingMiddleware(self._client)
+
+    @property
+    def client(self) -> SteeperClient:
+        return self._client

steeper/integrations/ptb.py

@@ -0,0 +1,176 @@
+"""Steeper middleware for **python-telegram-bot** (PTB v20+).
+
+Usage::
+
+    from telegram.ext import ApplicationBuilder
+    from steeper.integrations.ptb import SteeperMiddleware
+
+    app = ApplicationBuilder().token(BOT_TOKEN).build()
+
+    steeper = SteeperMiddleware(
+        base_url="http://localhost:8000",
+        bot_id="<uuid>",
+        bot_token=BOT_TOKEN,
+    )
+    steeper.setup(app)
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from steeper._client import SteeperClient
+from steeper._config import SteeperConfig
+
+logger = logging.getLogger("steeper.ptb")
+
+try:
+    from telegram import Message, Update, User, Chat
+    from telegram.ext import (
+        Application,
+        BaseHandler,
+        ContextTypes,
+    )
+except ImportError as _exc:
+    raise ImportError(
+        "python-telegram-bot>=20.0 is required for this integration. "
+        "Install it with: pip install steeper[ptb]"
+    ) from _exc
+
+
+def _update_to_dict(update: Update) -> dict[str, Any]:
+    """Convert a PTB Update to a Telegram-compatible dict."""
+    raw: dict[str, Any] = {"update_id": update.update_id}
+
+    if update.message:
+        raw["message"] = _message_to_dict(update.message)
+    if update.edited_message:
+        raw["edited_message"] = _message_to_dict(update.edited_message)
+    return raw
+
+
+def _user_to_dict(user: User) -> dict[str, Any]:
+    data: dict[str, Any] = {
+        "id": user.id,
+        "is_bot": user.is_bot,
+        "first_name": user.first_name,
+    }
+    if user.last_name:
+        data["last_name"] = user.last_name
+    if user.username:
+        data["username"] = user.username
+    if user.language_code:
+        data["language_code"] = user.language_code
+    return data
+
+
+def _chat_to_dict(chat: Chat) -> dict[str, Any]:
+    data: dict[str, Any] = {"id": chat.id, "type": chat.type}
+    if chat.title:
+        data["title"] = chat.title
+    if chat.username:
+        data["username"] = chat.username
+    if chat.first_name:
+        data["first_name"] = chat.first_name
+    if chat.last_name:
+        data["last_name"] = chat.last_name
+    return data
+
+
+def _message_to_dict(msg: Message) -> dict[str, Any]:
+    data: dict[str, Any] = {
+        "message_id": msg.message_id,
+        "chat": _chat_to_dict(msg.chat),
+        "date": int(msg.date.timestamp()) if msg.date else int(time.time()),
+    }
+    if msg.from_user:
+        data["from"] = _user_to_dict(msg.from_user)
+    if msg.text:
+        data["text"] = msg.text
+    if msg.caption:
+        data["caption"] = msg.caption
+    return data
+
+
+class _SteeperHandler(BaseHandler[Update, ContextTypes.DEFAULT_TYPE]):
+    """Low-priority handler that intercepts every update for Steeper logging."""
+
+    def __init__(self, client: SteeperClient) -> None:
+        super().__init__(callback=self._noop)
+        self._client = client
+
+    def check_update(self, update: object) -> bool:
+        return isinstance(update, Update)
+
+    async def handle_update(
+        self,
+        update: Update,
+        application: Application,  # type: ignore[type-arg]
+        check_result: Any,
+        context: ContextTypes.DEFAULT_TYPE,
+    ) -> None:
+        raw = _update_to_dict(update)
+        await self._client.forward_update(raw)
+
+    @staticmethod
+    async def _noop(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        pass
+
+
+def _wrap_bot_send(application: Application, client: SteeperClient) -> None:  # type: ignore[type-arg]
+    """Patch ``Bot.send_message`` to also log to Steeper."""
+    bot = application.bot
+    _original_send = bot.send_message
+
+    async def _patched_send(*args: Any, **kwargs: Any) -> Message:
+        result: Message = await _original_send(*args, **kwargs)
+        try:
+            await client.log_bot_message(
+                chat_id=result.chat.id,
+                text=result.text or result.caption or "",
+                message_id=result.message_id,
+                date=int(result.date.timestamp()) if result.date else None,
+            )
+        except Exception:
+            logger.debug("Failed to log outgoing message", exc_info=True)
+        return result
+
+    bot.send_message = _patched_send  # type: ignore[assignment]
+
+
+class SteeperMiddleware:
+    """All-in-one Steeper integration for python-telegram-bot v20+.
+
+    Call :meth:`setup` to register both incoming and outgoing hooks.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        bot_id: str,
+        bot_token: str,
+        *,
+        timeout: float = 10.0,
+    ) -> None:
+        self._config = SteeperConfig(
+            base_url=base_url,
+            bot_id=bot_id,
+            bot_token=bot_token,
+        )
+        self._client = SteeperClient(self._config, timeout=timeout)
+
+    def setup(self, application: Application) -> None:  # type: ignore[type-arg]
+        """Register Steeper hooks on a PTB Application.
+
+        - Incoming: a low-priority handler that captures every Update.
+        - Outgoing: ``Bot.send_message`` is patched to log bot replies.
+        """
+        application.add_handler(_SteeperHandler(self._client), group=-1)
+        _wrap_bot_send(application, self._client)
+        logger.info("Steeper middleware registered for python-telegram-bot")
+
+    @property
+    def client(self) -> SteeperClient:
+        return self._client

steeper/integrations/telebot.py

@@ -0,0 +1,167 @@
+"""Steeper middleware for **pyTelegramBotAPI** (telebot).
+
+Usage::
+
+    import telebot
+    from steeper.integrations.telebot import SteeperMiddleware
+
+    bot = telebot.TeleBot(BOT_TOKEN)
+
+    steeper = SteeperMiddleware(
+        base_url="http://localhost:8000",
+        bot_id="<uuid>",
+        bot_token=BOT_TOKEN,
+    )
+    steeper.setup(bot)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Any
+
+from steeper._client import SteeperClient
+from steeper._config import SteeperConfig
+
+logger = logging.getLogger("steeper.telebot")
+
+try:
+    import telebot as _telebot
+    from telebot import types as tg_types
+except ImportError as _exc:
+    raise ImportError(
+        "pyTelegramBotAPI>=4.0 is required for this integration. "
+        "Install it with: pip install steeper[telebot]"
+    ) from _exc
+
+
+def _run_async(coro: Any) -> None:
+    """Fire-and-forget an async coroutine from sync context."""
+    try:
+        loop = asyncio.get_running_loop()
+        loop.create_task(coro)
+    except RuntimeError:
+        asyncio.run(coro)
+
+
+def _update_to_dict(update: tg_types.Update) -> dict[str, Any]:
+    """Convert a telebot Update to a Telegram-compatible dict."""
+    raw: dict[str, Any] = {"update_id": update.update_id}
+
+    if update.message:
+        raw["message"] = _message_to_dict(update.message)
+    if update.edited_message:
+        raw["edited_message"] = _message_to_dict(update.edited_message)
+    return raw
+
+
+def _message_to_dict(msg: tg_types.Message) -> dict[str, Any]:
+    """Convert a telebot Message to a Telegram-compatible dict."""
+    data: dict[str, Any] = {
+        "message_id": msg.message_id,
+        "chat": {"id": msg.chat.id, "type": msg.chat.type},
+        "date": msg.date or int(time.time()),
+    }
+    if msg.chat.title:
+        data["chat"]["title"] = msg.chat.title
+    if msg.chat.username:
+        data["chat"]["username"] = msg.chat.username
+    if msg.chat.first_name:
+        data["chat"]["first_name"] = msg.chat.first_name
+    if msg.chat.last_name:
+        data["chat"]["last_name"] = msg.chat.last_name
+
+    if msg.from_user:
+        data["from"] = {
+            "id": msg.from_user.id,
+            "is_bot": msg.from_user.is_bot,
+            "first_name": msg.from_user.first_name,
+        }
+        if msg.from_user.last_name:
+            data["from"]["last_name"] = msg.from_user.last_name
+        if msg.from_user.username:
+            data["from"]["username"] = msg.from_user.username
+        if msg.from_user.language_code:
+            data["from"]["language_code"] = msg.from_user.language_code
+
+    if msg.text:
+        data["text"] = msg.text
+    if msg.caption:
+        data["caption"] = msg.caption
+    return data
+
+
+class SteeperMiddleware:
+    """All-in-one Steeper integration for pyTelegramBotAPI.
+
+    Call :meth:`setup` to register both incoming and outgoing hooks.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        bot_id: str,
+        bot_token: str,
+        *,
+        timeout: float = 10.0,
+    ) -> None:
+        self._config = SteeperConfig(
+            base_url=base_url,
+            bot_id=bot_id,
+            bot_token=bot_token,
+        )
+        self._client = SteeperClient(self._config, timeout=timeout)
+
+    def setup(self, bot: _telebot.TeleBot) -> None:
+        """Register Steeper hooks on a sync TeleBot instance.
+
+        - Incoming: ``middleware_handler`` that fires on every update.
+        - Outgoing: ``send_message`` is patched to log bot replies.
+        """
+        bot.use_class_middlewares = True
+
+        class _Incoming(_telebot.handler_backends.BaseMiddleware):
+            update_types = ["message", "edited_message"]
+
+            def __init__(self_inner) -> None:  # noqa: N805
+                super().__init__()
+                self_inner.client = self._client
+
+            def pre_process(self_inner, message: tg_types.Message, data: dict[str, Any]) -> None:  # noqa: N805
+                update_dict: dict[str, Any] = {
+                    "update_id": 0,
+                    "message": _message_to_dict(message),
+                }
+                _run_async(self_inner.client.forward_update(update_dict))
+
+            def post_process(self_inner, message: tg_types.Message, data: dict[str, Any], exception: BaseException | None) -> None:  # noqa: N805
+                pass
+
+        bot.register_middleware_handler(_Incoming())
+
+        _original_send = bot.send_message
+
+        def _patched_send(*args: Any, **kwargs: Any) -> tg_types.Message:
+            result: tg_types.Message = _original_send(*args, **kwargs)
+            try:
+                _run_async(
+                    self._client.log_bot_message(
+                        chat_id=result.chat.id,
+                        text=result.text or result.caption or "",
+                        message_id=result.message_id,
+                        date=result.date or int(time.time()),
+                    )
+                )
+            except Exception:
+                logger.debug("Failed to log outgoing message", exc_info=True)
+            return result
+
+        bot.send_message = _patched_send  # type: ignore[assignment]
+
+        logger.info("Steeper middleware registered for pyTelegramBotAPI")
+
+    @property
+    def client(self) -> SteeperClient:
+        return self._client

steeper-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: steeper
+Version: 0.1.0
+Summary: Telegram bot middleware for Steeper — intercepts updates and outgoing messages to sync with the Steeper platform.
+Project-URL: Homepage, https://github.com/steeper/steeper
+Project-URL: Repository, https://github.com/steeper/steeper
+License-Expression: MIT
+Keywords: aiogram,bot,middleware,python-telegram-bot,steeper,telebot,telegram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: Communications :: Chat
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25
+Provides-Extra: aiogram
+Requires-Dist: aiogram>=3.0; extra == 'aiogram'
+Provides-Extra: all
+Requires-Dist: aiogram>=3.0; extra == 'all'
+Requires-Dist: pytelegrambotapi>=4.0; extra == 'all'
+Requires-Dist: python-telegram-bot>=20.0; extra == 'all'
+Provides-Extra: ptb
+Requires-Dist: python-telegram-bot>=20.0; extra == 'ptb'
+Provides-Extra: telebot
+Requires-Dist: pytelegrambotapi>=4.0; extra == 'telebot'
+Description-Content-Type: text/markdown
+
+# Steeper
+
+Telegram bot middleware that syncs incoming user messages and outgoing bot replies with the **Steeper** platform.
+
+## Installation
+
+```bash
+# Core (pick one extra for your framework)
+pip install steeper[aiogram]     # aiogram v3
+pip install steeper[telebot]     # pyTelegramBotAPI
+pip install steeper[ptb]         # python-telegram-bot v20+
+```
+
+## Configuration
+
+Every integration requires three values:
+
+| Parameter   | Description                                  |
+|-------------|----------------------------------------------|
+| `base_url`  | Steeper backend URL (e.g. `http://localhost:8000`) |
+| `bot_id`    | UUID of the bot registered in Steeper        |
+| `bot_token` | Raw Telegram bot token from BotFather        |
+
+## Usage
+
+### aiogram v3
+
+```python
+from aiogram import Bot, Dispatcher
+from steeper.integrations.aiogram import SteeperMiddleware
+
+BOT_TOKEN = "123456:ABC-DEF..."
+bot = Bot(token=BOT_TOKEN)
+dp = Dispatcher()
+
+steeper = SteeperMiddleware(
+    base_url="http://localhost:8000",
+    bot_id="your-bot-uuid",
+    bot_token=BOT_TOKEN,
+)
+steeper.setup(dp, bot)
+
+# ... register your handlers as usual ...
+dp.run_polling(bot)
+```
+
+### pyTelegramBotAPI (telebot)
+
+```python
+import telebot
+from steeper.integrations.telebot import SteeperMiddleware
+
+BOT_TOKEN = "123456:ABC-DEF..."
+bot = telebot.TeleBot(BOT_TOKEN)
+
+steeper = SteeperMiddleware(
+    base_url="http://localhost:8000",
+    bot_id="your-bot-uuid",
+    bot_token=BOT_TOKEN,
+)
+steeper.setup(bot)
+
+# ... register your handlers as usual ...
+bot.polling()
+```
+
+### python-telegram-bot v20+
+
+```python
+from telegram.ext import ApplicationBuilder
+from steeper.integrations.ptb import SteeperMiddleware
+
+BOT_TOKEN = "123456:ABC-DEF..."
+app = ApplicationBuilder().token(BOT_TOKEN).build()
+
+steeper = SteeperMiddleware(
+    base_url="http://localhost:8000",
+    bot_id="your-bot-uuid",
+    bot_token=BOT_TOKEN,
+)
+steeper.setup(app)
+
+# ... register your handlers as usual ...
+app.run_polling()
+```
+
+## How it works
+
+1. **Incoming messages** — the middleware intercepts every Telegram Update, serializes it to the standard Telegram JSON format, and POSTs it to the Steeper webhook endpoint. Your handlers still run normally.
+
+2. **Outgoing messages** — `Bot.send_message` is patched so that every bot reply is also logged to the Steeper bot-message endpoint.
+
+Both operations are fire-and-forget: if the Steeper backend is unreachable, a warning is logged but your bot continues to work.
+
+## License
+
+MIT

steeper-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+steeper/__init__.py,sha256=lf6SiHgcInqYbkhHmqUskqlS3VJvjdd-2vqFd9nSefc,462
+steeper/_client.py,sha256=4ElOj0SVFnCFU98W0s_FJgzj95fl1g9kgFF46bb-W2k,1756
+steeper/_config.py,sha256=GKWDYbIB_t_S4erWjwv9Swmvvk44jW0L9rjzr68tIDg,987
+steeper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+steeper/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+steeper/integrations/aiogram.py,sha256=P7YsQPDtltkSNoV95O5KT4nDhb4GZbChPHxOYhk5_WE,4109
+steeper/integrations/ptb.py,sha256=DB0lyq1wEeO3aN_gZe31sj_NOX0CpxgK0nHqmdkAA70,5313
+steeper/integrations/telebot.py,sha256=YI_cWHS8lbLldfIdjPDDSJ4yhm9s-1IfV_ad6aI10CQ,5319
+steeper-0.1.0.dist-info/METADATA,sha256=EHGee0FWIavTQ5PurY9x1BLcVYEl1g36X9gk5lm9p2M,3877
+steeper-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+steeper-0.1.0.dist-info/RECORD,,

steeper-0.1.0.dist-info/WHEEL

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