Bugfixing, refactoring and adding changed module to render from scratch

Author: zanjonke

git_utils.py

@@ -61,7 +61,10 @@ def _ensure_git_config(repo: Repo) -> None:
 
 
 def init_git_repo(
-    path_to_repo: Union[str, os.PathLike], module_name: Optional[str] = None, render_id: Optional[str] = None
+    path_to_repo: Union[str, os.PathLike],
+    module_name: Optional[str] = None,
+    render_id: Optional[str] = None,
+    additional_files: Optional[dict[str, str]] = None,
 ) -> Repo:
     """
     Initializes a new git repository in the given path.
@@ -75,6 +78,11 @@ def init_git_repo(
 
     repo = Repo.init(path_to_repo)
     _ensure_git_config(repo)
+
+    if additional_files:
+        file_utils.store_response_files(path_to_repo, additional_files, [])
+        repo.git.add(".")
+
     repo.git.commit(
         "--allow-empty", "-m", _get_full_commit_message(INITIAL_COMMIT_MESSAGE, module_name, None, render_id)
     )
@@ -83,9 +91,18 @@ def init_git_repo(
 
 
 def clone_repo(
-    source_repo_path: str, new_repo_path: str, module_name: Optional[str] = None, render_id: Optional[str] = None
+    source_repo_path: str,
+    new_repo_path: str,
+    module_name: Optional[str] = None,
+    render_id: Optional[str] = None,
+    additional_files: Optional[dict[str, str]] = None,
 ) -> Repo:
     repo = Repo.clone_from(source_repo_path, new_repo_path)
+
+    if additional_files:
+        file_utils.store_response_files(new_repo_path, additional_files, [])
+        repo.git.add(".")
+
     repo.git.commit(
         "--allow-empty", "-m", _get_full_commit_message(INITIAL_COMMIT_MESSAGE, module_name, None, render_id)
     )

module_renderer.py

@@ -47,10 +47,7 @@ def _build_render_context_for_module(
         return RenderContext(
             self.codeplainAPI,
             memory_manager,
-            plain_module.module_name,
-            plain_module.plain_source,
-            plain_module.all_required_modules,
-            plain_module.template_dirs,
+            plain_module,
             build_folder=os.path.join(self.args.build_folder, plain_module.module_name),
             build_dest=self.args.build_dest,
             conformance_tests_folder=self.args.conformance_tests_folder,
@@ -94,19 +91,19 @@ def _render_module(
 
                 if rendering_failed:
                     return False, True
-        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))
+            (
+                (not force_render)
+                or any(module.module_name == plain_module.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
 
+        # plain_module.save_module_metadata(only_hashes=True)
+
         memory_manager = MemoryManager(
             self.codeplainAPI,
             os.path.join(

partial_rendering.py

@@ -1,15 +1,16 @@
 from dataclasses import dataclass
 
+import plain_spec
 from plain2code_exceptions import ModuleDoesNotExistError
 from plain_modules import PlainModule
 
 
 @dataclass
 class PartialRender:
-    module: PlainModule
-    frid: str | None = None
-    spec_change: bool = False
-    code_change: bool = False
+    last_render_module: PlainModule
+    last_render_frid: str | None
+    change: PlainModule | None = None
+    change_type: str | None = None
 
 
 @dataclass
@@ -55,13 +56,14 @@ def code_change(plain_module: PlainModule) -> PlainModule | None:
             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
+    if len(plain_module.required_modules) > 0:
+        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
 
@@ -94,31 +96,38 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
         if required_module.module_name == last_rendered_module:
             module = required_module
 
+    if last_rendered_module == plain_module.module_name:
+        if (
+            last_rendered_frid is None
+            or plain_spec.get_next_frid(plain_module.plain_source, last_rendered_frid) is not None
+        ):
+            module = plain_module
+        else:
+            return None
+
     if module is None:
         raise ModuleDoesNotExistError(
-            f"Last rendered module {last_rendered_module} not found in {all_required_modules}"
+            f"Last rendered module {last_rendered_module} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
         )
 
     pr = PartialRender(
-        module=module,
-        frid=last_rendered_frid,
-        spec_change=False,
-        code_change=False,
+        last_render_module=module,
+        last_render_frid=last_rendered_frid,
+        change=None,
+        change_type=None,
     )
 
     if sc is None and cc is None:
         return pr
 
-    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
+    if sc is not None:
+        pr.change = sc
+        pr.change_type = "spec_change"
+
+    if cc is not None and (
+        pr.change is None or (pr.change is not None and module_comes_before(all_required_modules, cc, pr.change))
+    ):
+        pr.change = cc
+        pr.change_type = "code_change"
 
     return pr

plain_modules.py

@@ -141,33 +141,40 @@ def _get_module_functional_requirements(self) -> list[str]:
         return module_functional_requirements
 
     def get_functionalities(self) -> dict[str, list[str]]:
-        module_metadata = self.load_module_metadata()
-        if module_metadata is None:
-            raise ModuleDoesNotExistError(f"Module {self.module_name} does not exist or has no metadata.")
-
-        if REQUIRED_MODULES_FUNCTIONALITIES in module_metadata:
-            functionalities = module_metadata[REQUIRED_MODULES_FUNCTIONALITIES]
-        else:
-            functionalities = {}
+        functionalities = {}
+        for required_module in self.required_modules:
+            functionalities.update(required_module.get_functionalities())
 
-        functionalities[self.module_name] = module_metadata[MODULE_FUNCTIONALITIES]
+        functionalities[self.module_name] = self._get_module_functional_requirements()
 
         return functionalities
 
-    def save_module_metadata(
-        self,
-    ):
+    def module_metadata_path(self, for_git_repo: bool = False) -> str:
+        if for_git_repo:
+            return os.path.join(CODEPLAIN_METADATA_FOLDER, MODULE_METADATA_FILENAME)
+
+        return os.path.join(self.get_codeplain_folder(), MODULE_METADATA_FILENAME)
+
+    def get_hashes(self) -> dict[str, str]:
+        hashes = {"source_hash": self.get_module_source_hash()}
+        if len(self.required_modules) > 0:
+            hashes["required_modules_code_hash"] = self.required_modules[-1].get_module_code_hash()
+        return hashes
+
+    def save_module_metadata(self, only_hashes: bool = False):
         codeplain_folder = self.get_codeplain_folder()
         os.makedirs(codeplain_folder, exist_ok=True)
 
-        module_metadata = {
-            "source_hash": self.get_module_source_hash(),
-            MODULE_FUNCTIONALITIES: self._get_module_functional_requirements(),
-        }
+        module_metadata = self.get_hashes()
+
+        metadata_path = self.module_metadata_path()
 
-        if self.required_modules is not None and len(self.required_modules) > 0:
-            previous_module = self.required_modules[-1]
-            module_metadata["required_modules_code_hash"] = previous_module.get_module_code_hash()
+        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 = {}
         for required_module in self.required_modules:
@@ -176,7 +183,6 @@ def save_module_metadata(
         if required_modules_functionalities:
             module_metadata[REQUIRED_MODULES_FUNCTIONALITIES] = required_modules_functionalities
 
-        metadata_path = os.path.join(codeplain_folder, MODULE_METADATA_FILENAME)
         with open(metadata_path, "w", encoding="utf-8") as f:
             json.dump(module_metadata, f, indent=4)
 

render_machine/actions/prepare_repositories.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any
 
 import file_utils
@@ -33,6 +34,11 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                 )
 
         else:
+            module_hashes = render_context.plain_module.get_hashes()
+            additional_files = {
+                render_context.plain_module.module_metadata_path(for_git_repo=True): json.dumps(module_hashes)
+            }
+
             if render_context.required_modules:
                 previous_module = render_context.required_modules[-1]
                 if render_context.verbose:
@@ -44,13 +50,17 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                     render_context.build_folder,
                     render_context.module_name,
                     render_context.run_state.render_id,
+                    additional_files,
                 )
             else:
                 if render_context.verbose:
                     console.debug("Initializing git repositories for the render folders.")
 
                 git_utils.init_git_repo(
-                    render_context.build_folder, render_context.module_name, render_context.run_state.render_id
+                    render_context.build_folder,
+                    render_context.module_name,
+                    render_context.run_state.render_id,
+                    additional_files,
                 )
 
                 if render_context.base_folder:
@@ -68,6 +78,7 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                     render_context.conformance_tests.get_module_conformance_tests_folder(render_context.module_name),
                     render_context.module_name,
                     render_context.run_state.render_id,
+                    additional_files,
                 )
 
         return self.SUCCESSFUL_OUTCOME, None

render_machine/render_context.py

@@ -33,10 +33,7 @@ def __init__(
         self,
         codeplain_api,
         memory_manager,
-        module_name: str,
-        plain_source_tree: dict,
-        required_modules: list[PlainModule],
-        template_dirs: list[str],
+        plain_module: PlainModule,
         build_folder: str,
         build_dest: str,
         conformance_tests_folder: str,
@@ -58,10 +55,11 @@ def __init__(
     ):
         self.codeplain_api: CodeplainAPI = codeplain_api
         self.memory_manager = memory_manager
-        self.plain_source_tree = plain_source_tree
-        self.module_name = module_name
-        self.template_dirs = template_dirs
-        self.required_modules = required_modules
+        self.plain_module = plain_module
+        self.plain_source_tree = plain_module.plain_source
+        self.module_name = plain_module.module_name
+        self.template_dirs = plain_module.template_dirs
+        self.required_modules = plain_module.required_modules
         self.build_folder = build_folder
         self.build_dest = build_dest
         self.conformance_tests_folder = conformance_tests_folder
@@ -84,8 +82,8 @@ def __init__(
         self.test_script_timeout = test_script_timeout
 
         resources_list = []
-        plain_spec.collect_linked_resources(plain_source_tree, resources_list, None, True)
-        self.all_linked_resources = file_utils.load_linked_resources(template_dirs, resources_list)
+        plain_spec.collect_linked_resources(self.plain_source_tree, resources_list, None, True)
+        self.all_linked_resources = file_utils.load_linked_resources(self.template_dirs, resources_list)
 
         # Initialize context objects
         self.frid_context: Optional[FridContext] = None
@@ -130,6 +128,7 @@ def create_snapshot(self) -> RenderContextSnapshot:
         )
 
     def get_required_modules_functionalities(self):
+        print(f"Getting required modules functionalities for {self.module_name}...")
         required_modules_functionalities = {}
         if self.required_modules is not None and len(self.required_modules) > 0:
             for required_module in self.required_modules: