cordscript 0.1.0__py3-none-any.whl

cordscript/__init__.py

@@ -0,0 +1,5 @@
+from .client import Client
+from .parser import Parser
+
+__version__ = "0.1.0"
+__all__ = ["Client", "Parser"]

cordscript/client.py

@@ -0,0 +1,306 @@
+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
+
+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)
+
+_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", []):
+                _add_item_to_view(view, item, client)
+                added = True
+        elif comp.get("type") in (2, 3):
+            _add_item_to_view(view, comp, client)
+            added = True
+
+    return view if added else None
+
+
+def _add_item_to_view(view: ui.View, item: dict, client: "Client"):
+    if item.get("type") == 2:
+        styles = {
+            1: discord.ButtonStyle.primary,
+            2: discord.ButtonStyle.secondary,
+            3: discord.ButtonStyle.success,
+            4: discord.ButtonStyle.danger,
+        }
+        style = styles.get(item.get("style", 1), discord.ButtonStyle.primary)
+        button = ui.Button(
+            label=item.get("label", "Button"),
+            custom_id=item.get("custom_id"),
+            style=style,
+        )
+        async def button_callback(interaction: discord.Interaction, cid=item.get("custom_id")):
+            await client._dispatch_interaction(interaction, cid)
+        button.callback = button_callback
+        view.add_item(button)
+
+    elif item.get("type") == 3:
+        options = [
+            discord.SelectOption(label=o["label"], value=o["value"])
+            for o in item.get("options", [])
+        ]
+        select = ui.Select(
+            custom_id=item.get("custom_id"),
+            placeholder=item.get("placeholder", "Selecione..."),
+            options=options,
+        )
+        async def select_callback(interaction: discord.Interaction, cid=item.get("custom_id")):
+            await client._dispatch_interaction(interaction, cid)
+        select.callback = select_callback
+        view.add_item(select)
+
+
+class Client(discord.Client):
+    def __init__(
+        self,
+        *,
+        prefix: str | list[str],
+        token: str,
+        insensitive: bool = False,
+        ignoreBots: bool = True,
+        intents: discord.Intents | None = None,
+        **kwargs,
+    ):
+        resolved_intents = intents or discord.Intents.default()
+        resolved_intents.message_content = 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._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._commands_path: str | None = None
+        self._main_file: str | None = None
+
+    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 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]
+            target = os.path.abspath(path) if path else self._commands_path
+            self._load_from_path(target)
+        else:
+            if not self._main_file:
+                return
+            self._commands.clear()
+            self._static_commands.clear()
+            self._static_entries.clear()
+            spec = importlib.util.spec_from_file_location("__main_reload__", self._main_file)
+            module = importlib.util.module_from_spec(spec)
+            module.bot = self
+            try:
+                spec.loader.exec_module(module)
+                print(f"[cordscript] Reloaded main file")
+            except Exception as e:
+                print(f"[cordscript] Failed to reload: {e}")
+
+    def _load_from_path(self, path: str):
+        loaded = 0
+        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)
+                module.bot = self
+                try:
+                    spec.loader.exec_module(module)
+                    loaded += 1
+                except Exception as e:
+                    print(f"[cordscript] Failed to load {filepath}: {e}")
+        print(f"[cordscript] Loaded {loaded} command file(s) from '{path}'")
+
+    def run(self, token: str | None = None):
+        self._main_file = os.path.abspath(inspect.stack()[1].filename)
+        super().run(token or self._token)
+
+    async def on_ready(self):
+        prefixes = ", ".join(f'"{p}"' for p in self._prefixes)
+        print(f"[cordscript] Logged in as {self.user} (ID: {self.user.id})")
+        print(f"[cordscript] Prefixes: {prefixes} | insensitive={self._insensitive} | ignoreBots={self._ignore_bots}")
+        if self._ready_command:
+            await self._execute_ready(self._ready_command["code"])
+
+    async def on_message(self, message: discord.Message):
+        if self._ignore_bots and message.author.bot:
+            return
+
+        content = message.content
+        matched_prefix: str | None = None
+
+        for prefix in self._prefixes:
+            check_content = content.lower() if self._insensitive else content
+            check_prefix = prefix.lower() if self._insensitive else prefix
+            if check_content.startswith(check_prefix):
+                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 _send_cv2(self, channel_id: int, components: list[dict], content: str | None = None):
+        url = f"https://discord.com/api/v10/channels/{channel_id}/messages"
+        headers = {
+            "Authorization": f"Bot {self._token}",
+            "Content-Type": "application/json",
+        }
+        payload: dict = {"flags": _CV2_FLAG, "components": components}
+        if content:
+            payload["content"] = content
+        async with aiohttp.ClientSession() as session:
+            resp = await session.post(url, headers=headers, data=json.dumps(payload))
+            if not resp.ok:
+                text = await resp.text()
+                print(f"[cordscript cv2] Error {resp.status}: {text}")
+
+    async def _edit_cv2(self, interaction: discord.Interaction, components: list[dict], content: str | None = None):
+        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": components}
+        if content:
+            payload["content"] = content
+        async with aiohttp.ClientSession() as session:
+            resp = await session.patch(url, headers=headers, data=json.dumps(payload))
+            if not resp.ok:
+                text = await resp.text()
+                print(f"[cordscript cv2] Error {resp.status}: {text}")
+
+    async def _execute(self, ctx: discord.Message, code: str):
+        parser = Parser(ctx, self)
+        text, embeds, extra_messages = await parser.evaluate(code)
+
+        if parser._cv2_pending:
+            await self._send_cv2(ctx.channel.id, parser._cv2_pending, text or None)
+        else:
+            kwargs: dict = {}
+            if text:
+                kwargs["content"] = text
+            if embeds:
+                kwargs["embeds"] = [discord.Embed.from_dict(e) for e in embeds]
+
+            view = _build_view(parser._components, self)
+            if view:
+                kwargs["view"] = view
+
+            if kwargs:
+                delete_after = parser._delete_after
+                if parser._reply_content:
+                    kwargs["content"] = parser._reply_content
+                    await ctx.reply(**kwargs, delete_after=delete_after)
+                else:
+                    await ctx.channel.send(**kwargs, delete_after=delete_after)
+
+        for msg in extra_messages:
+            channel = self.get_channel(msg["channel_id"])
+            if not channel:
+                try:
+                    channel = await self.fetch_channel(msg["channel_id"])
+                except Exception:
+                    continue
+
+            send_kwargs: dict = {}
+            if msg["content"]:
+                send_kwargs["content"] = msg["content"]
+            if msg["embeds"]:
+                send_kwargs["embeds"] = [discord.Embed.from_dict(e) for e in msg["embeds"]]
+
+            if send_kwargs:
+                await channel.send(**send_kwargs, delete_after=msg.get("delete_after"))
+
+    async def _execute_interaction(self, interaction: discord.Interaction, code: str):
+        parser = Parser(interaction, self)
+        text, embeds, _ = await parser.evaluate(code)
+
+        if parser._cv2_pending:
+            if not interaction.response.is_done():
+                await interaction.response.defer()
+            await self._edit_cv2(interaction, parser._cv2_pending, text or None)
+        else:
+            kwargs: dict = {}
+            if text:
+                kwargs["content"] = text
+            if embeds:
+                kwargs["embeds"] = [discord.Embed.from_dict(e) for e in embeds]
+
+            view = _build_view(parser._components, self)
+            if view:
+                kwargs["view"] = view
+
+            if not interaction.response.is_done() and kwargs:
+                await interaction.response.send_message(**kwargs, ephemeral=parser._ephemeral)
+
+    async def _execute_ready(self, code: str):
+        class FakeCtx:
+            class channel:
+                id = 0
+            class author:
+                id = 0
+                name = "System"
+
+        parser = Parser(FakeCtx(), self)
+        text, embeds, _ = await parser.evaluate(code)
+        if text:
+            print(f"[cordscript ready] {text}")

cordscript/functions/__init__.py

@@ -0,0 +1,19 @@
+from .utility import handle_utility
+from .user import handle_user
+from .embed import handle_embed
+from .message import handle_message
+from .components import handle_components
+from .componentsv2 import handle_componentsv2
+from .interaction import handle_interaction
+from .logic import handle_logic
+
+__all__ = [
+    "handle_utility",
+    "handle_user",
+    "handle_embed",
+    "handle_message",
+    "handle_components",
+    "handle_componentsv2",
+    "handle_interaction",
+    "handle_logic",
+]

cordscript/functions/components.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+
+async def handle_components(fn: str, args: list[str], raw: str, parser) -> str | None:
+    match fn:
+        case "addbutton":
+            label = args[0] if len(args) > 0 else "Button"
+            custom_id = args[1] if len(args) > 1 else "button"
+            style_raw = args[2].strip().lower() if len(args) > 2 else "primary"
+            styles = {"primary": 1, "secondary": 2, "success": 3, "danger": 4, "link": 5}
+            style = styles.get(style_raw, 1)
+            comp: dict = {
+                "type": 2,
+                "label": label,
+                "style": style,
+            }
+            if style == 5:
+                comp["url"] = custom_id
+            else:
+                comp["custom_id"] = custom_id
+            parser._components.append(comp)
+            return ""
+
+        case "selectmenu":
+            custom_id = args[0] if len(args) > 0 else "select"
+            placeholder = args[1] if len(args) > 1 else "Selecione..."
+            options = []
+            for opt in args[2:]:
+                opt = opt.strip()
+                if opt:
+                    options.append({"label": opt, "value": opt.lower().replace(" ", "_")})
+            parser._components.append({
+                "type": 3,
+                "custom_id": custom_id,
+                "placeholder": placeholder,
+                "options": options,
+            })
+            return ""
+
+        case _:
+            return None

cordscript/functions/componentsv2.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+import json
+import discord
+
+_CV2_TOKEN = "\x00CV2:"
+_CV2_END = "\x00"
+
+
+def _parse_color(value: str) -> int | None:
+    if not value:
+        return None
+    value = value.strip().lstrip("#")
+    try:
+        return int(value, 16)
+    except ValueError:
+        named = {
+            "red": 0xFF0000, "green": 0x00FF00, "blue": 0x0000FF,
+            "yellow": 0xFFFF00, "orange": 0xFF8000, "purple": 0x800080,
+            "pink": 0xFFC0CB, "white": 0xFFFFFF, "black": 0x000000,
+            "cyan": 0x00FFFF, "blurple": 0x5865F2, "gray": 0x808080,
+        }
+        return named.get(value.lower())
+
+
+def _token(data: dict) -> str:
+    return f"{_CV2_TOKEN}{json.dumps(data)}{_CV2_END}"
+
+
+def _extract_tokens(value: str) -> list[dict]:
+    items = []
+    parts = value.split(_CV2_TOKEN)
+    for part in parts[1:]:
+        end = part.find(_CV2_END)
+        if end != -1:
+            try:
+                items.append(json.loads(part[:end]))
+            except Exception:
+                pass
+    return items
+
+
+def _is_token(value: str) -> bool:
+    return _CV2_TOKEN in value
+
+
+async def handle_componentsv2(fn: str, args: list[str], raw: str, parser) -> str | None:
+    in_container = getattr(parser, "_cv2_in_container", False)
+
+    match fn:
+        case "addtextdisplay":
+            content = args[0] if args else raw
+            data = {"type": 10, "content": content}
+            if in_container:
+                return _token(data)
+            parser._cv2_pending.append(data)
+            return ""
+
+        case "addseparator":
+            visible = (args[0].strip().lower() if args else "true") in ("true", "yes", "1")
+            spacing_raw = args[1].strip().lower() if len(args) > 1 else "small"
+            spacing = 2 if spacing_raw == "large" else 1
+            data = {"type": 14, "divider": visible, "spacing": spacing}
+            if in_container:
+                return _token(data)
+            parser._cv2_pending.append(data)
+            return ""
+
+        case "addthumbnail":
+            url = args[0].strip() if args else ""
+            desc = args[1] if len(args) > 1 else ""
+            data = {"type": 11, "media": {"url": url}}
+            if desc:
+                data["description"] = desc
+            if in_container:
+                return _token(data)
+            parser._cv2_pending.append(data)
+            return ""
+
+        case "addmediagallery":
+            items = []
+            i = 0
+            while i < len(args):
+                url = args[i].strip()
+                desc = args[i + 1] if i + 1 < len(args) else ""
+                if url:
+                    item = {"media": {"url": url}}
+                    if desc:
+                        item["description"] = desc
+                    items.append(item)
+                i += 2
+            data = {"type": 12, "items": items}
+            if in_container:
+                return _token(data)
+            parser._cv2_pending.append(data)
+            return ""
+
+        case "addsection":
+            text = args[0] if len(args) > 0 else ""
+            accessory_type = args[1].strip().lower() if len(args) > 1 else ""
+            accessory_value = args[2] if len(args) > 2 else ""
+            data = {
+                "type": 9,
+                "components": [{"type": 10, "content": text}],
+            }
+            if accessory_type == "thumbnail":
+                data["accessory"] = {"type": 11, "media": {"url": accessory_value}}
+            elif accessory_type == "button":
+                parts = accessory_value.split(";")
+                label = parts[0] if parts else "Button"
+                custom_id = parts[1] if len(parts) > 1 else "btn"
+                style_raw = parts[2].strip().lower() if len(parts) > 2 else "secondary"
+                styles = {"primary": 1, "secondary": 2, "success": 3, "danger": 4}
+                data["accessory"] = {
+                    "type": 2,
+                    "label": label,
+                    "custom_id": custom_id,
+                    "style": styles.get(style_raw, 2),
+                }
+            if in_container:
+                return _token(data)
+            parser._cv2_pending.append(data)
+            return ""
+
+        case "addcontainer":
+            parser._cv2_in_container = True
+            inner_items = []
+            color_raw = ""
+
+            for arg in args:
+                if _is_token(arg):
+                    inner_items.extend(_extract_tokens(arg))
+                else:
+                    color_raw = arg.strip()
+
+            parser._cv2_in_container = False
+            data: dict = {"type": 17, "components": inner_items}
+            color = _parse_color(color_raw)
+            if color is not None:
+                data["accent_color"] = color
+            parser._cv2_pending.append(data)
+            return ""
+
+        case _:
+            return None

cordscript/functions/embed.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from datetime import datetime, timezone
+
+
+async def handle_embed(fn: str, args: list[str], raw: str, parser) -> str | None:
+    match fn:
+        case "title":
+            parser._current_embed()._title = args[0] if args else raw
+            return ""
+
+        case "description":
+            parser._current_embed()._description = args[0] if args else raw
+            return ""
+
+        case "color" | "colour":
+            raw_color = args[0] if args else raw
+            parser._current_embed()._color = parser._parse_color(raw_color)
+            return ""
+
+        case "footer":
+            parser._current_embed()._footer_text = args[0] if args else raw
+            return ""
+
+        case "footericon":
+            parser._current_embed()._footer_icon = args[0] if args else raw
+            return ""
+
+        case "image":
+            parser._current_embed()._image = args[0] if args else raw
+            return ""
+
+        case "thumbnail":
+            parser._current_embed()._thumbnail = args[0] if args else raw
+            return ""
+
+        case "author":
+            eb = parser._current_embed()
+            eb._author_text = args[0] if len(args) > 0 else ""
+            eb._author_icon = args[1] if len(args) > 1 else None
+            return ""
+
+        case "addfield":
+            name = args[0] if len(args) > 0 else "\u200b"
+            value = args[1] if len(args) > 1 else "\u200b"
+            inline_raw = args[2].strip().lower() if len(args) > 2 else "false"
+            inline = inline_raw in ("true", "1", "yes")
+            parser._current_embed()._fields.append({
+                "name": name,
+                "value": value,
+                "inline": inline,
+            })
+            return ""
+
+        case "addtimestamp":
+            parser._current_embed()._timestamp = True
+            return ""
+
+        case _:
+            return None

cordscript/functions/interaction.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+import discord
+
+
+async def handle_interaction(fn: str, args: list[str], raw: str, parser) -> str | None:
+    ctx = parser.ctx
+    is_interaction = isinstance(ctx, discord.Interaction)
+
+    match fn:
+        case "customid":
+            if is_interaction and ctx.data:
+                return ctx.data.get("custom_id", "")
+            return ""
+
+        case "defer":
+            if is_interaction and not ctx.response.is_done():
+                await ctx.response.defer()
+            return ""
+
+        case "deferephemeral":
+            if is_interaction and not ctx.response.is_done():
+                await ctx.response.defer(ephemeral=True)
+            return ""
+
+        case "interactionupdate":
+            content = args[0] if args else raw
+            if is_interaction and not ctx.response.is_done():
+                await ctx.response.edit_message(content=content)
+            elif is_interaction:
+                await ctx.edit_original_response(content=content)
+            return ""
+
+        case "ephemeral":
+            parser._ephemeral = True
+            return ""
+
+        case "interactionuser":
+            if is_interaction:
+                return str(ctx.user.id)
+            return str(ctx.author.id)
+
+        case "interactionchannel":
+            if is_interaction:
+                return str(ctx.channel_id)
+            return str(ctx.channel.id)
+
+        case _:
+            return None

cordscript/functions/l/303/263gico.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+
+def _evaluate_condition(condition: str) -> bool:
+    for op in (">=", "<=", "!=", "==", ">", "<"):
+        if op in condition:
+            left, right = condition.split(op, 1)
+            left, right = left.strip(), right.strip()
+            try:
+                l, r = float(left), float(right)
+            except ValueError:
+                l, r = left, right
+            match op:
+                case "==": return l == r
+                case "!=": return l != r
+                case ">":  return l > r
+                case "<":  return l < r
+                case ">=": return l >= r
+                case "<=": return l <= r
+    return False
+
+
+async def handle_logic(fn: str, args: list[str], raw: str, parser) -> str | None:
+    match fn:
+        case "if":
+            if not args:
+                return ""
+            condition = args[0].strip()
+            true_val = args[1] if len(args) > 1 else ""
+            false_val = args[2] if len(args) > 2 else ""
+            return true_val if _evaluate_condition(condition) else false_val
+
+        case _:
+            return None

cordscript/functions/message.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+
+async def handle_message(fn: str, args: list[str], raw: str, parser) -> str | None:
+    match fn:
+        case "sendmessage":
+            channel_id_raw = args[0].strip() if args else ""
+            content = args[1] if len(args) > 1 else ""
+            if channel_id_raw:
+                try:
+                    channel_id = int(channel_id_raw)
+                    from ..parser import Parser
+                    sub_parser = Parser(parser.ctx, parser.client)
+                    sub_parser._start_time = parser._start_time
+                    parsed_content, parsed_embeds, _ = await sub_parser.evaluate(content)
+                    parser._extra_messages.append({
+                        "channel_id": channel_id,
+                        "content": parsed_content,
+                        "embeds": parsed_embeds,
+                        "delete_after": None,
+                    })
+                except (ValueError, Exception):
+                    pass
+            return ""
+
+        case "reply":
+            parser._reply = True
+            if args:
+                parser._reply_content = args[0]
+            return ""
+
+        case "deletein":
+            try:
+                parser._delete_after = float(args[0].strip()) if args else None
+            except ValueError:
+                pass
+            return ""
+
+        case "updatecommands":
+            path = args[0].strip() if args and args[0].strip() else None
+            parser.client.reloadCommands(path)
+            return ""
+
+        case _:
+            return None

cordscript/functions/ultility.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+import random
+import time
+import ast
+import operator
+from datetime import datetime, timezone
+
+
+_OPERATORS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+    ast.USub: operator.neg,
+}
+
+
+def _eval_expr(node):
+    if isinstance(node, ast.Expression):
+        return _eval_expr(node.body)
+    elif isinstance(node, ast.Constant):
+        return node.value
+    elif isinstance(node, ast.BinOp):
+        op = _OPERATORS.get(type(node.op))
+        if op is None:
+            raise ValueError("Operador não suportado")
+        return op(_eval_expr(node.left), _eval_expr(node.right))
+    elif isinstance(node, ast.UnaryOp):
+        op = _OPERATORS.get(type(node.op))
+        if op is None:
+            raise ValueError("Operador não suportado")
+        return op(_eval_expr(node.operand))
+    raise ValueError("Expressão inválida")
+
+
+async def handle_utility(fn: str, args: list[str], raw: str, parser) -> str | None:
+    match fn:
+        case "ping":
+            latency = round(parser.client.latency * 1000)
+            return f"{latency}ms"
+
+        case "executiontime":
+            elapsed = round((time.monotonic() - parser._start_time) * 1000)
+            return f"{elapsed}ms"
+
+        case "channelid":
+            return str(parser.ctx.channel.id)
+
+        case "messageid":
+            return str(parser.ctx.id)
+
+        case "random":
+            try:
+                min_val = int(args[0].strip()) if len(args) > 0 and args[0].strip() else 1
+                max_val = int(args[1].strip()) if len(args) > 1 and args[1].strip() else 100
+                return str(random.randint(min_val, max_val))
+            except ValueError:
+                return "0"
+
+        case "upper":
+            return args[0].upper() if args else raw.upper()
+
+        case "lower":
+            return args[0].lower() if args else raw.lower()
+
+        case "length":
+            return str(len(args[0]) if args else len(raw))
+
+        case "trim":
+            return args[0].strip() if args else raw.strip()
+
+        case "replace":
+            text = args[0] if len(args) > 0 else ""
+            from_ = args[1] if len(args) > 1 else ""
+            to_ = args[2] if len(args) > 2 else ""
+            return text.replace(from_, to_)
+
+        case "includes":
+            text = args[0] if len(args) > 0 else ""
+            search = args[1] if len(args) > 1 else ""
+            return "true" if search in text else "false"
+
+        case "repeat":
+            try:
+                times = int(args[0].strip()) if args else 1
+            except ValueError:
+                times = 1
+            text = args[1] if len(args) > 1 else ""
+            return text * times
+
+        case "time":
+            now = datetime.now()
+            return now.strftime("%H:%M:%S")
+
+        case "date":
+            now = datetime.now()
+            return now.strftime("%d/%m/%Y")
+
+        case "var":
+            name = args[0].strip() if args else ""
+            if not name:
+                return ""
+            if len(args) > 1:
+                parser._vars[name] = args[1]
+                return ""
+            return parser._vars.get(name, "")
+
+        case "textsplit":
+            text = args[0] if len(args) > 0 else ""
+            sep = args[1] if len(args) > 1 else ","
+            parser._split_cache = text.split(sep)
+            return ""
+
+        case "splittext":
+            cache = getattr(parser, "_split_cache", [])
+            try:
+                index = int(args[0].strip()) - 1 if args and args[0].strip() else 0
+                return cache[index] if 0 <= index < len(cache) else ""
+            except (ValueError, IndexError):
+                return ""
+
+        case "eval":
+            expr = args[0] if args else raw
+            if "$" in expr:
+                return await parser._eval(expr)
+            try:
+                tree = ast.parse(expr, mode="eval")
+                result = _eval_expr(tree)
+                if isinstance(result, float) and result.is_integer():
+                    return str(int(result))
+                return str(result)
+            except Exception:
+                return expr
+
+        case "dpyeval":
+            code = args[0] if args else raw
+            try:
+                local_vars = {"ctx": parser.ctx, "bot": parser.client, "result": None}
+                wrapped = f"async def __fn():\n" + "\n".join(f"    {line}" for line in code.splitlines())
+                exec(wrapped, local_vars)
+                ret = await local_vars["__fn"]()
+                return str(ret) if ret is not None else ""
+            except Exception as e:
+                return f"Error: {e}"
+
+        case "message":
+            parts = parser.ctx.content.split(None, 1)
+            content = parts[1] if len(parts) > 1 else ""
+            if not args or not args[0].strip():
+                return content
+            try:
+                index = int(args[0].strip()) - 1
+                words = content.split()
+                return words[index] if 0 <= index < len(words) else ""
+            except (ValueError, IndexError):
+                return ""
+
+        case _:
+            return None

cordscript/functions/user.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+
+async def handle_user(fn: str, args: list[str], raw: str, parser) -> str | None:
+    msg = parser.ctx
+
+    match fn:
+        case "authorid":
+            return str(msg.author.id)
+
+        case "username":
+            uid = args[0].strip() if args and args[0].strip() else None
+            if uid:
+                try:
+                    user = await parser.client.fetch_user(int(uid))
+                    return user.name
+                except Exception:
+                    return "Unknown"
+            return msg.author.name
+
+        case "nickname":
+            global_name = getattr(msg.author, "global_name", None)
+            return global_name or msg.author.name
+
+        case "mentioned":
+            mentions = msg.mentions
+            index_raw = args[0].strip() if args and args[0].strip() else "1"
+            return_author_raw = args[1].strip().lower() if len(args) > 1 else "false"
+            return_author = return_author_raw in ("true", "yes")
+            try:
+                index = int(index_raw) - 1
+            except ValueError:
+                index = 0
+            if not mentions:
+                return str(msg.author.id) if return_author else ""
+            if index < 0 or index >= len(mentions):
+                return str(msg.author.id) if return_author else ""
+            return str(mentions[index].id)
+
+        case "useravatar":
+            uid = args[0].strip() if args and args[0].strip() else None
+            if uid:
+                try:
+                    user = await parser.client.fetch_user(int(uid))
+                    return str(user.display_avatar.url) if user.display_avatar else ""
+                except Exception:
+                    return ""
+            avatar = msg.author.display_avatar
+            return str(avatar.url) if avatar else ""
+
+        case "servername":
+            return msg.guild.name if msg.guild else ""
+
+        case "serverid":
+            return str(msg.guild.id) if msg.guild else ""
+
+        case "membercount":
+            return str(msg.guild.member_count) if msg.guild else "0"
+
+        case _:
+            return None

cordscript/parser.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+import time
+from datetime import datetime, timezone
+from .functions import (
+    handle_utility, handle_user, handle_embed, handle_message,
+    handle_components, handle_componentsv2, handle_interaction, handle_logic
+)
+
+
+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
+
+
+class EmbedBuilder:
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self._title: str | None = None
+        self._description: str | None = None
+        self._color: int | None = None
+        self._footer_text: str | None = None
+        self._footer_icon: str | None = None
+        self._image: str | None = None
+        self._thumbnail: str | None = None
+        self._author_text: str | None = None
+        self._author_icon: str | None = None
+        self._fields: list[dict] = []
+        self._timestamp: bool = False
+
+    def has_data(self) -> bool:
+        return any([
+            self._title, self._description, self._color is not None,
+            self._footer_text, self._image, self._thumbnail,
+            self._author_text, self._fields, self._timestamp,
+        ])
+
+    def to_dict(self) -> dict:
+        embed: dict = {"type": "rich"}
+        if self._title:
+            embed["title"] = self._title
+        if self._description:
+            embed["description"] = self._description
+        if self._color is not None:
+            embed["color"] = self._color
+        if self._footer_text:
+            embed["footer"] = {"text": self._footer_text}
+            if self._footer_icon:
+                embed["footer"]["icon_url"] = self._footer_icon
+        if self._image:
+            embed["image"] = {"url": self._image}
+        if self._thumbnail:
+            embed["thumbnail"] = {"url": self._thumbnail}
+        if self._author_text:
+            embed["author"] = {"name": self._author_text}
+            if self._author_icon:
+                embed["author"]["icon_url"] = self._author_icon
+        if self._fields:
+            embed["fields"] = self._fields
+        if self._timestamp:
+            embed["timestamp"] = datetime.now(timezone.utc).isoformat()
+        return embed
+
+
+class Parser:
+    def __init__(self, ctx, client):
+        self.ctx = ctx
+        self.client = client
+        self._start_time = time.monotonic()
+        self._embeds: list[EmbedBuilder] = [EmbedBuilder()]
+        self._extra_messages: list[dict] = []
+        self._reply: bool = False
+        self._reply_content: str | None = None
+        self._delete_after: float | None = None
+        self._components: list[dict] = []
+        self._cv2_pending: list = []
+        self._cv2_in_container: bool = False
+        self._split_cache: list[str] = []
+        self._ephemeral: bool = False
+        self._vars: dict[str, str] = {}
+
+    def _current_embed(self) -> EmbedBuilder:
+        return self._embeds[-1]
+
+    def _parse_color(self, value: str) -> int:
+        value = value.strip().lstrip("#")
+        try:
+            return int(value, 16)
+        except ValueError:
+            named = {
+                "red": 0xFF0000, "green": 0x00FF00, "blue": 0x0000FF,
+                "yellow": 0xFFFF00, "orange": 0xFF8000, "purple": 0x800080,
+                "pink": 0xFFC0CB, "white": 0xFFFFFF, "black": 0x000000,
+                "cyan": 0x00FFFF, "blurple": 0x5865F2, "gray": 0x808080,
+            }
+            return named.get(value.lower(), 0x2B2D31)
+
+    async def evaluate(self, code: str) -> tuple[str, list[dict], list[dict]]:
+        result = await self._eval(code)
+        embeds = [eb.to_dict() for eb in self._embeds if eb.has_data()]
+        return result.strip(), embeds, self._extra_messages
+
+    async def _eval(self, code: str) -> str:
+        functions = _find_functions(code)
+        if not functions:
+            return code
+
+        result = code
+        for start, end, fn_name, raw_args in reversed(functions):
+            if raw_args is not None:
+                if fn_name.lower() == "addcontainer":
+                    self._cv2_in_container = True
+                    evaluated_args_str = await self._eval_container_args(raw_args)
+                    self._cv2_in_container = False
+                else:
+                    evaluated_args_str = await self._eval(raw_args)
+                args = _split_args(evaluated_args_str)
+            else:
+                args = []
+
+            replacement = await self._resolve(fn_name.lower(), args, raw_args or "")
+            result = result[:start] + replacement + result[end:]
+
+        return result
+
+    async def _eval_container_args(self, code: str) -> str:
+        functions = _find_functions(code)
+        if not functions:
+            return code
+
+        result = code
+        for start, end, fn_name, raw_args in reversed(functions):
+            if raw_args is not None:
+                evaluated_args_str = await self._eval(raw_args)
+                args = _split_args(evaluated_args_str)
+            else:
+                args = []
+
+            replacement = await self._resolve(fn_name.lower(), args, raw_args or "")
+            result = result[:start] + replacement + result[end:]
+
+        return result
+
+    async def _resolve(self, fn: str, args: list[str], raw: str) -> str:
+        for handler in [
+            handle_utility, handle_user, handle_embed, handle_message,
+            handle_components, handle_componentsv2, handle_interaction, handle_logic
+        ]:
+            result = await handler(fn, args, raw, self)
+            if result is not None:
+                return result
+
+        if raw:
+            return f"${fn}[{raw}]"
+        return f"${fn}"

cordscript-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: cordscript
+Version: 0.1.0
+Home-page: 
+Author: Arimo
+Author-email: alysonk078@gmail.com
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Requires-Dist: discord.py
+Requires-Dist: aiohttp
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python

cordscript-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+cordscript/__init__.py,sha256=j0CRkRbGgmAVjDX2MMX3uYxnndD27rXb8L7n0RZjQ4k,108
+cordscript/client.py,sha256=Z7KWnldTntkvyxyGrRQ3Ecy4uxQdQ4kReqbxf2oP8Ek,11926
+cordscript/parser.py,sha256=BhHJnmcNzXswrfnbwRczdtlLUODNq8FQL9naz31DfDE,6955
+cordscript/functions/__init__.py,sha256=BoiR31KqV6bvXks-AVOwGBuaVO5tNv3SYhL5w0G-V84,494
+cordscript/functions/components.py,sha256=qQX5F4y7_odzgdYC3J_CvP9qcXncO2bBOMQTsXgu5Rg,1464
+cordscript/functions/componentsv2.py,sha256=2f9EmjJDGYTo4EYkpcFKPeTWldJjXR3PRRJdaWxBaa8,4875
+cordscript/functions/embed.py,sha256=a11I785o_Rx6vQBUxrnZegBHMYXGuKEY39bVezEY_YU,1907
+cordscript/functions/interaction.py,sha256=kAqmSZENmttOqyV-m3hcDVWdJzkbwEqmBnVr1pl6fao,1449
+cordscript/functions/lógico.py,sha256=-0eGlA8r40nX_4EviXbEtXRIwriF5m-CKijharBBgsA,1121
+cordscript/functions/message.py,sha256=V3uowZZwUve2RFLskCpfaRHBSZaK0vxRDqCFyLfGnxs,1578
+cordscript/functions/ultility.py,sha256=mGa3Gz2dz5Bd1e3E97VPG9ordHyBomXoOUYknxKBak4,5309
+cordscript/functions/user.py,sha256=jXziCray2SRqqZsapORf_CPqzn4xSrC1HgoOoCJQN9c,2142
+cordscript-0.1.0.dist-info/METADATA,sha256=u3czKTMDi0tyQ5fwphzNflQ4gXqWDKoGW0EjgsbeHas,396
+cordscript-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cordscript-0.1.0.dist-info/top_level.txt,sha256=OVTk5gwO8_wFSHGhXAEiEI6AwUhGf6xWGya5YcuemlM,11
+cordscript-0.1.0.dist-info/RECORD,,

cordscript-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cordscript-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cordscript