codeplain 0.1.0__py3-none-any.whl

render_machine/actions/render_functional_requirement.py

@@ -0,0 +1,69 @@
+from typing import Any
+
+import file_utils
+import render_machine.render_utils as render_utils
+from plain2code_console import console
+from plain2code_exceptions import FunctionalRequirementTooComplex
+from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_context import RenderContext
+
+MAX_CODE_GENERATION_RETRIES = 2
+
+
+class RenderFunctionalRequirement(BaseAction):
+    SUCCESSFUL_OUTCOME = "code_and_unit_tests_generated"
+    FUNCTIONAL_REQUIREMENT_TOO_COMPLEX_OUTCOME = "functional_requirement_too_complex"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        render_utils.revert_uncommitted_changes(render_context)
+        existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(render_context)
+
+        if render_context.args.verbose:
+            msg = f"Rendering functional requirement {render_context.frid_context.frid}"
+            if render_context.frid_context.functional_requirement_render_attempts > 1:
+                msg += f", attempt number {render_context.frid_context.functional_requirement_render_attempts}/{MAX_CODE_GENERATION_RETRIES}."
+            msg += f"\n[b]{render_context.frid_context.functional_requirement_text}[/b]"
+            console.info("\n-------------------------------------")
+            console.info(msg)
+            console.info("-------------------------------------\n")
+
+        try:
+            if render_context.args.verbose:
+                render_utils.print_inputs(
+                    render_context, existing_files_content, "Files sent as input to code generation:"
+                )
+
+            with console.status(
+                f"[{console.INFO_STYLE}]Generating functional requirement {render_context.frid_context.frid}...\n"
+            ):
+                response_files = render_context.codeplain_api.render_functional_requirement(
+                    render_context.frid_context.frid,
+                    render_context.plain_source_tree,
+                    render_context.frid_context.linked_resources,
+                    existing_files_content,
+                    render_context.run_state,
+                )
+        except FunctionalRequirementTooComplex as e:
+            error_message = f"The functional requirement:\n[b]{render_context.frid_context.functional_requirement_text}[/b]\n is too complex to be implemented. Please break down the functional requirement into smaller parts ({str(e)})."
+            if e.proposed_breakdown:
+                error_message += "\nProposed breakdown:"
+                for _, part in e.proposed_breakdown.items():
+                    error_message += f"\n  - {part}"
+
+            return self.FUNCTIONAL_REQUIREMENT_TOO_COMPLEX_OUTCOME, error_message
+
+        _, changed_files = file_utils.update_build_folder_with_rendered_files(
+            render_context.args.build_folder, existing_files, response_files
+        )
+        render_context.frid_context.changed_files.update(changed_files)
+
+        if render_context.args.verbose:
+            console.print_files(
+                "Files generated or updated:",
+                render_context.args.build_folder,
+                response_files,
+                style=console.OUTPUT_STYLE,
+            )
+
+        return self.SUCCESSFUL_OUTCOME, None

render_machine/actions/run_conformance_tests.py

@@ -0,0 +1,44 @@
+from typing import Any
+
+import render_machine.render_utils as render_utils
+from plain2code_console import console
+from render_machine.actions.base_action import BaseAction
+from render_machine.conformance_test_helpers import ConformanceTestHelpers
+from render_machine.render_context import RenderContext
+
+UNRECOVERABLE_ERROR_EXIT_CODES = [69]
+
+
+class RunConformanceTests(BaseAction):
+
+    SUCCESSFUL_OUTCOME = "conformance_tests_passed"
+    FAILED_OUTCOME = "conformance_tests_failed"
+    UNRECOVERABLE_ERROR_OUTCOME = "unrecoverable_error_occurred"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        conformance_tests_folder_name = ConformanceTestHelpers.get_current_conformance_test_folder_name(
+            render_context.conformance_tests_running_context  # type: ignore
+        )
+
+        if render_context.args.verbose:
+            console.info(
+                f"\n[b]Running conformance tests script {render_context.args.conformance_tests_script} for {conformance_tests_folder_name} (functional requirement {render_context.conformance_tests_running_context.current_testing_frid}).[/b]"
+            )
+        exit_code, conformance_tests_issue = render_utils.execute_script(
+            render_context.args.conformance_tests_script,
+            [render_context.args.build_folder, conformance_tests_folder_name],
+            render_context.args.verbose,
+            "Conformance Tests",
+        )
+
+        if exit_code == 0:
+            return self.SUCCESSFUL_OUTCOME, None
+
+        if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:
+            console.error(conformance_tests_issue)
+            return (
+                self.UNRECOVERABLE_ERROR_OUTCOME,
+                {"previous_conformance_tests_issue": conformance_tests_issue},
+            )
+
+        return self.FAILED_OUTCOME, {"previous_conformance_tests_issue": conformance_tests_issue}

render_machine/actions/run_unit_tests.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import render_machine.render_utils as render_utils
+from plain2code_console import console
+from render_machine.actions.base_action import BaseAction
+from render_machine.render_context import RenderContext
+
+UNRECOVERABLE_ERROR_EXIT_CODES = [69]
+
+
+class RunUnitTests(BaseAction):
+    SUCCESSFUL_OUTCOME = "unit_tests_succeeded"
+    FAILED_OUTCOME = "unit_tests_failed"
+    UNRECOVERABLE_ERROR_OUTCOME = "unrecoverable_error_occurred"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        if render_context.args.verbose:
+            console.info(
+                f"[b]Running unit tests script {render_context.args.unittests_script}.[/b] (attempt: {render_context.unit_tests_running_context.fix_attempts + 1})"
+            )
+        exit_code, unittests_issue = render_utils.execute_script(
+            render_context.args.unittests_script,
+            [render_context.args.build_folder],
+            render_context.args.verbose,
+            "Unit Tests",
+        )
+
+        if exit_code == 0:
+            return self.SUCCESSFUL_OUTCOME, None
+
+        elif exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:
+            console.error(unittests_issue)
+            return (
+                self.UNRECOVERABLE_ERROR_OUTCOME,
+                "Unit tests script failed due to problems in the environment setup. Please check the your environment or update the script for running unittests.",
+            )
+        else:
+            return self.FAILED_OUTCOME, {"previous_unittests_issue": unittests_issue}

render_machine/actions/summarize_conformance_tests.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from plain2code_console import console
+from render_machine.actions.base_action import BaseAction
+from render_machine.conformance_test_helpers import ConformanceTestHelpers
+from render_machine.render_context import RenderContext
+
+
+class SummarizeConformanceTests(BaseAction):
+    SUCCESSFUL_OUTCOME = "conformance_tests_summarized"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        console.info(f"Summarizing conformance tests for functional requirement {render_context.frid_context.frid}.")
+
+        _, existing_conformance_test_files_content = ConformanceTestHelpers.fetch_existing_conformance_test_files(
+            render_context.conformance_tests_running_context  # type: ignore
+        )
+
+        with console.status(
+            f"[{console.INFO_STYLE}]Summarizing finished conformance tests for functional requirement {render_context.frid_context.frid}...\n"
+        ):
+            summary = render_context.codeplain_api.summarize_finished_conformance_tests(
+                frid=render_context.frid_context.frid,
+                plain_source_tree=render_context.plain_source_tree,
+                linked_resources=render_context.frid_context.linked_resources,
+                conformance_test_files_content=existing_conformance_test_files_content,
+                run_state=render_context.run_state,
+            )
+
+        ConformanceTestHelpers.set_current_conformance_tests_summary(
+            render_context.conformance_tests_running_context, summary  # type: ignore
+        )
+
+        return self.SUCCESSFUL_OUTCOME, None

render_machine/code_renderer.py

@@ -0,0 +1,50 @@
+from transitions.extensions.diagrams import HierarchicalGraphMachine
+
+from plain2code_state import RunState
+from render_machine.render_context import RenderContext
+from render_machine.state_machine_config import StateMachineConfig, States
+
+
+class CodeRenderer:
+    """Main code renderer class that orchestrates the code generation workflow using a hierarchical state machine."""
+
+    def __init__(self, codeplain_api, plain_source_tree: dict, args: dict, run_state: RunState):
+        self.render_context = RenderContext(codeplain_api, plain_source_tree, args, run_state)
+        self.state_machine_config = StateMachineConfig()
+
+        # Initialize the state machine
+        states = self.state_machine_config.get_states(self.render_context)
+        transitions = self.state_machine_config.get_transitions()
+
+        self.machine = HierarchicalGraphMachine(
+            model=self.render_context,
+            states=states,
+            transitions=transitions,
+            initial=States.RENDER_INITIALISED.value,
+        )
+        self.render_context.set_machine(self.machine)
+
+        # Get action mappings
+        self.action_map = self.state_machine_config.get_action_map()
+        self.action_result_triggers_map = self.state_machine_config.get_action_result_triggers_map()
+
+    def run(self):
+        """Execute the main rendering workflow."""
+        previous_action_payload = None
+        while True:
+            outcome, previous_action_payload = self.action_map[self.render_context.state].execute(
+                self.render_context, previous_action_payload
+            )
+
+            if self.render_context.state in [
+                States.RENDER_FAILED.value,
+                States.RENDER_COMPLETED.value,
+            ]:
+                break
+
+            next_trigger = self.action_result_triggers_map[outcome]
+            self.machine.dispatch(next_trigger)
+
+    def generate_render_machine_graph(self):
+        """Generate a visual diagram of the state machine."""
+        self.render_context.get_graph().draw("render_machine_diagram.png", prog="dot")

render_machine/conformance_test_helpers.py

@@ -0,0 +1,68 @@
+import os
+from typing import Optional
+
+import file_utils
+import plain_spec
+from render_machine.render_types import ConformanceTestsRunningContext
+
+
+class ConformanceTestHelpers:
+    @staticmethod
+    def fetch_existing_conformance_test_folder_names(conformance_tests_folder: str):
+        if os.path.isdir(conformance_tests_folder):
+            existing_folder_names = file_utils.list_folders_in_directory(conformance_tests_folder)
+        else:
+            # This happens if we're rendering the first FRID (without previously created conformance tests)
+            existing_folder_names = []
+        return existing_folder_names
+
+    @staticmethod
+    def fetch_existing_conformance_test_files(conformance_tests_running_context: ConformanceTestsRunningContext):
+        conformance_test_folder_name = ConformanceTestHelpers.get_current_conformance_test_folder_name(
+            conformance_tests_running_context
+        )
+        existing_conformance_test_files = file_utils.list_all_text_files(conformance_test_folder_name)
+        existing_conformance_test_files_content = file_utils.get_existing_files_content(
+            conformance_test_folder_name, existing_conformance_test_files
+        )
+        return existing_conformance_test_files, existing_conformance_test_files_content
+
+    @staticmethod
+    def current_conformance_tests_exist(conformance_tests_running_context: ConformanceTestsRunningContext) -> bool:
+        return (
+            conformance_tests_running_context.conformance_tests_json.get(
+                conformance_tests_running_context.current_testing_frid
+            )
+            is not None
+        )
+
+    @staticmethod
+    def get_current_conformance_test_folder_name(
+        conformance_tests_running_context: ConformanceTestsRunningContext,
+    ) -> str:
+        return conformance_tests_running_context.conformance_tests_json[
+            conformance_tests_running_context.current_testing_frid
+        ]["folder_name"]
+
+    @staticmethod
+    def get_current_acceptance_tests(
+        conformance_tests_running_context: ConformanceTestsRunningContext,
+    ) -> Optional[list[str]]:
+        if (
+            plain_spec.ACCEPTANCE_TESTS
+            in conformance_tests_running_context.conformance_tests_json[
+                conformance_tests_running_context.current_testing_frid
+            ]
+        ):
+            return conformance_tests_running_context.conformance_tests_json[
+                conformance_tests_running_context.current_testing_frid
+            ][plain_spec.ACCEPTANCE_TESTS]
+        return None
+
+    @staticmethod
+    def set_current_conformance_tests_summary(
+        conformance_tests_running_context: ConformanceTestsRunningContext, summary: list[dict]
+    ):
+        conformance_tests_running_context.conformance_tests_json[
+            conformance_tests_running_context.current_testing_frid
+        ]["test_summary"] = summary

render_machine/implementation_code_helpers.py

@@ -0,0 +1,20 @@
+import file_utils
+import git_utils
+import plain_spec
+from render_machine.render_context import RenderContext
+
+
+class ImplementationCodeHelpers:
+    @staticmethod
+    def fetch_existing_files(render_context: RenderContext):
+        existing_files = file_utils.list_all_text_files(render_context.args.build_folder)
+        existing_files_content = file_utils.get_existing_files_content(render_context.args.build_folder, existing_files)
+        return existing_files, existing_files_content
+
+    @staticmethod
+    def get_code_diff(render_context: RenderContext):
+        previous_frid_code_diff = git_utils.diff(
+            render_context.args.build_folder,
+            plain_spec.get_previous_frid(render_context.plain_source_tree, render_context.frid_context.frid),
+        )
+        return previous_frid_code_diff

render_machine/render_context.py

@@ -0,0 +1,280 @@
+from typing import Optional
+
+import file_utils
+import git_utils
+import plain_spec
+from codeplain_REST_api import CodeplainAPI
+from plain2code_console import console
+from plain2code_state import CONFORMANCE_TESTS_DEFINITION_FILE_NAME, ConformanceTestsUtils, RunState
+from render_machine import triggers
+from render_machine.conformance_test_helpers import ConformanceTestHelpers
+from render_machine.render_types import ConformanceTestsRunningContext, FridContext, UnitTestsRunningContext
+
+DEFAULT_TEMPLATE_DIRS = "standard_template_library"
+
+MAX_UNITTEST_FIX_ATTEMPTS = 20
+MAX_CODE_GENERATION_RETRIES = 2
+MAX_CONFORMANCE_TEST_RERENDER_ATTEMPTS = 1
+MAX_REFACTORING_ITERATIONS = 5
+MAX_CONFORMANCE_TEST_FIX_ATTEMPTS = 20
+MAX_FUNCTIONAL_REQUIREMENT_RENDER_ATTEMPTS_FAILED_UNIT_DURING_CONFORMANCE_TESTS = 2
+
+
+class RenderContext:
+    def __init__(self, codeplain_api, plain_source_tree: dict, args: dict, run_state: RunState):
+        self.codeplain_api: CodeplainAPI = codeplain_api
+        self.plain_source_tree = plain_source_tree
+        self.args = args
+        self.run_state = run_state
+        self.starting_frid = None
+
+        template_dirs = file_utils.get_template_directories(args.filename, args.template_dir, DEFAULT_TEMPLATE_DIRS)
+        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)
+
+        # Initialize context objects
+        self.frid_context: Optional[FridContext] = None
+        self.unit_tests_running_context: Optional[UnitTestsRunningContext] = None
+        self.conformance_tests_running_context: Optional[ConformanceTestsRunningContext] = None
+        # Constants that should remain for a single frid, but possible over multiple rerenderings of the same frid
+        self.functional_requirements_render_attempts_failed_unit_during_conformance_tests = 0
+        # Initialize conformance tests utilities
+        self.conformance_tests_utils = ConformanceTestsUtils(
+            conformance_tests_folder=args.conformance_tests_folder,
+            conformance_tests_definition_file_name=CONFORMANCE_TESTS_DEFINITION_FILE_NAME,
+            verbose=args.verbose,
+        )
+
+        self.machine = None
+
+    def set_machine(self, machine):
+        self.machine = machine
+
+    def start_implementing_frid(self):
+        if self.starting_frid is not None:
+            frid = self.starting_frid
+            self.starting_frid = None
+        elif self.frid_context is None:
+            frid = plain_spec.get_first_frid(self.plain_source_tree)
+        else:
+            frid = plain_spec.get_next_frid(self.plain_source_tree, self.frid_context.frid)
+
+        if frid is None:
+            # If frid context is empty, it means that all frids have been implemented
+            self.frid_context = None
+            self.machine.dispatch(triggers.PREPARE_FINAL_OUTPUT)
+            return
+
+        specifications, _ = plain_spec.get_specifications_for_frid(self.plain_source_tree, frid)
+        functional_requirement_text = specifications[plain_spec.FUNCTIONAL_REQUIREMENTS][-1]
+
+        resources_list = []
+        plain_spec.collect_linked_resources(self.plain_source_tree, resources_list, None, True, frid)
+
+        linked_resources = {}
+        for resource in resources_list:
+            linked_resources[resource["target"]] = self.all_linked_resources[resource["target"]]
+
+        self.frid_context = FridContext(
+            frid=frid,
+            specifications=specifications,
+            functional_requirement_text=functional_requirement_text,
+            linked_resources=linked_resources,
+            functional_requirement_render_attempts=0,
+        )
+
+    def check_frid_iteration_limit(self):
+        # If frid context is not set, it means that all frids have been implemented
+        if self.frid_context is None:
+            return
+
+        if self.frid_context.functional_requirement_render_attempts >= MAX_CODE_GENERATION_RETRIES:
+            console.error(
+                f"Unittests could not be fixed after rendering the functional requirement {self.frid_context.frid} for the {MAX_CODE_GENERATION_RETRIES} times."
+            )
+            self.machine.dispatch(triggers.HANDLE_ERROR)
+
+        self.frid_context.functional_requirement_render_attempts += 1
+
+        if self.frid_context.functional_requirement_render_attempts > 1:
+            # this if is intended just for logging
+            console.info(
+                f"Unittests could not be fixed after rendering the functional requirement. "
+                f"Restarting rendering the functional requirement {self.frid_context.frid} from scratch."
+            )
+
+    def finish_implementing_frid(self):
+        self.functional_requirements_render_attempts_failed_unit_during_conformance_tests = 0
+        pass
+
+    def start_unittests_processing(self):
+        self.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
+        self.run_state.increment_unittest_batch_id()
+
+    def start_unittests_processing_in_conformance_tests(self):
+        self.start_unittests_processing()
+        # set to first FRID
+        self.conformance_tests_running_context.current_testing_frid = plain_spec.get_first_frid(self.plain_source_tree)
+
+    def finish_unittests_processing(self):
+        existing_files = file_utils.list_all_text_files(self.args.build_folder)
+
+        # TODO: Double check if this logic is what we want
+        for file_name in self.unit_tests_running_context.changed_files:
+            if file_name not in existing_files:
+                self.frid_context.changed_files.discard(file_name)
+            else:
+                self.frid_context.changed_files.add(file_name)
+        self.unit_tests_running_context.fix_attempts = 1
+
+    def start_fixing_unit_tests(self):
+        self.unit_tests_running_context.fix_attempts += 1
+
+        if self.unit_tests_running_context.fix_attempts > MAX_UNITTEST_FIX_ATTEMPTS:
+            self.machine.dispatch(triggers.RESTART_FRID_PROCESSING)
+
+    def start_fixing_unit_tests_in_conformance_tests(self):
+        self.unit_tests_running_context.fix_attempts += 1
+
+        if self.unit_tests_running_context.fix_attempts > MAX_UNITTEST_FIX_ATTEMPTS:
+            self.functional_requirements_render_attempts_failed_unit_during_conformance_tests += 1
+            if (
+                self.functional_requirements_render_attempts_failed_unit_during_conformance_tests
+                >= MAX_FUNCTIONAL_REQUIREMENT_RENDER_ATTEMPTS_FAILED_UNIT_DURING_CONFORMANCE_TESTS
+            ):
+                console.error(
+                    f"Failed to adjust unit tests after implementation code was update while fixing conformance tests for functional requirement {self.frid_context.frid} for the {MAX_FUNCTIONAL_REQUIREMENT_RENDER_ATTEMPTS_FAILED_UNIT_DURING_CONFORMANCE_TESTS} times."
+                )
+                self.machine.dispatch(triggers.HANDLE_ERROR)
+            else:
+                console.info(
+                    f"Failed to adjust unit tests after implementation code was update while fixing conformance tests for functional requirement {self.frid_context.frid}."
+                )
+                console.info(f"Restarting rendering the functional requirement {self.frid_context.frid} from scratch.")
+                self.machine.dispatch(triggers.RESTART_FRID_PROCESSING)
+
+    def start_fixing_unit_tests_in_refactoring(self):
+        self.unit_tests_running_context.fix_attempts += 1
+
+        if self.unit_tests_running_context.fix_attempts > MAX_UNITTEST_FIX_ATTEMPTS:
+            git_utils.revert_changes(self.args.build_folder)
+            self.machine.dispatch(triggers.START_NEW_REFACTORING_ITERATION)
+
+    def start_refactoring_code(self):
+
+        if self.frid_context.refactoring_iteration == 0:
+            console.info("\n[b]Refactoring the generated code...[/b]\n")
+
+        self.frid_context.refactoring_iteration += 1
+
+        if self.frid_context.refactoring_iteration >= MAX_REFACTORING_ITERATIONS:
+            if self.args.verbose:
+                console.info(
+                    f"Refactoring iterations limit of {MAX_REFACTORING_ITERATIONS} reached for functional requirement {self.frid_context.frid}."
+                )
+            self.machine.dispatch(triggers.PROCEED_FRID_PROCESSING)
+
+    def start_testing_environment_preparation(self):
+        if (
+            self.args.prepare_environment_script is None
+            or not self.conformance_tests_running_context.should_prepare_testing_environment
+        ):
+            self.machine.dispatch(triggers.MARK_TESTING_ENVIRONMENT_PREPARED)
+
+    def start_conformance_tests_processing(self):
+        console.info("\n[b]Implementing conformance tests...[/b]\n")
+        conformance_tests_json = self.conformance_tests_utils.get_conformance_tests_json()
+        self.conformance_tests_running_context = ConformanceTestsRunningContext(
+            current_testing_frid=None,
+            current_testing_frid_specifications=None,
+            conformance_test_phase_index=0,
+            fix_attempts=0,
+            conformance_tests_json=conformance_tests_json,
+            conformance_tests_render_attempts=0,
+            should_prepare_testing_environment=True,
+        )
+
+    def finish_conformance_tests_processing(self):
+        self.conformance_tests_running_context = None
+
+    def start_conformance_tests_for_frid(self):
+        if self.conformance_tests_running_context.regenerating_conformance_tests:
+            if self.args.verbose:
+                console.info(
+                    f"Recreating conformance tests for functional requirement {self.conformance_tests_running_context.current_testing_frid}."
+                )
+
+            existing_conformance_tests_folder = self.conformance_tests_running_context.conformance_tests_json.pop(
+                self.conformance_tests_running_context.current_testing_frid
+            )
+
+            file_utils.delete_folder(existing_conformance_tests_folder["folder_name"])
+
+            self.conformance_tests_running_context.conformance_tests_render_attempts += 1
+            self.conformance_tests_running_context.fix_attempts = 0
+            self.conformance_tests_running_context.regenerating_conformance_tests = False
+        else:
+            if self.conformance_tests_running_context.current_testing_frid == self.frid_context.frid:
+
+                if not self.frid_context.specifications.get(
+                    plain_spec.ACCEPTANCE_TESTS
+                ) or self.conformance_tests_running_context.conformance_test_phase_index == len(
+                    self.frid_context.specifications[plain_spec.ACCEPTANCE_TESTS]
+                ):
+                    self.machine.dispatch(triggers.MARK_ALL_CONFORMANCE_TESTS_PASSED)
+                    return
+
+                should_reset_high_level_implementation_plan = (
+                    self.conformance_tests_running_context.current_testing_frid == self.frid_context.frid
+                    and self.conformance_tests_running_context.conformance_test_phase_index == 0
+                )
+                if should_reset_high_level_implementation_plan:
+                    self.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan = None
+
+                self.conformance_tests_running_context.conformance_test_phase_index += 1
+                current_acceptance_tests = self.frid_context.specifications[plain_spec.ACCEPTANCE_TESTS][
+                    : self.conformance_tests_running_context.conformance_test_phase_index
+                ]
+                self.conformance_tests_running_context.conformance_tests_json[self.frid_context.frid][
+                    plain_spec.ACCEPTANCE_TESTS
+                ] = current_acceptance_tests
+                return
+
+            if self.conformance_tests_running_context.current_testing_frid is None:
+                self.conformance_tests_running_context.current_testing_frid = plain_spec.get_first_frid(
+                    self.plain_source_tree
+                )
+            else:
+                self.conformance_tests_running_context.current_testing_frid = plain_spec.get_next_frid(
+                    self.plain_source_tree, self.conformance_tests_running_context.current_testing_frid
+                )
+            self.conformance_tests_running_context.current_testing_frid_specifications, _ = (
+                plain_spec.get_specifications_for_frid(
+                    self.plain_source_tree, self.conformance_tests_running_context.current_testing_frid
+                )
+            )
+            if ConformanceTestHelpers.current_conformance_tests_exist(self.conformance_tests_running_context):  # type: ignore
+                self.machine.dispatch(triggers.MARK_CONFORMANCE_TESTS_READY)
+
+    def start_fixing_conformance_tests(self):
+        self.conformance_tests_running_context.fix_attempts += 1
+
+        if self.conformance_tests_running_context.fix_attempts >= MAX_CONFORMANCE_TEST_FIX_ATTEMPTS:
+            if (
+                self.conformance_tests_running_context.conformance_tests_render_attempts
+                >= MAX_CONFORMANCE_TEST_RERENDER_ATTEMPTS
+            ):
+                console.error(
+                    f"We've already tried to fix the issue by recreating the conformance tests but tests still fail. Please fix the issues manually. FRID: {self.frid_context.frid}, Render ID: {self.run_state.render_id}"
+                )
+                self.machine.dispatch(triggers.HANDLE_ERROR)
+            else:
+                self.conformance_tests_running_context.regenerating_conformance_tests = True
+                self.machine.dispatch(triggers.MARK_REGENERATION_OF_CONFORMANCE_TESTS)
+
+    def finish_fixing_conformance_tests(self):
+        if self.args.verbose:
+            console.info(
+                f"[b]Running conformance tests attempt {self.conformance_tests_running_context.fix_attempts + 1}.[/b]"
+            )

render_machine/render_types.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class FridContext:
+    frid: str
+    specifications: dict
+    functional_requirement_text: str
+    linked_resources: dict
+    functional_requirement_render_attempts: int = 0
+    changed_files: set[str] = field(default_factory=set)
+    refactoring_iteration: int = 0
+
+
+@dataclass
+class UnitTestsRunningContext:
+    fix_attempts: int
+    changed_files: set[str] = field(default_factory=set)
+
+
+@dataclass
+class ConformanceTestsRunningContext:
+    current_testing_frid: Optional[str]
+    fix_attempts: int
+    conformance_tests_json: dict
+    conformance_tests_render_attempts: int
+    current_testing_frid_specifications: Optional[dict[str, list]]
+    conformance_test_phase_index: int  # 0 => conformance tests, 1 or more => acceptance tests
+    regenerating_conformance_tests: bool = False
+
+    # will be propagated only when:
+    # - current_testing_frid == frid  noqa: E800
+    # - conformance_test_phase_index == 0 (conformance tests phase)
+    current_testing_frid_high_level_implementation_plan: Optional[str] = None
+    should_prepare_testing_environment: bool = False