auto-editor 28.0.2__py3-none-any.whl → 29.0.0__py3-none-any.whl

auto_editor/json.py

@@ -1,297 +0,0 @@
-from __future__ import annotations
-
-from io import StringIO, TextIOWrapper
-from typing import TYPE_CHECKING
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.lib.err import MyError
-
-if TYPE_CHECKING:
-    from typing import Any, NoReturn
-
-    from _typeshed import SupportsWrite
-
-    Token = tuple[int, object]
-
-
-EOF, LCUR, RCUR, LBRAC, RBRAC, COL, COMMA, STR, VAL = range(9)
-str_escape = {
-    "\\": "\\",
-    "/": "/",
-    '"': '"',
-    "b": "\b",
-    "f": "\f",
-    "n": "\n",
-    "r": "\r",
-    "t": "\t",
-}
-
-
-def normalize_string(v: str) -> str:
-    for to, replace in str_escape.items():
-        if to == "/":
-            continue
-        v = v.replace(replace, f"\\{to}")
-    return v
-
-
-class Lexer:
-    __slots__ = ("filename", "text", "pos", "char", "lineno", "column")
-
-    def __init__(self, filename: str, text: str | bytes | TextIOWrapper):
-        self.filename = filename
-        self.pos: int = 0
-        self.lineno: int = 1
-        self.column: int = 1
-
-        if isinstance(text, bytes):
-            self.text: str = text.decode("utf-8", "replace")
-        elif isinstance(text, str):
-            self.text = text
-        else:
-            self.text = text.read()
-
-        self.char: str | None = self.text[self.pos] if text else None
-
-    def error(self, msg: str) -> NoReturn:
-        raise MyError(f"{msg}\n  at {self.filename}:{self.lineno}:{self.column}")
-
-    def advance(self) -> None:
-        if self.char == "\n":
-            self.lineno += 1
-            self.column = 0
-
-        self.pos += 1
-
-        if self.pos > len(self.text) - 1:
-            self.char = None
-        else:
-            self.char = self.text[self.pos]
-            self.column += 1
-
-    def rewind(self) -> None:
-        self.pos = 0
-        self.lineno = 1
-        self.column = 1
-        self.char = self.text[self.pos] if self.text else None
-
-    def peek(self) -> str | None:
-        peek_pos = self.pos + 1
-        return None if peek_pos > len(self.text) - 1 else self.text[peek_pos]
-
-    def string(self) -> str:
-        result = StringIO()
-        while self.char is not None and self.char != '"':
-            if self.char == "\\":
-                self.advance()
-                if self.char is None:
-                    break
-
-                if self.char == "u":
-                    buf = ""
-                    for _ in range(4):
-                        self.advance()
-                        if self.char is None:
-                            self.error("\\u escape sequence needs 4 hexs")
-                        buf += self.char
-                    try:
-                        result.write(chr(int(buf, 16)))
-                    except ValueError:
-                        self.error(f"Invalid \\u escape sequence: `{buf}`")
-                if self.char in str_escape:
-                    result.write(str_escape[self.char])
-                    self.advance()
-                    continue
-
-                self.error(f"Unknown escape sequence `\\{self.char}` in string")
-            else:
-                result.write(self.char)
-            self.advance()
-
-        if self.char is None:
-            self.error('Expected a closing `"`')
-
-        self.advance()
-        return result.getvalue()
-
-    def number(self) -> Token:
-        buf = StringIO()
-
-        has_dot = False
-        while self.char is not None and self.char in "-0123456789.":
-            if self.char == ".":
-                if has_dot:
-                    self.error("Number has multiple `.`s")
-                has_dot = True
-            buf.write(self.char)
-            self.advance()
-
-        result = buf.getvalue()
-
-        try:
-            return (VAL, float(result) if has_dot else int(result))
-        except ValueError:
-            self.error(f"`{result}` is not a valid JSON Number")
-
-    def is_whitespace(self) -> bool:
-        return self.char is None or self.char in " \t\n\r\x0b\x0c"
-
-    def get_next_token(self) -> Token:
-        while self.char is not None:
-            while self.char is not None and self.is_whitespace():
-                self.advance()
-            if self.char is None:
-                break
-
-            if self.char == '"':
-                self.advance()
-                return (STR, self.string())
-
-            if self.char == "-":
-                _peek = self.peek()
-                if _peek is not None and _peek in "0123456789.":
-                    return self.number()
-
-            if self.char in "0123456789.":
-                return self.number()
-
-            table = {"{": LCUR, "}": RCUR, "[": LBRAC, "]": RBRAC, ":": COL, ",": COMMA}
-            if self.char in table:
-                key = table[self.char]
-                self.advance()
-                return (key, None)
-
-            keyword = ""
-            for _ in range(5):  # Longest valid keyword length
-                if self.char is None or self.char in " \t\n\r\x0b\x0c[]}{,":
-                    break
-                keyword += self.char
-                self.advance()
-
-            if keyword == "true":
-                return (VAL, True)
-            if keyword == "false":
-                return (VAL, False)
-            if keyword == "null":
-                return (VAL, None)
-
-            self.error(f"Invalid keyword: `{keyword}`")
-        return (EOF, None)
-
-
-class Parser:
-    __slots__ = ("lexer", "current_token")
-
-    def __init__(self, lexer: Lexer):
-        self.lexer = lexer
-        self.current_token = self.lexer.get_next_token()
-
-    def eat(self) -> None:
-        self.current_token = self.lexer.get_next_token()
-
-    def expr(self) -> Any:
-        self.current_token
-
-        if self.current_token[0] in {STR, VAL}:
-            val = self.current_token[1]
-            self.eat()
-            return val
-
-        if self.current_token[0] == LCUR:
-            self.eat()
-
-            my_dic = {}
-            while self.current_token[0] != RCUR:
-                if self.current_token[0] != STR:
-                    if self.current_token[0] in {LBRAC, VAL}:
-                        self.lexer.error("JSON Objects only allow strings as keys")
-                    self.lexer.error("Expected closing `}`")
-                key = self.current_token[1]
-                if key in my_dic:
-                    self.lexer.error(f"Object has repeated key `{key}`")
-                self.eat()
-                if self.current_token[0] != COL:
-                    self.lexer.error("Expected `:`")
-                self.eat()
-
-                my_dic[key] = self.expr()
-                if self.current_token[0] != RCUR:
-                    if self.current_token[0] != COMMA:
-                        self.lexer.error("Expected `,` between Object entries")
-                    self.eat()
-                    if self.current_token[0] == RCUR:
-                        self.lexer.error("Trailing `,` in Object")
-
-            self.eat()
-            return my_dic
-
-        if self.current_token[0] == LBRAC:
-            self.eat()
-            my_arr = []
-            while self.current_token[0] != RBRAC:
-                my_arr.append(self.expr())
-                if self.current_token[0] != RBRAC:
-                    if self.current_token[0] != COMMA:
-                        self.lexer.error("Expected `,` between array entries")
-                    self.eat()
-                    if self.current_token[0] == RBRAC:
-                        self.lexer.error("Trailing `,` in array")
-            self.eat()
-            return my_arr
-
-        raise MyError(f"Unknown token: {self.current_token}")
-
-
-def load(path: str, f: str | bytes | TextIOWrapper) -> dict[str, object]:
-    lexer = Lexer(path, f)
-    if lexer.get_next_token()[0] != LCUR:
-        raise MyError("Expected JSON Object")
-    lexer.rewind()
-    return Parser(lexer).expr()
-
-
-def dump(
-    data: object, file: SupportsWrite[str], indent: int | None = None, level: int = 0
-) -> None:
-    if data is True:
-        file.write("true")
-    elif data is False:
-        file.write("false")
-    elif data is None:
-        file.write("null")
-    elif isinstance(data, str):
-        file.write(f'"{normalize_string(data)}"')
-    elif isinstance(data, FileInfo):
-        file.write(f'"{normalize_string(f"{data.path}")}"')
-    elif isinstance(data, int | float):
-        file.write(f"{data}")
-    elif isinstance(data, list | tuple):
-        file.write("[")
-        if indent is not None:
-            level += indent
-            file.write("\n" + (" " * level))
-
-        for item in data[:-1]:
-            dump(item, file, indent, level)
-            file.write(", " if indent is None else f",\n{' ' * level}")
-        if data:
-            dump(data[-1], file, indent, level)
-        file.write("]" if indent is None else f"\n{' ' * (level - indent)}]")
-    else:
-        my_dic = data if isinstance(data, dict) else data.__dict__
-        file.write("{")
-        if indent is not None:
-            level += indent
-            file.write("\n" + (" " * level))
-        not_first = False
-        for key, item in my_dic.items():
-            if not_first:
-                file.write(", " if indent is None else f",\n{' ' * level}")
-            dump(key, file, indent, level)
-            file.write(": ")
-            dump(item, file, indent, level)
-            not_first = True
-
-        if indent is not None:
-            file.write(f"\n{' ' * (level - indent)}")
-        file.write("}")

auto_editor/lang/libintrospection.py

@@ -1,10 +0,0 @@
-from .palet import Syntax
-
-
-def all() -> dict[str, object]:
-    return {
-        "get-current-env": Syntax(lambda env, node: env.data.copy()),
-        "proc-name": Syntax(
-            lambda env, node: [proc := node[1].val, env[proc].name][-1]
-        ),
-    }

auto_editor/lang/libmath.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import math
-
-from auto_editor.lib.contracts import Proc, andc, between_c, gt_c, is_real
-
-
-def all() -> dict[str, object]:
-    return {
-        "exp": Proc("exp", math.exp, (1, 1), is_real),
-        "ceil": Proc("ceil", math.ceil, (1, 1), is_real),
-        "floor": Proc("floor", math.floor, (1, 1), is_real),
-        "sin": Proc("sin", math.sin, (1, 1), is_real),
-        "cos": Proc("cos", math.cos, (1, 1), is_real),
-        "tan": Proc("tan", math.tan, (1, 1), is_real),
-        "asin": Proc("asin", math.asin, (1, 1), between_c(-1, 1)),
-        "acos": Proc("acos", math.acos, (1, 1), between_c(-1, 1)),
-        "atan": Proc("atan", math.atan, (1, 1), is_real),
-        "log": Proc("log", math.log, (1, 2), andc(is_real, gt_c(0))),
-        "pi": math.pi,
-        "e": math.e,
-        "tau": math.tau,
-    }