parlon-bot 0.1.0__tar.gz

parlon_bot-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parlon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

parlon_bot-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: parlon-bot
+Version: 0.1.0
+Summary: Official Python SDK for Parlon bots (api beta v0.1) — text messages and buttons.
+Author: Parlon
+License-Expression: MIT
+Project-URL: Homepage, https://parlon-app.vercel.app
+Project-URL: Developer Portal, https://parlon-developers.vercel.app
+Keywords: parlon,bot,chatbot,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# parlon-bot
+
+Official Python SDK for **Parlon** bots — **api beta v0.1**.
+
+Supports text messages and buttons today; image messages are coming and will
+first land on the [developer portal](https://parlon-developers.vercel.app),
+then in this library.
+
+## Install
+
+```bash
+pip install parlon-bot
+```
+
+## Get a token
+
+1. Open the [Parlon Developer Portal](https://parlon-developers.vercel.app) and sign in
+   (same account as the main [Parlon](https://parlon-app.vercel.app) app).
+2. Create an application. You get a token **once** — copy it immediately (you
+   can always reset it later, like Discord).
+3. A persistent **Sandbox** server is created for you automatically and your
+   bot is already installed there — open the main Parlon app with the same
+   account to test.
+
+## Quick start
+
+```python
+import os
+from parlon_bot import Bot, ActionRow, Button
+
+bot = Bot(token=os.environ["PARLON_BOT_TOKEN"])
+
+@bot.on_message
+def handle_message(message):
+    if message.content.strip() == "!ping":
+        message.reply(
+            "Pong! Click the button:",
+            components=[ActionRow(Button(label="Again", custom_id="ping_again", style="primary"))],
+        )
+
+@bot.on_button_click
+def handle_click(interaction):
+    if interaction.custom_id == "ping_again":
+        interaction.respond("Pong again! 🏓")
+
+bot.run()
+```
+
+## API
+
+- `Bot(token, *, poll_interval=2.0)` — create a client. `run()` blocks and polls for
+  events; `poll_once(since)` if you want to drive the loop yourself (e.g. inside
+  an existing asyncio/Flask app).
+- `@bot.on_message` — called for every new message in a server this bot is installed
+  in (not its own messages). Handler receives a `Message`.
+- `@bot.on_button_click` — called when a member clicks a button. Handler receives an
+  `Interaction`.
+- `message.reply(content, components=None)` / `interaction.respond(content, components=None)`
+  — send a message into the same channel.
+- `interaction.update_message(content=None, components=None)` — edit the original
+  message the button was attached to (e.g. pass `components=[]` to remove the buttons).
+- `bot.send_message(channel_id, content, components=None)` / `bot.edit_message(message_id, ...)`
+  — lower-level, if you already have a channel/message id.
+- `Button(label, custom_id, style="secondary", disabled=False)` — `style` is one of
+  `primary`, `secondary`, `success`, `danger`.
+- `ActionRow(*buttons)` — up to 5 buttons per row; pass one or more rows as
+  `components=[...]`.
+
+## Permissions & installation
+
+A bot only acts on servers it's installed on, and only within the permissions
+it was granted there (`read_messages`, `send_messages`, `manage_messages`).
+Generate an "Add to server" link from the developer portal's application page —
+whoever manages that server opens it and approves, exactly like adding a bot on
+Discord.
+
+## Notes on this beta
+
+- Delivery is by short-interval HTTP polling (default every 2s), not a
+  persistent socket yet — simple to run anywhere, including from a basic
+  script or a free-tier host. This may be swapped for a real-time gateway in
+  a later version without breaking your bot's code.
+- DMs aren't supported yet — bots operate in server channels only.
+- Report issues / feature requests to the Parlon team.

parlon_bot-0.1.0/README.md

@@ -0,0 +1,84 @@
+# parlon-bot
+
+Official Python SDK for **Parlon** bots — **api beta v0.1**.
+
+Supports text messages and buttons today; image messages are coming and will
+first land on the [developer portal](https://parlon-developers.vercel.app),
+then in this library.
+
+## Install
+
+```bash
+pip install parlon-bot
+```
+
+## Get a token
+
+1. Open the [Parlon Developer Portal](https://parlon-developers.vercel.app) and sign in
+   (same account as the main [Parlon](https://parlon-app.vercel.app) app).
+2. Create an application. You get a token **once** — copy it immediately (you
+   can always reset it later, like Discord).
+3. A persistent **Sandbox** server is created for you automatically and your
+   bot is already installed there — open the main Parlon app with the same
+   account to test.
+
+## Quick start
+
+```python
+import os
+from parlon_bot import Bot, ActionRow, Button
+
+bot = Bot(token=os.environ["PARLON_BOT_TOKEN"])
+
+@bot.on_message
+def handle_message(message):
+    if message.content.strip() == "!ping":
+        message.reply(
+            "Pong! Click the button:",
+            components=[ActionRow(Button(label="Again", custom_id="ping_again", style="primary"))],
+        )
+
+@bot.on_button_click
+def handle_click(interaction):
+    if interaction.custom_id == "ping_again":
+        interaction.respond("Pong again! 🏓")
+
+bot.run()
+```
+
+## API
+
+- `Bot(token, *, poll_interval=2.0)` — create a client. `run()` blocks and polls for
+  events; `poll_once(since)` if you want to drive the loop yourself (e.g. inside
+  an existing asyncio/Flask app).
+- `@bot.on_message` — called for every new message in a server this bot is installed
+  in (not its own messages). Handler receives a `Message`.
+- `@bot.on_button_click` — called when a member clicks a button. Handler receives an
+  `Interaction`.
+- `message.reply(content, components=None)` / `interaction.respond(content, components=None)`
+  — send a message into the same channel.
+- `interaction.update_message(content=None, components=None)` — edit the original
+  message the button was attached to (e.g. pass `components=[]` to remove the buttons).
+- `bot.send_message(channel_id, content, components=None)` / `bot.edit_message(message_id, ...)`
+  — lower-level, if you already have a channel/message id.
+- `Button(label, custom_id, style="secondary", disabled=False)` — `style` is one of
+  `primary`, `secondary`, `success`, `danger`.
+- `ActionRow(*buttons)` — up to 5 buttons per row; pass one or more rows as
+  `components=[...]`.
+
+## Permissions & installation
+
+A bot only acts on servers it's installed on, and only within the permissions
+it was granted there (`read_messages`, `send_messages`, `manage_messages`).
+Generate an "Add to server" link from the developer portal's application page —
+whoever manages that server opens it and approves, exactly like adding a bot on
+Discord.
+
+## Notes on this beta
+
+- Delivery is by short-interval HTTP polling (default every 2s), not a
+  persistent socket yet — simple to run anywhere, including from a basic
+  script or a free-tier host. This may be swapped for a real-time gateway in
+  a later version without breaking your bot's code.
+- DMs aren't supported yet — bots operate in server channels only.
+- Report issues / feature requests to the Parlon team.

parlon_bot-0.1.0/parlon_bot/__init__.py

@@ -0,0 +1,34 @@
+"""parlon-bot — official Python SDK for Parlon bots (api beta v0.1).
+
+    pip install parlon-bot
+
+    from parlon_bot import Bot, Button, ActionRow
+
+    bot = Bot(token="parlon_...")
+
+    @bot.on_message
+    def handle_message(message):
+        if message.content == "!ping":
+            message.reply("pong", components=[ActionRow(Button(label="Again", custom_id="again"))])
+
+    bot.run()
+
+Get a token at the Parlon developer portal (create an application there —
+it's free and instant, and comes with a persistent sandbox server to test in).
+"""
+from .client import Bot
+from .components import ActionRow, Button
+from .errors import ParlonError
+from .models import Channel, Interaction, Message, SentMessage
+
+__version__ = "0.1.0"
+__all__ = [
+    "Bot",
+    "Button",
+    "ActionRow",
+    "Message",
+    "Interaction",
+    "Channel",
+    "SentMessage",
+    "ParlonError",
+]

parlon_bot-0.1.0/parlon_bot/client.py

@@ -0,0 +1,168 @@
+"""The Bot client: authenticate, send messages/buttons, and poll for events."""
+from __future__ import annotations
+
+import time
+import traceback
+from typing import Callable, List, Optional
+
+import requests
+
+from .components import ActionRow, components_to_payload
+from .errors import ParlonError
+from .models import Channel, Interaction, Message, SentMessage
+
+# Public Supabase project backing Parlon. The anon/publishable key below is
+# the same one shipped in the main site's browser bundle — it grants no
+# access by itself, every bot_* RPC verifies YOUR bot token server-side.
+# Point at a different backend (self-hosted / staging) via base_url + anon_key.
+DEFAULT_BASE_URL = "https://zhqazyivekavtsnsfwgm.supabase.co"
+DEFAULT_ANON_KEY = "sb_publishable_ODxl_hlVpNflwdo_M0aKqw_tzIjKCZd"
+
+MessageHandler = Callable[[Message], None]
+InteractionHandler = Callable[[Interaction], None]
+
+
+class Bot:
+    """A Parlon bot.
+
+    Example:
+        bot = Bot(token="parlon_...")
+
+        @bot.on_message
+        def handle_message(message):
+            if message.content == "!ping":
+                message.reply("pong")
+
+        bot.run()
+    """
+
+    def __init__(
+        self,
+        token: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        anon_key: str = DEFAULT_ANON_KEY,
+        poll_interval: float = 2.0,
+    ):
+        if not token:
+            raise ValueError("token is required — create a bot at the Parlon developer portal")
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.anon_key = anon_key
+        self.poll_interval = poll_interval
+
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "apikey": anon_key,
+                "Authorization": f"Bearer {anon_key}",
+                "Content-Type": "application/json",
+            }
+        )
+
+        self._message_handlers: List[MessageHandler] = []
+        self._button_handlers: List[InteractionHandler] = []
+        self._running = False
+
+    # ---------------------------------------------------------------- rpc --
+    def _rpc(self, fn: str, payload: dict) -> dict:
+        resp = self._session.post(f"{self.base_url}/rest/v1/rpc/{fn}", json=payload, timeout=30)
+        if resp.status_code >= 400:
+            message = resp.text
+            code = None
+            try:
+                data = resp.json()
+                message = data.get("message", message)
+                code = data.get("code")
+            except ValueError:
+                pass
+            raise ParlonError(message, code=code)
+        if resp.text == "" or resp.text == "null":
+            return {}
+        return resp.json()
+
+    # ------------------------------------------------------------- actions --
+    def send_message(self, channel_id: str, content: str = "", components: Optional[List[ActionRow]] = None) -> SentMessage:
+        """Send a text message (optionally with buttons) as this bot."""
+        row = self._rpc(
+            "bot_send_message",
+            {
+                "p_token": self.token,
+                "p_channel_id": channel_id,
+                "p_content": content,
+                "p_components": components_to_payload(components),
+            },
+        )
+        return SentMessage(id=row["id"], channel_id=row["channel_id"], content=row["content"], raw=row)
+
+    def edit_message(self, message_id: str, content: Optional[str] = None, components: Optional[List[ActionRow]] = None) -> SentMessage:
+        """Edit a message this bot previously sent. Pass ``components=[]`` to remove its buttons."""
+        row = self._rpc(
+            "bot_edit_message",
+            {
+                "p_token": self.token,
+                "p_message_id": message_id,
+                "p_content": content,
+                "p_components": components_to_payload(components),
+            },
+        )
+        return SentMessage(id=row["id"], channel_id=row["channel_id"], content=row["content"], raw=row)
+
+    def channel(self, channel_id: str) -> Channel:
+        """Get a :class:`Channel` handle to send messages into, by id."""
+        return Channel(self, channel_id)
+
+    # -------------------------------------------------------------- events --
+    def on_message(self, handler: MessageHandler) -> MessageHandler:
+        """Decorator: called for every new message in a server this bot is installed in
+        (excluding the bot's own messages)."""
+        self._message_handlers.append(handler)
+        return handler
+
+    def on_button_click(self, handler: InteractionHandler) -> InteractionHandler:
+        """Decorator: called when a member clicks a button this bot attached to a message."""
+        self._button_handlers.append(handler)
+        return handler
+
+    # ---------------------------------------------------------------- run --
+    def poll_once(self, since: Optional[str] = None) -> str:
+        """Run a single poll cycle; returns the server_time cursor to pass as ``since`` next time."""
+        data = self._rpc("bot_poll", {"p_token": self.token, "p_since": since, "p_limit": 50})
+        for row in data.get("messages", []):
+            for handler in self._message_handlers:
+                try:
+                    handler(Message(self, row))
+                except Exception:  # noqa: BLE001 - keep the bot alive on handler bugs
+                    traceback.print_exc()
+        for row in data.get("interactions", []):
+            for handler in self._button_handlers:
+                try:
+                    handler(Interaction(self, row))
+                except Exception:  # noqa: BLE001
+                    traceback.print_exc()
+        return data.get("server_time", since)
+
+    def run(self) -> None:
+        """Blocking loop: poll for new messages/button clicks every ``poll_interval`` seconds.
+
+        v0.1 beta uses simple HTTP polling (no persistent socket yet) — easy
+        to get started with, and swappable for push delivery later without
+        changing your bot's code.
+        """
+        since = None
+        self._running = True
+        print(f"Parlon bot running (polling every {self.poll_interval}s)... Ctrl+C to stop.")
+        try:
+            while self._running:
+                try:
+                    since = self.poll_once(since)
+                except ParlonError as e:
+                    print(f"[parlon-bot] API error: {e}")
+                time.sleep(self.poll_interval)
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self._running = False
+
+    def stop(self) -> None:
+        self._running = False

parlon_bot-0.1.0/parlon_bot/components.py

@@ -0,0 +1,66 @@
+"""Message components: buttons grouped into action rows.
+
+Only text + buttons are supported in api beta v0.1 (images/attachments will
+be added through the developer portal in a later version).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+VALID_STYLES = ("primary", "secondary", "success", "danger")
+
+
+@dataclass
+class Button:
+    """A single clickable button attached to a bot message.
+
+    Args:
+        label: Text shown on the button.
+        custom_id: Opaque string you choose — echoed back to your
+            ``on_button_click`` handler when a member clicks it, so you know
+            which button was pressed. Must be unique within the message.
+        style: One of "primary", "secondary" (default), "success", "danger".
+        disabled: Render the button but make it unclickable.
+    """
+
+    label: str
+    custom_id: str
+    style: str = "secondary"
+    disabled: bool = False
+
+    def __post_init__(self) -> None:
+        if self.style not in VALID_STYLES:
+            raise ValueError(f"button style must be one of {VALID_STYLES}, got {self.style!r}")
+        if not self.custom_id:
+            raise ValueError("custom_id is required")
+
+    def to_dict(self) -> dict:
+        return {
+            "type": "button",
+            "custom_id": self.custom_id,
+            "label": self.label,
+            "style": self.style,
+            "disabled": self.disabled,
+        }
+
+
+@dataclass
+class ActionRow:
+    """A horizontal row of up to 5 buttons. Pass one or more to `components=`."""
+
+    buttons: List[Button] = field(default_factory=list)
+
+    def __init__(self, *buttons: Button):
+        if len(buttons) > 5:
+            raise ValueError("an action row can hold at most 5 buttons")
+        self.buttons = list(buttons)
+
+    def to_dict(self) -> dict:
+        return {"type": "action_row", "buttons": [b.to_dict() for b in self.buttons]}
+
+
+def components_to_payload(components: Optional[List[ActionRow]]) -> Optional[list]:
+    if components is None:
+        return None
+    return [row.to_dict() for row in components]

parlon_bot-0.1.0/parlon_bot/errors.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Optional
+
+
+class ParlonError(Exception):
+    """Raised when the Parlon API rejects a request (invalid token, missing
+    permission, bot not installed on that server, etc). ``str(error)``
+    contains the server-provided message."""
+
+    def __init__(self, message: str, code: Optional[str] = None):
+        super().__init__(message)
+        self.code = code

parlon_bot-0.1.0/parlon_bot/models.py

@@ -0,0 +1,87 @@
+"""Data models returned to your event handlers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from .components import ActionRow
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import Bot
+
+
+@dataclass
+class SentMessage:
+    """A message that was just sent or edited, returned by ``channel.send`` / ``bot.edit_message``."""
+
+    id: str
+    channel_id: str
+    content: str
+    raw: dict
+
+
+class Channel:
+    """Lightweight handle for sending messages into one channel."""
+
+    def __init__(self, bot: "Bot", channel_id: str):
+        self._bot = bot
+        self.id = channel_id
+
+    def send(self, content: str = "", components: Optional[List[ActionRow]] = None) -> SentMessage:
+        """Send a text message, optionally with buttons, into this channel."""
+        return self._bot.send_message(self.id, content, components=components)
+
+
+class Message:
+    """A message received while polling (from a server the bot is installed in)."""
+
+    def __init__(self, bot: "Bot", raw: dict):
+        self._bot = bot
+        self.raw = raw
+        self.id: str = raw["id"]
+        self.channel_id: str = raw["channel_id"]
+        self.author_id: Optional[str] = raw.get("author_id")
+        self.author_name: str = raw.get("author_name", "")
+        self.content: str = raw.get("content", "")
+        self.created_at: str = raw.get("created_at", "")
+        self.bot_id: Optional[str] = raw.get("bot_id")
+
+    @property
+    def channel(self) -> Channel:
+        return Channel(self._bot, self.channel_id)
+
+    def reply(self, content: str = "", components: Optional[List[ActionRow]] = None) -> SentMessage:
+        return self.channel.send(content, components=components)
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"<Message id={self.id!r} author={self.author_name!r} content={self.content!r}>"
+
+
+class Interaction:
+    """A button click, delivered to your ``on_button_click`` handler."""
+
+    def __init__(self, bot: "Bot", raw: dict):
+        self._bot = bot
+        self.raw = raw
+        self.id: str = raw["id"]
+        self.custom_id: str = raw["custom_id"]
+        self.message_id: str = raw["message_id"]
+        self.channel_id: str = raw["channel_id"]
+        self.server_id: str = raw["server_id"]
+        self.user_id: str = raw["user_id"]
+        self.created_at: str = raw.get("created_at", "")
+
+    @property
+    def channel(self) -> Channel:
+        return Channel(self._bot, self.channel_id)
+
+    def respond(self, content: str = "", components: Optional[List[ActionRow]] = None) -> SentMessage:
+        """Send a new message into the same channel in response to this click."""
+        return self.channel.send(content, components=components)
+
+    def update_message(self, content: Optional[str] = None, components: Optional[List[ActionRow]] = None) -> SentMessage:
+        """Edit the original message the button was attached to (e.g. to disable the button)."""
+        return self._bot.edit_message(self.message_id, content=content, components=components)
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"<Interaction custom_id={self.custom_id!r} user_id={self.user_id!r}>"

parlon_bot-0.1.0/parlon_bot.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: parlon-bot
+Version: 0.1.0
+Summary: Official Python SDK for Parlon bots (api beta v0.1) — text messages and buttons.
+Author: Parlon
+License-Expression: MIT
+Project-URL: Homepage, https://parlon-app.vercel.app
+Project-URL: Developer Portal, https://parlon-developers.vercel.app
+Keywords: parlon,bot,chatbot,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# parlon-bot
+
+Official Python SDK for **Parlon** bots — **api beta v0.1**.
+
+Supports text messages and buttons today; image messages are coming and will
+first land on the [developer portal](https://parlon-developers.vercel.app),
+then in this library.
+
+## Install
+
+```bash
+pip install parlon-bot
+```
+
+## Get a token
+
+1. Open the [Parlon Developer Portal](https://parlon-developers.vercel.app) and sign in
+   (same account as the main [Parlon](https://parlon-app.vercel.app) app).
+2. Create an application. You get a token **once** — copy it immediately (you
+   can always reset it later, like Discord).
+3. A persistent **Sandbox** server is created for you automatically and your
+   bot is already installed there — open the main Parlon app with the same
+   account to test.
+
+## Quick start
+
+```python
+import os
+from parlon_bot import Bot, ActionRow, Button
+
+bot = Bot(token=os.environ["PARLON_BOT_TOKEN"])
+
+@bot.on_message
+def handle_message(message):
+    if message.content.strip() == "!ping":
+        message.reply(
+            "Pong! Click the button:",
+            components=[ActionRow(Button(label="Again", custom_id="ping_again", style="primary"))],
+        )
+
+@bot.on_button_click
+def handle_click(interaction):
+    if interaction.custom_id == "ping_again":
+        interaction.respond("Pong again! 🏓")
+
+bot.run()
+```
+
+## API
+
+- `Bot(token, *, poll_interval=2.0)` — create a client. `run()` blocks and polls for
+  events; `poll_once(since)` if you want to drive the loop yourself (e.g. inside
+  an existing asyncio/Flask app).
+- `@bot.on_message` — called for every new message in a server this bot is installed
+  in (not its own messages). Handler receives a `Message`.
+- `@bot.on_button_click` — called when a member clicks a button. Handler receives an
+  `Interaction`.
+- `message.reply(content, components=None)` / `interaction.respond(content, components=None)`
+  — send a message into the same channel.
+- `interaction.update_message(content=None, components=None)` — edit the original
+  message the button was attached to (e.g. pass `components=[]` to remove the buttons).
+- `bot.send_message(channel_id, content, components=None)` / `bot.edit_message(message_id, ...)`
+  — lower-level, if you already have a channel/message id.
+- `Button(label, custom_id, style="secondary", disabled=False)` — `style` is one of
+  `primary`, `secondary`, `success`, `danger`.
+- `ActionRow(*buttons)` — up to 5 buttons per row; pass one or more rows as
+  `components=[...]`.
+
+## Permissions & installation
+
+A bot only acts on servers it's installed on, and only within the permissions
+it was granted there (`read_messages`, `send_messages`, `manage_messages`).
+Generate an "Add to server" link from the developer portal's application page —
+whoever manages that server opens it and approves, exactly like adding a bot on
+Discord.
+
+## Notes on this beta
+
+- Delivery is by short-interval HTTP polling (default every 2s), not a
+  persistent socket yet — simple to run anywhere, including from a basic
+  script or a free-tier host. This may be swapped for a real-time gateway in
+  a later version without breaking your bot's code.
+- DMs aren't supported yet — bots operate in server channels only.
+- Report issues / feature requests to the Parlon team.

parlon_bot-0.1.0/parlon_bot.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+parlon_bot/__init__.py
+parlon_bot/client.py
+parlon_bot/components.py
+parlon_bot/errors.py
+parlon_bot/models.py
+parlon_bot.egg-info/PKG-INFO
+parlon_bot.egg-info/SOURCES.txt
+parlon_bot.egg-info/dependency_links.txt
+parlon_bot.egg-info/requires.txt
+parlon_bot.egg-info/top_level.txt

parlon_bot-0.1.0/parlon_bot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

parlon_bot-0.1.0/parlon_bot.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

parlon_bot-0.1.0/parlon_bot.egg-info/top_level.txt

@@ -0,0 +1 @@
+parlon_bot

parlon_bot-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parlon-bot"
+version = "0.1.0"
+description = "Official Python SDK for Parlon bots (api beta v0.1) — text messages and buttons."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [{ name = "Parlon" }]
+keywords = ["parlon", "bot", "chatbot", "api", "sdk"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Communications :: Chat",
+]
+dependencies = [
+  "requests>=2.28",
+]
+
+[project.urls]
+Homepage = "https://parlon-app.vercel.app"
+"Developer Portal" = "https://parlon-developers.vercel.app"
+
+[tool.setuptools.packages.find]
+include = ["parlon_bot*"]

parlon_bot-0.1.0/setup.cfg

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