sonolus.py 0.9.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

sonolus/backend/visitor.py

@@ -47,9 +47,14 @@ def compile_and_call[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.k
 def compile_and_call_at_definition[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs) -> R:
     if not ctx():
         return fn(*args, **kwargs)
-    if ctx().no_eval:
-        return compile_and_call(fn, *args, **kwargs)
     source_file, node = get_function(fn)
+    if ctx().no_eval:
+        debug_stack = ctx().callback_state.debug_stack
+        try:
+            debug_stack.append(f'File "{source_file}", line {node.lineno}, in <callback>')
+            return compile_and_call(fn, *args, **kwargs)
+        finally:
+            debug_stack.pop()
     location_args = {
         "lineno": node.lineno,
         "col_offset": node.col_offset,
@@ -64,10 +69,16 @@ def compile_and_call_at_definition[**P, R](fn: Callable[P, R], /, *args: P.args,
             **location_args,
         )
     )
-    return eval(
-        compile(expr, filename=source_file, mode="eval"),
-        {"fn": lambda: compile_and_call(fn, *args, **kwargs), "_filter_traceback_": True, "_traceback_root_": True},
-    )
+
+    debug_stack = ctx().callback_state.debug_stack
+    try:
+        debug_stack.append(f'File "{source_file}", line {node.lineno}, in <callback>')
+        return eval(
+            compile(expr, filename=source_file, mode="eval"),
+            {"fn": lambda: compile_and_call(fn, *args, **kwargs), "_filter_traceback_": True, "_traceback_root_": True},
+        )
+    finally:
+        debug_stack.pop()
 
 
 def generate_fn_impl(fn: Callable):
@@ -111,7 +122,9 @@ def eval_fn(fn: Callable, /, *args, **kwargs):
         **fn.__globals__,
         **nonlocal_vars,
     }
-    return Visitor(source_file, bound_args, global_vars).run(node)
+    return Visitor(
+        source_file, bound_args, global_vars, parent=None, function_name=getattr(fn, "__name__", "<unnamed>")
+    ).run(node)
 
 
 unary_ops = {
@@ -232,14 +245,16 @@ class Visitor(ast.NodeVisitor):
     resume_ctxs: list[Context]  # Contexts after yield statements
     active_ctx: Context | None  # The active context for use in nested functions
     parent: Visitor | None  # The parent visitor for use in nested functions
-    used_parent_binding_values: dict[str, Value]  # Values of parent bindings used in this function
+    used_parent_binding_values: dict[str, Value]  # Values of parent bindings used in this
+    function_name: str
 
     def __init__(
         self,
         source_file: str,
         bound_args: inspect.BoundArguments,
         global_vars: dict[str, Any],
-        parent: Visitor | None = None,
+        parent: Visitor | None,
+        function_name: str,
     ):
         self.source_file = source_file
         self.globals = global_vars
@@ -253,6 +268,7 @@ class Visitor(ast.NodeVisitor):
         self.active_ctx = None
         self.parent = parent
         self.used_parent_binding_values = {}
+        self.function_name = function_name
 
     def run(self, node):
         before_ctx = ctx()
@@ -433,7 +449,8 @@ class Visitor(ast.NodeVisitor):
                 self.source_file,
                 bound,
                 self.globals,
-                self,
+                parent=self,
+                function_name=name,
             ).run(node)
 
         fn._meta_fn_ = True
@@ -951,7 +968,8 @@ class Visitor(ast.NodeVisitor):
                 self.source_file,
                 bound,
                 self.globals,
-                self,
+                parent=self,
+                function_name="<lambda>",
             ).run(node)
 
         fn._meta_fn_ = True
@@ -1002,7 +1020,9 @@ class Visitor(ast.NodeVisitor):
 
     def visit_GeneratorExp(self, node):
         self.active_ctx = ctx()
-        return Visitor(self.source_file, inspect.Signature([]).bind(), self.globals, self).run(node)
+        return Visitor(
+            self.source_file, inspect.Signature([]).bind(), self.globals, parent=self, function_name="<genexp>"
+        ).run(node)
 
     def visit_Await(self, node):
         raise NotImplementedError("Await expressions are not supported")
@@ -1326,15 +1346,20 @@ class Visitor(ast.NodeVisitor):
     ) -> R | Value:
         """Handles a call to the given callable."""
         self.active_ctx = ctx()
-        if (
-            isinstance(fn, Value)
-            and fn._is_py_()
-            and isinstance(fn._as_py_(), type)
-            and issubclass(fn._as_py_(), Value)
-        ):
-            return validate_value(self.execute_at_node(node, fn._as_py_(), *args, **kwargs))
-        else:
-            return self.execute_at_node(node, lambda: validate_value(compile_and_call(fn, *args, **kwargs)))
+        debug_stack = self.active_ctx.callback_state.debug_stack
+        try:
+            debug_stack.append(f'File "{self.source_file}", line {node.lineno}, in {self.function_name}')
+            if (
+                isinstance(fn, Value)
+                and fn._is_py_()
+                and isinstance(fn._as_py_(), type)
+                and issubclass(fn._as_py_(), Value)
+            ):
+                return validate_value(self.execute_at_node(node, fn._as_py_(), *args, **kwargs))
+            else:
+                return self.execute_at_node(node, lambda: validate_value(compile_and_call(fn, *args, **kwargs)))
+        finally:
+            debug_stack.pop()
 
     def handle_getitem(self, node: ast.stmt | ast.expr, target: Value, key: Value) -> Value:
         with self.reporting_errors_at_node(node):

sonolus/build/cli.py

@@ -14,6 +14,7 @@ from sonolus.build.dev_server import run_server
 from sonolus.build.engine import no_gil, package_engine, validate_engine
 from sonolus.build.level import package_level_data
 from sonolus.build.project import build_project_to_collection, get_project_schema
+from sonolus.script.internal.context import ProjectContextState
 from sonolus.script.internal.error import CompilationError
 from sonolus.script.project import BuildConfig, Project
 
@@ -88,12 +89,18 @@ def validate_project(project: Project, config: BuildConfig):
     validate_engine(project.engine.data, config)
 
 
-def build_collection(project: Project, build_dir: Path, config: BuildConfig | None, cache: CompileCache | None = None):
+def build_collection(
+    project: Project,
+    build_dir: Path,
+    config: BuildConfig | None,
+    cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
+):
     site_dir = build_dir / "site"
     shutil.rmtree(site_dir, ignore_errors=True)
     site_dir.mkdir(parents=True, exist_ok=True)
 
-    collection = build_project_to_collection(project, config, cache=cache)
+    collection = build_project_to_collection(project, config, cache=cache, project_state=project_state)
     collection.write(site_dir)
 
 
@@ -217,14 +224,9 @@ def main():
             print(f"Project built successfully to '{build_dir.resolve()}' in {end_time - start_time:.2f}s")
         elif args.command == "dev":
             build_dir = Path(args.build_dir)
-            start_time = perf_counter()
             config = get_config(args)
-            cache = CompileCache()
-            build_collection(project, build_dir, config, cache=cache)
-            end_time = perf_counter()
-            print(f"Build finished in {end_time - start_time:.2f}s")
             run_server(
-                build_dir / "site", args.port, project_module.__name__, core_module_names, build_dir, config, cache
+                build_dir / "site", args.port, project_module.__name__, core_module_names, build_dir, config, project
             )
         elif args.command == "schema":
             print(json.dumps(get_project_schema(project), indent=2))

sonolus/build/compile.py

@@ -17,8 +17,8 @@ from sonolus.script.internal.callbacks import CallbackInfo
 from sonolus.script.internal.context import (
     CallbackContextState,
     Context,
-    GlobalContextState,
-    ReadOnlyMemory,
+    ModeContextState,
+    ProjectContextState,
     context_to_cfg,
     ctx,
     using_ctx,
@@ -54,7 +54,7 @@ class CompileCache:
 
 def compile_mode(
     mode: Mode,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     archetypes: list[type[_BaseArchetype]] | None,
     global_callbacks: list[tuple[CallbackInfo, Callable]] | None,
     passes: Sequence[CompilerPass] | None = None,
@@ -65,10 +65,9 @@ def compile_mode(
     if passes is None:
         passes = STANDARD_PASSES
 
-    global_state = GlobalContextState(
+    mode_state = ModeContextState(
         mode,
         {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
-        rom,
     )
     nodes = OutputNodeGenerator()
     results = {}
@@ -84,7 +83,7 @@ def compile_mode(
         - (cb_info.name, node_index) for global callbacks, or
         - (cb_info.name, {"index": node_index, "order": cb_order}) for archetype callbacks.
         """
-        cfg = callback_to_cfg(global_state, cb, cb_info.name, arch)
+        cfg = callback_to_cfg(project_state, mode_state, cb, cb_info.name, arch)
         if validate_only:
             if arch is not None:
                 cb_order = getattr(cb, "_callback_order_", 0)
@@ -185,27 +184,29 @@ def compile_mode(
 
 
 def callback_to_cfg(
-    global_state: GlobalContextState,
+    project_state: ProjectContextState,
+    mode_state: ModeContextState,
     callback: Callable,
     name: str,
     archetype: type[_BaseArchetype] | None = None,
 ) -> BasicBlock:
     try:
         # Default to no_eval=True for performance unless there's an error.
-        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=True)
+        return _callback_to_cfg(project_state, mode_state, callback, name, archetype, no_eval=True)
     except CompilationError:
-        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=False)
+        return _callback_to_cfg(project_state, mode_state, callback, name, archetype, no_eval=False)
 
 
 def _callback_to_cfg(
-    global_state: GlobalContextState,
+    project_state: ProjectContextState,
+    mode_state: ModeContextState,
     callback: Callable,
     name: str,
     archetype: type[_BaseArchetype] | None,
     no_eval: bool,
 ) -> BasicBlock:
     callback_state = CallbackContextState(name, no_eval=no_eval)
-    context = Context(global_state, callback_state)
+    context = Context(project_state, mode_state, callback_state)
     with using_ctx(context):
         if archetype is not None:
             result = compile_and_call_at_definition(callback, archetype._for_compilation())

sonolus/build/dev_server.py

@@ -6,6 +6,7 @@ import http.server
 import importlib
 import queue
 import shlex
+import shutil
 import socket
 import socketserver
 import sys
@@ -15,53 +16,97 @@ import traceback
 from dataclasses import dataclass
 from pathlib import Path
 from time import perf_counter
-from typing import TYPE_CHECKING, Protocol
+from typing import TYPE_CHECKING, NamedTuple, Protocol
 
 from sonolus.backend.excepthook import print_simple_traceback
 from sonolus.backend.utils import get_function, get_functions, get_tree_from_file
 from sonolus.build.compile import CompileCache
+from sonolus.script.internal.context import ProjectContextState
 from sonolus.script.internal.error import CompilationError
 
 if TYPE_CHECKING:
-    from sonolus.script.project import BuildConfig
+    from sonolus.script.project import BuildConfig, Project
 
 HELP_TEXT = """
 [r]ebuild
+[d]ecode <message_code>
+[h]elp
 [q]uit
 """.strip()
 
 HELP_TEXT = textwrap.dedent(HELP_TEXT)
 
 
+class CommandHelp(NamedTuple):
+    alias: str
+    command: str
+    description: list[str]
+
+
+DETAILED_HELP_TEXT = [
+    CommandHelp(
+        alias="r",
+        command="rebuild",
+        description=[
+            ("Rebuild the project with the latest changes from source files."),
+        ],
+    ),
+    CommandHelp(
+        alias="d",
+        command="decode <message_code>",
+        description=[
+            (
+                "Decode a debug message code to its original text with a stack trace. "
+                "Message codes are generated by assert statements, debug.error(), and debug.notify() calls. "
+                "The game is automatically paused when these are triggered in debug mode and the message code "
+                "can be found in the debug log."
+            ),
+            "Example: d 42",
+        ],
+    ),
+    CommandHelp(
+        alias="h",
+        command="help",
+        description=[
+            "Show this help message.",
+        ],
+    ),
+    CommandHelp(
+        alias="q",
+        command="quit",
+        description=[
+            "Exit the development server.",
+        ],
+    ),
+]
+
+
+@dataclass
+class ServerState:
+    project: Project
+    project_module_name: str
+    core_module_names: set[str]
+    build_dir: Path
+    config: BuildConfig
+    cache: CompileCache
+    project_state: ProjectContextState
+
+
 class Command(Protocol):
-    def execute(
-        self,
-        project_module_name: str,
-        core_module_names: set[str],
-        build_dir: Path,
-        config: BuildConfig,
-        cache: CompileCache,
-    ) -> None: ...
+    def execute(self, server_state: ServerState) -> None: ...
 
 
 @dataclass
 class RebuildCommand:
-    def execute(
-        self,
-        project_module_name: str,
-        core_module_names: set[str],
-        build_dir: Path,
-        config: BuildConfig,
-        cache: CompileCache,
-    ):
+    def execute(self, server_state: ServerState):
         from sonolus.build.cli import build_collection
 
         for module_name in tuple(sys.modules):
-            if module_name not in core_module_names:
+            if module_name not in server_state.core_module_names:
                 del sys.modules[module_name]
 
         try:
-            project_module = importlib.import_module(project_module_name)
+            project_module = importlib.import_module(server_state.project_module_name)
         except Exception:
             print(traceback.format_exc())
             return
@@ -72,7 +117,15 @@ class RebuildCommand:
         print("Rebuilding...")
         try:
             start_time = perf_counter()
-            build_collection(project_module.project, build_dir, config, cache=cache)
+            server_state.project_state = ProjectContextState()
+            server_state.project = project_module.project
+            build_collection(
+                server_state.project,
+                server_state.build_dir,
+                server_state.config,
+                cache=server_state.cache,
+                project_state=server_state.project_state,
+            )
             end_time = perf_counter()
             print(f"Rebuild completed in {end_time - start_time:.2f} seconds")
         except CompilationError:
@@ -80,16 +133,47 @@ class RebuildCommand:
             print_simple_traceback(*exc_info)
 
 
+@dataclass
+class DecodeCommand:
+    message_code: int
+
+    def execute(self, server_state: ServerState):
+        debug_str_mappings = server_state.project_state.debug_str_mappings
+        message = next((msg for msg, code in debug_str_mappings.items() if code == self.message_code), None)
+
+        if message is not None:
+            print(message)
+        else:
+            print(f"Unknown message code: {self.message_code}")
+
+
+@dataclass
+class HelpCommand:
+    def execute(self, server_state: ServerState):
+        terminal_width = shutil.get_terminal_size().columns
+        max_width = min(terminal_width, 120)
+
+        print("Available Commands:\n")
+
+        for entry in DETAILED_HELP_TEXT:
+            print(f"  [{entry.alias}] {entry.command}")
+
+            for paragraph in entry.description:
+                initial_indent = "    "
+                subsequent_indent = "    "
+                wrapped = textwrap.fill(
+                    paragraph,
+                    width=max_width - len(initial_indent),
+                    initial_indent=initial_indent,
+                    subsequent_indent=subsequent_indent,
+                )
+                print(wrapped)
+                print()
+
+
 @dataclass
 class ExitCommand:
-    def execute(
-        self,
-        project_module_name: str,
-        core_module_names: set[str],
-        build_dir: Path,
-        config: BuildConfig,
-        cache: CompileCache,
-    ):
+    def execute(self, server_state: ServerState):
         print("Exiting...")
         sys.exit(0)
 
@@ -99,12 +183,19 @@ def parse_dev_command(command_line: str) -> Command | None:
     subparsers = parser.add_subparsers(dest="cmd")
 
     subparsers.add_parser("rebuild", aliases=["r"])
+    decode_parser = subparsers.add_parser("decode", aliases=["d"])
+    decode_parser.add_argument("message_code", type=int, help="Message code to decode")
+    subparsers.add_parser("help", aliases=["h"])
     subparsers.add_parser("quit", aliases=["q"])
 
     try:
         args = parser.parse_args(shlex.split(command_line))
         if args.cmd in {"rebuild", "r"}:
             return RebuildCommand()
+        elif args.cmd in {"decode", "d"}:
+            return DecodeCommand(message_code=args.message_code)
+        elif args.cmd in {"help", "h"}:
+            return HelpCommand()
         elif args.cmd in {"quit", "q"}:
             return ExitCommand()
         return None
@@ -164,8 +255,18 @@ def run_server(
     core_module_names: set[str] | None,
     build_dir: Path,
     config: BuildConfig,
-    cache: CompileCache,
+    project,
 ):
+    from sonolus.build.cli import build_collection
+
+    cache = CompileCache()
+    project_state = ProjectContextState()
+
+    start_time = perf_counter()
+    build_collection(project, build_dir, config, cache=cache, project_state=project_state)
+    end_time = perf_counter()
+    print(f"Build finished in {end_time - start_time:.2f}s")
+
     interactive = project_module_name is not None and core_module_names is not None
 
     class DirectoryHandler(http.server.SimpleHTTPRequestHandler):
@@ -187,6 +288,16 @@ def run_server(
             print(f"  http://{ip}:{port}")
 
         if interactive:
+            server_state = ServerState(
+                project=project,
+                project_module_name=project_module_name,
+                core_module_names=core_module_names,
+                build_dir=build_dir,
+                config=config,
+                cache=cache,
+                project_state=project_state,
+            )
+
             threading.Thread(target=httpd.serve_forever, daemon=True).start()
 
             command_queue = queue.Queue()
@@ -202,12 +313,12 @@ def run_server(
                 while True:
                     try:
                         cmd = command_queue.get(timeout=0.5)
-                        cmd.execute(project_module_name, core_module_names, build_dir, config, cache)
+                        cmd.execute(server_state)
                         prompt_event.set()
                     except queue.Empty:
                         continue
             except KeyboardInterrupt:
-                print("\nStopping server...")
+                print("Exiting...")
                 sys.exit(0)
             finally:
                 httpd.shutdown()