banterbotapi 0.2.4__tar.gz → 0.2.5__tar.gz

{banterbotapi-0.2.4 → banterbotapi-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banterbotapi
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python SDK for building bots on Banter (banterchat.org) — discord.py-style.
 Author-email: Banter <contact@banterchat.org>
 License-Expression: MIT

{banterbotapi-0.2.4 → banterbotapi-0.2.5}/banterapi/__init__.py

@@ -23,7 +23,7 @@ The library mirrors discord.py conventions where possible. See the Bot,
 Intents, Embed, and Permissions classes for the main entry points.
 """
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 from .client import Bot
 from .intents import Intents

{banterbotapi-0.2.4 → banterbotapi-0.2.5}/banterapi/client.py

@@ -47,6 +47,140 @@ _DEFAULT_BASE_URL = "https://banterchat.org"
 _GATEWAY_PATH = "/api/v1/bot/gateway"
 
 
+def _auto_options_from_signature(fn):
+    """Best-effort convert a prefix-command signature into slash options.
+
+    Skips the leading ctx parameter. Maps int → integer, bool → boolean,
+    everything else → string. A parameter with a default is marked
+    optional; one without is required. Keyword-only (*, text: str)
+    gets the same treatment as a normal positional — the interaction
+    adapter joins all option values into args_raw so the
+    remainder-grabbing behaviour still works.
+    """
+    from .commands import OPTION_STRING, OPTION_INTEGER, OPTION_BOOLEAN
+    try:
+        sig = inspect.signature(fn)
+    except (ValueError, TypeError):
+        return []
+    params = list(sig.parameters.values())[1:]  # skip ctx
+    out = []
+    for p in params:
+        if p.kind is inspect.Parameter.VAR_POSITIONAL:
+            # *args — too unstructured for the slash UI to render.
+            continue
+        if p.annotation is int:
+            opt_type = OPTION_INTEGER
+        elif p.annotation is bool:
+            opt_type = OPTION_BOOLEAN
+        else:
+            opt_type = OPTION_STRING
+        required = p.default is inspect.Parameter.empty
+        out.append({
+            "name": p.name,
+            "type": opt_type,
+            "description": p.name,
+            "required": required,
+        })
+    return out
+
+
+class _InteractionContext:
+    """Context adapter for prefix commands invoked via slash.
+
+    Presents the same surface as commands.Context (bot/message/author/
+    channel_id/guild_id/reply/send/trigger_typing) but routes replies
+    through interaction.respond() so the server emits the correct
+    slash_command_response event + ephemeral gating.
+
+    Built on the fly in Bot._dispatch for interaction_create events
+    when the command is registered as a prefix command with slash=True.
+    """
+
+    def __init__(self, bot, interaction):
+        self.bot = bot
+        self.interaction = interaction
+        self.invoked_with = interaction.command_name
+        # Build args_raw from the options dict in stable (alphabetical)
+        # order so prefix-command parsers that read positional args
+        # still work. Values are space-joined; string values with
+        # spaces are NOT quoted — options with spaces need to declare
+        # a keyword-only parameter (def cmd(ctx, *, text: str)) which
+        # consumes the rest of the string.
+        opts = interaction.options or {}
+        self.args_raw = " ".join(str(opts[k]) for k in sorted(opts.keys()))
+        # author_perms isn't carried in the interaction event today;
+        # set to 0 and rely on server-side perm checks. has_permissions
+        # will return False for everything, which is safe-by-default.
+        self.author_perms = 0
+        # Synthetic author + channel + message stubs so handlers that
+        # access these attrs don't crash. Kept minimal — handlers that
+        # need real user data should use the Interaction API directly
+        # or upgrade to @bot.slash_command.
+        self.channel_id = interaction.channel_id
+        self.guild_id = interaction.guild_id
+        self.author = _StubUser(interaction.user_id)
+        self.channel = None
+        self.message = _StubMessage(interaction)
+
+    def has_permissions(self, required):
+        # Without perm data in the interaction payload we can't check.
+        # Return False so guarded commands fail closed; handlers that
+        # rely on this should be @bot.slash_command instead.
+        return False
+
+    async def send(self, content="", embed=None):
+        return await self.reply(content=content, embed=embed)
+
+    async def reply(self, content="", embed=None):
+        if self.interaction._responded:
+            await self.interaction.followup(content=content, embed=embed)
+        else:
+            await self.interaction.respond(content=content, embed=embed)
+
+    async def trigger_typing(self):
+        # Mapped to defer so the thinking indicator stays up.
+        if not self.interaction._responded:
+            try:
+                await self.interaction.defer()
+            except Exception:
+                pass
+
+
+class _StubUser:
+    __slots__ = ("id", "username", "display_name", "bot")
+
+    def __init__(self, user_id):
+        self.id = user_id
+        self.username = ""
+        self.display_name = ""
+        self.bot = False
+
+
+class _StubMessage:
+    """Enough of a Message to keep handlers that touch ctx.message happy."""
+    __slots__ = ("_interaction", "id", "user_id", "channel_id", "guild_id", "content")
+
+    def __init__(self, interaction):
+        self._interaction = interaction
+        self.id = interaction.id
+        self.user_id = interaction.user_id
+        self.channel_id = interaction.channel_id
+        self.guild_id = interaction.guild_id
+        self.content = ""
+
+    async def reply(self, content="", embed=None):
+        if self._interaction._responded:
+            await self._interaction.followup(content=content, embed=embed)
+        else:
+            await self._interaction.respond(content=content, embed=embed)
+
+    async def add_reaction(self, emoji):
+        # Not meaningful on a synthetic interaction message. No-op so
+        # example code doesn't crash; bot devs who need real reactions
+        # should use @bot.slash_command + explicit channel.send().
+        return None
+
+
 class Bot:
     """Main bot entry point.
 
@@ -213,14 +347,20 @@ class Bot:
                     "name": cmd.name,
                     "description": description or cmd.help or cmd.name,
                 }
+                from .commands import SlashOption as _SO
                 if options:
-                    # Defer import to avoid a circular: commands.py is
-                    # loaded by client.py, and SlashOption lives there.
-                    from .commands import SlashOption as _SO
                     entry["options"] = [
                         (o.to_dict() if isinstance(o, _SO) else dict(o))
                         for o in options
                     ]
+                else:
+                    # No explicit options declared: try to auto-generate
+                    # from the function signature so prefix-style typed
+                    # handlers (def echo(ctx, *, text: str)) work via
+                    # slash without the author repeating themselves.
+                    auto = _auto_options_from_signature(fn)
+                    if auto:
+                        entry["options"] = auto
                 self._slash_commands.append(entry)
             return fn
         return decorator
@@ -413,13 +553,9 @@ class Bot:
             return
 
         if event_type == "interaction_create":
-            # Route slash-command invocations to their registered
-            # handlers. Falls back to a no-op (plus on_raw_event) if
-            # the command name isn't known — that shouldn't normally
-            # happen because the server filters by command ownership,
-            # but we don't want to crash the dispatch loop on drift.
             from .interactions import Interaction
             interaction = Interaction(payload, client=self)
+            # Dedicated @bot.slash_command handler — takes an Interaction.
             handler = self._slash_handlers.get(interaction.command_name)
             if handler is not None:
                 try:
@@ -428,6 +564,41 @@ class Bot:
                         await result
                 except Exception:
                     log.exception("slash handler %r raised", interaction.command_name)
+                await self._fire("on_interaction", interaction)
+                return
+            # Fall back to a prefix-style @bot.command handler. Build a
+            # Context adapter so the handler's existing ctx.reply / send
+            # / args-parsing keep working; responses route through
+            # interaction.respond.
+            cmd = self._commands.get(interaction.command_name)
+            if cmd is not None:
+                ctx = _InteractionContext(self, interaction)
+                try:
+                    await cmd.invoke(ctx)
+                    # If the handler never called reply/send, ack the
+                    # interaction so the server stops spinning. Sending
+                    # an empty message would fail validation; defer is
+                    # the safe no-op.
+                    if not interaction._responded:
+                        try:
+                            await interaction.defer()
+                        except Exception:
+                            pass
+                except CommandError as e:
+                    await self._fire("on_command_error", ctx, e)
+                    if not interaction._responded:
+                        try:
+                            await interaction.respond(f"error: {e}")
+                        except Exception:
+                            pass
+                except Exception as e:
+                    await self._fire("on_command_error", ctx, e)
+                    log.exception("prefix handler %r raised on interaction", interaction.command_name)
+                    if not interaction._responded:
+                        try:
+                            await interaction.respond(f"error: {e}")
+                        except Exception:
+                            pass
             else:
                 log.warning(
                     "received interaction for unknown slash command %r",

{banterbotapi-0.2.4 → banterbotapi-0.2.5}/banterbotapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banterbotapi
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python SDK for building bots on Banter (banterchat.org) — discord.py-style.
 Author-email: Banter <contact@banterchat.org>
 License-Expression: MIT

{banterbotapi-0.2.4 → banterbotapi-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "banterbotapi"
-version = "0.2.4"
+version = "0.2.5"
 description = "Python SDK for building bots on Banter (banterchat.org) — discord.py-style."
 readme = "README.md"
 requires-python = ">=3.9"