cordscript 1.0.0__py3-none-any.whl

cordscript/functions/database/store.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+import os
+import threading
+from tinydb import TinyDB, Query
+
+
+class Database:
+    def __init__(self, path: str = "database/data.json"):
+        self.path = path
+        directory = os.path.dirname(path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        self._lock = threading.Lock()
+        self._db = TinyDB(path)
+        self._tables = {
+            "user": self._db.table("users"),
+            "channel": self._db.table("channels"),
+            "guild": self._db.table("guilds"),
+        }
+        self._q = Query()
+
+    def _table(self, scope: str):
+        table = self._tables.get(scope)
+        if table is None:
+            raise ValueError(f"Escopo de database inválido: {scope}")
+        return table
+
+    def get(self, scope: str, scope_id: str, key: str, default: str = "") -> str:
+        scope_id = str(scope_id)
+        table = self._table(scope)
+        with self._lock:
+            doc = table.get(self._q.id == scope_id)
+        if not doc:
+            return default
+        return str(doc.get("vars", {}).get(key, default))
+
+    def set(self, scope: str, scope_id: str, key: str, value: str) -> None:
+        scope_id = str(scope_id)
+        table = self._table(scope)
+        with self._lock:
+            doc = table.get(self._q.id == scope_id)
+            if doc:
+                variables = dict(doc.get("vars", {}))
+                variables[key] = value
+                table.update({"vars": variables}, self._q.id == scope_id)
+            else:
+                table.insert({"id": scope_id, "vars": {key: value}})
+
+    def all(self, scope: str, scope_id: str) -> dict:
+        scope_id = str(scope_id)
+        table = self._table(scope)
+        with self._lock:
+            doc = table.get(self._q.id == scope_id)
+        return dict(doc.get("vars", {})) if doc else {}
+
+    def get_all(self) -> dict:
+        result = {}
+        with self._lock:
+            for scope_name, table in self._tables.items():
+                result[scope_name] = {}
+                for doc in table.all():
+                    scope_id = doc.get("id", "unknown")
+                    result[scope_name][scope_id] = doc.get("vars", {})
+        return result
+
+    def wipe(self) -> None:
+        with self._lock:
+            for table in self._tables.values():
+                table.truncate()

cordscript/functions/discord/__init__.py

@@ -0,0 +1,15 @@
+from .message import handle_message
+from .interaction import handle_interaction
+from .embed import handle_embed
+from .components import handle_components, _flush_row, _flush_select
+from .componentsv2 import handle_componentsv2
+from .logic import handle_logic
+from .moderation import handle_moderation
+from .status import handle_status
+
+__all__ = [
+    "handle_message", "handle_interaction", "handle_embed",
+    "handle_components", "handle_componentsv2", "handle_logic",
+    "handle_moderation", "handle_status",
+    "_flush_row", "_flush_select",
+]

cordscript/functions/discord/components.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+_STYLE_MAP = {
+    "primary": 1,
+    "secondary": 2,
+    "success": 3,
+    "danger": 4,
+    "link": 5,
+}
+
+
+def _target_list(parser) -> list:
+    """Action rows go into the current CV2 container if we're inside one,
+    otherwise into the top-level (legacy) components list."""
+    if parser._cv2_stack:
+        return parser._cv2_target()
+    return parser._components
+
+
+async def handle_components(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "addactionrow":
+                items = list(parser._pending_row or [])
+                if parser._pending_select:
+                    items.append(parser._pending_select)
+                if items:
+                    _target_list(parser).append({"type": 1, "components": items})
+                parser._pending_row = []
+                parser._pending_select = None
+                return ""
+
+            case "addbutton":
+                if parser._pending_row is None:
+                    return "[Error in $addButton: must be inside $addActionRow]"
+
+                custom_id = args[0].strip() if len(args) > 0 else ""
+                label = args[1] if len(args) > 1 else ""
+                style_raw = args[2].strip().lower() if len(args) > 2 and args[2].strip() else "secondary"
+                emoji = args[3].strip() if len(args) > 3 and args[3].strip() else ""
+                disabled = (args[4].strip().lower() if len(args) > 4 else "") in ("true", "yes", "1")
+                url = args[5].strip() if len(args) > 5 and args[5].strip() else ""
+
+                if not custom_id and not url:
+                    return "[Error in $addButton: custom_id or url required]"
+
+                data: dict = {
+                    "type": 2,
+                    "style": _STYLE_MAP.get(style_raw, 2),
+                    "label": label,
+                    "disabled": disabled,
+                }
+                if url:
+                    data["url"] = url
+                    data["style"] = 5
+                else:
+                    data["custom_id"] = custom_id
+                if emoji:
+                    data["emoji"] = {"name": emoji}
+
+                parser._pending_row.append(data)
+                if len(parser._pending_row) >= 5:
+                    _target_list(parser).append({"type": 1, "components": parser._pending_row})
+                    parser._pending_row = []
+                return ""
+
+            case "addselectmenu":
+                if parser._pending_row is None:
+                    return "[Error in $addSelectMenu: must be inside $addActionRow]"
+
+                custom_id = args[0].strip() if len(args) > 0 else ""
+                placeholder = args[1] if len(args) > 1 else ""
+                try:
+                    min_values = int(args[2].strip()) if len(args) > 2 and args[2].strip() else 1
+                except ValueError:
+                    min_values = 1
+                try:
+                    max_values = int(args[3].strip()) if len(args) > 3 and args[3].strip() else 1
+                except ValueError:
+                    max_values = 1
+                disabled = (args[4].strip().lower() if len(args) > 4 else "") in ("true", "yes", "1")
+
+                if not custom_id:
+                    return "[Error in $addSelectMenu: custom_id required]"
+
+                parser._pending_select = {
+                    "type": 3,
+                    "custom_id": custom_id,
+                    "placeholder": placeholder,
+                    "min_values": min_values,
+                    "max_values": max_values,
+                    "disabled": disabled,
+                    "options": [],
+                }
+                return ""
+
+            case "addoption":
+                if parser._pending_select is None:
+                    return "[Error in $addOption: no $addSelectMenu started]"
+                label = args[0] if len(args) > 0 else ""
+                value = args[1] if len(args) > 1 else label
+                description = args[2] if len(args) > 2 else ""
+                emoji = args[3].strip() if len(args) > 3 and args[3].strip() else ""
+                default = (args[4].strip().lower() if len(args) > 4 else "") in ("true", "yes", "1")
+
+                option: dict = {"label": label, "value": value, "default": default}
+                if description:
+                    option["description"] = description
+                if emoji:
+                    option["emoji"] = {"name": emoji}
+                parser._pending_select["options"].append(option)
+                return ""
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"
+
+
+def _flush_row(parser) -> None:
+    """Called at the end of evaluate() to catch a row left open without
+    an explicit $addActionRow close."""
+    if parser._pending_row:
+        _target_list(parser).append({"type": 1, "components": parser._pending_row})
+        parser._pending_row = []
+
+
+def _flush_select(parser) -> None:
+    """Called at the end of evaluate() to catch a select menu left open
+    without an explicit $addActionRow close."""
+    if parser._pending_select:
+        _target_list(parser).append({"type": 1, "components": [parser._pending_select]})
+        parser._pending_select = None

cordscript/functions/discord/componentsv2.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+
+async def handle_componentsv2(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "addcontainer":
+                color = args[1] if len(args) > 1 else None
+
+                # If an $addActionRow was opened inside this container and never
+                # explicitly closed, flush it into the container now (it's still
+                # the current target) before we pop the container's children off
+                # the stack.
+                if parser._pending_row or parser._pending_select:
+                    items = list(parser._pending_row or [])
+                    if parser._pending_select:
+                        items.append(parser._pending_select)
+                    if items:
+                        parser._cv2_target().append({"type": 1, "components": items})
+                    parser._pending_row = []
+                    parser._pending_select = None
+
+                # Pop the children collected while this container's content was
+                # being evaluated (pushed onto the stack in parser._eval).
+                children = parser._cv2_stack.pop() if parser._cv2_stack else []
+
+                container: dict = {"type": 17, "components": children}
+                if color:
+                    try:
+                        container["accent_color"] = parser._parse_color(color)
+                    except Exception:
+                        pass
+
+                parser._cv2_target().append(container)
+                return ""
+
+            case "addtextdisplay":
+                title = args[0] if len(args) > 0 else ""
+                value = args[1] if len(args) > 1 else ""
+                if title and value:
+                    content = f"**{title}**\n{value}"
+                else:
+                    content = title or value
+                if not content:
+                    return ""
+
+                parser._cv2_target().append({"type": 10, "content": content})
+                return ""
+
+            case "addseparator":
+                parser._cv2_target().append({"type": 14, "divider": True, "spacing": 1})
+                return ""
+
+            case "addthumbnail":
+                url = args[0] if len(args) > 0 else ""
+                if not url:
+                    return ""
+
+                target = parser._cv2_target()
+                # If the previous item is a section without an accessory yet,
+                # attach the thumbnail there instead of adding a stray component.
+                if target and target[-1].get("type") == 9 and "accessory" not in target[-1]:
+                    target[-1]["accessory"] = {"type": 11, "media": {"url": url}}
+                else:
+                    target.append({"type": 11, "media": {"url": url}})
+                return ""
+
+            case "addmediagallery":
+                urls = args[0] if len(args) > 0 else ""
+                items = [{"media": {"url": u.strip()}} for u in urls.split(";") if u.strip()]
+                if not items:
+                    return ""
+
+                parser._cv2_target().append({"type": 12, "items": items})
+                return ""
+
+            case "addsection":
+                title = args[0] if len(args) > 0 else ""
+                if not title:
+                    return ""
+
+                parser._cv2_target().append({
+                    "type": 9,
+                    "components": [{"type": 10, "content": title}],
+                })
+                return ""
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/discord/embed.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from datetime import datetime, timezone
+
+
+async def handle_embed(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        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
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/discord/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/discord/logic.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from ...exceptions import StopExecution
+
+
+def _evaluate_condition(condition: str) -> bool:
+    condition = condition.strip()
+    for op in (">=", "<=", "!=", "==", ">", "<"):
+        if op in condition:
+            left, right = condition.split(op, 1)
+            left, right = left.strip(), right.strip()
+            try:
+                l_val: float | str = float(left)
+                r_val: float | str = float(right)
+            except ValueError:
+                l_val, r_val = left, right
+            match op:
+                case "==": return l_val == r_val
+                case "!=": return l_val != r_val
+                case ">":  return l_val > r_val
+                case "<":  return l_val < r_val
+                case ">=": return l_val >= r_val
+                case "<=": return l_val <= r_val
+    return bool(condition) and condition.lower() not in ("false", "0", "no")
+
+
+async def handle_logic(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "if":
+                if not args:
+                    return f"[Error in $if: condition required]"
+                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 "and":
+                if not args:
+                    return f"[Error in $and: at least one condition required]"
+                return "true" if all(_evaluate_condition(a.strip()) for a in args) else "false"
+
+            case "or":
+                if not args:
+                    return f"[Error in $or: at least one condition required]"
+                return "true" if any(_evaluate_condition(a.strip()) for a in args) else "false"
+
+            case "not":
+                val = args[0].strip() if args else ""
+                return "false" if _evaluate_condition(val) else "true"
+
+            case "switch":
+                if not args:
+                    return f"[Error in $switch: value required]"
+                value = args[0].strip()
+                i = 1
+                while i + 1 < len(args):
+                    if value == args[i].strip():
+                        return args[i + 1]
+                    i += 2
+                return args[i] if i < len(args) else ""
+
+            case "onlyif":
+                if not args:
+                    return "[Error in $onlyIf: condition required]"
+                condition = args[0].strip()
+                error_msg = args[1] if len(args) > 1 else ""
+                if not _evaluate_condition(condition):
+                    raise StopExecution(error_msg)
+                return ""
+
+            case "try":
+                code = args[0] if len(args) > 0 else ""
+                fallback = args[1] if len(args) > 1 else ""
+                try:
+                    return await parser._eval(code)
+                except StopExecution:
+                    raise
+                except Exception:
+                    return fallback
+
+            case _:
+                return None
+
+    except StopExecution:
+        raise
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/discord/message.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+
+async def handle_message(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "reply":
+                parser._reply = True
+                content = args[0] if args else (raw if raw else None)
+                if content:
+                    parser._reply_content = content
+                return ""
+
+            case "deleteafter":
+                seconds = args[0].strip() if args else raw.strip()
+                try:
+                    parser._delete_after = float(seconds)
+                except ValueError:
+                    return "[Error in $deleteAfter: invalid duration]"
+                return ""
+
+            case "sendmessage":
+                channel_id = args[0].strip() if len(args) > 0 else ""
+                content = args[1] if len(args) > 1 else ""
+                return_var = args[2].strip() if len(args) > 2 and args[2].strip() else None
+                if not channel_id:
+                    return "[Error in $sendMessage: channel id required]"
+                try:
+                    cid = int(channel_id)
+                except ValueError:
+                    return "[Error in $sendMessage: invalid channel id]"
+                msg = {
+                    "channel_id": cid,
+                    "content": content,
+                    "embeds": [],
+                    "components": [],
+                    "cv2": [],
+                    "delete_after": None,
+                }
+                if return_var:
+                    msg["return_id"] = True
+                    msg["return_var"] = return_var
+                    msg["_parser"] = parser
+                parser._extra_messages.append(msg)
+                return ""
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"