cordscript 1.0.0__py3-none-any.whl

cordscript/__init__.py

@@ -0,0 +1,6 @@
+from .client import Client
+from .parser import Parser
+from .functions.database import Database
+
+__version__ = "1.0.0"
+__all__ = ["Client", "Parser", "Database"]

cordscript/client.py

@@ -0,0 +1,590 @@
+from __future__ import annotations
+import os
+import json
+import logging
+import importlib.util
+import inspect
+import aiohttp
+import discord
+from discord import ui
+from .parser import Parser
+from .functions.database import Database
+
+logging.getLogger("discord").setLevel(logging.WARNING)
+logging.getLogger("discord.http").setLevel(logging.WARNING)
+logging.getLogger("discord.gateway").setLevel(logging.WARNING)
+logging.getLogger("discord.client").setLevel(logging.WARNING)
+
+
+class _Color:
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+    BRIGHT_BLACK = "\033[90m"
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+
+    ORANGE = "\033[38;5;208m"
+    PURPLE = "\033[38;5;93m"
+    PINK = "\033[38;5;205m"
+    GOLD = "\033[38;5;220m"
+    LIME = "\033[38;5;154m"
+    TEAL = "\033[38;5;30m"
+    NAVY = "\033[38;5;17m"
+    BROWN = "\033[38;5;94m"
+    GRAY = "\033[38;5;245m"
+    LIGHT_GRAY = "\033[38;5;250m"
+    DARK_RED = "\033[38;5;88m"
+    DARK_GREEN = "\033[38;5;22m"
+    SKY_BLUE = "\033[38;5;117m"
+    INDIGO = "\033[38;5;54m"
+    SALMON = "\033[38;5;209m"
+    TURQUOISE = "\033[38;5;80m"
+
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+    BG_WHITE = "\033[47m"
+
+
+def _tag() -> str:
+    return f"{_Color.PURPLE}{_Color.BOLD}[cordscript]{_Color.RESET}"
+
+_CV2_FLAG = 1 << 15
+
+
+def _build_view(components: list[dict], client: "Client") -> ui.View | None:
+    view = ui.View(timeout=None)
+    added = False
+    for comp in components:
+        if comp.get("type") == 1:
+            for item in comp.get("components", []):
+                if _add_item(view, item, client):
+                    added = True
+        elif comp.get("type") in (2, 3):
+            if _add_item(view, comp, client):
+                added = True
+    return view if added else None
+
+
+def _add_item(view: ui.View, item: dict, client: "Client") -> bool:
+    try:
+        t = item.get("type")
+        if t == 2:
+            style_map = {
+                1: discord.ButtonStyle.primary,
+                2: discord.ButtonStyle.secondary,
+                3: discord.ButtonStyle.success,
+                4: discord.ButtonStyle.danger,
+            }
+            style = style_map.get(item.get("style", 1), discord.ButtonStyle.primary)
+            emoji = None
+            if "emoji" in item:
+                e = item["emoji"]
+                if e.get("id"):
+                    emoji = discord.PartialEmoji(
+                        name=e.get("name", ""),
+                        id=int(e["id"]),
+                        animated=e.get("animated", False)
+                    )
+                else:
+                    emoji = e.get("name")
+            btn = ui.Button(
+                label=item.get("label", ""),
+                custom_id=item.get("custom_id"),
+                style=style,
+                emoji=emoji,
+                disabled=item.get("disabled", False),
+                url=item.get("url"),
+            )
+            async def btn_cb(interaction: discord.Interaction, cid=item.get("custom_id")):
+                await client._dispatch_interaction(interaction, cid)
+            btn.callback = btn_cb
+            view.add_item(btn)
+            return True
+
+        elif t == 3:
+            options = [
+                discord.SelectOption(
+                    label=o.get("label", ""),
+                    value=o.get("value", ""),
+                    description=o.get("description"),
+                    default=o.get("default", False),
+                    emoji=o.get("emoji", {}).get("name") if "emoji" in o else None,
+                )
+                for o in item.get("options", [])
+            ]
+            sel = ui.Select(
+                custom_id=item.get("custom_id"),
+                placeholder=item.get("placeholder"),
+                min_values=item.get("min_values", 1),
+                max_values=item.get("max_values", 1),
+                disabled=item.get("disabled", False),
+                options=options or [discord.SelectOption(label="placeholder", value="placeholder")],
+            )
+            async def sel_cb(interaction: discord.Interaction, cid=item.get("custom_id")):
+                await client._dispatch_interaction(interaction, cid)
+            sel.callback = sel_cb
+            view.add_item(sel)
+            return True
+    except Exception as e:
+        print(f"[cordscript] Error building component: {e}")
+    return False
+
+
+async def _send_payload(
+    channel,
+    text: str,
+    embeds: list,
+    components: list,
+    cv2: list,
+    token: str,
+    delete_after=None,
+    reply_to=None,
+    client=None,
+):
+    if cv2:
+        url = f"https://discord.com/api/v10/channels/{channel.id}/messages"
+        headers = {"Authorization": f"Bot {token}", "Content-Type": "application/json"}
+        payload: dict = {"flags": _CV2_FLAG, "components": cv2}
+        if reply_to is not None:
+            msg_id = reply_to.id if isinstance(reply_to, discord.Message) else None
+            if msg_id:
+                payload["message_reference"] = {"message_id": str(msg_id)}
+        async with aiohttp.ClientSession() as session:
+            resp = await session.post(url, headers=headers, data=json.dumps(payload))
+            if not resp.ok:
+                print(f"[cordscript cv2] Error {resp.status}: {await resp.text()}")
+        return None
+
+    kwargs: dict = {}
+    if text is not None and len(text.strip()) > 0:
+        kwargs["content"] = text
+    if embeds:
+        kwargs["embeds"] = [discord.Embed.from_dict(e) for e in embeds]
+    if components and client:
+        view = _build_view(components, client)
+        if view:
+            kwargs["view"] = view
+
+    if not kwargs:
+        return None
+
+    if delete_after is not None:
+        kwargs["delete_after"] = delete_after
+
+    if reply_to is not None:
+        try:
+            return await reply_to.reply(**kwargs)
+        except Exception:
+            pass
+
+    return await channel.send(**kwargs)
+
+
+class Client(discord.Client):
+    def __init__(
+        self,
+        *,
+        prefix: str | list[str],
+        token: str,
+        insensitive: bool = False,
+        ignoreBots: bool = True,
+        intents: discord.Intents | None = None,
+        database=None,
+        database_url: str | None = None,
+        editMessage: bool = False,
+        **kwargs,
+    ):
+        resolved_intents = intents or discord.Intents.all()
+        resolved_intents.message_content = True
+        resolved_intents.members = True
+        super().__init__(intents=resolved_intents, **kwargs)
+
+        self._prefixes: list[str] = [prefix] if isinstance(prefix, str) else list(prefix)
+        self._token = token
+        self._insensitive = insensitive
+        self._ignore_bots = ignoreBots
+        self._edit_message = editMessage
+        self._commands: dict[str, dict] = {}
+        self._static_commands: set[str] = set()
+        self._static_entries: dict[str, tuple] = {}
+        self._interactions: list[dict] = []
+        self._ready_command: dict | None = None
+        self._memberadd_command: dict | None = None
+        self._memberremove_command: dict | None = None
+        self._commands_path: str | None = None
+        self._main_file: str | None = None
+        self._loaded_commands: int = 0
+
+        if database is None and database_url is None:
+            database = Database()
+
+        self._database = database
+        self._database_url = database_url
+        self._client_var_name: str | None = None
+
+    async def setup_hook(self):
+        if self._database_url and not isinstance(self._database, Database):
+            from .functions.database import connect_from_url, _init_table
+            self._database = await connect_from_url(self._database_url)
+            await _init_table(self._database)
+        elif self._database is not None and not isinstance(self._database, Database):
+            from .functions.database import _init_table
+            await _init_table(self._database)
+
+    def command(self, *, name: str, code: str, aliases: list[str] | None = None):
+        key = name.lower() if self._insensitive else name
+        entry = {"name": name, "code": code}
+        self._commands[key] = entry
+        self._static_commands.add(key)
+        self._static_entries[key] = (name, code, aliases)
+        for alias in (aliases or []):
+            alias_key = alias.lower() if self._insensitive else alias
+            self._commands[alias_key] = entry
+            self._static_commands.add(alias_key)
+
+    def interaction(self, *, code: str, customId: str | None = None):
+        self._interactions.append({"customId": customId, "code": code})
+
+    def readyCommand(self, *, code: str):
+        self._ready_command = {"code": code}
+
+    def memberadd(self, *, code: str, channelId: int | str | None = None):
+        self._memberadd_command = {"code": code, "channelId": channelId}
+
+    def memberremove(self, *, code: str, channelId: int | str | None = None):
+        self._memberremove_command = {"code": code, "channelId": channelId}
+
+    def loadCommands(self, path: str):
+        self._commands_path = os.path.abspath(path)
+        self._load_from_path(self._commands_path)
+
+    def reloadCommands(self, path: str | None = None):
+        if self._commands_path:
+            for k in list(self._commands.keys()):
+                if k not in self._static_commands:
+                    del self._commands[k]
+            self._load_from_path(os.path.abspath(path) if path else self._commands_path)
+            return
+
+        if not self._main_file:
+            return
+
+        for k in list(self._commands.keys()):
+            if k not in self._static_commands:
+                del self._commands[k]
+
+        spec = importlib.util.spec_from_file_location("__main_reload__", self._main_file)
+        module = importlib.util.module_from_spec(spec)
+        var = self._client_var_name or "bot"
+        setattr(module, var, self)
+        module.bot = self
+
+        _original_run = self.__class__.run
+
+        def _noop_run(self_, *a, **kw):
+            pass
+
+        self.__class__.run = _noop_run
+        try:
+            spec.loader.exec_module(module)
+            print("[cordscript] Reloaded main file")
+        except Exception as e:
+            print(f"[cordscript] Failed to reload: {e}")
+        finally:
+            self.__class__.run = _original_run
+
+    def _load_from_path(self, path: str):
+        loaded = 0
+        var = self._client_var_name or "bot"
+        for root, _, files in os.walk(path):
+            for filename in files:
+                if not filename.endswith(".py") or filename.startswith("_"):
+                    continue
+                filepath = os.path.join(root, filename)
+                spec = importlib.util.spec_from_file_location(filename[:-3], filepath)
+                module = importlib.util.module_from_spec(spec)
+                setattr(module, var, self)
+                module.bot = self
+                try:
+                    spec.loader.exec_module(module)
+                    loaded += 1
+                except Exception as e:
+                    print(f"{_tag()} {_Color.YELLOW}failed to load {filepath}: {e}{_Color.RESET}")
+        self._loaded_commands = loaded
+
+    def run(self, token: str | None = None):
+        frame = inspect.stack()[1]
+        self._main_file = os.path.abspath(frame.filename)
+        for var, val in frame[0].f_locals.items():
+            if val is self and not var.startswith("_"):
+                self._client_var_name = var
+                break
+        super().run(token or self._token)
+
+    async def on_ready(self):
+        print(
+            f"{_tag()} Logged in as "
+            f"{_Color.GREEN}{self.user}{_Color.RESET} "
+            f"(ID: {_Color.YELLOW}{self.user.id}{_Color.RESET})"
+        )
+        print(f"{_tag()} Registered commands: {_Color.GREEN}{self._loaded_commands}{_Color.RESET}")
+
+        if self._ready_command:
+            await self._execute_ready(self._ready_command["code"])
+
+    async def on_member_join(self, member: discord.Member):
+        if self._memberadd_command:
+            await self._execute_member_event(
+                member, self._memberadd_command["code"],
+                channel_id=self._memberadd_command.get("channelId"),
+            )
+
+    async def on_member_remove(self, member: discord.Member):
+        if self._memberremove_command:
+            await self._execute_member_event(
+                member, self._memberremove_command["code"],
+                channel_id=self._memberremove_command.get("channelId"),
+            )
+
+    async def on_message(self, message: discord.Message):
+        if self._ignore_bots and message.author.bot:
+            return
+        await self._handle_message(message)
+
+    async def on_message_edit(self, before: discord.Message, after: discord.Message):
+        if not self._edit_message:
+            return
+        if self._ignore_bots and after.author.bot:
+            return
+        if before.content == after.content:
+            return
+        await self._handle_message(after)
+
+    async def _handle_message(self, message: discord.Message):
+        content = message.content
+        matched_prefix: str | None = None
+        for prefix in self._prefixes:
+            cc = content.lower() if self._insensitive else content
+            cp = prefix.lower() if self._insensitive else prefix
+            if cc.startswith(cp):
+                matched_prefix = prefix
+                break
+        if matched_prefix is None:
+            return
+        raw = content[len(matched_prefix):]
+        parts = raw.split(None, 1)
+        if not parts:
+            return
+        cmd_name = parts[0].lower() if self._insensitive else parts[0]
+        command = self._commands.get(cmd_name)
+        if not command:
+            return
+        await self._execute(message, command["code"])
+
+    async def _dispatch_interaction(self, interaction: discord.Interaction, custom_id: str | None):
+        for entry in self._interactions:
+            if entry["customId"] is None or entry["customId"] == custom_id:
+                await self._execute_interaction(interaction, entry["code"])
+                return
+
+    async def _execute(self, ctx: discord.Message, code: str):
+        parser = Parser(ctx, self)
+        text, embeds, extra_messages = await parser.evaluate(code)
+
+        reply_content = parser._reply_content
+        has_reply = parser._reply
+        has_content = (text is not None and len(text.strip()) > 0) or (has_reply and reply_content and len(reply_content.strip()) > 0)
+        has_embeds = len(embeds) > 0
+        has_cv2 = len(parser._cv2_pending) > 0
+        has_components = len(parser._components) > 0
+
+        send_text = reply_content if (has_reply and reply_content) else text
+        reply_to = ctx if has_reply else None
+
+        if has_cv2:
+            # ComponentsV2 messages cannot contain content or embeds, only components.
+            await _send_payload(
+                ctx.channel, None, [], [],
+                parser._cv2_pending, self._token,
+                delete_after=parser._delete_after,
+                reply_to=reply_to, client=self
+            )
+        elif has_content or has_embeds or has_components:
+            await _send_payload(
+                ctx.channel, send_text, embeds, parser._components,
+                [], self._token,
+                delete_after=parser._delete_after,
+                reply_to=reply_to, client=self
+            )
+
+        for msg in extra_messages:
+            await self._send_extra(msg)
+
+    async def _send_extra(self, msg: dict):
+        channel_id = msg["channel_id"]
+        channel = self.get_channel(channel_id)
+        if not channel:
+            try:
+                channel = await self.fetch_channel(channel_id)
+            except Exception as e:
+                print(f"[cordscript] _send_extra fetch_channel failed: {e}")
+                return
+
+        sent = await _send_payload(
+            channel,
+            msg.get("content", ""),
+            msg.get("embeds", []),
+            msg.get("components", []),
+            msg.get("cv2", []),
+            self._token,
+            delete_after=msg.get("delete_after"),
+            client=self,
+        )
+
+        if msg.get("return_id") and sent is not None:
+            parser = msg.get("_parser")
+            var_name = msg.get("return_var")
+            if parser and var_name:
+                parser._vars[var_name] = str(sent.id)
+
+    async def _execute_interaction(self, interaction: discord.Interaction, code: str):
+        parser = Parser(interaction, self)
+        text, embeds, extra_messages = await parser.evaluate(code)
+
+        reply_content = parser._reply_content
+        has_reply = parser._reply
+        has_content = (text is not None and len(text.strip()) > 0) or (has_reply and reply_content and len(reply_content.strip()) > 0)
+        has_embeds = len(embeds) > 0
+        has_cv2 = len(parser._cv2_pending) > 0
+        has_components = len(parser._components) > 0
+
+        send_text = reply_content if (has_reply and reply_content) else text
+
+        if has_cv2:
+            # ComponentsV2 responses cannot contain content or embeds, only components.
+            if not interaction.response.is_done():
+                await interaction.response.defer()
+            url = f"https://discord.com/api/v10/webhooks/{self.application_id}/{interaction.token}/messages/@original"
+            headers = {"Content-Type": "application/json"}
+            payload: dict = {"flags": _CV2_FLAG, "components": parser._cv2_pending}
+            async with aiohttp.ClientSession() as session:
+                resp = await session.patch(url, headers=headers, data=json.dumps(payload))
+                if not resp.ok:
+                    print(f"[cordscript cv2] Error {resp.status}: {await resp.text()}")
+        else:
+            kwargs: dict = {}
+            if send_text is not None and len(send_text.strip()) > 0:
+                kwargs["content"] = send_text
+            if has_embeds:
+                kwargs["embeds"] = [discord.Embed.from_dict(e) for e in embeds]
+            if has_components:
+                view = _build_view(parser._components, self)
+                if view:
+                    kwargs["view"] = view
+
+            if kwargs:
+                if not interaction.response.is_done():
+                    await interaction.response.send_message(**kwargs, ephemeral=parser._ephemeral)
+                else:
+                    await interaction.edit_original_response(**kwargs)
+
+        for msg in extra_messages:
+            await self._send_extra(msg)
+
+    async def _execute_member_event(self, member: discord.Member, code: str, channel_id: int | str | None = None):
+        channel = None
+        if channel_id:
+            try:
+                channel = self.get_channel(int(channel_id)) or await self.fetch_channel(int(channel_id))
+            except Exception as e:
+                print(f"[cordscript] member event: could not resolve channelId {channel_id}: {e}")
+        if channel is None:
+            channel = getattr(member.guild, "system_channel", None)
+
+        class MemberCtx:
+            def __init__(self, m: discord.Member, ch):
+                self.author = m
+                self.guild = m.guild
+                self.channel = ch
+                self.mentions = []
+                self.id = 0
+                self.content = ""
+
+        parser = Parser(MemberCtx(member, channel), self)
+        text, embeds, extra_messages = await parser.evaluate(code)
+
+        has_content = text is not None and len(text.strip()) > 0
+        has_embeds = len(embeds) > 0
+        has_cv2 = len(parser._cv2_pending) > 0
+        has_components = len(parser._components) > 0
+
+        if channel is None:
+            if has_content or has_embeds or has_cv2 or has_components:
+                print(f"[cordscript memberadd] No channel resolved, message not sent: {text}")
+        elif has_cv2:
+            await _send_payload(
+                channel, None, [], [],
+                parser._cv2_pending, self._token,
+                client=self,
+            )
+        elif has_content or has_embeds or has_components:
+            await _send_payload(
+                channel, text, embeds, parser._components,
+                [], self._token,
+                client=self,
+            )
+
+        for msg in extra_messages:
+            await self._send_extra(msg)
+
+    async def _execute_ready(self, code: str):
+        class FakeCtx:
+            class author:
+                id = 0
+                name = "System"
+                global_name = None
+                bot = False
+                display_avatar = None
+            class channel:
+                id = 0
+            class guild:
+                id = 0
+                name = ""
+                member_count = 0
+                icon = None
+                banner = None
+                owner_id = 0
+                premium_subscription_count = 0
+                roles = []
+                members = []
+            mentions = []
+            content = ""
+            id = 0
+
+        parser = Parser(FakeCtx(), self)
+        text, _, _ = await parser.evaluate(code)
+        if text:
+            print(f"[cordscript ready] {text}")

cordscript/core/__init__.py

@@ -0,0 +1,9 @@
+from .runtime import find_functions, split_args
+from .context import get_author, get_author_id, get_guild, get_channel, get_channel_id, is_interaction
+from .variables import VariableStore
+
+__all__ = [
+    "find_functions", "split_args",
+    "get_author", "get_author_id", "get_guild", "get_channel", "get_channel_id", "is_interaction",
+    "VariableStore",
+]

cordscript/core/context.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+import discord
+
+
+def get_author(ctx):
+    if isinstance(ctx, discord.Interaction):
+        return ctx.user
+    return getattr(ctx, "author", None)
+
+
+def get_author_id(ctx) -> str:
+    a = get_author(ctx)
+    return str(a.id) if a else ""
+
+
+def get_guild(ctx):
+    return getattr(ctx, "guild", None)
+
+
+def get_channel(ctx):
+    return getattr(ctx, "channel", None)
+
+
+def get_channel_id(ctx) -> str:
+    if hasattr(ctx, "channel") and ctx.channel:
+        return str(ctx.channel.id)
+    if hasattr(ctx, "channel_id") and ctx.channel_id:
+        return str(ctx.channel_id)
+    return ""
+
+
+def is_interaction(ctx) -> bool:
+    return isinstance(ctx, discord.Interaction)

cordscript/core/runtime.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+
+def find_functions(code: str) -> list[tuple[int, int, str, str | None]]:
+    results = []
+    i = 0
+    length = len(code)
+    while i < length:
+        if code[i] != "$":
+            i += 1
+            continue
+        j = i + 1
+        while j < length and (code[j].isalnum() or code[j] == "_"):
+            j += 1
+        if j == i + 1:
+            i += 1
+            continue
+        fn_name = code[i + 1:j]
+        if j < length and code[j] == "[":
+            depth = 1
+            k = j + 1
+            while k < length and depth > 0:
+                if code[k] == "[":
+                    depth += 1
+                elif code[k] == "]":
+                    depth -= 1
+                k += 1
+            if depth == 0:
+                raw_args = code[j + 1:k - 1]
+                results.append((i, k, fn_name, raw_args))
+                i = k
+                continue
+        results.append((i, j, fn_name, None))
+        i = j
+    return results
+
+
+def split_args(raw: str) -> list[str]:
+    args = []
+    depth = 0
+    current = []
+    for ch in raw:
+        if ch == "[":
+            depth += 1
+            current.append(ch)
+        elif ch == "]":
+            depth -= 1
+            current.append(ch)
+        elif ch == ";" and depth == 0:
+            args.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+    args.append("".join(current))
+    return args