sonolus.py 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

sonolus/build/cli.py

@@ -2,6 +2,7 @@ import argparse
 import contextlib
 import http.server
 import importlib
+import json
 import shutil
 import socket
 import socketserver
@@ -11,7 +12,7 @@ from time import perf_counter
 
 from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
-from sonolus.build.project import build_project_to_collection
+from sonolus.build.project import build_project_to_collection, get_project_schema
 from sonolus.script.project import Project
 
 
@@ -147,6 +148,14 @@ def main():
     dev_parser.add_argument("--build-dir", type=str, default="./build")
     dev_parser.add_argument("--port", type=int, default=8000)
 
+    schema_parser = subparsers.add_parser("schema")
+    schema_parser.add_argument(
+        "module",
+        type=str,
+        nargs="?",
+        help="Module path (e.g., 'module.name'). If omitted, will auto-detect if only one module exists.",
+    )
+
     args = parser.parse_args()
 
     if not args.module:
@@ -161,16 +170,18 @@ def main():
     if project is None:
         sys.exit(1)
 
-    build_dir = Path(args.build_dir)
-
     if args.command == "build":
+        build_dir = Path(args.build_dir)
         start_time = perf_counter()
         build_project(project, build_dir)
         end_time = perf_counter()
         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()
         build_collection(project, build_dir)
         end_time = perf_counter()
         print(f"Build finished in {end_time - start_time:.2f}s")
         run_server(build_dir / "site", port=args.port)
+    elif args.command == "schema":
+        print(json.dumps(get_project_schema(project), indent=2))

sonolus/build/compile.py

@@ -1,15 +1,15 @@
 from collections.abc import Callable
 
 from sonolus.backend.finalize import cfg_to_engine_node
-from sonolus.backend.flow import BasicBlock
 from sonolus.backend.ir import IRConst, IRInstr
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
-from sonolus.backend.optimize import optimize_and_allocate
+from sonolus.backend.optimize.flow import BasicBlock
+from sonolus.backend.optimize.optimize import optimize_and_allocate
 from sonolus.backend.visitor import compile_and_call
 from sonolus.build.node import OutputNodeGenerator
-from sonolus.script.archetype import BaseArchetype
-from sonolus.script.callbacks import CallbackInfo
+from sonolus.script.archetype import _BaseArchetype
+from sonolus.script.internal.callbacks import CallbackInfo
 from sonolus.script.internal.context import (
     CallbackContextState,
     Context,
@@ -19,13 +19,13 @@ from sonolus.script.internal.context import (
     ctx,
     using_ctx,
 )
-from sonolus.script.num import is_num
+from sonolus.script.num import _is_num
 
 
 def compile_mode(
     mode: Mode,
     rom: ReadOnlyMemory,
-    archetypes: list[type[BaseArchetype]] | None,
+    archetypes: list[type[_BaseArchetype]] | None,
     global_callbacks: list[tuple[CallbackInfo, Callable]] | None,
 ) -> dict:
     global_state = GlobalContextState(
@@ -74,7 +74,7 @@ def compile_mode(
 
 
 def callback_to_cfg(
-    global_state: GlobalContextState, callback: Callable, name: str, archetype: type[BaseArchetype] | None = None
+    global_state: GlobalContextState, callback: Callable, name: str, archetype: type[_BaseArchetype] | None = None
 ) -> BasicBlock:
     callback_state = CallbackContextState(name)
     context = Context(global_state, callback_state)
@@ -83,6 +83,6 @@ def callback_to_cfg(
             result = compile_and_call(callback, archetype._for_compilation())
         else:
             result = compile_and_call(callback)
-        if is_num(result):
+        if _is_num(result):
             ctx().add_statements(IRInstr(Op.Break, [IRConst(1), result.ir()]))
     return context_to_cfg(context)

sonolus/build/engine.py

@@ -7,15 +7,20 @@ from pathlib import Path
 
 from sonolus.backend.mode import Mode
 from sonolus.build.compile import compile_mode
-from sonolus.script.archetype import BaseArchetype
+from sonolus.script.archetype import _BaseArchetype
 from sonolus.script.bucket import Buckets
-from sonolus.script.callbacks import navigate_callback, preprocess_callback, update_callback, update_spawn_callback
 from sonolus.script.effect import Effects
 from sonolus.script.engine import EngineData
 from sonolus.script.instruction import (
     TutorialInstructionIcons,
     TutorialInstructions,
 )
+from sonolus.script.internal.callbacks import (
+    navigate_callback,
+    preprocess_callback,
+    update_callback,
+    update_spawn_callback,
+)
 from sonolus.script.internal.context import ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
@@ -101,7 +106,7 @@ def build_engine_configuration(
 
 
 def build_play_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     effects: Effects,
     particles: Particles,
@@ -118,7 +123,7 @@ def build_play_mode(
 
 
 def build_watch_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     effects: Effects,
     particles: Particles,
@@ -138,7 +143,7 @@ def build_watch_mode(
 
 
 def build_preview_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     rom: ReadOnlyMemory,
 ):

sonolus/build/project.py

@@ -5,7 +5,7 @@ from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
 from sonolus.script.level import Level
-from sonolus.script.project import Project
+from sonolus.script.project import Project, ProjectSchema
 
 BLANK_PNG = (
     b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x007n\xf9$"
@@ -92,3 +92,32 @@ def load_resources_files_to_collection(base_path: Path) -> Collection:
         collection.load_from_scp(path)
     collection.load_from_source(base_path)
     return collection
+
+
+def get_project_schema(project: Project) -> ProjectSchema:
+    by_archetype: dict[str, dict[str, bool]] = {}
+    for archetype in project.engine.data.play.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        # If a field is exported, we should exclude it if it's imported in watch mode
+        for field in archetype._exported_keys_:
+            fields[field] = False
+        for field in archetype._imported_keys_:
+            fields[field] = True
+    for archetype in project.engine.data.watch.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        for field in archetype._imported_keys_:
+            if field not in fields:
+                fields[field] = True
+    for archetype in project.engine.data.preview.archetypes:
+        fields = by_archetype.setdefault(archetype.name, {})
+        for field in archetype._imported_keys_:
+            fields[field] = True
+    return {
+        "archetypes": [
+            {
+                "name": name,
+                "fields": [*fields],
+            }
+            for name, fields in by_archetype.items()
+        ]
+    }