codeplain 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

plain2code.py

@@ -2,7 +2,7 @@ import importlib.resources
 import logging
 import logging.config
 import os
-import traceback
+import sys
 from typing import Optional
 
 import yaml
@@ -17,7 +17,20 @@ from event_bus import EventBus
 from module_renderer import ModuleRenderer
 from plain2code_arguments import parse_arguments
 from plain2code_console import console
-from plain2code_exceptions import InvalidFridArgument, MissingAPIKey, PlainSyntaxError
+from plain2code_exceptions import (
+    ConflictingRequirements,
+    CreditBalanceTooLow,
+    InternalServerError,
+    InvalidAPIKey,
+    InvalidFridArgument,
+    LLMInternalError,
+    MissingAPIKey,
+    MissingPreviousFunctionalitiesError,
+    MissingResource,
+    OutdatedClientVersion,
+    PlainSyntaxError,
+    UnexpectedState,
+)
 from plain2code_logger import (
     CrashLogHandler,
     IndentedFormatter,
@@ -89,6 +102,7 @@ def setup_logging(
     log_to_file: bool,
     log_file_name: str,
     plain_file_path: Optional[str],
+    render_id: str,
 ):
     # Set default level to INFO for everything not explicitly configured
     logging.getLogger().setLevel(logging.INFO)
@@ -148,11 +162,29 @@ def setup_logging(
         crash_handler.setFormatter(formatter)
         root_logger.addHandler(crash_handler)
 
+    root_logger.info(f"Render ID: {render_id}")  # Ensure render ID is logged in to codeplain.log file
 
-def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # noqa: C901
-    # Check system requirements before proceeding
-    system_config.verify_requirements()
 
+def _check_connection(codeplainAPI):
+    """Check API connectivity and validate API key and client version."""
+    response = codeplainAPI.connection_check(system_config.client_version)
+
+    if not response.get("api_key_valid", False):
+        raise InvalidAPIKey(
+            "Provided API key is invalid. Please provide a valid API key using the CODEPLAIN_API_KEY environment variable "
+            "or the --api-key argument."
+        )
+
+    if not response.get("client_version_valid", False):
+        min_version = response.get("min_client_version", "unknown")
+        raise OutdatedClientVersion(
+            f"Your client version ({system_config.client_version}) is outdated. Minimum required version is {min_version}. "
+            "Please update using:"
+            "  uv tool upgrade codeplain"
+        )
+
+
+def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # noqa: C901
     template_dirs = file_utils.get_template_directories(args.filename, args.template_dir, DEFAULT_TEMPLATE_DIRS)
 
     console.info(f"Rendering {args.filename} to target code.")
@@ -173,6 +205,8 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     assert args.api is not None and args.api != "", "API URL is required"
     codeplainAPI.api_url = args.api
 
+    _check_connection(codeplainAPI)
+
     module_renderer = ModuleRenderer(
         codeplainAPI,
         args.filename,
@@ -190,6 +224,7 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
         unittests_script=args.unittests_script,
         conformance_tests_script=args.conformance_tests_script,
         prepare_environment_script=args.prepare_environment_script,
+        state_machine_version=system_config.client_version,
         css_path="styles.css",
     )
     result = app.run()
@@ -202,18 +237,19 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     return
 
 
-def main():
+def main():  # noqa: C901
     args = parse_arguments()
 
     event_bus = EventBus()
 
-    setup_logging(args, event_bus, args.log_to_file, args.log_file_name, args.filename)
-
     if not args.api:
         args.api = "https://api.codeplain.ai"
 
     run_state = RunState(spec_filename=args.filename, replay_with=args.replay_with)
 
+    setup_logging(args, event_bus, args.log_to_file, args.log_file_name, args.filename, run_state.render_id)
+
+    exc_info = None
     try:
         # Validate API key is present
         if not args.api_key:
@@ -221,39 +257,71 @@ def main():
                 "API key is required. Please set the CODEPLAIN_API_KEY environment variable or provide it with the --api-key argument."
             )
 
+        console.debug(f"Render ID: {run_state.render_id}")  # Ensure render ID is logged to the console
         render(args, run_state, codeplain_api, event_bus)
     except InvalidFridArgument as e:
+        exc_info = sys.exc_info()
         console.error(f"Invalid FRID argument: {str(e)}.\n")
-        # No need to print render ID since this error is going to be thrown at the very start so user will be able to
-        # see the render ID that's printed at the very start of the rendering process.
-        dump_crash_logs(args)
     except FileNotFoundError as e:
+        exc_info = sys.exc_info()
         console.error(f"File not found: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
     except TemplateNotFoundError as e:
+        exc_info = sys.exc_info()
         console.error(f"Template not found: {str(e)}\n")
         console.error(system_config.get_error_message("template_not_found"))
-        dump_crash_logs(args)
     except PlainSyntaxError as e:
+        exc_info = sys.exc_info()
         console.error(f"Plain syntax error: {str(e)}\n")
-        dump_crash_logs(args)
     except KeyboardInterrupt:
+        exc_info = sys.exc_info()
         console.error("Keyboard interrupt")
-        # Don't print the traceback here because it's going to be from keyboard interrupt and we don't really care about that
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
     except RequestException as e:
+        exc_info = sys.exc_info()
+        console.error(f"Error rendering plain code: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except MissingPreviousFunctionalitiesError as e:
+        exc_info = sys.exc_info()
         console.error(f"Error rendering plain code: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
     except MissingAPIKey as e:
         console.error(f"Missing API key: {str(e)}\n")
+    except InvalidAPIKey as e:
+        console.error(f"Invalid API key: {str(e)}\n")
+    except OutdatedClientVersion as e:
+        console.error(f"Outdated client version: {str(e)}\n")
+    except (InternalServerError, UnexpectedState):
+        exc_info = sys.exc_info()
+        console.error(
+            f"Internal server error.\n\nPlease report the error to support@codeplain.ai with the attached {args.log_file_name} file."
+        )
+        console.debug(f"Render ID: {run_state.render_id}")
+    except ConflictingRequirements as e:
+        exc_info = sys.exc_info()
+        console.error(f"Conflicting requirements: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except CreditBalanceTooLow as e:
+        exc_info = sys.exc_info()
+        console.error(f"Credit balance too low: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except LLMInternalError as e:
+        exc_info = sys.exc_info()
+        console.error(f"LLM internal error: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except MissingResource as e:
+        exc_info = sys.exc_info()
+        console.error(f"Missing resource: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
     except Exception as e:
+        exc_info = sys.exc_info()
         console.error(f"Error rendering plain code: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
-        traceback.print_exc()
-        dump_crash_logs(args)
+    finally:
+        if exc_info:
+            # Log traceback using the logging system
+            logging.error("Render crashed with exception:", exc_info=exc_info)
+            dump_crash_logs(args)
 
 
 if __name__ == "__main__":  # noqa: C901

plain2code_console.py

@@ -52,7 +52,7 @@ class Plain2CodeConsole(Console):
             return
 
         tree = self._create_tree_from_files(root_folder, files)
-        super().print(f"\n[b]{header}[/b]", style=style)
+        super().print(f"\n{header}", style=style)
 
         super().print(tree, style=style)
 
@@ -87,9 +87,7 @@ class Plain2CodeConsole(Console):
                         else:
                             file_lines = len(content.splitlines())
                             file_tokens = len(self.llm_encoding.encode(content))
-                            current_level = current_level.add(
-                                f"{part} [b]({file_lines} lines, {file_tokens} tokens)[/b]"
-                            )
+                            current_level = current_level.add(f"{part} ({file_lines} lines, {file_tokens} tokens)")
                     else:
                         current_level = current_level.add(part)
                 else:
@@ -107,7 +105,7 @@ class Plain2CodeConsole(Console):
             if resource_name["target"] in linked_resources:
                 file_tokens = len(self.llm_encoding.encode(linked_resources[resource_name["target"]]))
                 self.input(
-                    f"- {resource_name['text']} [b][#4169E1]({resource_name['target']}, {file_tokens} tokens)[/#4169E1][/b]"
+                    f"- {resource_name['text']} [#4169E1]({resource_name['target']}, {file_tokens} tokens)[/#4169E1]"
                 )
 
         self.input()

plain2code_exceptions.py

@@ -25,19 +25,19 @@ class PlainSyntaxError(Exception):
     pass
 
 
-class NoRenderFound(Exception):
+class UnexpectedState(Exception):
     pass
 
 
-class MultipleRendersFound(Exception):
+class MissingAPIKey(Exception):
     pass
 
 
-class UnexpectedState(Exception):
+class InvalidAPIKey(Exception):
     pass
 
 
-class MissingAPIKey(Exception):
+class OutdatedClientVersion(Exception):
     pass
 
 
@@ -57,3 +57,13 @@ class InvalidLiquidVariableName(Exception):
 
 class ModuleDoesNotExistError(Exception):
     pass
+
+
+class InternalServerError(Exception):
+    pass
+
+
+class MissingPreviousFunctionalitiesError(Exception):
+    """Raised when trying to render from a FRID but previous FRID commits are missing."""
+
+    pass

plain2code_logger.py

@@ -4,7 +4,6 @@ import time
 from typing import Optional
 
 from event_bus import EventBus
-from plain2code_console import console
 from plain2code_events import LogMessageEmitted
 
 
@@ -42,6 +41,7 @@ class TuiLoggingHandler(logging.Handler):
         super().__init__()
         self.event_bus = event_bus
         self._buffer = []
+        self.start_time = time.time()  # Record start time for offset calculation
 
         # Register to be notified when event bus is ready
         self.event_bus.on_ready(self._flush_buffer)
@@ -49,8 +49,11 @@ class TuiLoggingHandler(logging.Handler):
     def emit(self, record):
         try:
             # Extract structured data from the log record
-
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.created))
+            offset_seconds = record.created - self.start_time
+            minutes = int(offset_seconds // 60)
+            seconds = int(offset_seconds % 60)
+            milliseconds = int((offset_seconds % 1) * 100)
+            timestamp = f"{minutes:02d}:{seconds:02d}:{milliseconds:02d}"
             event = LogMessageEmitted(
                 logger_name=record.name,
                 level=record.levelname,
@@ -63,6 +66,10 @@ class TuiLoggingHandler(logging.Handler):
                 self.event_bus.publish(event)
             else:
                 self._buffer.append(event)
+        except RuntimeError:
+            # We're going to get this crash after the TUI app is closed (forcefully).
+            # NOTE: This should be more thought out.
+            pass
         except Exception:
             self.handleError(record)
 
@@ -123,5 +130,4 @@ def dump_crash_logs(args, formatter=None):
     if crash_handler and args.filename:
         log_file_path = get_log_file_path(args.filename, args.log_file_name)
 
-        if crash_handler.dump_to_file(log_file_path, formatter):
-            console.error(f"\nLogs have been dumped to {log_file_path}")
+        crash_handler.dump_to_file(log_file_path, formatter)

plain2code_utils.py

@@ -24,15 +24,17 @@ def print_dry_run_output(plain_source_tree: dict, render_range: Optional[list[st
             console.info(
                 "-------------------------------------"
                 f"Rendering functional requirement {frid}"
-                f"[b]{functional_requirement_text}[/b]"
+                f"{functional_requirement_text}"
                 "-------------------------------------"
             )
             if plain_spec.ACCEPTANCE_TESTS in specifications:
                 for i, acceptance_test in enumerate(specifications[plain_spec.ACCEPTANCE_TESTS], 1):
-                    console.info(f"\nGenerating acceptance test #{i}:\n\n{acceptance_test}")
+                    console.info(f"Generating acceptance test #{i}:\n\n{acceptance_test}")
         else:
-            console.info("-------------------------------------")
-            console.info(f"Skipping rendering iteration: {frid}")
-            console.info("-------------------------------------")
+            console.info(
+                "-------------------------------------\n"
+                f"Skipping rendering iteration: {frid}\n"
+                "-------------------------------------"
+            )
 
         frid = plain_spec.get_next_frid(plain_source_tree, frid)

plain_file.py

@@ -206,7 +206,7 @@ def _process_single_acceptance_test_requirement(functional_requirement: mistleto
             # Handle the case when the heading is not valid. This case includes cases such as:
             # - Writing `acceptance test` instead of `acceptance tests` (or any other syntax diffs).
             # - Instead of specifying `acceptance tests` below the functional requirement, creator of the plain file
-            #   might have specified some other building block (e.g. `technical specs`)
+            #   might have specified some other building block (e.g. `implementation reqs`)
             raise PlainSyntaxError(acceptance_test_heading_problem)
 
         if is_acceptance_test_heading:

plain_spec.py

@@ -8,8 +8,8 @@ from liquid2.filter import with_context
 from plain2code_exceptions import InvalidLiquidVariableName
 
 DEFINITIONS = "definitions"
-NON_FUNCTIONAL_REQUIREMENTS = "technical specs"
-TEST_REQUIREMENTS = "test specs"
+NON_FUNCTIONAL_REQUIREMENTS = "implementation reqs"
+TEST_REQUIREMENTS = "test reqs"
 FUNCTIONAL_REQUIREMENTS = "functional specs"
 ACCEPTANCE_TESTS = "acceptance_tests"
 ACCEPTANCE_TEST_HEADING = "acceptance tests"
@@ -178,6 +178,26 @@ def get_previous_frid(plain_source_tree, frid):
     raise Exception(f"Functional requirement {frid} does not exist.")
 
 
+def get_frids_before(plain_source_tree, target_frid: str) -> list[str]:
+    """
+    Get all FRIDs that appear before the target FRID in the specification.
+
+    Args:
+        plain_source_tree: The plain source tree
+        target_frid: The FRID to find predecessors for
+
+    Returns:
+        List of FRIDs that appear before target_frid, in order
+    """
+    previous_frids = []
+    for frid in get_frids(plain_source_tree):
+        if frid == target_frid:
+            break
+        previous_frids.append(frid)
+
+    return previous_frids
+
+
 def get_specification_item_markdown(specification_item, code_variables, replace_code_variables):
     markdown = specification_item["markdown"]
     if "code_variables" in specification_item:

render_machine/actions/create_dist.py

@@ -21,6 +21,6 @@ class CreateDist(BaseAction):
                 render_context.conformance_tests.get_module_conformance_tests_folder(render_context.module_name),
                 render_context.conformance_tests_dest,
             )
-        console.info(f"Render {render_context.run_state.render_id} completed successfully.")
+        console.info(f"[#79FC96]Render {render_context.run_state.render_id} completed successfully.[/#79FC96]")
 
         return self.SUCCESSFUL_OUTCOME, None

render_machine/actions/exit_with_error.py

@@ -18,7 +18,7 @@ class ExitWithError(BaseAction):
 
         if render_context.frid_context is not None:
             console.info(
-                f"To continue rendering from the last successfully rendered functional requirement, provide the [red][b]--render-from {render_context.frid_context.frid}[/b][/red] flag."
+                f"To continue rendering from the last successfully rendered functional requirement, provide the [red]--render-from {render_context.frid_context.frid}[/red] flag."
             )
 
         if render_context.run_state.render_id is not None:

render_machine/actions/prepare_testing_environment.py

@@ -14,7 +14,7 @@ class PrepareTestingEnvironment(BaseAction):
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         if render_context.verbose:
             console.info(
-                f"[b]Running testing environment preparation script {render_context.prepare_environment_script} for build folder {render_context.build_folder}.[/b]"
+                f"Running testing environment preparation script {render_context.prepare_environment_script} for build folder {render_context.build_folder}."
             )
         exit_code, _, preparation_temp_file_path = render_utils.execute_script(
             render_context.prepare_environment_script,

render_machine/actions/render_conformance_tests.py

@@ -24,7 +24,7 @@ class RenderConformanceTests(BaseAction):
 
     def _render_conformance_tests(self, render_context: RenderContext):
         if render_context.verbose:
-            console.info("[b]Implementing test requirements:[/b]")
+            console.info("Implementing test requirements:")
             console.print_list(
                 render_context.conformance_tests_running_context.current_testing_frid_specifications[
                     plain_spec.TEST_REQUIREMENTS
@@ -149,9 +149,7 @@ class RenderConformanceTests(BaseAction):
         ]
 
         if render_context.verbose:
-            console.info("\n[b]Generating acceptance test:[/b]")
-            console.info(f"[b]{acceptance_test}[/b]")
-            console.info()
+            console.info(f"Generating acceptance test:\n  {acceptance_test}")
 
         with console.status(
             f"[{console.INFO_STYLE}]Generating acceptance test for functional requirement {render_context.frid_context.frid}...\n"

render_machine/actions/render_functional_requirement.py

@@ -25,14 +25,14 @@ class RenderFunctionalRequirement(BaseAction):
         _, memory_files_content = MemoryManager.fetch_memory_files(render_context.memory_manager.memory_folder)
 
         if render_context.verbose:
-            msg = f"Module: {render_context.module_name}\n"
-            msg += f"Rendering functional requirement {render_context.frid_context.frid}"
+            msg = "-------------------------------------\n"
+            msg += f"Module: {render_context.module_name}\n"
+            msg += f"Rendering functionality {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("-------------------------------------")
+            msg += f"\n{render_context.frid_context.functional_requirement_text}\n"
+            msg += "-------------------------------------"
             console.info(msg)
-            console.info("-------------------------------------")
 
         try:
             if render_context.verbose:
@@ -54,7 +54,7 @@ class RenderFunctionalRequirement(BaseAction):
                     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)})."
+            error_message = f"The functional requirement:\n{render_context.frid_context.functional_requirement_text}\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["functional_requirements"].items():

render_machine/actions/run_conformance_tests.py

@@ -32,17 +32,18 @@ class RunConformanceTests(BaseAction):
 
         if render_context.verbose:
             console.info(
-                f"\n[b]Running conformance tests script {render_context.conformance_tests_script} "
+                f"Running conformance tests script {render_context.conformance_tests_script} "
                 + f"for {conformance_tests_folder_name} ("
                 + f"functional requirement {render_context.conformance_tests_running_context.current_testing_frid} "
                 + f"in module {render_context.conformance_tests_running_context.current_testing_module_name}"
-                + ").[/b]"
+                + ")."
             )
         exit_code, conformance_tests_issue, conformance_tests_temp_file_path = render_utils.execute_script(
             render_context.conformance_tests_script,
             [render_context.build_folder, conformance_tests_folder_name],
             render_context.verbose,
             "Conformance Tests",
+            render_context.conformance_tests_running_context.current_testing_frid,
         )
         render_context.script_execution_history.latest_conformance_test_output_path = conformance_tests_temp_file_path
         render_context.script_execution_history.should_update_script_outputs = True

render_machine/actions/run_unit_tests.py

@@ -17,7 +17,7 @@ class RunUnitTests(BaseAction):
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         if render_context.verbose:
             console.info(
-                f"[b]Running unit tests script {render_context.unittests_script}.[/b] (attempt: {render_context.unit_tests_running_context.fix_attempts + 1})"
+                f"Running unit tests script {render_context.unittests_script}. (attempt: {render_context.unit_tests_running_context.fix_attempts + 1})"
             )
         exit_code, unittests_issue, unittests_temp_file_path = render_utils.execute_script(
             render_context.unittests_script,

render_machine/render_context.py

@@ -327,7 +327,7 @@ class RenderContext:
     def start_refactoring_code(self):
 
         if self.frid_context.refactoring_iteration == 0:
-            console.info("[b]Refactoring the generated code...[/b]")
+            console.info("Refactoring the generated code...")
 
         self.frid_context.refactoring_iteration += 1
 
@@ -349,7 +349,7 @@ class RenderContext:
             self.machine.dispatch(triggers.MARK_TESTING_ENVIRONMENT_PREPARED)
 
     def start_conformance_tests_processing(self):
-        console.info("[b]Implementing conformance tests...[/b]")
+        console.info("Implementing conformance tests...")
         self.conformance_tests_running_context = ConformanceTestsRunningContext(
             current_testing_module_name=self.module_name,
             current_testing_frid=None,
@@ -444,5 +444,5 @@ class RenderContext:
     def finish_fixing_conformance_tests(self):
         if self.verbose:
             console.info(
-                f"[b]Running conformance tests attempt {self.conformance_tests_running_context.fix_attempts + 1}.[/b]"
+                f"Running conformance tests attempt {self.conformance_tests_running_context.fix_attempts + 1}."
             )

render_machine/render_utils.py

@@ -42,7 +42,7 @@ def print_inputs(render_context, existing_files_content, message):
 
 
 def execute_script(
-    script: str, scripts_args: list[str], verbose: bool, script_type: str
+    script: str, scripts_args: list[str], verbose: bool, script_type: str, frid: Optional[str] = None
 ) -> tuple[int, str, Optional[str]]:
     temp_file_path = None
     try:
@@ -68,14 +68,22 @@ def execute_script(
                     temp_file.write(f"{script_type} script {script} successfully passed.\n")
                 temp_file.write(f"{script_type} script execution time: {elapsed_time:.2f} seconds.\n")
 
-            console.info(f"[b]{script_type} script output stored in: {temp_file_path}[/b]")
+            console.info(f"[#888888]{script_type} script output stored in: {temp_file_path.strip()}[/#888888]")
 
             if result.returncode != 0:
-                console.info(
-                    f"[b]The {script_type} script has failed. Initiating the patching mode to automatically correct the discrepancies.[/b]"
-                )
+                if frid is not None:
+                    console.info(
+                        f"The {script_type} script for ID {frid} has failed. Initiating the patching mode to automatically correct the discrepancies."
+                    )
+                else:
+                    console.info(
+                        f"The {script_type} script has failed. Initiating the patching mode to automatically correct the discrepancies."
+                    )
             else:
-                console.info(f"[b]All {script_type} script passed successfully.[/b]")
+                if frid is not None:
+                    console.info(f"[#79FC96]The {script_type} script for ID {frid} has passed successfully.[/#79FC96]")
+                else:
+                    console.info(f"[#79FC96]All {script_type} script passed successfully.[/#79FC96]")
 
         return result.returncode, result.stdout, temp_file_path
     except subprocess.TimeoutExpired as e:

standard_template_library/golang-console-app-template.plain

@@ -7,14 +7,14 @@
 - :ConformanceTestsExecutableFile: is the main executable code file of :ConformanceTests:.
 
 
-***technical specs***
+***implementation reqs***
 
 - :Implementation: should be in Go lang.
 
 - :Implementation: should include unit tests using Go's built-in testing package.
 
 
-***test specs***
+***test reqs***
 
 - :ConformanceTests: should be implemented in Go lang.
 

standard_template_library/python-console-app-template.plain

@@ -7,13 +7,13 @@
 - :MainExecutableFile: is the main executable code file of :App:.
 
 
-***technical specs***
+***implementation reqs***
 
 - :Implementation: should be in Python.
 
 - :Implementation: should include :Unittests: using Unittest framework! If :Unittests: are put in the subfolder, make sure to include __init__.py to make them discoverable.
 
-***test specs***
+***test reqs***
 
 - :ConformanceTests: of :App: should be implemented in Python using Unittest framework. :ConformanceTests: will be run using "python -m unittest discover" command. Therefore, if :ConformanceTests: are put in the subfolder, make sure to include __init__.py to make them discoverable. 
 

standard_template_library/typescript-react-app-template.plain

@@ -3,7 +3,7 @@
 - :App: is a web application.
 
 
-***technical specs***
+***implementation reqs***
 
 - :App: should be implemented in TypeScript, using React as a web framework.
 
@@ -12,6 +12,6 @@
 - :App: should run on port 3000.
 
 
-***test specs***
+***test reqs***
 
 - :ConformanceTests: of :App: should be written in TypeScript, using Cypress as the framework for :ConformanceTests:.

system_config.py

@@ -1,5 +1,4 @@
 import importlib.resources
-import shutil
 import sys
 
 import yaml
@@ -12,12 +11,12 @@ class SystemConfig:
 
     def __init__(self):
         self.config = self._load_config()
-        if "system_requirements" not in self.config:
-            raise KeyError("Missing 'system_requirements' section in system_config.yaml")
+        if "client_version" not in self.config:
+            raise KeyError("Missing 'client_version' in system_config.yaml")
         if "error_messages" not in self.config:
             raise KeyError("Missing 'error_messages' section in system_config.yaml")
 
-        self.requirements = self.config["system_requirements"]
+        self.client_version = self.config["client_version"]
         self.error_messages = self.config["error_messages"]
 
     def _load_config(self):
@@ -31,13 +30,6 @@ class SystemConfig:
             console.error(f"Failed to load system configuration: {e}")
             sys.exit(69)
 
-    def verify_requirements(self):
-        """Verify all system requirements are met."""
-        for req_data in self.requirements.values():
-            if not shutil.which(req_data["command"]):
-                console.error(req_data["error_message"])
-                sys.exit(69)
-
     def get_error_message(self, message_key, **kwargs):
         """Get a formatted error message by its key."""
         if message_key not in self.error_messages: