reorganize core submodules; start in on terminal abstraction layer

.gitignore

···
 build
 *.ipynb
 *.ipynb.py
+.TODO
 

pyt/core/__init__.py

···
     manually nesting loops and try-catch blocks.
 """
 
-from .core import AttrDict, Errs, errs, lsnap
-
-from .logger import Logger
-
-from .sketch import try_dump_locals
-
-from .commands import builtin_commands, command_registrar
+from .general import *
 
 from .session import PytSession
 

pyt/core/commands.py

···
-
-import shlex
-
-from argparse import ArgumentParser, ArgumentError
-
-from pyt.core import lsnap
-from pyt.lib.ansi import codes as ac
-
-builtin_commands = []
-
-def command_registrar(command_group):
-    def register_command(*aliases, arg_parser=None):
-        aliases = list(aliases)
-        if any(" " in alias for alias in aliases):
-            raise RuntimeError("spaces are not permitted in command aliases!")
-        def _register_command(behavior):
-            _behavior = behavior
-            if isinstance(arg_parser, ArgumentParser):
-                arg_parser.exit_on_error = False
-                def _behavior(session, args):
-                    try:
-                        _args = arg_parser.parse_args(shlex.split(args))
-                    except ArgumentError:
-                        session.log(arg_parser.format_usage(), mode="info", indent=4)
-                        raise
-                    return behavior(session, _args)
-            command_group.append((aliases, _behavior))
-            return behavior
-        return _register_command
-    return register_command
-
-_builtin = command_registrar(builtin_commands)
-
-test_parser = ArgumentParser("test")
-test_parser.add_argument("--foo", dest="bar", type=str, default="baz")
-
-@_builtin("test", arg_parser=test_parser)
-def cmd_test(session, args):
-    print(args.bar)
-
-new_parser = ArgumentParser("new")
-new_parser.add_argument("name", type=str, help="Name of the new sketch")
-new_parser.add_argument("--template", "-t", type=str, default=None,
-                        help="Template to use (verbose, basic, or path to file)")
-
-@_builtin("new", arg_parser=new_parser)
-def cmd_new(session, args):
-    import shutil
-    from pathlib import Path
-
-    log = session.log
-
-    template = args.template or session.env.get("TEMPLATE") or "verbose"
-
-    if template in ["verbose", "basic"]:
-        from importlib import import_module
-        template_module = import_module(f"pyt.core.templates.{template}")
-        template = Path(template_module.__file__)
-    elif isinstance(template, Path):
-        if not template.exists():
-            log(f"template file not found: {template}", mode="error")
-            return
-    elif isinstance(template, str):
-        try:
-            template = Path(template)
-        except:
-            log("template could not be interpreted as a path", mode="error")
-            return
-        if not template.exists():
-            log(f"template file not found: {template}", mode="error")
-            return
-    else:
-        log("template could not be interpreted as a path", mode="error")
-        return
-
-    sketch_dir = session.env.SKETCH
-    new_sketch = sketch_dir / f"{args.name}.py"
-
-    if new_sketch.exists():
-        log(f"sketch {args.name} already exists", mode="error")
-        return
-
-    shutil.copy(template, new_sketch)
-    sketch_link = ac.file_link(new_sketch)
-    template_link = ac.file_link(template)
-
-    log(f"created {sketch_link} from template {template_link}", mode="ok")
-
-@_builtin("flush")
-def cmd_flush(session, args):
-    import gc
-    import sys
-    session.persistent_state = {}
-    session.persistent_hashes = {}
-    gc.collect()
-    if "torch" in sys.modules:
-        torch = sys.modules["torch"]
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-    session.log("state flushed")
-
-@_builtin("exit", "quit", ":q", ",q")
-def cmd_exit(session, args):
-    session.log.blank().log("goodbye <3").blank()
-    session.repl_continue = False
-
-@_builtin("hello", "hi")
-def cmd_hi(session, args):
-    session.log("hiii :3")
-
-@_builtin("reload", "refresh", "rr")
-def cmd_reload(session, args):
-    import sys
-    from importlib import reload
-
-    log = session.log
-
-    session_reload = False
-
-    # TODO find a robust way to track which files have actually changed
-    for name, module in list(sys.modules.items()):
-        if name.startswith("pyt"):
-            try:
-                reload(module)
-                log(f"reloaded {name}")
-                if name == "pyt.core.session":
-                    session_reload = True
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except:
-                log.indented().trace()
-                log(f"failed to reload {name}", mode="error")
-
-    if session_reload:
-        new_session_module = sys.modules["pyt.core.session"]
-        session.update_class(new_session_module.PytSession)
-
-
-@_builtin("rrun")
-def cmd_reload_run(session, args):
-    if session.try_handle_command("reload", ""):
-        session.handle_message(f"run {args}")
-
-@_builtin("crash")
-def cmd_crash(session, args):
-    raise Exception("crashing on purpose >:3")
-
-@_builtin("bash", ";")
-def cmd_bash(session, args):
-    import os
-    import subprocess
-
-    log = session.log
-
-    if args == "":
-        log("switching to bash!", mode="info")
-        subprocess.run(["bash"])
-        log("wb bestie!")
-        return
-
-    args = session.favorite_dirs.get(args, args)
-
-    path = os.path.expandvars(os.path.expanduser(args))
-
-    if not os.path.isdir(path):
-        log(f"{args} is not a directory but that's ok", mode="warning")
-        log(f"switching to bash. home directory", mode="info")
-        subprocess.run(["bash"])
-        log("welcome back")
-    else:
-        log(f"switching to bash, working directory {path}", mode="info")
-        subprocess.run(["bash"], cwd=path)
-        log("back in the pyt :D")
-
-@_builtin("faves", "ff")
-def cmd_faves(session, args):
-    from pyt.lib.ansi import codes as ac
-    links = ["Favorite Directories:"]
-    dirs = session.favorite_dirs
-    for key in dirs.keys():
-        cyan = ac.ansi(ac.fg('cyan'))
-        links.append("    " + ac.file_link(dirs[key], text=f"{cyan}{key}{ac.reset} -> {dirs[key]}"))
-    session.log("\n".join(links))
-
-def _python_subprocess(session):
-    import subprocess
-
-    from pyt.lib.ansi import codes as ac
-
-    log = session.log
-
-    log("switching to python!", mode="info")
-
-    if session.env.PYTHON_PATH != None:
-        try:
-            subprocess.run([session.env.PYTHON_PATH, "-q"])
-        except FileNotFoundError:
-            link = ac.link(f"file://{session.env.PYTHON_PATH}", "preferred python")
-            log(f"your {link} didn't load. trying system python :/", mode="warning")
-            subprocess.run(["python", "-q"])
-    else:
-        subprocess.run(["python", "-q"])
-
-    log("wb bestie!")
-
-
-
-def _python_stateful(session):
-    log = session.log
-    log("entering python mode. persistent state is available", mode="info")
-
-    state = dict(session.persistent_state)
-    state["session"] = session
-    state["print"] = log.tag("python")
-    state["_print"] = print
-
-    from pyt.core.pywrapl import repl
-
-    # TODO on_version_mismatch from pytrc
-    repl(local=state, log=log, on_version_mismatch="warning")
-
-    log("back to snakepyt :)")
-
-@_builtin("python", "py", "'")
-def cmd_python(session, args):
-    if args == "fresh":
-        _python_subprocess(session)
-    else:
-        if args != "":
-            session.log("i dunno what u expect me to do w/ that argument lol", mode="info")
-        _python_stateful(session)
-
-@_builtin("run")
-def cmd_run(session, args):
-    import os
-    import sys
-    import inspect
-    import time
-    import shutil
-    from pathlib import Path
-    from time import perf_counter
-    from importlib import import_module
-
-    from pyt.core.run import run, handle_persistent
-
-    sketch_name, remainder = lsnap(args)
-
-    log = session.log
-
-    try:
-        log(f"loading sketch \"{sketch_name}\"", mode="info")
-        module_name = f"{sketch_name}"
-        if module_name in sys.modules:
-            del sys.modules[module_name]
-        sys.path.insert(0, str(session.env.SKETCH))
-        sketch = import_module(module_name)
-        sys.path.pop(0)
-    except ModuleNotFoundError:
-        log.indented().trace()
-        log("no such sketch", mode="error", indent=4).blank()
-        return
-    except KeyboardInterrupt:
-        log("aborted", mode="info").blank()
-        return
-    except SystemExit:
-        raise
-    except:
-        log.indented().trace()
-        return
-
-    sources = { name : inspect.getsource(member)
-                for name, member in inspect.getmembers(sketch)
-                if inspect.isfunction(member) and member.__module__ == module_name
-               }
-
-    log = log.tag(sketch_name).mode("info")
-
-    t0 = perf_counter()
-    if hasattr(sketch, "persistent"):
-        if not handle_persistent(session, sketch_name, sketch.persistent, sketch.__dict__, log, sources):
-            log.blank()
-            return
-
-    sketch.__dict__.update(session.persistent_state)
-
-    pyt_out = session.env.OUT
-
-    if not pyt_out:
-        session.log("no output directory has been specified.\nset via --out flag, or session.env.OUT in your ~/.config/pytrc.py, or by setting the PYT_OUT environment variable", mode="error")
-        session.log("aborting.", mode="error")
-        return
-
-    daily = time.strftime("%d.%m.%Y")
-    moment = time.strftime("t%H.%M.%S")
-
-    run_dir = Path(os.path.join(pyt_out, sketch_name, daily, moment))
-    sketch.__dict__["run_dir"] = run_dir
-    run_dir.mkdir(parents=True, exist_ok=True)
-
-    shutil.copy(sketch.__file__, run_dir / f"{sketch_name}.py")
-
-    with open(run_dir / f".snakepyt", "w") as metadata:
-        metadata.write(f"snakepyt version {session.snakepyt_version[0]}.{session.snakepyt_version[1]}\n")
-
-    if hasattr(sketch, "main"):
-        if hasattr(sketch, "final"):
-            finalizer = sketch.final.__code__
-        else:
-            finalizer = None
-        try:
-            failures, runs = run(session, sketch.main, None, (), sketch.__dict__, log, sources, finalizer)
-        except KeyboardInterrupt:
-            log.blank().log("aborted", mode="info").blank()
-            return
-    else:
-        log("sketch has no main function", mode="error", indent=4)
-
-    if failures == 0:
-        log(f"finished {runs} run(s) in {perf_counter() - t0:.3f}s", mode="ok")
-    elif failures < runs:
-        log(f"finished {runs-failures} of {runs} run(s) in {perf_counter() - t0:.3f}s", mode="info")
-        log(f"{failures} run(s) failed to finish", mode="error")
-    else:
-        log(f"all {failures} run(s) failed to finish", mode="error")
-

pyt/core/commands/__init__.py

···
+
+from .commands import registrar_attr, register_builtins as core_builtins
+
+from .sketch import register_builtins as sketch_builtins
+
+from ._test import register_builtins as _test_builtins
+
+def register_builtins(group):
+    core_builtins(group)
+    sketch_builtins(group)
+    _test_builtins(group)
+

pyt/core/commands/_test.py

···
+
+from argparse import ArgumentParser
+
+from pyt.core.commands.commands import registrar_attr
+
+_builtins = []
+_builtin = registrar_attr(_builtins)
+
+def register_builtins(group):
+    group += _builtins
+
+@_builtin("kitty")
+def cmd_kitty(session, args):
+    import sys, os, termios, tty, select
+
+    timeout = 0.1
+
+    if not sys.stdin.isatty():
+        return False
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        os.write(sys.stdout.fileno(), b"\x1b[?u") # ask for kitty flags
+
+        if not select.select([fd], [], [], timeout)[0]:
+            return False
+
+        resp = os.read(fd, 16)
+        print(resp.startswith(b"\x1b[?") and resp.endswith(b"u"))
+        return
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    print(False)
+
+test_parser = ArgumentParser("test")
+test_parser.add_argument("--foo", dest="bar", type=str, default="baz")
+
+@_builtin("test", arg_parser=test_parser)
+def cmd_test(session, args):
+    session.log(args.bar)
+
+@_builtin("crash")
+def cmd_crash(session, args):
+    raise Exception("crashing on purpose >:3")
+

pyt/core/commands/commands.py

···
+
+import shlex
+
+from argparse import ArgumentParser, ArgumentError
+
+from pyt.core import lsnap
+from pyt.core.terminal.ansi import codes as ac
+
+def _apply_parser(behavior, parser):
+    parser.exit_on_error = False
+    def _behavior(session, args):
+        try:
+            _args = parser.parse_args(shlex.split(args))
+            behavior(session, _args)
+        except ArgumentError:
+            session.log(parser.format_usage(), mode="info", indent=4)
+            raise
+    return _behavior
+
+def register(group, behavior, *aliases, arg_parser=None):
+    if any(" " in alias for alias in aliases):
+        raise RuntimeError("spaces are not permitted in command aliases!")
+
+    if isinstance(arg_parser, ArgumentParser):
+        behavior = _apply_parser(behavior, arg_parser)
+
+    group.append((list(aliases), behavior))
+
+# looks arcane but it's just chopping register up for attribute-style usage:
+# cmd = registar_attr(some_cmd_group)
+# @cmd("some", "aliases", arg_parser=ap)
+# def foo: ...
+registrar_attr = lambda g: lambda *a, arg_parser=None: lambda b: register(g, b, *a, arg_parser=arg_parser)
+
+_builtins = []
+_builtin = registrar_attr(_builtins)
+
+def register_builtins(group):
+    group += _builtins
+
+@_builtin("exit", "quit", ":q", ",q")
+def _exit(session, args):
+    from pyt.core.terminal import persona
+    session.log.blank().log(f"goodbye {persona.smile()}").blank()
+    session.repl_continue = False
+
+@_builtin("cmds")
+def _commands(session, args):
+    from pyt.core.terminal.ansi import codes as ac
+    fg = ac.ansi(ac.fg("cyan"))
+    bg = ac.ansi(ac.fg("cyan"), ac.mode("dim"))
+    res = "commands:\n" + "\n".join([f" {bg}aka{ac.reset} ".join(f'{bg}"{ac.reset}{fg}' + y + f'{ac.reset}{bg}"{ac.reset}' for y in x[0]) for x in session.commands.all_available])
+    session.log(res)
+
+@_builtin("hello", "hi")
+def _hi(session, args):
+    from pyt.core.terminal import persona
+    session.log(f"{persona.hello()} {persona.smile()}")
+
+@_builtin("reload", "refresh", "rr")
+def _reload(session, args):
+    import sys
+    from importlib import reload
+
+    log = session.log
+
+    session_reload = False
+
+    # TODO find a robust way to track which files have actually changed
+    for name, module in list(sys.modules.items()):
+        if name.startswith("pyt"):
+            try:
+                reload(module)
+                log(f"reloaded {name}")
+                if name == "pyt.core.session":
+                    session_reload = True
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except:
+                log.indented().trace()
+                log(f"failed to reload {name}", mode="error")
+
+    if session_reload:
+        new_session_module = sys.modules["pyt.core.session"]
+        session.update_class(new_session_module.PytSession)
+
+@_builtin("prefix", "pfx", "pre")
+def _prefix(session, args):
+    if args == ";":
+        session.try_handle_command("bash", "")
+        return
+
+    session.prefix = args
+
+@_builtin("do", ";")
+def _bash_do(session, args):
+    import subprocess
+
+    subprocess.run(
+        ["bash", "-ic", args]
+    )
+
+@_builtin("bash", ":")
+def _bash(session, args):
+    import os
+    import subprocess
+
+    from pyt.core.terminal import persona
+
+    log = session.log
+
+    if args == "":
+        log("switching to bash!", mode="info")
+        subprocess.run(["bash"])
+        log("wb bestie!")
+        return
+
+    args = session.favorite_dirs.get(args, args)
+
+    path = os.path.expandvars(os.path.expanduser(args))
+
+    if not os.path.isdir(path):
+        log(f"{args} is not a directory but that's ok", mode="warning")
+        log(f"switching to bash. home directory", mode="info")
+        subprocess.run(["bash"])
+        log("welcome back")
+    else:
+        log(f"switching to bash, working directory {path}", mode="info")
+        subprocess.run(["bash"], cwd=path)
+        log(f"back in the pyt {persona.smile()}")
+
+@_builtin("faves", "ff")
+def _faves(session, args):
+    from pyt.core.terminal.ansi import codes as ac
+    links = ["Favorite Directories:"]
+    dirs = session.favorite_dirs
+    for key in dirs.keys():
+        cyan = ac.ansi(ac.fg('cyan'))
+        links.append("    " + ac.file_link(dirs[key], text=f"{cyan}{key}{ac.reset} -> {dirs[key]}"))
+    session.log("\n".join(links))
+
+def _python_subprocess(session):
+    import subprocess
+
+    from pyt.core.terminal.ansi import codes as ac
+
+    log = session.log
+
+    log("switching to python!", mode="info")
+
+    if session.env.PYTHON_PATH != None:
+        try:
+            subprocess.run([session.env.PYTHON_PATH, "-q"])
+        except FileNotFoundError:
+            link = ac.link(f"file://{session.env.PYTHON_PATH}", "preferred python")
+            log(f"your {link} didn't load. trying system python :/", mode="warning")
+            subprocess.run(["python", "-q"])
+    else:
+        subprocess.run(["python", "-q"])
+
+    log("wb bestie!")
+
+def _python_stateful(session):
+    from pyt.core.terminal import persona
+
+    log = session.log
+    log("entering python mode. persistent state is available", mode="info")
+
+    state = dict(session.persistent_state)
+    state["session"] = session
+    state["print"] = log.tag("python")
+    state["_print"] = print
+
+    from pyt.core.terminal.pywrapl import repl
+
+    # TODO on_version_mismatch from pytrc
+    repl(local=state, log=log, on_version_mismatch="warning")
+
+    log(f"back to snakepyt {persona.smile()}")
+
+@_builtin("python", "py", "'")
+def _python(session, args):
+    from pyt.core.terminal import persona
+
+    if args == "fresh":
+        _python_subprocess(session)
+    else:
+        if args != "":
+            session.log(f"i dunno what u expect me to do w/ that argument {persona.laugh()}", mode="info")
+        _python_stateful(session)
+

pyt/core/commands/sketch.py

···
+
+from argparse import ArgumentParser
+
+from pyt.core.commands.commands import registrar_attr
+
+_builtins = []
+_builtin = registrar_attr(_builtins)
+
+def register_builtins(group):
+    group += _builtins
+
+@_builtin("flush")
+def _flush_state(session, args):
+    import gc
+    import sys
+    session.persistent_state = {}
+    session.persistent_hashes = {}
+    gc.collect()
+    if "torch" in sys.modules:
+        torch = sys.modules["torch"]
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    session.log("state flushed")
+
+new_parser = ArgumentParser("new")
+new_parser.add_argument("name", type=str, help="Name of the new sketch")
+new_parser.add_argument("--template", "-t", type=str, default=None,
+                        help="Template to use (verbose, basic, or path to file)")
+
+@_builtin("new", arg_parser=new_parser)
+def _new_sketch(session, args):
+    import shutil
+
+    from pathlib import Path
+
+    from pyt.core.terminal.ansi import codes as ac
+
+    log = session.log
+
+    template = args.template or session.env.get("TEMPLATE") or "verbose"
+
+    if template in ["verbose", "basic"]:
+        from importlib import import_module
+        template_module = import_module(f"pyt.core.templates.{template}")
+        template = Path(template_module.__file__)
+    elif isinstance(template, Path):
+        if not template.exists():
+            log(f"template file not found: {template}", mode="error")
+            return
+    elif isinstance(template, str):
+        try:
+            template = Path(template)
+        except:
+            log("template could not be interpreted as a path", mode="error")
+            return
+        if not template.exists():
+            log(f"template file not found: {template}", mode="error")
+            return
+    else:
+        log("template could not be interpreted as a path", mode="error")
+        return
+
+    sketch_dir = session.env.SKETCH
+    new_sketch = sketch_dir / f"{args.name}.py"
+
+    if new_sketch.exists():
+        log(f"sketch {args.name} already exists", mode="error")
+        return
+
+    shutil.copy(template, new_sketch)
+    sketch_link = ac.file_link(new_sketch)
+    template_link = ac.file_link(template)
+
+    log(f"created {sketch_link} from template {template_link}", mode="ok")
+
+@_builtin("rrun")
+def _reload_run(session, args):
+    if session.try_handle_command("reload", ""):
+        session.try_handle_command("run", args)
+
+@_builtin("run")
+def _run(session, args):
+    import os
+    import sys
+    import inspect
+    import time
+    import shutil
+    from pathlib import Path
+    from time import perf_counter
+    from importlib import import_module
+
+    from pyt.core.sketch.run import run, handle_persistent
+    from pyt.core import lsnap
+
+    sketch_name, remainder = lsnap(args)
+
+    log = session.log
+
+    try:
+        log(f"loading sketch \"{sketch_name}\"", mode="info")
+        module_name = f"{sketch_name}"
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        sys.path.insert(0, str(session.env.SKETCH))
+        sketch = import_module(module_name)
+        sys.path.pop(0)
+    except ModuleNotFoundError:
+        log.indented().trace()
+        log("no such sketch", mode="error", indent=4).blank()
+        return
+    except KeyboardInterrupt:
+        log("aborted", mode="info").blank()
+        return
+    except SystemExit:
+        raise
+    except:
+        log.indented().trace()
+        return
+
+    sources = { name : inspect.getsource(member)
+                for name, member in inspect.getmembers(sketch)
+                if inspect.isfunction(member) and member.__module__ == module_name
+               }
+
+    log = log.tag(sketch_name).mode("info")
+
+    t0 = perf_counter()
+    if hasattr(sketch, "persistent"):
+        if not handle_persistent(session, sketch_name, sketch.persistent, sketch.__dict__, log, sources):
+            log.blank()
+            return
+
+    sketch.__dict__.update(session.persistent_state)
+
+    pyt_out = session.env.OUT
+
+    if not pyt_out:
+        session.log("no output directory has been specified.\nset via --out flag, or session.env.OUT in your ~/.config/pytrc.py, or by setting the PYT_OUT environment variable", mode="error")
+        session.log("aborting.", mode="error")
+        return
+
+    daily = time.strftime("%d.%m.%Y")
+    moment = time.strftime("t%H.%M.%S")
+
+    run_dir = Path(os.path.join(pyt_out, sketch_name, daily, moment))
+    sketch.__dict__["run_dir"] = run_dir
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    shutil.copy(sketch.__file__, run_dir / f"{sketch_name}.py")
+
+    with open(run_dir / f".snakepyt", "w") as metadata:
+        metadata.write(f"snakepyt version {session.snakepyt_version[0]}.{session.snakepyt_version[1]}\n")
+
+    if hasattr(sketch, "main"):
+        if hasattr(sketch, "final"):
+            finalizer = sketch.final.__code__
+        else:
+            finalizer = None
+            failures, runs = 0, 0
+        try:
+            failures, runs = run(session, sketch.main, None, (), sketch.__dict__, log, sources, finalizer)
+        except KeyboardInterrupt:
+            log.blank().log("aborted", mode="info").blank()
+            return
+    else:
+        log("sketch has no main function", mode="error", indent=4)
+
+    if failures == 0:
+        log(f"finished {runs} run(s) in {perf_counter() - t0:.3f}s", mode="ok")
+    elif failures < runs:
+        log(f"finished {runs-failures} of {runs} run(s) in {perf_counter() - t0:.3f}s", mode="info")
+        log(f"{failures} run(s) failed to finish", mode="error")
+    else:
+        log(f"all {failures} run(s) failed to finish", mode="error")
+

pyt/core/core.py pyt/core/general.py

···
     parts = s.lstrip().split(delimiter, 1)
     return (parts[0].rstrip(), parts[1].lstrip() if len(parts) > 1 else "")
 
+from dataclasses import dataclass
+

pyt/core/logger.py pyt/core/terminal/logger.py

···
 from typing import Optional
 from pathlib import Path
 
-from pyt.lib.ansi import codes as ac
+from pyt.core.terminal.ansi import codes as ac
 
 _tag_colors = {
     "error": ac.ansi(ac.fg("red")),
···
         print()
         return self
 
-    def input(self, username=None):
-        if username is None:
-            username = ":"
-        return _input(f"{username}:", mode="user", indent=self._indent)
+    def input(self, fore):
+        if fore is None:
+            fore = ":"
+        return _input(f"{fore}", mode="user", indent=self._indent)
 

pyt/core/persona.py

···
-
-# TODO: weighted RNG; replace (list str) with (dict str->weight),
-# precompute a single looping rng buffer w/ like, 101 entries of randoms in [0,1)
-# normalize weights of each dict during startup
-# iterator will take the next rng val, run thru the dict keys subtracting their value,
-# stop when it hits / passes 0
-
-_smiles = [":)", ":3", ":D", "c:", "^^", "^_^", "<3"]
-_laughs = ["haha", "lol", "lmao", "hehe", "ha"]
-_hellos = ["hello", "hi", "hiya", "hey", "hiii"]
-
-def _iterate(items):
-    i = 0
-    n = len(items)
-    while True:
-        i = (i + 1) % n
-        yield items[i]
-
-smiles = _iterate(_smiles)
-laughs = _iterate(_laughs)
-hellos = _iterate(_hellos)
-

pyt/core/pywrapl.py pyt/core/terminal/pywrapl.py

···
 
 import sys
 
-_VERSION = {
-    "major": [3],
-    "minor": [14],
-    "micro": [2]
-}
+_VERSION = [
+    (3,14,2)
+]
 
 class VersionMismatch(RuntimeError):
     pass
···
     from _pyrepl import console, simple_interact, readline, trace, historical_reader
 
     version = sys.version_info
-    if not (version.major in _VERSION["major"] and version.minor in _VERSION["minor"] and version.micro in _VERSION["micro"]):
+    if not ((version.major, version.minor, version.micro) in _VERSION):
         if on_version_mismatch == "error":
             raise VersionMismatch("wrapper for unsupported _pyrepl module was designed around a different version")
         elif on_version_mismatch == "warning":
             log("wrapper for unsupported _pyrepl module was designed around a different version", mode="warning")
-        elif on_version_mismatch == "ignore":
+        elif on_version_mismatch != "ignore":
             log("on_version_mismatch should be one of [\"error\", \"warning\", \"ignore\"]", mode="warning")
 
     local["exit"] = _ReplExitSentinel()

pyt/core/run.py pyt/core/sketch/run.py

···
     return (schedule, _schedule)
 
 def handle_persistent(session, sketch_name, persistent_fn, module_globals, log, sources):
+    # TODO refactor to not parse the same shit more than once
+    import ast
     import hashlib
-    from pyt.core import try_dump_locals
+    import inspect
+    from pyt.core.sketch.sketch import try_dump_locals
+
+    # strip semantically-irrelevant whitespace & comments
+    canonicalized_source = ast.unparse(ast.parse(sources[persistent_fn.__name__]))
+    bytecode_hash = hashlib.sha256(canonicalized_source.encode()).hexdigest()
 
-    # TODO better to hash the source code tbh
-    bytecode_hash = hashlib.sha256(persistent_fn.__code__.co_code).hexdigest()
     if sketch_name in session.persistent_hashes:
         if bytecode_hash == session.persistent_hashes[sketch_name]:
             return True
+
     (success, locals_or_err) = try_dump_locals(persistent_fn,
                                                sources[persistent_fn.__name__],
                                                [], {},
                                                module_globals, log)
+
     if success:
         session.persistent_hashes[sketch_name] = bytecode_hash
+        # TODO: sketches should get their own persistent state dicts, w/ a non-default
+        # option to persist items into the top-level persistent_state instead
         session.persistent_state.update(locals_or_err)
     else:
         log(f"failed to run persistent function: {locals_or_err}", mode="error")
···
 def run(session, fn, arg, partial_id, outer_scope, log, sources, finalizer=None):
     from time import perf_counter
 
-    from pyt.core import try_dump_locals
+    from pyt.core.sketch.sketch import try_dump_locals
 
     scope = dict(outer_scope)
     schedule, schedule_fn = establish_scheduler()

pyt/core/session.py

···
 
 from pathlib import Path
 
-from pyt.lib.ansi import codes as ac
+from pyt.core.terminal.ansi import codes as ac
 from pyt.core import AttrDict, lsnap
-from pyt.core.commands import command_registrar, builtin_commands
+from pyt.core.commands import registrar_attr, register_builtins
 
 def _find_pytrc():
     config_home = os.getenv("XDG_CONFIG_HOME")
···
         self.snakepyt_version = (0, 2)
         self.repl_continue = True
 
+        self.prefix = None
 
         self.favorite_dirs = {}
 
         self.persistent_state = {}
         self.persistent_hashes = {}
 
-        from pyt.core import Logger
+        from pyt.core.terminal import Logger
         self.log = Logger().mode("ok").tag("snakepyt")
 
         self.commands = AttrDict()
···
 
         self._get_paths()
 
-        self.commands.all_available = self.commands.user + builtin_commands
+        self.commands.builtin = []
+
+        register_builtins(self.commands.builtin)
+
+        self.commands.all_available = self.commands.user + self.commands.builtin
 
     def _get_paths(self):
         # priority order: cli > pytrc > env > default
···
         if isinstance(self.env.OUT, str): self.env.OUT = Path(self.env.OUT)
         if isinstance(self.env.IN, str): self.env.IN = Path(self.env.IN)
         if isinstance(self.env.SKETCH, str): self.env.SKETCH = Path(self.env.SKETCH)
-        if isinstance(self.env.TEMPLATE, str): self.env.TEMPLATE = Path(self.env.TEMPLATE)
 
         if isinstance(self.env.PYTHON_PATH, str): self.env.PYTHON_PATH = Path(self.env.PYTHON_PATH)
 
···
 
         if pytrc.exists():
             namespace = {
-                "command": command_registrar(self.commands.user),
+                "command": registrar_attr(self.commands.user),
                 "session": self,
                 "print": log
             }
···
     def handle_message(self, message):
         log = self.log
         try:
+            if self.prefix:
+                if message in ["un", "unpre", "unprefix"]:
+                    self.prefix = None
+                    return
+                message = " ".join([self.prefix, message])
+
             if message.startswith("."):
                 if message.rstrip() == ".":
                     state_dump = "\n".join([f"    {k}: {type(v).__name__}" for k, v in self.persistent_state.items()])
···
 
         state = self.persistent_state
         hashes = self.persistent_hashes
+        prefix = self.prefix
 
         self.__class__ = new_instance.__class__
         self.__dict__.clear()
···
 
         self.persistent_state = state
         self.persistent_hashes = hashes
+        self.prefix = prefix
 

pyt/core/sketch.py pyt/core/sketch/sketch.py

···
 import ast
 import inspect
 
-from pyt.core.core import Errs, errs
+from pyt.core import Errs, errs
 
 class ReturnLocalsWalker(ast.NodeTransformer):
     def __init__(self, logger):
···
 
     return (True, new_func)
 
+# TODO this function signature is a mess
 @errs(_Errs)
 def try_dump_locals(fn, fn_source, args, kwargs, deftime_globals, log):
     (success, fn_or_err) = modify_to_dump_locals(fn, fn_source, deftime_globals, log)

pyt/core/terminal/__init__.py

···
+
+from .logger import Logger
+

pyt/core/terminal/persona.py

···
+
+import random
+
+_smiles = {
+    ":)": 8.0, ":3": 5.0, ":D": 4.0,
+    "c:": 0.3, "^^": 1.0, "^_^": 1.0,
+    "<3": 3.0,
+}
+
+_laughs = {
+    "haha": 1.0, "lol": 1.0, "lmao": 1.0,
+    "hehe": 1.0, "ha": 1.0,
+}
+
+_hellos = {
+    "hello": 1.0, "hi": 1.0, "hiya": 1.0,
+    "hey": 1.0, "hiii": 1.0,
+}
+
+def _get_sampler(weighted_strs: dict[str, float]):
+    keys = list(weighted_strs.keys())
+    return lambda: random.choices(keys, weights=weighted_strs.values(), k=1)[0]
+
+smile = _get_sampler(_smiles)
+laugh = _get_sampler(_laughs)
+hello = _get_sampler(_hellos)
+
+maybe_emote = _get_sampler({"": 10.0, **_smiles, **_hellos, "lmao": 0.0})
+

pyt/core/terminal/terminal.py

···
+
+from dataclasses import dataclass
+
+class ColorRGB:
+    pass
+
+class Color256:
+    pass
+
+class Color216:
+    pass
+
+class ColorTerm:
+    pass
+
+# TODO: come up with strong type for color and modes, and anything else that gets added here,
+# and once all that's done, we can make this a frozen dataclass
+class Style:
+    def __init__(self):
+        self.color = None
+        self.modes = [] # list of idk some kinda enum
+
+class StyleChange:
+    pass
+
+def _write(stream, text, style):
+    # convert style to ansi
+    # or if u wanna get real fancy, convert all *style changes* to ansi
+    pass
+
+def _flush(stream):
+    pass
+
+class _MockOut:
+    # TODO do-nothing methods for fake out stream
+    pass
+
+class _MockIn:
+    # TODO do-nothing methods for fake in stream
+    pass
+
+class Terminal:
+    """
+    Abstract terminal
+    """
+
+    _in_stream = None
+    _out_streams = None
+
+    def __init__(self, in_stream, out_streams):
+        self._in_stream = in_stream if in_stream else _MockIn()
+        if not out_streams or len(out_streams) == 0:
+            self._out_streams = { "default": _MockOut() }
+        else:
+            self._out_streams = out_streams
+        if "default" not in self._out_streams:
+            self._out_streams["default"] = next(iter(out_streams.values()))
+
+        # TODO: figure out what kinds of styling each out stream actually supports
+        # including fancy kitty extension stuff! speaking of which, also check if we can
+        # get nice kitty-mode input events
+
+        # construct style filters from this
+
+    # TODO: function that turns (Style | None, Style | None) pair into StyleChange | None
+
+    # TODO: function that turns an iterable of (text, Style | None) pairs
+    # into an iterable of text | StyleChange
+
+    def write(self, text, style=None, to="default"):
+        target = self._out_streams.get(to, None)
+        if target is None:
+            raise RuntimeError("valid streams: [\"out\", \"err\"]")
+        if isinstance(text, list):
+            for entry in text:
+                _write(target, entry[0], entry[1])
+        else:
+            _write(target, text, style)
+        _flush(target)
+
+    # TODO default link style
+    def write_link(self, uri, text, style=None, to="default"):
+        # need to handle the case where the link is made up of multiple styles ofc.
+        # just means tacking on a wrapper around text and style and passing them thru to
+        # write.
+        # also need to ensure link capability of the stream tho
+        pass
+
+    def query(self, query, on_result, on_timeout=None):
+        # wrap ansi queries so that user doesn't have to poll
+        # maybe also expose a blocking version? idk
+        pass
+
+    def read(self):
+        # just the text out of the input queue; kitty makes this easy but oldschool ansi
+        # code untangling might be a pain
+        pass
+
+    def get_input_events(self, clear=True):
+        # access the input event queue. by default, consume it
+        # maybe add filtering for which kinds of events the caller cares about
+        pass
+

pyt/lib/ansi/codes.py pyt/core/terminal/ansi/codes.py

···
     k: str(i) for (i,k) in enumerate(_modes)
 }
 
+def mode(mode):
+    return _mode_digits[mode]
 
 
 # cursor shapes (DECSCUSR)

pyt/repl.py

···
 from argparse import ArgumentParser
 
 from pyt.core import PytSession
+from pyt.core.terminal import persona
 
 parser = ArgumentParser("snakepyt")
 PytSession.define_cli_args(parser)
···
     try:
         username = os.getlogin()
     except:
-        username = None
-    session.log(f"hello {username}! <3" if username else "hello! <3")
+        username = ""
+
+    session.log(f"{persona.hello()} {username}! {persona.smile()}" if username else f"{persona.hello()}! {persona.smile()}")
     session.log.blank()
 
     while session.repl_continue:
         try:
-            message = session.log.input(username)
+            tag = f"{username}: {session.prefix}" if session.prefix else username + ':'
+            message = session.log.input(tag)
         except (KeyboardInterrupt, EOFError, SystemExit):
-            session.log.blank().log("goodbye <3").blank()
+            session.log.blank().log(f"goodbye {persona.smile()}").blank()
             session.repl_continue = False
             continue
-
-        if "prefix" in session.persistent_state:
-            message = " ".join([session.persistent_state["prefix"], message])
 
         session.handle_message(message.lstrip())