Cleanup and bugfixing

Author: zanjonke

file_utils.py

@@ -239,15 +239,17 @@ def load_linked_resources(template_dirs: list[str], resources_list):
         content = open_from(template_dirs, file_name)
 
         if content is None:
-            raise FileNotFoundError(f"""
+            raise FileNotFoundError(
+                f"""
                 Resource file {file_name} not found. Resource files are searched in the following order (highest to lowest precedence):
 
                 1. The directory containing your .plain file
                 2. The directory specified by --template-dir (if provided)
                 3. The built-in 'standard_template_library' directory
 
                 Please ensure that the resource exists in one of these locations, or specify the correct --template-dir if using custom templates.
-                """)
+                """
+            )
 
         linked_resources[file_name] = content
 

git_utils.py

@@ -429,6 +429,8 @@ def get_last_finished_frid(repo_path: Union[str, os.PathLike]) -> tuple[Optional
     if not commit_sha:
         return None, None
     commit_message = repo.commit(commit_sha).message
+    if isinstance(commit_message, bytes):
+        commit_message = commit_message.decode("utf-8")
     match = re.search(r"FRID\):(\S+) fully implemented", commit_message)
     frid = match.group(1) if match else None
 

module_renderer.py

@@ -2,16 +2,11 @@
 import os
 import threading
 
-import git_utils
-import plain_file
-import plain_modules
-import plain_spec
 from event_bus import EventBus
 from memory_management import MemoryManager
 from partial_rendering import PartialRenderChoice
 from plain2code_console import console
 from plain2code_events import RenderCompleted, RenderFailed
-from plain2code_exceptions import MissingPreviousFunctionalitiesError
 from plain2code_state import RunState
 from plain_modules import PlainModule
 from render_machine.code_renderer import CodeRenderer
@@ -78,7 +73,7 @@ def _build_render_context_for_module(
 
     def _render_module(
         self, plain_module: PlainModule, render_range: list[str] | None, force_render: bool
-    ) -> tuple[bool, list[PlainModule], bool]:
+    ) -> tuple[bool, bool]:
         """Render a module.
 
         Returns:
@@ -99,14 +94,16 @@ def _render_module(
 
                 if rendering_failed:
                     return False, True
-
-        if not (
-            force_render
-            or any(module.filename == plain_module.filename for module in self.loaded_modules)
-            or plain_module.get_repo() is None
-            or (plain_module.has_plain_spec_changed() or False)
-            or (plain_module.has_required_modules_code_changed() or False)
-            or has_any_required_module_changed
+        console.debug(f"{plain_module.module_name=}, {force_render=}, {has_any_required_module_changed=}")
+        console.debug(
+            f"{plain_module.get_repo()=}, {plain_module.has_plain_spec_changed()=}, {plain_module.has_required_modules_code_changed()=}"
+        )
+        if (
+            ((not force_render) or any(module.name == plain_module.name for module in self.loaded_modules))
+            and plain_module.get_repo() is not None
+            and not plain_module.has_plain_spec_changed()
+            and not plain_module.has_required_modules_code_changed()
+            and not has_any_required_module_changed
         ):
             return False, False
 
@@ -145,7 +142,7 @@ def _render_module(
 
     def render_module(self) -> None:
         self.loaded_modules = list[PlainModule]()
-        if self.partial_render_choice is not None:
+        if self.partial_render_choice is not None and self.partial_render_choice.module is not None:
             self._render_module(self.partial_render_choice.module, self.partial_render_choice.render_range, True)
 
         _, rendering_failed = self._render_module(self.plain_module, self.render_range, True)

partial_rendering.py

@@ -1,11 +1,12 @@
 from dataclasses import dataclass
 
+from plain2code_exceptions import ModuleDoesNotExistError
 from plain_modules import PlainModule
 
 
 @dataclass
 class PartialRender:
-    module: PlainModule | None = None
+    module: PlainModule
     frid: str | None = None
     spec_change: bool = False
     code_change: bool = False
@@ -19,34 +20,58 @@ class PartialRenderChoice:
 
 
 def spec_change(plain_module: PlainModule) -> PlainModule | None:
-    if len(plain_module.required_modules) == 0:
-        return plain_module if plain_module.has_plain_spec_changed() else None
-
-    for required_module in plain_module.required_modules:
-        sc = spec_change(required_module)
-        if sc is not None:
-            return sc
-
-    return plain_module if plain_module.has_plain_spec_changed() else None
+    for required_module in plain_module.all_required_modules:
+        module_metadata = required_module.load_module_metadata()
+        if (
+            module_metadata
+            and "source_hash" in module_metadata
+            and module_metadata["source_hash"] != required_module.get_module_source_hash()
+        ):
+            return required_module
+
+    module_metadata = plain_module.load_module_metadata()
+    if (
+        module_metadata
+        and "source_hash" in module_metadata
+        and module_metadata["source_hash"] != plain_module.get_module_source_hash()
+    ):
+        return plain_module
+
+    return None
 
 
 def code_change(plain_module: PlainModule) -> PlainModule | None:
-    if len(plain_module.required_modules) == 0:
-        return plain_module if plain_module.has_required_modules_code_changed() else None
-
-    for required_module in plain_module.required_modules:
-        cc = code_change(required_module)
-        if cc is not None:
-            return cc
-
-    return plain_module if plain_module.has_required_modules_code_changed() else None
+    for required_module in plain_module.all_required_modules:
+        if len(required_module.required_modules) == 0:
+            continue
+
+        module_metadata = required_module.load_module_metadata()
+        previous_module = required_module.required_modules[-1]
+        if (
+            module_metadata
+            and "required_modules_code_hash" in module_metadata
+            and module_metadata["required_modules_code_hash"] != previous_module.get_module_code_hash()
+        ):
+            return required_module
+
+    module_metadata = plain_module.load_module_metadata()
+    previous_module = plain_module.required_modules[-1]
+    if (
+        module_metadata
+        and "required_modules_code_hash" in module_metadata
+        and module_metadata["required_modules_code_hash"] != previous_module.get_module_code_hash()
+    ):
+        return plain_module
+
+    return None
 
 
 def module_comes_before(
     all_required_modules: list[PlainModule],
     module1: PlainModule,
     module2: PlainModule,
 ) -> bool:
+
     for module in all_required_modules:
         if module.module_name == module1.module_name:
             return True
@@ -69,6 +94,11 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
         if required_module.module_name == last_rendered_module:
             module = required_module
 
+    if module is None:
+        raise ModuleDoesNotExistError(
+            f"Last rendered module {last_rendered_module} not found in {all_required_modules}"
+        )
+
     pr = PartialRender(
         module=module,
         frid=last_rendered_frid,
@@ -79,17 +109,16 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
     if sc is None and cc is None:
         return pr
 
-    if sc is not None:
-        if module_comes_before(all_required_modules, sc, pr.module):
-            pr.module = sc
-            pr.spec_change = True
-            pr.frid = None
-
-    if cc is not None:
-        if module_comes_before(all_required_modules, cc, pr.module):
-            pr.module = cc
-            pr.code_change = True
-            pr.spec_change = False
-            pr.frid = None
+    if sc is not None and module_comes_before(all_required_modules, sc, pr.module):
+        pr.module = sc
+        pr.spec_change = True
+        pr.code_change = False
+        pr.frid = None
+
+    if cc is not None and module_comes_before(all_required_modules, cc, pr.module):
+        pr.module = cc
+        pr.code_change = True
+        pr.spec_change = False
+        pr.frid = None
 
     return pr

plain_modules.py

@@ -112,23 +112,23 @@ def has_required_modules_code_changed(
         self,
     ) -> bool:
         if self.required_modules is None or len(self.required_modules) == 0:
-            return None
+            return False
 
         module_metadata = self.load_module_metadata()
 
         if not module_metadata or "required_modules_code_hash" not in module_metadata:
-            return None
+            return True
 
         previous_module = self.required_modules[-1]
         return module_metadata["required_modules_code_hash"] != previous_module.get_module_code_hash()
 
     def has_plain_spec_changed(self) -> bool:
         module_metadata = self.load_module_metadata()
         if not module_metadata:
-            return None
+            return True
 
         if "source_hash" not in module_metadata:
-            return None
+            return True
 
         return module_metadata["source_hash"] != self.get_module_source_hash()
 
@@ -282,7 +282,7 @@ def get_next_module(self, module_name: str) -> PlainModule | None:
             if module.module_name == module_name and idx < len(self.all_required_modules) - 1:
                 return self.all_required_modules[idx + 1]
 
-        return None
+        return self
 
     def get_next_frid(self, frid: str, module_name: str) -> tuple[str, PlainModule]:
         module = self.get_module_by_name(module_name)