Bugfixing module_renderer.py

zanjonke · zanjonke · commit 8e4bb3b65026 · 2026-04-24T10:49:56.000+02:00
diff --git a/module_renderer.py b/module_renderer.py
@@ -81,20 +81,23 @@ def _render_module(
             and self.partial_render_choice.module is not None
             and self.partial_render_choice.module.module_name == plain_module.module_name
         )
-        render_range = self.partial_render_choice.render_range if is_partial_render_choice_module else render_range
+
+        if is_partial_render_choice_module:
+            render_range = self.partial_render_choice.render_range
+
         if render_range is not None:
             plain_module.ensure_previous_frid_commits_exist(render_range, self.args.render_conformance_tests)
 
         has_any_required_module_changed = False
         if not self.args.render_machine_graph and plain_module.required_modules and not is_partial_render_choice_module:
             console.debug(f"Analyzing required modules of module {plain_module.module_name}...")
             for required_module in plain_module.required_modules:
-                has_any_required_module_changed, rendering_failed = self._render_module(
+                has_module_changed, rendering_failed = self._render_module(
                     required_module,
                     None,
                     self.args.force_render,
                 )
-
+                has_any_required_module_changed |= has_module_changed
                 if rendering_failed:
                     return False, True
 
@@ -145,6 +148,18 @@ def _render_module(
         return True, False
 
     def render_module(self) -> None:
+        if self.partial_render_choice is not None and self.partial_render_choice.wipe_later_modules:
+            later_module = False
+            all_modules = self.plain_module.all_required_modules + [self.plain_module]
+            for module in all_modules:
+                if module.module_name == self.partial_render_choice.module.module_name:
+                    later_module = True
+                    continue
+
+                if later_module:
+                    console.info(f"Wiping module {module.module_name}...")
+                    module.wipe_module()
+
         self.loaded_modules = list[PlainModule]()
         _, rendering_failed = self._render_module(self.plain_module, self.render_range, True)
         if not rendering_failed:
diff --git a/partial_rendering.py b/partial_rendering.py
@@ -19,6 +19,7 @@ class PartialRenderChoice:
     module: PlainModule | None = None
     render_range: list[str] | None = None
     msg: str | None = None
+    wipe_later_modules: bool = False
 
 
 def spec_change(plain_module: PlainModule) -> PlainModule | None:
@@ -72,7 +73,7 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
     sc = spec_change(plain_module)
     cc = code_change(plain_module)
     all_required_modules = plain_module.all_required_modules
-    last_rendered_module_name, last_rendered_frid = plain_module.get_module_last_rendered_functionality()
+    last_rendered_module_name, last_rendered_frid = plain_module.get_module_render_status()
     if last_rendered_module_name is None and last_rendered_frid is None:
         return None
 
@@ -84,16 +85,17 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
             module = plain_module
         else:
             return None
-
-    module = None
-    for required_module in all_required_modules:
-        if required_module.module_name == last_rendered_module_name:
-            module = required_module
-
-    if module is None:
-        raise ModuleDoesNotExistError(
-            f"Last rendered module {last_rendered_module_name} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
-        )
+    else:
+        found_module: PlainModule | None = None
+        for required_module in all_required_modules:
+            if required_module.module_name == last_rendered_module_name:
+                found_module = required_module
+
+        if found_module is None:
+            raise ModuleDoesNotExistError(
+                f"Last rendered module {last_rendered_module_name} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
+            )
+        module = found_module
 
     pr = PartialRender(
         last_render_module=module,
@@ -119,36 +121,56 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
     return pr
 
 
-def get_choices(plain_module: PlainModule, partial_render: PartialRender) -> dict[str, PartialRenderChoice]:
+def get_choices(
+    plain_module: PlainModule,
+    partial_render: PartialRender,
+    force_render: bool = False,
+) -> dict[str, PartialRenderChoice]:
     choices = dict[str, PartialRenderChoice]()
     choice_idx = 1
-    if not partial_render.last_render_module.is_module_fully_rendered():
+
+    if partial_render.last_render_module.is_initial_module():
         choices[str(choice_idx)] = PartialRenderChoice(
             module=partial_render.last_render_module,
             render_range=None,
             msg=f"Start from module [#5593FF]{partial_render.last_render_module.module_name}[/]",
+            wipe_later_modules=True,
         )
         choice_idx += 1
-        if not partial_render.last_render_module.is_initial_module():
-            if not partial_render.last_render_frid:
-                raise ValueError("Last render FRID is not set for a non-initial module")
 
-            next_frid, next_module = plain_module.get_next_frid(
-                partial_render.last_render_frid, partial_render.last_render_module.module_name
-            )
-            render_range = plain_spec.get_render_range_from(next_frid, next_module.plain_source)
-            msg = "Continue from"
-            if next_frid != plain_spec.get_first_frid(next_module.plain_source):
-                msg += f" functionality [#5593FF]{next_frid}[/]"
-            else:
-                msg += f" module [#5593FF]{next_module.module_name}[/]"
+    elif not partial_render.last_render_module.is_module_fully_rendered():
+        if not partial_render.last_render_frid:
+            raise ValueError("Last render FRID is not set for a non-initial module")
 
-            choices[str(choice_idx)] = PartialRenderChoice(
-                module=next_module,
-                render_range=render_range,
-                msg=msg,
-            )
-            choice_idx += 1
+        next_frid, next_module = plain_module.get_next_frid(
+            partial_render.last_render_frid, partial_render.last_render_module.module_name
+        )
+        render_range = plain_spec.get_render_range_from(next_frid, next_module.plain_source)
+        msg = "Continue from"
+        if next_frid != plain_spec.get_first_frid(next_module.plain_source):
+            msg += f" functionality [#5593FF]{next_frid}[/]"
+        else:
+            msg += f" module [#5593FF]{next_module.module_name}[/]"
+
+        choices[str(choice_idx)] = PartialRenderChoice(
+            module=next_module,
+            render_range=render_range if not force_render else None,
+            wipe_later_modules=force_render,
+            msg=msg,
+        )
+        choice_idx += 1
+
+    else:
+        next_module = plain_module.get_next_module(partial_render.last_render_module.module_name)
+        if next_module is None:
+            next_module = partial_render.last_render_module
+
+        choices[str(choice_idx)] = PartialRenderChoice(
+            module=next_module,
+            render_range=None,
+            msg=f"Start from module [#5593FF]{next_module.module_name}[/]",
+        )
+        choice_idx += 1
 
     if partial_render.change:
         all_affected_modules = list[str]()
@@ -163,19 +185,22 @@ def get_choices(plain_module: PlainModule, partial_render: PartialRender) -> dic
             module=partial_render.change,
             render_range=None,
             msg=f"Re-render all affected modules ([#5593FF]{', '.join(all_affected_modules)}[/])",
+            wipe_later_modules=True,
         )
         choice_idx += 1
 
-    first_module = plain_module.all_required_modules[0]
-    if first_module.module_name != partial_render.last_render_module.module_name and (
-        partial_render.change is not None and first_module.module_name != partial_render.change.module_name
-    ):
-        choices[str(choice_idx)] = PartialRenderChoice(
-            module=first_module,
-            render_range=None,
-            msg=f"Re-render from first module ([#5593FF]{first_module.module_name}[/])",
-        )
-        choice_idx += 1
+    if len(plain_module.all_required_modules) > 0:
+        first_module = plain_module.all_required_modules[0]
+        if first_module.module_name != partial_render.last_render_module.module_name and (
+            partial_render.change is not None and first_module.module_name != partial_render.change.module_name
+        ):
+            choices[str(choice_idx)] = PartialRenderChoice(
+                module=first_module,
+                render_range=None,
+                msg=f"Re-render from first module ([#5593FF]{first_module.module_name}[/])",
+                wipe_later_modules=True,
+            )
+            choice_idx += 1
 
     choices[str(choice_idx)] = PartialRenderChoice(module=None, render_range=None, msg="Quit")
 
diff --git a/plain2code.py b/plain2code.py
@@ -181,7 +181,7 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
     if render_range is None:
         partial_render = detect_partial_rendering(plain_module)
         if partial_render is not None:
-            choices = get_choices(plain_module, partial_render)
+            choices = get_choices(plain_module, partial_render, args.force_render)
             if len(choices) > 2:
                 app = PartialRenderTUI(
                     plain_module,
@@ -202,8 +202,8 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
                 # Last choice is Quit, first choice is the only other actionable choice
                 partial_render_choice = choices[list(choices.keys())[0]]
 
-    # We can't have both partial render choice and render range
-    assert not (partial_render_choice is not None and render_range is not None)
+    if partial_render_choice is not None and render_range is not None:
+        raise Exception("Partial rendering and render range cannot be used together")
 
     module_renderer = ModuleRenderer(
         codeplainAPI,
diff --git a/plain_modules.py b/plain_modules.py
@@ -2,13 +2,15 @@
 
 import json
 import os
+import shutil
 from functools import cached_property
 
 from git.exc import NoSuchPathError
 
 import git_utils
 import plain_file
 import plain_spec
+from plain2code_console import console
 from plain2code_exceptions import MissingPreviousFunctionalitiesError, ModuleDoesNotExistError
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 
@@ -68,7 +70,7 @@ def module_build_folder(self):
     def get_codeplain_folder(self):
         return os.path.join(self.module_build_folder, CODEPLAIN_METADATA_FOLDER)
 
-    def get_module_last_rendered_functionality(self) -> tuple[str | None, str | None]:
+    def get_module_render_status(self) -> tuple[str | None, str | None]:
         if len(self.required_modules) == 0:
             return git_utils.get_last_rendered_functionality(self.module_build_folder)
 
@@ -77,7 +79,7 @@ def get_module_last_rendered_functionality(self) -> tuple[str | None, str | None
             return module_name, frid
 
         for module in reversed(self.required_modules):
-            last_rendered_module_name, last_rendered_frid = module.get_module_last_rendered_functionality()
+            last_rendered_module_name, last_rendered_frid = module.get_module_render_status()
             if last_rendered_module_name is not None:
                 return last_rendered_module_name, last_rendered_frid
 
@@ -162,19 +164,12 @@ def get_hashes(self) -> dict[str, str]:
             hashes["required_modules_code_hash"] = self.required_modules[-1].get_module_code_hash()
         return hashes
 
-    def save_module_metadata(self, only_hashes: bool = False):
+    def save_module_metadata(self):
         codeplain_folder = self.get_codeplain_folder()
         os.makedirs(codeplain_folder, exist_ok=True)
 
         module_metadata = self.get_hashes()
-
         metadata_path = self.module_metadata_path()
-
-        if only_hashes:
-            with open(metadata_path, "w", encoding="utf-8") as f:
-                json.dump(module_metadata, f, indent=4)
-            return
-
         module_metadata[MODULE_FUNCTIONALITIES] = self._get_module_functional_requirements()
 
         required_modules_functionalities = {}
@@ -277,10 +272,7 @@ def ensure_previous_frid_commits_exist(self, render_range: list[str], render_con
         for prev_frid in previous_frids:
             self._ensure_frid_commit_exists(prev_frid, first_render_frid, render_conformance_tests)
 
-    def get_module_by_name(self, module_name: str) -> PlainModule:
-        if self.module_name == module_name:
-            return self
-
+    def get_required_module_by_name(self, module_name: str) -> PlainModule:
         for module in self.all_required_modules:
             if module.module_name == module_name:
                 return module
@@ -294,16 +286,22 @@ def get_next_module(self, module_name: str) -> PlainModule:
                 return all_modules[idx + 1]
 
         if module_name == self.module_name:
-            return self
+            return None
 
         raise ModuleDoesNotExistError(f"Module {module_name} does not exist")
 
     def get_next_frid(self, frid: str, module_name: str) -> tuple[str, PlainModule]:
-        module = self.get_module_by_name(module_name)
+        if module_name != self.module_name:
+            module = self.get_required_module_by_name(module_name)
+        else:
+            module = self
+
         next_frid = plain_spec.get_next_frid(module.plain_source, frid)
 
         if next_frid is None:
             next_module = self.get_next_module(module_name)
+            if next_module is None:
+                next_module = self
             return plain_spec.get_first_frid(next_module.plain_source), next_module
 
         return next_frid, module
@@ -335,3 +333,12 @@ def is_initial_module(self) -> bool:
             return True
 
         return False
+
+    def wipe_module(self) -> None:
+        if os.path.exists(self.module_build_folder):
+            console.warning(f"Wiping module {self.module_build_folder}...")
+            shutil.rmtree(self.module_build_folder)
+
+        if os.path.exists(self.module_conformance_tests_folder):
+            console.warning(f"Wiping conformance tests for module {self.module_conformance_tests_folder}...")
+            shutil.rmtree(self.module_conformance_tests_folder)
diff --git a/tests/test_partial_rendering.py b/tests/test_partial_rendering.py
@@ -6,16 +6,11 @@
 under test relies on: ``module_name``, ``required_modules``,
 ``all_required_modules``, ``load_module_metadata``, ``get_module_source_hash``,
 ``get_module_code_hash`` and (for ``detect_partial_rendering``)
-``get_module_last_rendered_functionality``.
+``get_module_render_status``.
 """
 
 import pytest
 
-# Import ``plain_file`` first — it pulls in ``file_utils`` which transitively
-# imports ``plain_modules``; starting the import graph at ``plain_file``
-# sidesteps a circular-import failure that occurs when tests import
-# ``partial_rendering`` (and therefore ``plain_modules``) first.
-import plain_file  # noqa: F401
 from partial_rendering import (
     PartialRender,
     code_change,
@@ -61,7 +56,7 @@ def get_module_source_hash(self):
     def get_module_code_hash(self):
         return self._code_hash
 
-    def get_module_last_rendered_functionality(self):
+    def get_module_render_status(self):
         return self._last_rendered
 
 
@@ -260,7 +255,7 @@ def test_detect_partial_rendering_raises_when_last_rendered_module_unknown():
 def test_detect_partial_rendering_spec_change_on_earlier_module_wins():
     """A spec change on an earlier (required) module is reported via
     ``change``/``change_type``; ``last_render_module`` and ``last_render_frid``
-    remain the ones reported by ``get_module_last_rendered_functionality``."""
+    remain the ones reported by ``get_module_render_status``."""
     root, middle, leaf = _build_fresh_tree(last_rendered=("middle", "1"))
     leaf._metadata = {"source_hash": "stale-leaf"}  # leaf's spec changed
 
diff --git a/tests/test_plain_modules.py b/tests/test_plain_modules.py
diff --git a/tui/partial_render_tui.py b/tui/partial_render_tui.py
