auto-editor 28.1.0__py3-none-any.whl → 29.0.1__py3-none-any.whl

auto_editor/lib/contracts.py

@@ -1,235 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from fractions import Fraction
-from typing import TYPE_CHECKING
-
-from numpy import float64
-
-from .data_structs import Sym, print_str
-from .err import MyError
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from typing import Any
-
-
-@dataclass(slots=True)
-class Contract:
-    # Convenient flat contract class
-    name: str
-    c: Callable[[object], bool]
-
-    def __call__(self, *v: object) -> bool:
-        if len(v) != 1:
-            o = self.name
-            raise MyError(f"`{o}` has an arity mismatch. Expected 1, got {len(v)}")
-        return self.c(v[0])
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        return f"#<proc:{self.name} (1 1)>"
-
-
-def check_contract(c: object, val: object) -> bool:
-    if type(c) is Contract:
-        return c(val)
-    if (
-        isinstance(c, Proc)
-        and c.arity[0] < 2
-        and (c.arity[1] is None or c.arity[1] > 0)
-    ):
-        return c(val)
-    if c is True:
-        return val is True
-    if c is False:
-        return val is False
-    if type(c) in (int, float, float64, Fraction, str, Sym):
-        return val == c
-    raise MyError(f"Invalid contract, got: {print_str(c)}")
-
-
-def check_args(
-    name: str,
-    values: list | tuple,
-    arity: tuple[int, int | None],
-    cont: tuple[Any, ...],
-) -> None:
-    lower, upper = arity
-    amount = len(values)
-
-    assert not (upper is not None and lower > upper)
-    base = f"`{name}` has an arity mismatch. Expected "
-
-    if lower == upper and len(values) != lower:
-        raise MyError(f"{base}{lower}, got {amount}")
-    if upper is None and amount < lower:
-        raise MyError(f"{base}at least {lower}, got {amount}")
-    if upper is not None and (amount > upper or amount < lower):
-        raise MyError(f"{base}between {lower} and {upper}, got {amount}")
-
-    if not cont:
-        return
-
-    for i, val in enumerate(values):
-        check = cont[-1] if i >= len(cont) else cont[i]
-        if not check_contract(check, val):
-            exp = f"{check}" if callable(check) else print_str(check)
-            raise MyError(f"`{name}` expected {exp}, but got {print_str(val)}")
-
-
-class Proc:
-    __slots__ = ("name", "proc", "arity", "contracts", "kw_contracts")
-
-    def __init__(
-        self, n: str, p: Callable, a: tuple[int, int | None] = (1, None), *c: Any
-    ):
-        self.name = n
-        self.proc = p
-        self.arity = a
-
-        if c and type(c[-1]) is dict:
-            self.kw_contracts: dict[str, int] | None = c[-1]
-            self.contracts: tuple[Any, ...] = c[:-1]
-        else:
-            self.kw_contracts = None
-            self.contracts = c
-
-    def __call__(self, *args: Any, **kwargs: Any) -> Any:
-        lower, upper = self.arity
-        amount = len(args)
-        cont = self.contracts
-        kws = self.kw_contracts
-
-        assert not (upper is not None and lower > upper)
-        base = f"`{self.name}` has an arity mismatch. Expected "
-
-        if lower == upper and len(args) != lower:
-            raise MyError(f"{base}{lower}, got {amount}")
-        if upper is None and amount < lower:
-            raise MyError(f"{base}at least {lower}, got {amount}")
-        if upper is not None and (amount > upper or amount < lower):
-            raise MyError(f"{base}between {lower} and {upper}, got {amount}")
-
-        if not cont:
-            return self.proc(*args)
-
-        if kws is not None:
-            for key, val in kwargs.items():
-                if key not in kws:
-                    raise MyError(
-                        f"{self.name} got an unexpected keyword argument: {key}"
-                    )
-                check = cont[-1] if kws[key] >= len(cont) else cont[kws[key]]
-                if not check_contract(check, val):
-                    exp = f"{check}" if callable(check) else print_str(check)
-                    raise MyError(
-                        f"`{self.name} #:{key}` expected {exp}, but got {print_str(val)}"
-                    )
-
-        elif len(kwargs) > 0:
-            raise MyError("Keyword arguments are not allowed here")
-
-        for i, val in enumerate(args):
-            check = cont[-1] if i >= len(cont) else cont[i]
-            if not check_contract(check, val):
-                exp = f"{check}" if callable(check) else print_str(check)
-                raise MyError(f"`{self.name}` expected {exp}, but got {print_str(val)}")
-
-        return self.proc(*args, **kwargs)
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        n = "inf" if self.arity[1] is None else f"{self.arity[1]}"
-
-        if self.contracts is None:
-            c = ""
-        else:
-            c = " (" + " ".join([f"{c}" for c in self.contracts]) + ")"
-        return f"#<proc:{self.name} ({self.arity[0]} {n}){c}>"
-
-
-def is_contract(c: object) -> bool:
-    if type(c) is Contract:
-        return True
-    if (
-        isinstance(c, Proc)
-        and c.arity[0] < 2
-        and (c.arity[1] is None or c.arity[1] > 0)
-    ):
-        return True
-    if c is True or c is False:
-        return True
-    return type(c) in (int, float, Fraction, str, Sym)
-
-
-is_bool = Contract("bool?", lambda v: type(v) is bool)
-is_int = Contract("int?", lambda v: type(v) is int)
-is_nat = Contract("nat?", lambda v: type(v) is int and v > -1)
-is_nat1 = Contract("nat1?", lambda v: type(v) is int and v > 0)
-int_not_zero = Contract("(or/c (not/c 0) int?)", lambda v: v != 0 and is_int(v))
-is_real = Contract("real?", lambda v: type(v) in (int, float, float64, Fraction))
-is_num = is_real
-is_float = Contract("float?", lambda v: type(v) in (float, float64))
-is_frac = Contract("frac?", lambda v: type(v) is Fraction)
-is_str = Contract("string?", lambda v: type(v) is str)
-any_p = Contract("any", lambda v: True)
-is_void = Contract("void?", lambda v: v is None)
-is_int_or_float = Contract(
-    "(or/c int? float?)", lambda v: type(v) in (int, float, float64)
-)
-is_threshold = Contract(
-    "threshold?",
-    lambda v: type(v) in (int, float, float64) and v >= 0 and v <= 1,  # type: ignore
-)
-is_proc = Contract("procedure?", lambda v: isinstance(v, Proc | Contract))
-
-
-def contract_printer(cs) -> str:
-    return " ".join(
-        c.name if isinstance(c, Proc | Contract) else print_str(c) for c in cs
-    )
-
-
-def andc(*cs: object) -> Proc:
-    name = f"(and/c {contract_printer(cs)})"
-    return Proc(name, lambda v: all(check_contract(c, v) for c in cs), (1, 1), any_p)
-
-
-def orc(*cs: object) -> Proc:
-    name = f"(or/c {contract_printer(cs)})"
-    return Proc(name, lambda v: any(check_contract(c, v) for c in cs), (1, 1), any_p)
-
-
-def notc(c: object) -> Proc:
-    return Proc("flat-not/c", lambda v: not check_contract(c, v), (1, 1), any_p)
-
-
-def gte_c(n: int | float | Fraction) -> Proc:
-    return Proc(f"(>=/c {n})", lambda i: i >= n, (1, 1), is_real)
-
-
-def gt_c(n: int | float | Fraction) -> Proc:
-    return Proc(f"(>/c {n})", lambda i: i > n, (1, 1), is_real)
-
-
-def lte_c(n: int | float | Fraction) -> Proc:
-    return Proc(f"(<=/c {n})", lambda i: i <= n, (1, 1), is_real)
-
-
-def lt_c(n: int | float | Fraction) -> Proc:
-    return Proc(f"(</c {n})", lambda i: i < n, (1, 1), is_real)
-
-
-def between_c(n: Any, m: Any) -> Proc:
-    if m > n:
-        return Proc(
-            f"(between/c {n} {m})", lambda i: is_real(i) and i <= m and i >= n, (1, 1)
-        )
-    return Proc(
-        f"(between/c {n} {m})", lambda i: is_real(i) and i <= n and i >= m, (1, 1)
-    )

auto_editor/lib/data_structs.py

@@ -1,278 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-from dataclasses import dataclass
-from fractions import Fraction
-from io import StringIO
-from typing import Any
-
-import numpy as np
-
-
-class NotFound:
-    pass
-
-
-class Env:
-    __slots__ = ("data", "outer")
-
-    def __init__(self, data: dict[str, Any], outer: Env | None = None) -> None:
-        self.data = data
-        self.outer = outer
-
-    def __getitem__(self, key: str) -> Any:
-        if key in self.data:
-            return self.data[key]
-        if self.outer is not None:
-            return self.outer[key]
-
-    def __setitem__(self, key: str, val: Any) -> None:
-        self.data[key] = val
-
-    def __delitem__(self, key: str) -> None:
-        if key in self.data:
-            del self.data[key]
-        elif self.outer is not None:
-            del self.outer[key]
-
-    def __contains__(self, key: str) -> bool:
-        if key in self.data:
-            return True
-        if self.outer is not None:
-            return key in self.outer
-        return False
-
-    def update(self, my_dict: dict[str, Any]) -> None:
-        self.data.update(my_dict)
-
-    def get(self, key: str) -> Any:
-        if key in self.data:
-            return self.data[key]
-        if self.outer is not None:
-            return self.outer.get(key)
-        return NotFound()
-
-
-class Sym:
-    __slots__ = ("val", "hash", "lineno", "column")
-
-    def __init__(self, val: str, lineno: int = -1, column: int = -1):
-        assert isinstance(val, str)
-        self.val = val
-        self.hash = hash(val)
-        self.lineno = lineno
-        self.column = column
-
-    def __str__(self) -> str:
-        return self.val
-
-    __repr__ = __str__
-
-    def __hash__(self) -> int:
-        return self.hash
-
-    def __eq__(self, obj: object) -> bool:
-        return type(obj) is Sym and self.hash == obj.hash
-
-
-class Keyword:
-    __slots__ = "val"
-
-    def __init__(self, val: str):
-        self.val = val
-
-    def __str__(self) -> str:
-        return f"#:{self.val}"
-
-    __repr__ = __str__
-
-    def __eq__(self, obj: object) -> bool:
-        return type(obj) is Keyword and self.val == obj.val
-
-
-class QuotedKeyword:
-    __slots__ = "val"
-
-    def __init__(self, val: Keyword | str):
-        self.val = val if isinstance(val, Keyword) else Keyword(val)
-
-    def __str__(self) -> str:
-        return f"{self.val}"
-
-    __repr__ = __str__
-
-    def __eq__(self, obj: object) -> bool:
-        return type(obj) is QuotedKeyword and self.val == obj.val
-
-
-class Quoted:
-    __slots__ = "val"
-
-    def __init__(self, val: tuple):
-        self.val = val
-
-    def __len__(self) -> int:
-        return len(self.val)
-
-    def __getitem__(self, key: int | slice) -> Any:
-        if isinstance(key, slice) or type(self.val[key]) is tuple:
-            return Quoted(self.val[key])
-
-        return self.val[key]
-
-    def __iter__(self) -> Iterator:
-        return self.val.__iter__()
-
-    def __contains__(self, item: object) -> bool:
-        return item in self.val
-
-    def __eq__(self, obj: object) -> bool:
-        return type(obj) is Quoted and self.val == obj.val
-
-
-class Char:
-    __slots__ = "val"
-
-    def __init__(self, val: str | int):
-        if type(val) is int:
-            self.val: str = chr(val)
-        else:
-            assert type(val) is str and len(val) == 1
-            self.val = val
-
-    def __str__(self) -> str:
-        return self.val
-
-    def __repr__(self) -> str:
-        names = {" ": "space", "\n": "newline", "\t": "tab"}
-        return f"#\\{self.val}" if self.val not in names else f"#\\{names[self.val]}"
-
-    def __eq__(self, obj: object) -> bool:
-        return type(obj) is Char and self.val == obj.val
-
-    def __radd__(self, obj2: str) -> str:
-        return obj2 + self.val
-
-
-def display_dtype(dtype: np.dtype) -> str:
-    if dtype.kind == "b":
-        return "bool"
-
-    if dtype.kind == "i":
-        return f"int{dtype.itemsize * 8}"
-
-    if dtype.kind == "u":
-        return f"uint{dtype.itemsize * 8}"
-
-    return f"float{dtype.itemsize * 8}"
-
-
-def display_str(val: object) -> str:
-    if val is None:
-        return "#<void>"
-    if val is True:
-        return "#t"
-    if val is False:
-        return "#f"
-    if type(val) is Sym:
-        return val.val
-    if type(val) is str:
-        return val
-    if type(val) is Char:
-        return f"{val}"
-    if type(val) is range:
-        return "#<range>"
-    if type(val) is np.bool_:
-        return "1" if val else "0"
-    if type(val) is np.float64 or type(val) is np.float32:
-        return f"{float(val)}"
-    if type(val) is Fraction:
-        return f"{val.numerator}/{val.denominator}"
-    if type(val) is Quoted or type(val) is tuple:
-        if not val:
-            return "()"
-        result = StringIO()
-        result.write(f"({display_str(val[0])}")
-        for item in val[1:]:
-            result.write(f" {display_str(item)}")
-        result.write(")")
-        return result.getvalue()
-    if type(val) is list:
-        if not val:
-            return "#()"
-        result = StringIO()
-        result.write(f"#({print_str(val[0])}")
-        for item in val[1:]:
-            result.write(f" {print_str(item)}")
-        result.write(")")
-        return result.getvalue()
-    if isinstance(val, dict):
-        result = StringIO()
-        result.write("#hash(")
-        is_first = True
-        for k, v in val.items():
-            if is_first:
-                result.write(f"[{print_str(k)} {print_str(v)}]")
-                is_first = False
-            else:
-                result.write(f" [{print_str(k)} {print_str(v)}]")
-        result.write(")")
-        return result.getvalue()
-    if isinstance(val, np.ndarray):
-        result = StringIO()
-        result.write(f"(array '{display_dtype(val.dtype)}")
-        if val.dtype.kind == "b":
-            for item in val:
-                result.write(" 1" if item else " 0")
-        else:
-            for item in val:
-                result.write(f" {item}")
-        result.write(")")
-        return result.getvalue()
-
-    return f"{val!r}"
-
-
-str_escape = {
-    "\\": "\\\\",
-    '"': '\\"',
-    "\r": "\\r",
-    "\f": "\\f",
-    "\v": "\\v",
-    "\n": "\\n",
-    "\t": "\\t",
-    "\b": "\\b",
-    "\a": "\\a",
-}
-
-
-def print_str(val: object) -> str:
-    if type(val) is str:
-        for k, v in str_escape.items():
-            val = val.replace(k, v)
-        return f'"{val}"'
-    if type(val) is Char:
-        return f"{val!r}"
-    if type(val) is Keyword:
-        return f"'{val}"
-    if type(val) in (Sym, Quoted, QuotedKeyword):
-        return f"'{display_str(val)}"
-
-    return display_str(val)
-
-
-@dataclass(slots=True)
-class PaletClass:
-    name: str
-    attrs: tuple
-    values: list
-
-    def __str__(self) -> str:
-        result = StringIO()
-        result.write(f"({self.name}")
-        for i, val in enumerate(self.values):
-            result.write(f" #:{self.attrs[i * 2]} {print_str(val)}")
-        result.write(")")
-        return result.getvalue()
-
-    __repr__ = __str__

auto_editor/lib/err.py

@@ -1,2 +0,0 @@
-class MyError(Exception):
-    pass