cordscript 1.0.0__py3-none-any.whl

cordscript/functions/discord/moderation.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+import asyncio
+import re
+import discord
+from datetime import timedelta
+from ...core.context import get_guild
+
+_DURATION_PATTERN = re.compile(r"(\d+)\s*([smhdw])", re.IGNORECASE)
+_DURATION_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
+
+_PENDING_UNBANS: dict[tuple[int, int], asyncio.Task] = {}
+
+
+def _parse_duration(text: str) -> int | None:
+    if not text or not text.strip():
+        return None
+    matches = _DURATION_PATTERN.findall(text.strip())
+    if not matches:
+        return None
+    total = 0
+    for value, unit in matches:
+        total += int(value) * _DURATION_UNITS[unit.lower()]
+    return total if total > 0 else None
+
+
+def _cancel_pending_unban(guild_id: int, user_id: int):
+    task = _PENDING_UNBANS.pop((guild_id, user_id), None)
+    if task and not task.done():
+        task.cancel()
+
+
+def _schedule_unban(guild, user_id: int, delay: int):
+    _cancel_pending_unban(guild.id, user_id)
+
+    async def _runner():
+        try:
+            await asyncio.sleep(delay)
+            await guild.unban(discord.Object(id=user_id), reason="Tempo de banimento expirado")
+        except asyncio.CancelledError:
+            pass
+        except discord.NotFound:
+            pass
+        except Exception as e:
+            print(f"[cordscript] Failed to auto-unban {user_id}: {e}")
+        finally:
+            _PENDING_UNBANS.pop((guild.id, user_id), None)
+
+    _PENDING_UNBANS[(guild.id, user_id)] = asyncio.create_task(_runner())
+
+
+async def handle_moderation(fn: str, args: list[str], raw: str, parser) -> str | None:
+    if fn not in ("ban", "unban", "kick", "timeout", "untimeout"):
+        return None
+
+    guild = get_guild(parser.ctx)
+    if guild is None:
+        return f"[Error in ${fn}: no guild in this context]"
+
+    try:
+        match fn:
+            case "ban":
+                user_id = args[0].strip() if args else ""
+                reason = args[1] if len(args) > 1 and args[1].strip() else None
+                duration_raw = args[2] if len(args) > 2 else ""
+                if not user_id:
+                    return "[Error in $ban: user id required]"
+                try:
+                    uid = int(user_id)
+                except ValueError:
+                    return "[Error in $ban: invalid user id]"
+                duration = _parse_duration(duration_raw)
+                if duration_raw.strip() and duration is None:
+                    return "[Error in $ban: invalid time format, use e.g. 7s, 1m, 10h, 1d]"
+                try:
+                    await guild.ban(discord.Object(id=uid), reason=reason)
+                except discord.Forbidden:
+                    return "[Error in $ban: missing permissions]"
+                except discord.HTTPException as e:
+                    return f"[Error in $ban: {e}]"
+                if duration:
+                    _schedule_unban(guild, uid, duration)
+                return ""
+
+            case "unban":
+                user_id = args[0].strip() if args else ""
+                reason = args[1] if len(args) > 1 and args[1].strip() else None
+                if not user_id:
+                    return "[Error in $unban: user id required]"
+                try:
+                    uid = int(user_id)
+                except ValueError:
+                    return "[Error in $unban: invalid user id]"
+                _cancel_pending_unban(guild.id, uid)
+                try:
+                    await guild.unban(discord.Object(id=uid), reason=reason)
+                except discord.Forbidden:
+                    return "[Error in $unban: missing permissions]"
+                except discord.NotFound:
+                    return "[Error in $unban: user is not banned]"
+                except discord.HTTPException as e:
+                    return f"[Error in $unban: {e}]"
+                return ""
+
+            case "kick":
+                user_id = args[0].strip() if args else ""
+                reason = args[1] if len(args) > 1 and args[1].strip() else None
+                if not user_id:
+                    return "[Error in $kick: user id required]"
+                try:
+                    uid = int(user_id)
+                except ValueError:
+                    return "[Error in $kick: invalid user id]"
+                member = guild.get_member(uid)
+                if member is None:
+                    try:
+                        member = await guild.fetch_member(uid)
+                    except discord.NotFound:
+                        return "[Error in $kick: member not found]"
+                try:
+                    await guild.kick(member, reason=reason)
+                except discord.Forbidden:
+                    return "[Error in $kick: missing permissions]"
+                except discord.HTTPException as e:
+                    return f"[Error in $kick: {e}]"
+                return ""
+
+            case "timeout":
+                user_id = args[0].strip() if args else ""
+                reason = args[1] if len(args) > 1 and args[1].strip() else None
+                duration_raw = args[2] if len(args) > 2 else ""
+                if not user_id:
+                    return "[Error in $timeout: user id required]"
+                duration = _parse_duration(duration_raw)
+                if duration is None:
+                    return "[Error in $timeout: invalid or missing time, use e.g. 7s, 1m, 10h, 1d]"
+                try:
+                    uid = int(user_id)
+                except ValueError:
+                    return "[Error in $timeout: invalid user id]"
+                member = guild.get_member(uid)
+                if member is None:
+                    try:
+                        member = await guild.fetch_member(uid)
+                    except discord.NotFound:
+                        return "[Error in $timeout: member not found]"
+                try:
+                    until = discord.utils.utcnow() + timedelta(seconds=duration)
+                    await member.timeout(until, reason=reason)
+                except discord.Forbidden:
+                    return "[Error in $timeout: missing permissions]"
+                except discord.HTTPException as e:
+                    return f"[Error in $timeout: {e}]"
+                return ""
+
+            case "untimeout":
+                user_id = args[0].strip() if args else ""
+                reason = args[1] if len(args) > 1 and args[1].strip() else None
+                if not user_id:
+                    return "[Error in $untimeout: user id required]"
+                try:
+                    uid = int(user_id)
+                except ValueError:
+                    return "[Error in $untimeout: invalid user id]"
+                member = guild.get_member(uid)
+                if member is None:
+                    try:
+                        member = await guild.fetch_member(uid)
+                    except discord.NotFound:
+                        return "[Error in $untimeout: member not found]"
+                try:
+                    await member.timeout(None, reason=reason)
+                except discord.Forbidden:
+                    return "[Error in $untimeout: missing permissions]"
+                except discord.HTTPException as e:
+                    return f"[Error in $untimeout: {e}]"
+                return ""
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/discord/status.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import discord
+
+_STATUS_MAP = {
+    "online": discord.Status.online,
+    "idle": discord.Status.idle,
+    "dnd": discord.Status.dnd,
+    "invisible": discord.Status.invisible,
+}
+
+_TYPE_MAP = {
+    "competing": discord.ActivityType.competing,
+    "watching": discord.ActivityType.watching,
+    "listening": discord.ActivityType.listening,
+}
+
+
+async def handle_status(fn: str, args: list[str], raw: str, parser) -> str | None:
+    if fn != "setstatus":
+        return None
+
+    presence_raw = args[0].strip().lower() if len(args) > 0 else ""
+    type_raw = args[1].strip().lower() if len(args) > 1 else ""
+    name = args[2] if len(args) > 2 else ""
+    state = args[3] if len(args) > 3 and args[3].strip() else None
+    url = args[4].strip() if len(args) > 4 and args[4].strip() else None
+
+    status = _STATUS_MAP.get(presence_raw)
+    if status is None:
+        return "[Error in $setStatus: invalid presence, use online, idle, dnd or invisible]"
+
+    if type_raw not in ("competing", "custom", "watching", "streaming", "listening"):
+        return "[Error in $setStatus: invalid type, use competing, custom, watching, streaming or listening]"
+
+    try:
+        if type_raw == "custom":
+            text = state or name
+            if not text:
+                return "[Error in $setStatus: name or state required for custom]"
+            activity = discord.CustomActivity(name=text)
+        elif type_raw == "streaming":
+            if not name or not url:
+                return "[Error in $setStatus: name and url required for streaming]"
+            activity = discord.Streaming(name=name, url=url)
+        else:
+            if not name:
+                return "[Error in $setStatus: name required]"
+            activity = discord.Activity(type=_TYPE_MAP[type_raw], name=name, state=state)
+
+        await parser.client.change_presence(status=status, activity=activity)
+    except discord.HTTPException as e:
+        return f"[Error in $setStatus: {e}]"
+    except Exception as e:
+        return f"[Unexpected error in $setStatus: {e}]"
+
+    return ""

cordscript/functions/users/__init__.py

@@ -0,0 +1,3 @@
+from .user import handle_user
+
+__all__ = ["handle_user"]

cordscript/functions/users/user.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from ...core.context import get_author, get_author_id, get_guild
+
+
+def _resolve_member(parser, args, index=0):
+    guild = get_guild(parser.ctx)
+    if len(args) > index and args[index].strip():
+        target = args[index].strip()
+        if guild and target.isdigit():
+            member = guild.get_member(int(target))
+            if member:
+                return member
+        return None
+    return get_author(parser.ctx)
+
+
+async def handle_user(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "authorid":
+                return get_author_id(parser.ctx)
+
+            case "author":
+                user = get_author(parser.ctx)
+                return str(user) if user else ""
+
+            case "username":
+                user = get_author(parser.ctx)
+                return user.name if user else ""
+
+            case "nickname":
+                user = _resolve_member(parser, args)
+                if user is None:
+                    return ""
+                return getattr(user, "display_name", getattr(user, "name", ""))
+
+            case "mention":
+                user = _resolve_member(parser, args)
+                return user.mention if user else ""
+
+            case "avatar" | "useravatar":
+                user = _resolve_member(parser, args)
+                if user is None:
+                    return ""
+                avatar = getattr(user, "display_avatar", None)
+                return str(avatar.url) if avatar else ""
+
+            case "tag" | "usertag":
+                user = _resolve_member(parser, args)
+                return str(user) if user else ""
+
+            case "isbot":
+                user = _resolve_member(parser, args)
+                return "true" if (user and getattr(user, "bot", False)) else "false"
+
+            case "userid":
+                user = _resolve_member(parser, args)
+                return str(user.id) if user else ""
+
+            case "joinedat":
+                user = _resolve_member(parser, args)
+                joined = getattr(user, "joined_at", None) if user else None
+                return str(int(joined.timestamp())) if joined else ""
+
+            case "createdat":
+                user = _resolve_member(parser, args)
+                created = getattr(user, "created_at", None) if user else None
+                return str(int(created.timestamp())) if created else ""
+
+            case "hasrole":
+                role_id = args[0].strip() if args else ""
+                user = _resolve_member(parser, args, index=1)
+                if not user or not role_id:
+                    return "false"
+                roles = getattr(user, "roles", [])
+                return "true" if any(str(r.id) == role_id for r in roles) else "false"
+
+            case "highestrole":
+                user = _resolve_member(parser, args)
+                if not user:
+                    return ""
+                roles = [r for r in getattr(user, "roles", []) if r.name != "@everyone"]
+                if not roles:
+                    return ""
+                return max(roles, key=lambda r: r.position).name
+
+            case "membercount" | "guildmembercount":
+                guild = get_guild(parser.ctx)
+                return str(guild.member_count) if guild else ""
+
+            case "guildname" | "servername":
+                guild = get_guild(parser.ctx)
+                return guild.name if guild else ""
+
+            case "guildid" | "serverid":
+                guild = get_guild(parser.ctx)
+                return str(guild.id) if guild else ""
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/__init__.py

@@ -0,0 +1,14 @@
+from .math import handle_math, safe_math
+from .time import handle_time
+from .random import handle_random
+from .http import handle_http
+from .cooldown import handle_cooldown
+from .json import handle_json
+from .strings import handle_strings
+
+__all__ = [
+    "handle_math", "safe_math",
+    "handle_time", "handle_random",
+    "handle_http", "handle_cooldown",
+    "handle_json", "handle_strings",
+]

cordscript/functions/utility/cooldown.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+import time as time_module
+from ...exceptions import CooldownError
+from ...core.context import get_author_id
+
+_COOLDOWNS: dict[str, float] = {}
+
+
+async def handle_cooldown(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "cooldown":
+                try:
+                    seconds = float(args[0].strip()) if args and args[0].strip() else 0
+                except ValueError:
+                    return f"[Error in $cooldown: invalid duration]"
+                msg = args[1] if len(args) > 1 else ""
+                uid = get_author_id(parser.ctx)
+                cmd = getattr(parser, "_command_name", "unknown")
+                key = f"{uid}:{cmd}"
+                now = time_module.monotonic()
+                last = _COOLDOWNS.get(key, 0)
+                remaining = seconds - (now - last)
+                if remaining > 0:
+                    raise CooldownError(msg or f"{round(remaining, 1)}s")
+                _COOLDOWNS[key] = now
+                return ""
+
+            case _:
+                return None
+
+    except CooldownError:
+        raise
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/http.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+import json
+import aiohttp
+
+
+async def handle_http(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "httprequest" | "http":
+                url = args[0].strip() if args else ""
+                method = args[1].strip().upper() if len(args) > 1 and args[1].strip() else "GET"
+                body = args[2] if len(args) > 2 and args[2].strip() else None
+                headers_raw = args[3] if len(args) > 3 and args[3].strip() else None
+                key = args[4].strip() if len(args) > 4 and args[4].strip() else None
+                if not url:
+                    return f"[Error in $http: URL required]"
+                try:
+                    headers = json.loads(headers_raw) if headers_raw else {}
+                    async with aiohttp.ClientSession() as session:
+                        kwargs: dict = {"headers": headers}
+                        if body:
+                            try:
+                                kwargs["json"] = json.loads(body)
+                            except Exception:
+                                kwargs["data"] = body
+                        resp = await getattr(session, method.lower())(url, **kwargs)
+                        text = await resp.text()
+                        if key:
+                            try:
+                                parsed = json.loads(text)
+                                keys = key.split(".")
+                                val = parsed
+                                for k in keys:
+                                    if isinstance(val, list):
+                                        val = val[int(k)]
+                                    else:
+                                        val = val[k]
+                                return json.dumps(val) if isinstance(val, (dict, list)) else str(val)
+                            except Exception as e:
+                                return f"[Error in $http: key parse failed — {e}]"
+                        return text
+                except Exception as e:
+                    return f"[Error in $http: {e}]"
+
+            case "httpstatus":
+                url = args[0].strip() if args else ""
+                method = args[1].strip().upper() if len(args) > 1 and args[1].strip() else "GET"
+                if not url:
+                    return f"[Error in $httpStatus: URL required]"
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        resp = await getattr(session, method.lower())(url)
+                        return str(resp.status)
+                except Exception as e:
+                    return f"[Error in $httpStatus: {e}]"
+
+            case "httpheader":
+                url = args[0].strip() if args else ""
+                header = args[1].strip() if len(args) > 1 else ""
+                if not url or not header:
+                    return f"[Error in $httpHeader: URL and header name required]"
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        resp = await session.get(url)
+                        return resp.headers.get(header, "")
+                except Exception as e:
+                    return f"[Error in $httpHeader: {e}]"
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/json.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+import json as _json
+
+
+async def handle_json(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "jsonparse":
+                raw_json = args[0] if args else ""
+                key = args[1].strip() if len(args) > 1 and args[1].strip() else None
+                try:
+                    parsed = _json.loads(raw_json)
+                    if key is None:
+                        return _json.dumps(parsed)
+                    keys = key.split(".")
+                    val = parsed
+                    for k in keys:
+                        val = val[int(k)] if isinstance(val, list) else val[k]
+                    return _json.dumps(val) if isinstance(val, (dict, list)) else str(val)
+                except Exception as e:
+                    return f"[Error in $jsonParse: {e}]"
+
+            case "jsonset":
+                raw_json = args[0] if args else "{}"
+                key = args[1].strip() if len(args) > 1 else ""
+                value = args[2] if len(args) > 2 else ""
+                try:
+                    parsed = _json.loads(raw_json)
+                    keys = key.split(".")
+                    obj = parsed
+                    for k in keys[:-1]:
+                        obj = obj[k]
+                    try:
+                        obj[keys[-1]] = _json.loads(value)
+                    except Exception:
+                        obj[keys[-1]] = value
+                    return _json.dumps(parsed)
+                except Exception as e:
+                    return f"[Error in $jsonSet: {e}]"
+
+            case "jsonkeys":
+                try:
+                    return _json.dumps(list(_json.loads(args[0] if args else "{}").keys()))
+                except Exception as e:
+                    return f"[Error in $jsonKeys: {e}]"
+
+            case "jsonvalues":
+                try:
+                    return _json.dumps(list(_json.loads(args[0] if args else "{}").values()))
+                except Exception as e:
+                    return f"[Error in $jsonValues: {e}]"
+
+            case "jsondelete":
+                raw_json = args[0] if args else "{}"
+                key = args[1].strip() if len(args) > 1 else ""
+                try:
+                    parsed = _json.loads(raw_json)
+                    keys = key.split(".")
+                    obj = parsed
+                    for k in keys[:-1]:
+                        obj = obj[k]
+                    del obj[keys[-1]]
+                    return _json.dumps(parsed)
+                except Exception as e:
+                    return f"[Error in $jsonDelete: {e}]"
+
+            case "arraycreate":
+                return _json.dumps(list(args))
+
+            case "arraypush":
+                raw_arr = args[0] if args else "[]"
+                value = args[1] if len(args) > 1 else ""
+                try:
+                    arr = _json.loads(raw_arr)
+                    try:
+                        arr.append(_json.loads(value))
+                    except Exception:
+                        arr.append(value)
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arrayPush: {e}]"
+
+            case "arraypop":
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    arr.pop()
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arrayPop: {e}]"
+
+            case "arrayshift":
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    arr.pop(0)
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arrayShift: {e}]"
+
+            case "arrayget":
+                try:
+                    index = int(args[1].strip()) - 1 if len(args) > 1 else 0
+                    arr = _json.loads(args[0] if args else "[]")
+                    val = arr[index]
+                    return _json.dumps(val) if isinstance(val, (dict, list)) else str(val)
+                except Exception as e:
+                    return f"[Error in $arrayGet: {e}]"
+
+            case "arrayset":
+                try:
+                    index = int(args[1].strip()) - 1 if len(args) > 1 else 0
+                    value = args[2] if len(args) > 2 else ""
+                    arr = _json.loads(args[0] if args else "[]")
+                    try:
+                        arr[index] = _json.loads(value)
+                    except Exception:
+                        arr[index] = value
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arraySet: {e}]"
+
+            case "arrayremove":
+                try:
+                    index = int(args[1].strip()) - 1 if len(args) > 1 else 0
+                    arr = _json.loads(args[0] if args else "[]")
+                    arr.pop(index)
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arrayRemove: {e}]"
+
+            case "arrayincludes":
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    value = args[1] if len(args) > 1 else ""
+                    try:
+                        val = _json.loads(value)
+                    except Exception:
+                        val = value
+                    return "true" if val in arr else "false"
+                except Exception as e:
+                    return f"[Error in $arrayIncludes: {e}]"
+
+            case "arraylength":
+                try:
+                    return str(len(_json.loads(args[0] if args else "[]")))
+                except Exception as e:
+                    return f"[Error in $arrayLength: {e}]"
+
+            case "arrayjoin":
+                sep = args[1] if len(args) > 1 else ","
+                try:
+                    return sep.join(str(x) for x in _json.loads(args[0] if args else "[]"))
+                except Exception as e:
+                    return f"[Error in $arrayJoin: {e}]"
+
+            case "arraysort":
+                order = args[1].strip().lower() if len(args) > 1 else "asc"
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    arr.sort(reverse=(order == "desc"))
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arraySort: {e}]"
+
+            case "arrayreverse":
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    arr.reverse()
+                    return _json.dumps(arr)
+                except Exception as e:
+                    return f"[Error in $arrayReverse: {e}]"
+
+            case "arrayfind":
+                try:
+                    arr = _json.loads(args[0] if args else "[]")
+                    value = args[1] if len(args) > 1 else ""
+                    try:
+                        val = _json.loads(value)
+                    except Exception:
+                        val = value
+                    return str(arr.index(val) + 1) if val in arr else "-1"
+                except Exception as e:
+                    return f"[Error in $arrayFind: {e}]"
+
+            case "arrayfromjson":
+                raw_json = args[0] if args else "{}"
+                key = args[1].strip() if len(args) > 1 else ""
+                try:
+                    parsed = _json.loads(raw_json)
+                    if key:
+                        for k in key.split("."):
+                            parsed = parsed[k]
+                        return _json.dumps(parsed if isinstance(parsed, list) else list(parsed))
+                    return _json.dumps(list(parsed.values()))
+                except Exception as e:
+                    return f"[Error in $arrayFromJson: {e}]"
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"