elos 1.0.1__py3-none-any.whl

ELOS/__init__.py

@@ -0,0 +1,15 @@
+import sys as _sys
+from .runner import run, run_source
+
+__all__ = ["run", "run_source"]
+__version__ = "2.0.0"
+
+_sys.modules.pop("ELOS.runner", None)
+_sys.modules.pop("ELOS._bot", None)
+_sys.modules.pop("ELOS._gateway", None)
+_sys.modules.pop("ELOS._http", None)
+_sys.modules.pop("ELOS._runtime", None)
+_sys.modules.pop("ELOS._parser", None)
+_sys.modules.pop("ELOS._lexer", None)
+_sys.modules.pop("ELOS._ast", None)
+del _sys

ELOS/__main__.py

@@ -0,0 +1,24 @@
+import sys
+import argparse
+from pathlib import Path
+
+def main():
+    parser = argparse.ArgumentParser(prog="python -m ELOS")
+    parser.add_argument("file", help=".elos source file to run")
+    parser.add_argument("--user-id", type=int, default=0, metavar="INT")
+    parser.add_argument("--env", action="append", default=[], metavar="KEY=VALUE")
+    args = parser.parse_args()
+
+    extra_env = {}
+    for item in args.env:
+        if "=" not in item:
+            print(f"[ELOS] Invalid --env: {item}", file=sys.stderr)
+            sys.exit(1)
+        k, v = item.split("=", 1)
+        extra_env[k] = v
+
+    from ELOS.runner import run
+    sys.exit(run(args.file, user_id=args.user_id, env=extra_env or None))
+
+if __name__ == "__main__":
+    main()

ELOS/_ast.py

@@ -0,0 +1,86 @@
+import re
+
+class Node:
+    line: int = None
+
+class Program(Node):
+    def __init__(self, events, funcdefs=None, login_token=None):
+        self.events = events
+        self.funcdefs = funcdefs or []
+        self.login_token = login_token
+
+class EventBlock(Node):
+    def __init__(self, event_type, params, body):
+        self.event_type = event_type; self.params = params; self.body = body
+
+class FuncDef(Node):
+    def __init__(self, name, params, body):
+        self.name = name; self.params = params; self.body = body
+
+class AssignStmt(Node):
+    def __init__(self, target, value): self.target = target; self.value = value
+
+class IfStmt(Node):
+    def __init__(self, cond, body, elifs=None, else_body=None):
+        self.cond = cond; self.body = body
+        self.elifs = elifs or []; self.else_body = else_body or []
+
+class ForStmt(Node):
+    def __init__(self, var, iterable, body):
+        self.var = var; self.iterable = iterable; self.body = body
+
+class WhileStmt(Node):
+    def __init__(self, cond, body): self.cond = cond; self.body = body
+
+class TryCatch(Node):
+    def __init__(self, try_body, catch_body, catch_var=None):
+        self.try_body = try_body; self.catch_body = catch_body; self.catch_var = catch_var
+
+class ReturnStmt(Node):
+    def __init__(self, value=None): self.value = value
+
+class BreakStmt(Node): pass
+class ContinueStmt(Node): pass
+class StopStmt(Node): pass
+
+class ExprStmt(Node):
+    def __init__(self, expr): self.expr = expr
+
+class CallExpr(Node):
+    def __init__(self, func, args): self.func = func; self.args = args
+
+class IndexExpr(Node):
+    def __init__(self, obj, idx): self.obj = obj; self.idx = idx
+
+class BinOp(Node):
+    def __init__(self, left, op, right): self.left = left; self.op = op; self.right = right
+
+class UnaryOp(Node):
+    def __init__(self, op, operand): self.op = op; self.operand = operand
+
+class Ident(Node):
+    def __init__(self, name): self.name = name
+
+class StringLit(Node):
+    def __init__(self, value): self.value = value
+
+class NumberLit(Node):
+    def __init__(self, value): self.value = value
+
+class BoolLit(Node):
+    def __init__(self, value): self.value = value
+
+class NullLit(Node): pass
+
+class ListLit(Node):
+    def __init__(self, items): self.items = items
+
+class FStringLit(Node):
+    def __init__(self, parts): self.parts = parts
+
+class EmbedLit(Node):
+    def __init__(self): self.fields = []
+
+class TernaryExpr(Node):
+    def __init__(self, true_val, condition, false_val):
+        self.true_val = true_val; self.condition = condition; self.false_val = false_val

ELOS/_bot.py

@@ -0,0 +1,89 @@
+import asyncio
+import os
+import sys
+from typing import Optional
+
+from ._lexer import Lexer
+from ._parser import Parser
+from ._ast import Program, EventBlock, FuncDef
+from ._http import HTTP
+from ._gateway import Gateway
+from ._runtime import Interpreter, StopSignal, _red, _yellow
+
+class Bot:
+    def __init__(self, token: str, user_id: int = 0):
+        self.token = token
+        self.user_id = user_id
+        self._http = HTTP(token)
+        self._gw: Optional[Gateway] = None
+        self._interp: Optional[Interpreter] = None
+        self._handlers: list[EventBlock] = []
+        self._timer_handlers: list[EventBlock] = []
+        self._program: Optional[Program] = None
+
+    def load_source(self, source: str):
+        tokens = Lexer(source).tokenize()
+        program = Parser(tokens).parse()
+        self._program = program
+
+        self._interp = Interpreter(self._http)
+        if self.user_id:
+            var_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '.elos_vars')
+            os.makedirs(var_dir, exist_ok=True)
+            self._interp._var_file = os.path.join(var_dir, f'user_{self.user_id}.json')
+
+        for fd in program.funcdefs:
+            self._interp.user_funcs[fd.name] = fd
+
+        self._handlers = program.events
+        self._timer_handlers = [e for e in program.events if e.event_type in ('onTimerEnd', 'onTimerStart')]
+
+        async def _timer_dispatch(timer_id: str):
+            await self._dispatch_elos('onTimerEnd', {'timer_id': timer_id})
+        self._interp._timer_dispatch = _timer_dispatch
+
+        return program
+
+    async def _dispatch_elos(self, elos_event: str, ctx: dict):
+        for handler in self._handlers:
+            if handler.event_type != elos_event:
+                continue
+            env = dict(self._interp.globals)
+            for i, param in enumerate(handler.params):
+                env[param] = list(ctx.values())[i] if i < len(ctx) else None
+            try:
+                from ._runtime import ReturnSignal, BreakSignal
+                await self._interp._exec_block(handler.body, env)
+            except StopSignal:
+                pass
+            except Exception as e:
+                line = getattr(handler, 'line', '?')
+                _red(f"[ELOS] {type(e).__name__}: {e} [Event: {elos_event}, Line: {line}]")
+
+    async def _on_gateway_event(self, event: str, data: dict):
+        if not self._interp:
+            return
+
+        if event == "READY":
+            self._interp._bot_user = data.get("user", {})
+            self._interp.application_id = self._gw.application_id
+            await self._interp.run_event(self._handlers, event, data)
+            return
+
+        await self._interp.run_event(self._handlers, event, data)
+
+    async def start(self):
+        self._gw = Gateway(self.token, self._on_gateway_event)
+        try:
+            await self._gw.connect()
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self._http.close()
+            if self._gw:
+                await self._gw.close()
+
+    async def close(self):
+        if self._gw:
+            await self._gw.close()
+        await self._http.close()

ELOS/_gateway.py

@@ -0,0 +1,159 @@
+import asyncio
+import json
+import sys
+import time
+import aiohttp
+from typing import Callable, Optional
+
+RED   = "\033[91m"
+YELLOW= "\033[93m"
+RESET = "\033[0m"
+
+GW_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+
+OP_DISPATCH        = 0
+OP_HEARTBEAT       = 1
+OP_IDENTIFY        = 2
+OP_RESUME          = 6
+OP_RECONNECT       = 7
+OP_INVALID_SESSION = 9
+OP_HELLO           = 10
+OP_HEARTBEAT_ACK   = 11
+
+INTENT_GUILDS           = 1 << 0
+INTENT_GUILD_MEMBERS    = 1 << 1
+INTENT_GUILD_MODERATION = 1 << 2
+INTENT_GUILD_EMOJIS     = 1 << 3
+INTENT_GUILD_MESSAGES   = 1 << 9
+INTENT_GUILD_REACTIONS  = 1 << 10
+INTENT_GUILD_TYPING     = 1 << 11
+INTENT_DM_MESSAGES      = 1 << 12
+INTENT_MESSAGE_CONTENT  = 1 << 15
+INTENT_GUILD_VOICE      = 1 << 7
+
+ALL_INTENTS = (
+    INTENT_GUILDS | INTENT_GUILD_MEMBERS | INTENT_GUILD_MODERATION |
+    INTENT_GUILD_EMOJIS | INTENT_GUILD_MESSAGES | INTENT_GUILD_REACTIONS |
+    INTENT_GUILD_TYPING | INTENT_DM_MESSAGES | INTENT_MESSAGE_CONTENT |
+    INTENT_GUILD_VOICE
+)
+
+class Gateway:
+    def __init__(self, token: str, dispatch: Callable):
+        self.token = token
+        self.dispatch = dispatch
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._seq: Optional[int] = None
+        self._session_id: Optional[str] = None
+        self._heartbeat_interval: float = 41.25
+        self._last_ack: float = time.monotonic()
+        self._running = False
+        self.application_id: Optional[str] = None
+        self.user: Optional[dict] = None
+
+    async def connect(self):
+        self._running = True
+        self._session = aiohttp.ClientSession()
+        while self._running:
+            try:
+                await self._run()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                print(f"{RED}[ELOS] Gateway error: {e}{RESET}", file=sys.stderr)
+                if self._running:
+                    print(f"{YELLOW}[ELOS] Reconnecting in 5s...{RESET}", file=sys.stderr)
+                    await asyncio.sleep(5)
+
+    async def _run(self):
+        async with self._session.ws_connect(GW_URL) as ws:
+            self._ws = ws
+            hello = await ws.receive_json()
+            self._heartbeat_interval = hello["d"]["heartbeat_interval"] / 1000.0
+
+            hb_task = asyncio.create_task(self._heartbeat_loop())
+            try:
+                if self._session_id:
+                    await self._resume(ws)
+                else:
+                    await self._identify(ws)
+
+                async for msg in ws:
+                    if msg.type == aiohttp.WSMsgType.TEXT:
+                        await self._handle(json.loads(msg.data))
+                    elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                        break
+            finally:
+                hb_task.cancel()
+                try: await hb_task
+                except asyncio.CancelledError: pass
+
+    async def _identify(self, ws):
+        await ws.send_json({
+            "op": OP_IDENTIFY,
+            "d": {
+                "token": self.token,
+                "intents": ALL_INTENTS,
+                "properties": {"os": "linux", "browser": "ELOS", "device": "ELOS"},
+            }
+        })
+
+    async def _resume(self, ws):
+        await ws.send_json({
+            "op": OP_RESUME,
+            "d": {
+                "token": self.token,
+                "session_id": self._session_id,
+                "seq": self._seq,
+            }
+        })
+
+    async def _heartbeat_loop(self):
+        await asyncio.sleep(self._heartbeat_interval * 0.5)
+        while True:
+            if self._ws and not self._ws.closed:
+                await self._ws.send_json({"op": OP_HEARTBEAT, "d": self._seq})
+            await asyncio.sleep(self._heartbeat_interval)
+
+    async def _handle(self, msg: dict):
+        op = msg.get("op")
+        data = msg.get("d")
+        seq = msg.get("s")
+        event = msg.get("t")
+
+        if seq is not None:
+            self._seq = seq
+
+        if op == OP_DISPATCH:
+            if event == "READY":
+                self._session_id = data["session_id"]
+                self.user = data["user"]
+                self.application_id = data.get("application", {}).get("id") or data["user"]["id"]
+                print(f"[ELOS] Bot online: {data['user']['username']}#{data['user']['discriminator']}")
+            await self.dispatch(event, data)
+
+        elif op == OP_HEARTBEAT:
+            if self._ws:
+                await self._ws.send_json({"op": OP_HEARTBEAT, "d": self._seq})
+
+        elif op == OP_HEARTBEAT_ACK:
+            self._last_ack = time.monotonic()
+
+        elif op == OP_RECONNECT:
+            if self._ws: await self._ws.close()
+
+        elif op == OP_INVALID_SESSION:
+            resumable = bool(data)
+            if not resumable:
+                self._session_id = None
+                self._seq = None
+            await asyncio.sleep(2)
+            if self._ws: await self._ws.close()
+
+    async def close(self):
+        self._running = False
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+        if self._session and not self._session.closed:
+            await self._session.close()

ELOS/_http.py

@@ -0,0 +1,261 @@
+import asyncio
+import aiohttp
+import json
+import sys
+from typing import Optional
+
+YELLOW = "\033[93m"
+RESET  = "\033[0m"
+
+API = "https://discord.com/api/v10"
+
+class DiscordHTTPError(Exception):
+    def __init__(self, status: int, message: str, code: int = 0):
+        self.status = status
+        self.code = code
+        super().__init__(f"HTTP {status}: {message} (code={code})")
+
+class HTTP:
+    def __init__(self, token: str):
+        self.token = token
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._global_rl = asyncio.Event()
+        self._global_rl.set()
+
+    @property
+    def headers(self):
+        return {
+            "Authorization": f"Bot {self.token}",
+            "Content-Type": "application/json",
+            "User-Agent": "ELOS/1.0",
+        }
+
+    async def _session_get(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def request(self, method: str, path: str, **kwargs) -> dict | list | None:
+        await self._global_rl.wait()
+        session = await self._session_get()
+        url = f"{API}{path}"
+        headers = self.headers.copy()
+
+        data = kwargs.pop("json", None)
+        if data is not None:
+            kwargs["data"] = json.dumps(data)
+
+        form = kwargs.pop("form", None)
+
+        for attempt in range(5):
+            try:
+                if form:
+                    resp = await session.request(method, url, headers={k: v for k, v in headers.items() if k != "Content-Type"}, data=form)
+                else:
+                    resp = await session.request(method, url, headers=headers, **kwargs)
+
+                if resp.status == 429:
+                    data_rl = await resp.json()
+                    retry_after = data_rl.get("retry_after", 1.0)
+                    is_global = data_rl.get("global", False)
+                    print(f"{YELLOW}[ELOS] Rate limited. Retry after {retry_after}s (global={is_global}){RESET}", file=sys.stderr)
+                    if is_global:
+                        self._global_rl.clear()
+                        await asyncio.sleep(retry_after)
+                        self._global_rl.set()
+                    else:
+                        await asyncio.sleep(retry_after)
+                    continue
+
+                if resp.status == 204:
+                    return None
+
+                body = await resp.text()
+                try:
+                    result = json.loads(body)
+                except Exception:
+                    result = body
+
+                if resp.status >= 400:
+                    msg = result.get("message", body) if isinstance(result, dict) else body
+                    code = result.get("code", 0) if isinstance(result, dict) else 0
+                    raise DiscordHTTPError(resp.status, msg, code)
+
+                remaining = resp.headers.get("X-RateLimit-Remaining")
+                reset_after = resp.headers.get("X-RateLimit-Reset-After")
+                if remaining == "0" and reset_after:
+                    await asyncio.sleep(float(reset_after))
+
+                return result
+
+            except DiscordHTTPError:
+                raise
+            except aiohttp.ClientError as e:
+                if attempt == 4:
+                    raise
+                await asyncio.sleep(1 + attempt)
+
+        return None
+
+    async def close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def send_message(self, channel_id, content=None, embed=None, components=None, reference=None, ephemeral=False, files=None):
+        payload = {}
+        if content is not None:
+            payload["content"] = str(content)
+        if embed is not None:
+            payload["embeds"] = [embed if isinstance(embed, dict) else embed.to_dict()]
+        if components:
+            payload["components"] = components
+        if reference:
+            payload["message_reference"] = {"message_id": str(reference)}
+        if files:
+            form = aiohttp.FormData()
+            form.add_field("payload_json", json.dumps(payload), content_type="application/json")
+            for i, (name, data, ct) in enumerate(files):
+                form.add_field(f"files[{i}]", data, filename=name, content_type=ct)
+            return await self.request("POST", f"/channels/{channel_id}/messages", form=form)
+        return await self.request("POST", f"/channels/{channel_id}/messages", json=payload)
+
+    async def delete_message(self, channel_id, message_id):
+        return await self.request("DELETE", f"/channels/{channel_id}/messages/{message_id}")
+
+    async def edit_message(self, channel_id, message_id, content=None, embed=None):
+        payload = {}
+        if content is not None: payload["content"] = str(content)
+        if embed is not None: payload["embeds"] = [embed if isinstance(embed, dict) else embed.to_dict()]
+        return await self.request("PATCH", f"/channels/{channel_id}/messages/{message_id}", json=payload)
+
+    async def pin_message(self, channel_id, message_id):
+        return await self.request("PUT", f"/channels/{channel_id}/pins/{message_id}")
+
+    async def unpin_message(self, channel_id, message_id):
+        return await self.request("DELETE", f"/channels/{channel_id}/pins/{message_id}")
+
+    async def add_reaction(self, channel_id, message_id, emoji):
+        emoji_enc = emoji.replace("#", "%23")
+        return await self.request("PUT", f"/channels/{channel_id}/messages/{message_id}/reactions/{emoji_enc}/@me")
+
+    async def remove_reaction(self, channel_id, message_id, emoji, user_id=None):
+        emoji_enc = emoji.replace("#", "%23")
+        target = f"/{user_id}" if user_id else "/@me"
+        return await self.request("DELETE", f"/channels/{channel_id}/messages/{message_id}/reactions/{emoji_enc}{target}")
+
+    async def get_message(self, channel_id, message_id):
+        return await self.request("GET", f"/channels/{channel_id}/messages/{message_id}")
+
+    async def get_channel(self, channel_id):
+        return await self.request("GET", f"/channels/{channel_id}")
+
+    async def create_channel(self, guild_id, name, type=0, topic=None, parent_id=None):
+        payload = {"name": name, "type": type}
+        if topic: payload["topic"] = topic
+        if parent_id: payload["parent_id"] = str(parent_id)
+        return await self.request("POST", f"/guilds/{guild_id}/channels", json=payload)
+
+    async def delete_channel(self, channel_id):
+        return await self.request("DELETE", f"/channels/{channel_id}")
+
+    async def edit_channel(self, channel_id, **kwargs):
+        return await self.request("PATCH", f"/channels/{channel_id}", json=kwargs)
+
+    async def get_guild_channels(self, guild_id):
+        return await self.request("GET", f"/guilds/{guild_id}/channels")
+
+    async def create_invite(self, channel_id, max_age=86400, max_uses=0, temporary=False):
+        return await self.request("POST", f"/channels/{channel_id}/invites",
+                                  json={"max_age": max_age, "max_uses": max_uses, "temporary": temporary})
+
+    async def get_guild(self, guild_id):
+        return await self.request("GET", f"/guilds/{guild_id}")
+
+    async def get_guild_members(self, guild_id, limit=1000):
+        return await self.request("GET", f"/guilds/{guild_id}/members?limit={limit}")
+
+    async def get_member(self, guild_id, user_id):
+        return await self.request("GET", f"/guilds/{guild_id}/members/{user_id}")
+
+    async def ban_member(self, guild_id, user_id, reason=None, delete_days=0):
+        payload = {"delete_message_days": delete_days}
+        headers = {}
+        if reason: headers["X-Audit-Log-Reason"] = reason
+        return await self.request("PUT", f"/guilds/{guild_id}/bans/{user_id}", json=payload)
+
+    async def unban_member(self, guild_id, user_id):
+        return await self.request("DELETE", f"/guilds/{guild_id}/bans/{user_id}")
+
+    async def kick_member(self, guild_id, user_id, reason=None):
+        return await self.request("DELETE", f"/guilds/{guild_id}/members/{user_id}")
+
+    async def add_role(self, guild_id, user_id, role_id):
+        return await self.request("PUT", f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def remove_role(self, guild_id, user_id, role_id):
+        return await self.request("DELETE", f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def edit_member(self, guild_id, user_id, **kwargs):
+        return await self.request("PATCH", f"/guilds/{guild_id}/members/{user_id}", json=kwargs)
+
+    async def get_guild_roles(self, guild_id):
+        return await self.request("GET", f"/guilds/{guild_id}/roles")
+
+    async def create_role(self, guild_id, name, color=0, permissions="0", mentionable=False):
+        return await self.request("POST", f"/guilds/{guild_id}/roles",
+                                  json={"name": name, "color": color, "permissions": permissions, "mentionable": mentionable})
+
+    async def delete_role(self, guild_id, role_id):
+        return await self.request("DELETE", f"/guilds/{guild_id}/roles/{role_id}")
+
+    async def edit_role(self, guild_id, role_id, **kwargs):
+        return await self.request("PATCH", f"/guilds/{guild_id}/roles/{role_id}", json=kwargs)
+
+    async def get_user(self, user_id):
+        return await self.request("GET", f"/users/{user_id}")
+
+    async def get_me(self):
+        return await self.request("GET", "/users/@me")
+
+    async def create_webhook(self, channel_id, name):
+        return await self.request("POST", f"/channels/{channel_id}/webhooks", json={"name": name})
+
+    async def delete_webhook(self, webhook_id):
+        return await self.request("DELETE", f"/webhooks/{webhook_id}")
+
+    async def execute_webhook(self, webhook_id, webhook_token, content=None, username=None, avatar_url=None, embeds=None):
+        payload = {}
+        if content: payload["content"] = str(content)
+        if username: payload["username"] = username
+        if avatar_url: payload["avatar_url"] = avatar_url
+        if embeds: payload["embeds"] = embeds
+        return await self.request("POST", f"/webhooks/{webhook_id}/{webhook_token}", json=payload)
+
+    async def interaction_response(self, interaction_id, interaction_token, type: int, data: dict = None):
+        payload = {"type": type}
+        if data: payload["data"] = data
+        return await self.request("POST", f"/interactions/{interaction_id}/{interaction_token}/callback", json=payload)
+
+    async def edit_interaction_response(self, application_id, interaction_token, content=None, embeds=None):
+        payload = {}
+        if content is not None: payload["content"] = str(content)
+        if embeds: payload["embeds"] = embeds
+        return await self.request("PATCH", f"/webhooks/{application_id}/{interaction_token}/messages/@original", json=payload)
+
+    async def register_global_command(self, application_id, command: dict):
+        return await self.request("POST", f"/applications/{application_id}/commands", json=command)
+
+    async def register_guild_command(self, application_id, guild_id, command: dict):
+        return await self.request("POST", f"/applications/{application_id}/guilds/{guild_id}/commands", json=command)
+
+    async def get_global_commands(self, application_id):
+        return await self.request("GET", f"/applications/{application_id}/commands")
+
+    async def delete_global_command(self, application_id, command_id):
+        return await self.request("DELETE", f"/applications/{application_id}/commands/{command_id}")
+
+    async def trigger_typing(self, channel_id):
+        return await self.request("POST", f"/channels/{channel_id}/typing")
+
+    async def create_dm(self, user_id):
+        return await self.request("POST", "/users/@me/channels", json={"recipient_id": str(user_id)})