cordscript 1.0.0__py3-none-any.whl

cordscript/functions/utility/math.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+import ast
+import operator
+
+_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(f"Unsupported operator: {type(node.op).__name__}")
+        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(f"Unsupported operator: {type(node.op).__name__}")
+        return op(_eval_expr(node.operand))
+    raise ValueError(f"Unsupported expression: {type(node).__name__}")
+
+
+def safe_math(expr: str) -> str:
+    tree = ast.parse(expr.strip(), mode="eval")
+    result = _eval_expr(tree)
+    if isinstance(result, float) and result.is_integer():
+        return str(int(result))
+    return str(result)
+
+
+async def handle_math(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "math":
+                expr = args[0] if args else raw
+                try:
+                    return safe_math(expr)
+                except Exception as e:
+                    return f"[Error in $math: {e}]"
+
+            case "round":
+                try:
+                    num = float(args[0].strip()) if args else 0
+                    places = int(args[1].strip()) if len(args) > 1 and args[1].strip() else 0
+                    r = round(num, places)
+                    return str(r if places > 0 else int(r))
+                except ValueError as e:
+                    return f"[Error in $round: {e}]"
+
+            case "abs":
+                try:
+                    val = float(args[0].strip()) if args else 0
+                    r = abs(val)
+                    return str(int(r) if r == int(r) else r)
+                except ValueError as e:
+                    return f"[Error in $abs: {e}]"
+
+            case "max":
+                try:
+                    vals = [float(a.strip()) for a in args if a.strip()]
+                    if not vals:
+                        return f"[Error in $max: no values provided]"
+                    r = max(vals)
+                    return str(int(r) if r == int(r) else r)
+                except ValueError as e:
+                    return f"[Error in $max: {e}]"
+
+            case "min":
+                try:
+                    vals = [float(a.strip()) for a in args if a.strip()]
+                    if not vals:
+                        return f"[Error in $min: no values provided]"
+                    r = min(vals)
+                    return str(int(r) if r == int(r) else r)
+                except ValueError as e:
+                    return f"[Error in $min: {e}]"
+
+            case "isnumber":
+                val = args[0].strip() if args else ""
+                try:
+                    float(val)
+                    return "true"
+                except ValueError:
+                    return "false"
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/random.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+import random as _random
+
+
+async def handle_random(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            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
+                    if min_val > max_val:
+                        min_val, max_val = max_val, min_val
+                    return str(_random.randint(min_val, max_val))
+                except ValueError as e:
+                    return f"[Error in $random: {e}]"
+
+            case "randomitem":
+                if not args:
+                    return ""
+                return _random.choice(args)
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/strings.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+from ...exceptions import StopExecution
+from ...core.context import get_author_id
+
+
+def _get_args(parser) -> list[str]:
+    if not hasattr(parser.ctx, "content"):
+        return []
+    parts = parser.ctx.content.split(None, 1)
+    if len(parts) < 2:
+        return []
+    return parts[1].split()
+
+
+async def handle_strings(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "upper":
+                return (args[0] if args else raw).upper()
+
+            case "lower":
+                return (args[0] if args else raw).lower()
+
+            case "length":
+                return str(len(args[0] if args else raw))
+
+            case "trim":
+                return (args[0] if args else raw).strip()
+
+            case "replace":
+                if len(args) < 3:
+                    return f"[Error in $replace: expected 3 arguments (text;from;to)]"
+                return args[0].replace(args[1], args[2])
+
+            case "includes":
+                if len(args) < 2:
+                    return f"[Error in $includes: expected 2 arguments]"
+                return "true" if args[1] in args[0] else "false"
+
+            case "startswith":
+                if len(args) < 2:
+                    return f"[Error in $startsWith: expected 2 arguments]"
+                return "true" if args[0].startswith(args[1]) else "false"
+
+            case "endswith":
+                if len(args) < 2:
+                    return f"[Error in $endsWith: expected 2 arguments]"
+                return "true" if args[0].endswith(args[1]) else "false"
+
+            case "indexof":
+                if len(args) < 2:
+                    return f"[Error in $indexOf: expected 2 arguments]"
+                return str(args[0].find(args[1]))
+
+            case "slice":
+                if not args:
+                    return f"[Error in $slice: expected at least 1 argument]"
+                text = args[0]
+                try:
+                    start = int(args[1].strip()) if len(args) > 1 else 0
+                    end = int(args[2].strip()) if len(args) > 2 else len(text)
+                    return text[start:end]
+                except (ValueError, IndexError) as e:
+                    return f"[Error in $slice: {e}]"
+
+            case "concat":
+                return "".join(args)
+
+            case "split":
+                if not args:
+                    return f"[Error in $split: expected at least 1 argument]"
+                text = args[0]
+                sep = args[1] if len(args) > 1 else ","
+                try:
+                    index = int(args[2].strip()) - 1 if len(args) > 2 and args[2].strip() else None
+                except ValueError as e:
+                    return f"[Error in $split: {e}]"
+                parts = text.split(sep)
+                if index is not None:
+                    return parts[index] if 0 <= index < len(parts) else ""
+                return sep.join(parts)
+
+            case "repeat":
+                try:
+                    times = max(0, int(args[0].strip())) if args and args[0].strip() else 1
+                except ValueError as e:
+                    return f"[Error in $repeat: {e}]"
+                text = args[1] if len(args) > 1 else ""
+                return text * times
+
+            case "let":
+                name = args[0].strip() if args else ""
+                if not name:
+                    return f"[Error in $let: variable name required]"
+                parser._vars[name] = args[1] if len(args) > 1 else ""
+                return ""
+
+            case "get":
+                name = args[0].strip() if args else ""
+                if not name:
+                    return f"[Error in $get: variable name required]"
+                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 = parser._split_cache
+                if not cache:
+                    return ""
+                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) as e:
+                    return f"[Error in $splitText: {e}]"
+
+            case "args":
+                return " ".join(_get_args(parser))
+
+            case "arg":
+                try:
+                    index = int(args[0].strip()) - 1 if args and args[0].strip() else 0
+                    parts = _get_args(parser)
+                    return parts[index] if 0 <= index < len(parts) else ""
+                except (ValueError, IndexError):
+                    return ""
+
+            case "argslength":
+                return str(len(_get_args(parser)))
+
+            case "channelid":
+                if hasattr(parser.ctx, "channel") and parser.ctx.channel:
+                    return str(parser.ctx.channel.id)
+                if hasattr(parser.ctx, "channel_id") and parser.ctx.channel_id:
+                    return str(parser.ctx.channel_id)
+                return ""
+
+            case "channelname":
+                if hasattr(parser.ctx, "channel") and parser.ctx.channel:
+                    return str(parser.ctx.channel.name)
+                return ""
+
+            case "messageid":
+                return str(parser.ctx.id) if hasattr(parser.ctx, "id") else ""
+
+            case "stop":
+                raise StopExecution()
+
+            case "eval":
+                expr = args[0] if args else raw
+                if "$" in expr:
+                    return await parser._eval(expr)
+                from .math import safe_math
+                try:
+                    return safe_math(expr)
+                except Exception:
+                    return expr
+
+            case "dpyeval":
+                code = args[0] if args else raw
+                try:
+                    ctx = parser.ctx
+                    local_vars = {
+                        "ctx": ctx,
+                        "bot": parser.client,
+                        "client": parser.client,
+                        "channel": getattr(ctx, "channel", None),
+                        "guild": getattr(ctx, "guild", None),
+                        "author": getattr(ctx, "author", getattr(ctx, "user", None)),
+                    }
+                    wrapped = "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 in $dpyEval: {e}]"
+
+            case "message":
+                if not hasattr(parser.ctx, "content"):
+                    return ""
+                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) as e:
+                    return f"[Error in $message: {e}]"
+
+            case _:
+                return None
+
+    except StopExecution:
+        raise
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/functions/utility/time.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+import time as time_module
+from datetime import datetime, timezone
+
+_BOT_START_TIME = time_module.monotonic()
+
+
+async def handle_time(fn: str, args: list[str], raw: str, parser) -> str | None:
+    try:
+        match fn:
+            case "ping":
+                return str(round(parser.client.latency * 1000))
+
+            case "executiontime":
+                return str(round((time_module.monotonic() - parser._start_time) * 1000))
+
+            case "uptime":
+                elapsed = int(time_module.monotonic() - _BOT_START_TIME)
+                fmt = args[0].strip().lower() if args and args[0].strip() else "time"
+                if fmt == "timestamp":
+                    start_unix = int(datetime.now(timezone.utc).timestamp()) - elapsed
+                    return str(start_unix)
+                h = elapsed // 3600
+                m = (elapsed % 3600) // 60
+                s = elapsed % 60
+                return f"{h:02d}:{m:02d}:{s:02d}"
+
+            case "gettimestamp":
+                return str(int(datetime.now(timezone.utc).timestamp()))
+
+            case "time":
+                return datetime.now().strftime("%H:%M:%S")
+
+            case "date":
+                return datetime.now().strftime("%d/%m/%Y")
+
+            case _:
+                return None
+
+    except Exception as e:
+        return f"[Unexpected error in ${fn}: {e}]"

cordscript/parser.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+import time
+from datetime import datetime, timezone
+from .exceptions import StopExecution, CooldownError
+from .core import find_functions, split_args
+from .functions import (
+    handle_message, handle_interaction, handle_embed,
+    handle_components, handle_componentsv2, handle_logic,
+    handle_user, handle_database, handle_moderation, handle_status,
+    handle_math, handle_time, handle_random,
+    handle_http, handle_cooldown, handle_json, handle_strings,
+    _flush_select, _flush_row,
+)
+
+
+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_stack: list[list] = []
+        self._cv2_in_container: bool = False
+        self._split_cache: list[str] = []
+        self._ephemeral: bool = False
+        self._vars: dict[str, str] = {}
+        self._pending_select: dict | None = None
+        self._pending_row: list | None = None
+        self._stopped: bool = False
+        self._cooldown_msg: str | None = None
+
+    def _current_embed(self) -> EmbedBuilder:
+        return self._embeds[-1]
+
+    def _cv2_target(self) -> list:
+        return self._cv2_stack[-1] if self._cv2_stack else self._cv2_pending
+
+    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]]:
+        try:
+            result = await self._eval(code)
+        except StopExecution as e:
+            result = str(e)
+        except CooldownError as e:
+            self._cooldown_msg = str(e)
+            result = str(e)
+        _flush_select(self)
+        _flush_row(self)
+        embeds = [eb.to_dict() for eb in self._embeds if eb.has_data()]
+        result = result.strip("\n")
+        return result, embeds, self._extra_messages
+
+    async def _eval(self, code: str) -> str:
+        functions = find_functions(code)
+        if not functions:
+            return code
+        parts = []
+        offset = 0
+        for start, end, fn_name, raw_args in functions:
+            parts.append(code[offset:start])
+            if raw_args is not None:
+                if fn_name.lower() == "addcontainer":
+                    self._cv2_in_container = True
+                    self._cv2_stack.append([])
+                    evaluated_args_str = await self._eval_inner(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 "")
+            parts.append(replacement)
+            offset = end
+        parts.append(code[offset:])
+        return "".join(parts)
+
+    async def _eval_inner(self, code: str) -> str:
+        functions = find_functions(code)
+        if not functions:
+            return code
+        parts = []
+        offset = 0
+        for start, end, fn_name, raw_args in functions:
+            parts.append(code[offset:start])
+            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 "")
+            parts.append(replacement)
+            offset = end
+        parts.append(code[offset:])
+        return "".join(parts)
+
+    async def _resolve(self, fn: str, args: list[str], raw: str) -> str:
+        handlers = [
+            handle_message, handle_interaction, handle_embed,
+            handle_components, handle_componentsv2, handle_logic,
+            handle_user, handle_database, handle_moderation, handle_status,
+            handle_math, handle_time, handle_random,
+            handle_http, handle_cooldown, handle_json, handle_strings,
+        ]
+
+        for handler in handlers:
+            result = await handler(fn, args, raw, self)
+            if result is not None:
+                return result
+
+        for i in range(len(fn) - 1, 0, -1):
+            prefix = fn[:i]
+            suffix = fn[i:]
+            for handler in handlers:
+                result = await handler(prefix, [], "", self)
+                if result is not None:
+                    return result + suffix
+
+        if raw:
+            return f"${fn}[{raw}]"
+        return f"${fn}"

cordscript/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="cordscript",
+    version="1.0.0",
+    description="A Discord Bot library, with the mission of simplifying the use of the Discord API.",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="Arimoto",
+    author_email="",
+    url="https://github.com/[seu-usuario]/cordscript",
+    project_urls={
+        "Documentation": "https://github.com/[seu-usuario]/cordscript#readme",
+        "Bug Reports": "https://github.com/[seu-usuario]/cordscript/issues",
+        "Source Code": "https://github.com/[seu-usuario]/cordscript",
+    },
+    license="MIT",
+    python_requires=">=3.10",
+    packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]),
+    install_requires=[
+        "discord.py>=2.3.0",
+        "aiohttp>=3.8.0",
+        "tinydb>=4.7.0",
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Topic :: Communications :: Chat",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    keywords="discord bot easy",
+)

cordscript-1.0.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: cordscript
+Version: 1.0.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
+Requires-Dist: tinydb
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python

cordscript-1.0.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+cordscript/__init__.py,sha256=a4ZHPWsKv0Zcrh0blRGJN1YswCvSGoVg_XRpvcA-pNI,161
+cordscript/client.py,sha256=m_IObcMaEphuFzQ_rCibuvMtnx-QCL4Vj_wm41Zt7SE,21660
+cordscript/parser.py,sha256=MTVu6ewetq3OmNPnGpz10l_SnokjtQcKmzc50kS0rMs,7084
+cordscript/setup.py,sha256=2hegabR2_ZIFdXzC8ThabQjLHVUndTDmlbyCPn-1iw4,1463
+cordscript/core/__init__.py,sha256=6GBB7IiDkPZ85bhjuborlv1t6_hXKYvLkQrynNeJqeg,358
+cordscript/core/context.py,sha256=BFCO1-A1UX6DI1LE6ic6kfLF24j1vt5OJ5ylZVHJY6M,701
+cordscript/core/runtime.py,sha256=YbTLC2FkzRO1W5fbZ0EJ0HAf8I__dVlBoglSMbe78AU,1451
+cordscript/core/variables.py,sha256=sd6RbI9Lvt0JbJT7B0d3Bkhzx59S29C8zUKsUprwBZI,381
+cordscript/exceptions/__init__.py,sha256=mO4Z5NlFaDUAfbYnt-I-XvwIfpoXOnEYrjwDDX4UTpU,94
+cordscript/exceptions/errors.py,sha256=eKDm-v70Rslnyx3G9XScZwdxkA1IlVzIsxptT3OXwBQ,120
+cordscript/functions/__init__.py,sha256=F8fBbSieSpCpaqVpDbRN8iCqQTiGFlaRgEViuRUq2dk,875
+cordscript/functions/database/__init__.py,sha256=-00VOswf3b-pifUqa5y1IXzSwmTFxKjnlbdYtaLeCMA,175
+cordscript/functions/database/database.py,sha256=CT5zy9fw8-WbGl3lX0fnQaFnrVXGqGD2uvuQA0yni7s,38156
+cordscript/functions/database/store.py,sha256=NO1z-mSv7ZNr6BLGWfyLGyOq0ahHo2kOH0Rzuz9Ga5s,2361
+cordscript/functions/discord/__init__.py,sha256=dpMK4lgwz6upVuTwAfUqqo7CAADDwrG_znmxtDOzdak,550
+cordscript/functions/discord/components.py,sha256=WOsMZSE_PVmNU_MqnvB2FdPNEkBwX9GZ73R9OVq91Ec,5329
+cordscript/functions/discord/componentsv2.py,sha256=d_tIetSMAKcNWoNZdiJ_MrC3dV-jhxpBxcwj8Ni15e8,3637
+cordscript/functions/discord/embed.py,sha256=Hs_dDI3tlt_IzHpPYwT5iW6flvTyJcjjuPp1SUNvRv0,2170
+cordscript/functions/discord/interaction.py,sha256=-LDwTqVfEwPilhdaRu4QJ9RRtLVCxdaAYyrUHucOoc8,1448
+cordscript/functions/discord/logic.py,sha256=22G5rVItka0iueZyFYAAYLHEViEEL1lEsNnNn-d8Fgo,3279
+cordscript/functions/discord/message.py,sha256=J3xtBbtvmOYcS4adNsK_QvPJP7pZkc2d8WMxGx_a_6I,1873
+cordscript/functions/discord/moderation.py,sha256=rqDEhan3mLh857_zIF7suihEvqOsK1JMMjlSxgUljHg,7375
+cordscript/functions/discord/status.py,sha256=X7ymyjbHWs1Sq7c2dBt7phwxrGiW141qjYF2V9NaE5U,2091
+cordscript/functions/users/__init__.py,sha256=zKsYNHzNGo5tTI4ryEzm_YG_FraSk1WYTkxZ8oINtVI,57
+cordscript/functions/users/user.py,sha256=DRa9w9rifqNvlXkg8f3zstfHwzzhvTGnuWhOhJH_53M,3741
+cordscript/functions/utility/__init__.py,sha256=Edq7WcM3LYsumWNMJ-tMnoKCGtsOVchJtD9NvIWfb9k,396
+cordscript/functions/utility/cooldown.py,sha256=l5lY9WQ0QGw-0ZSlQLEOOWykBBGVYlOSpB1rSK8CGQk,1223
+cordscript/functions/utility/http.py,sha256=Nm-lua40q9bsrEQ3cX9b3gohDc_Ihdyt52yzAul6cCs,3430
+cordscript/functions/utility/json.py,sha256=qVZofu60GUCajjCRqrkVSDRBaYoPD2K-0eBCSyWpf0Y,8076
+cordscript/functions/utility/math.py,sha256=8IQwDtOMh7bUTQUXLUtU8RQ_OneLmdhDgsGRhEiHHyw,3475
+cordscript/functions/utility/random.py,sha256=wxeK6ymyN2-AMqvixJmBnTLk-05p1naEniy0zbxSw_k,936
+cordscript/functions/utility/strings.py,sha256=K5d3OM9bpVU4AVbngZdMqUaLMDfz4zv_EJaQZoz1veI,7664
+cordscript/functions/utility/time.py,sha256=u3r6n8hkGqc4ZdZJIqRwzqr_WEUbnzOOh1uhjmsG3ow,1389
+cordscript-1.0.0.dist-info/METADATA,sha256=3gwViBTel0H8vQpbVbGYBRsqj4IeQ9aD8uKa1DTR8xc,418
+cordscript-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+cordscript-1.0.0.dist-info/top_level.txt,sha256=OVTk5gwO8_wFSHGhXAEiEI6AwUhGf6xWGya5YcuemlM,11
+cordscript-1.0.0.dist-info/RECORD,,

cordscript-1.0.0.dist-info/WHEEL

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

cordscript-1.0.0.dist-info/top_level.txt

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