codeplain 0.2.11__tar.gz → 0.2.12__tar.gz

{codeplain-0.2.11 → codeplain-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.2.11
+Version: 0.2.12
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

codeplain-0.2.12/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.12"

{codeplain-0.2.11 → codeplain-0.2.12}/config/system_config.yaml

@@ -1,5 +1,3 @@
-client_version: "0.2.11"
-
 error_messages:
   template_not_found:
     message: |

{codeplain-0.2.11 → codeplain-0.2.12}/docs/plain_language_specification.md

@@ -13,68 +13,31 @@
 Here's an example of a "hello, world" program in ***plain.
 
 ```plain
-***Non-Functional Requirements:***
+***implementation reqs***
 
 - :Implementation: should be in Python.
 
-***Functional Requirements:***
+***functional specs***
 
 - Display "hello, world"
 ```
 
-# Source structure
-
-## Source organization
-
-***plain source can be organized in sections and subsection using markdown headers.
-
-```plain
-# Section 1
-
-# Section 2
-
-***Non-Functional Requirements:***
-
-- First simple non-functional requirement
-
-***Functional Requirements:***
-
-- First simple functional requirement
-
-## Section 2.1
-
-***Non-Functional Requirements:***
-
-- Second simple non-functional requirement
-
-***Functional Requirements:***
-
-- Second simple functional requirement
-```
-
-This enables hierarchical organization of the specification. 
-
-In example above:
-
-- While rendering the "First simple functional requirement", the renderer will not have access to the "Second simple non-functional requirement".
-- While rendering the "Second simple functional requirement", the renderer will not have access to the "First simple non-functional requirement".
-
 ### Specifications
 
 There are four types of specifications:
 
-- `***Definitions:***`
-- `***Non-Functional Requirements:***`
-- `***Functional Requirements:***`
-- `***Test Requirements:***`
+- `***definitions***`
+- `***implementation reqs***`
+- `***functional specs***`
+- `***test reqs***`
 
-Every plain source file requires at least one functional requirement and an associated non-functional requirement.
+Every plain source file requires at least one functional spec and an associated implementation req.
 
-Functional requirements must reside in leaf sections while other specifications can be placed also in non-leaf sections. Specifications in non-leaf sections apply not just to the section itself but to all of its subsections.
+Functional specs must reside in leaf sections while other specifications can be placed also in non-leaf sections. Specifications in non-leaf sections apply not just to the section itself but to all of its subsections.
 
 ## Definitions
 
-The `***Definitions:***` specification is a list of definitions of new concepts.
+The `***definitions***` specification is a list of definitions of new concepts.
 
 Here's an example of a simple definiton.
 
@@ -89,9 +52,9 @@ While providing definitions, you should adhere to the following 4 rules:
 - Every definition must start with the name of the concept you are defining.
 - Each concept name must be enclosed in colons (`:`) at both the beginning and end.
   - Valid characters for concept name include: Plus sign (`+`), Minus sign (`-`), Dot sign (`.`), Digits (`0`-`9`), Uppercase letters (`A`-`Z`), Underscore (`_`), Lowercase letters (`a`-`z`)
-  - Examples: `:App:`, `:Tasks:`, `:ListOfUsers:`, `:CLI:`. 
+  - Examples: `:App:`, `:Tasks:`, `:ListOfUsers:`, `:CLI:`.
 - Concept names must be globally unique (meaning, you cannot provide two definitions with the same concept name).
-- When referencing concepts in ***Test Requirements:***, ***Functional Requirements:***, ***Non-Functional Requirements:*** and ***Acceptance Tests:***, the concept name must exist in the ***Definitions:*** section.
+- When referencing concepts in ***test reqs***, ***functional specs***, ***implementation reqs*** and ***acceptance tests***, the concept name must exist in the ***definitions*** section.
 
 Furthermore, there are special concepts that are already defined and are ready to use. They should not be redefined:
 
@@ -111,9 +74,9 @@ Definitions are the mechanism for definining data structures in ***plain. Here's
   - Due Date - optional date by which :User: is supposed to complete :Task:.
 ```
 
-## Non-Functional Requirements
+## Implementation Reqs
 
-The `***Non-Functional Requirements:***` specification is a list of instructions that steer software code implementation and provide details of execution environment.
+The `***implementation reqs***` specification is a list of instructions that steer software code implementation and provide details of execution environment.
 
 Here's an example of a simple instruction specifying only that the ***plain specification should be rendered to Python software code.
 
@@ -133,9 +96,9 @@ Here's an example of more complex instructions.
 - The main executable file of :App: should be called hello_world.py
 ```
 
-## Functional Requirements
+## Functional Specs
 
-The `***Functional Requirements:***` specification provides a description of functionality that should be rendered to software code. The descriptions should be provided in natural language as a markdown list.
+The `***functional specs***` specification provides a description of functionality that should be rendered to software code. The descriptions should be provided in natural language as a markdown list.
 
 Here's an example of a simple description of the functionality of the "hello, world" application.
 
@@ -143,7 +106,7 @@ Here's an example of a simple description of the functionality of the "hello, wo
 - Display "hello, world"
 ```
 
-Each functional requirement must be limited in complexity. For example, for the functional requirement
+Each functional spec must be limited in complexity. For example, for the functional spec
 
 ```plain
 - :App: should implement a task manager application.
@@ -152,10 +115,10 @@ Each functional requirement must be limited in complexity. For example, for the
 the renderer of ***plain source to software code should respond with
 
 ```
-Functional requirement too complex!
+Functional spec too complex!
 ```
 
-In such case you need to break down the functioanlity into smaller, less-complex functional requirements.
+In such case you need to break down the functioanlity into smaller, less-complex functional specs.
 
 Here's an example how to do such a break down in the case of a task manager application.
 
@@ -173,38 +136,38 @@ Here's an example how to do such a break down in the case of a task manager appl
 - :User: should be able to mark :Task: as completed.
 ```
 
-Functional requirements are rendered incrementally one by one. Consequently earlier functional requirements cannot reference later functional requirements.
+Functional specs are rendered incrementally one by one. Consequently earlier functional specs cannot reference later functional specs.
 
 ### Acceptance Tests
 
-Acceptance tests can be used to further refine the functional requirement and especially to incorporate constraints on the implementation.
+Acceptance tests can be used to further refine the functional spec and especially to incorporate constraints on the implementation.
 
-Acceptance tests are specified with a keyword `***Acceptance Tests:***` as a subsection within `***Functional Requirements:***` section. Each acceptance tests must be an item in a list.
+Acceptance tests are specified with a keyword `***acceptance tests***` as a subsection within `***functional specs***` section. Each acceptance tests must be an item in a list.
 
 Here's an example of a "Hello, World" application with one acceptance test.
 
 ```plain
-***Functional Requirements:***
+***functional specs***
 
 - Display "hello, world"
 
-  ***Acceptance Tests:***
-    
+  ***acceptance tests***
+
   - :App: shouldn't show logging output in the console output (neither in stdout nor stderr).
 ```
 
-Acceptance tests extend **conformance tests**. The acceptance tests are implemented according to the ***Test Requirements:*** specification (see next section).
+Acceptance tests extend **conformance tests**. The acceptance tests are implemented according to the ***test reqs*** specification (see below).
 
-## Test Requirements
+## Test Reqs
 
-The `***Test Requirements:***` specification is a list of instructions that steer implementation of conformance tests and provide details of testing environment.
+The `***test reqs***` specification is a list of instructions that steer implementation of conformance tests and provide details of testing environment.
 
-**Conformance tests** is the generated code used to verify that the functional requirement is implemented according to the specification.
+**Conformance tests** is the generated code used to verify that the functional spec is implemented according to the specification.
 
-Here's an example specification of test requirements.
+Here's an example specification of test reqs.
 
 ```plain
-- :ConformanceTests: of :App: should be implemented in Python using Unittest framework. 
+- :ConformanceTests: of :App: should be implemented in Python using Unittest framework.
 ```
 
 # Extended Syntax

{codeplain-0.2.11 → codeplain-0.2.12}/file_utils.py

@@ -47,6 +47,11 @@ FILE_EXTENSION_MAPPING = {
 SYSTEM_FOLDERS = [".git", CODEPLAIN_METADATA_FOLDER, CODEPLAIN_MEMORY_SUBFOLDER]
 
 
+def is_system_folder_path(file_path: str) -> bool:
+    parts = Path(file_path).parts
+    return bool(parts) and parts[0] in SYSTEM_FOLDERS
+
+
 def get_file_type(file_name):
 
     # Extract the file extension

{codeplain-0.2.11 → codeplain-0.2.12}/memory_management.py

@@ -1,3 +1,4 @@
+import json
 import os
 
 import file_utils
@@ -20,6 +21,7 @@ class MemoryManager:
             return {}, {}
         memory_files = file_utils.list_all_text_files(memory_path)
         memory_files_content = file_utils.get_existing_files_content(memory_path, memory_files)
+        console.info(f"Loaded {len(memory_files_content)} memory files.")
         return memory_files, memory_files_content
 
     def __init__(self, codeplain_api, module_build_folder: str):
@@ -95,3 +97,26 @@ class MemoryManager:
         if len(response_files) > 0:
             memory_folder_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
             file_utils.store_response_files(memory_folder_path, response_files, existing_files)
+
+    def delete_unresolved_memory_files(self):
+        """Delete memory files whose resolution_status is not 'RESOLVED'."""
+        memory_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        if not os.path.exists(memory_path):
+            return
+
+        memory_files = file_utils.list_all_text_files(memory_path)
+        for file_name in memory_files:
+            file_path = os.path.join(memory_path, file_name)
+            try:
+                with open(file_path, "r") as f:
+                    content = json.load(f)
+                if content.get("resolution_status") == "RESOLVED":
+                    continue
+                else:
+                    os.remove(file_path)
+            except (json.JSONDecodeError, OSError):
+                # Not a valid JSON file, unlikely to be a valid memory file, delete it
+                console.error(f"Memory file is not a valid JSON file: {file_name}. Deleting it.")
+                os.remove(file_path)
+
+            console.debug(f"Deleted temporary memory file: {file_name}")

{codeplain-0.2.11 → codeplain-0.2.12}/plain2code_console.py

@@ -97,7 +97,7 @@ class Plain2CodeConsole(Console):
 
     def print_resources(self, resources_list, linked_resources):
         if len(resources_list) == 0:
-            self.input("No linked resources found.")
+            self.input("Linked resources: None")
             return
 
         self.input("Linked resources:")

{codeplain-0.2.11 → codeplain-0.2.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codeplain"
-version = "0.2.11"
+dynamic = ["version"]
 description = "Transform plain language specifications into working code"
 readme = "README.md"
 requires-python = "==3.11"
@@ -40,6 +40,9 @@ dev = [
 [project.scripts]
 codeplain = "plain2code:main"
 
+[tool.hatch.version]
+path = "_version.py"
+
 [tool.hatch.build.targets.wheel]
 include = [
     "*.py",

{codeplain-0.2.11 → codeplain-0.2.12}/render_machine/actions/analyze_specification_ambiguity.py

@@ -7,6 +7,7 @@ from plain2code_console import console
 from plain2code_exceptions import InternalClientError
 from plain2code_utils import AMBIGUITY_CAUSES
 from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 from render_machine.render_context import RenderContext
 
 
@@ -14,19 +15,21 @@ class AnalyzeSpecificationAmbiguity(BaseAction):
     SUCCESSFUL_OUTCOME = "conformance_tests_postanalyzed"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
-        fixed_implementation_code_diff = git_utils.get_fixed_implementation_code_diff(
+
+        fixed_implementation_code_diff = ImplementationCodeHelpers.get_fixed_implementation_code_diff(
             render_context.build_folder, render_context.frid_context.frid
         )
         if fixed_implementation_code_diff is None:
             raise InternalClientError(
                 "Fixes to the implementation code found during conformance testing are not committed to git."
             )
+
         previous_frid = plain_spec.get_previous_frid(render_context.plain_source_tree, render_context.frid_context.frid)
         git_utils.checkout_commit_with_frid(render_context.build_folder, previous_frid)
         existing_files = file_utils.list_all_text_files(render_context.build_folder)
         existing_files_content = file_utils.get_existing_files_content(render_context.build_folder, existing_files)
         git_utils.checkout_previous_branch(render_context.build_folder)
-        implementation_code_diff = git_utils.get_implementation_code_diff(
+        implementation_code_diff = ImplementationCodeHelpers.get_implementation_code_diff(
             render_context.build_folder, render_context.frid_context.frid, previous_frid
         )
         rendering_analysis = render_context.codeplain_api.analyze_rendering(

{codeplain-0.2.11 → codeplain-0.2.12}/render_machine/actions/run_conformance_tests.py

@@ -54,9 +54,7 @@ class RunConformanceTests(BaseAction):
         )
 
         if exit_code == 0:
-            conformance_tests_issue = "All conformance tests passed successfully!"
-
-        if exit_code == 0:
+            render_context.memory_manager.delete_unresolved_memory_files()
             return self.SUCCESSFUL_OUTCOME, None
 
         if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:

codeplain-0.2.12/render_machine/implementation_code_helpers.py

@@ -0,0 +1,49 @@
+import json
+
+import file_utils
+import git_utils
+import plain_spec
+
+
+class ImplementationCodeHelpers:
+    @staticmethod
+    def calculate_build_folder_hash(build_folder: str) -> str:
+        _, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(build_folder)
+        return plain_spec.hash_text(f"folder={build_folder}|{json.dumps(existing_files_content)}")
+
+    @staticmethod
+    def fetch_existing_files(build_folder: str):
+        existing_files = file_utils.list_all_text_files(build_folder)
+        existing_files_content = file_utils.get_existing_files_content(build_folder, existing_files)
+        return existing_files, existing_files_content
+
+    @staticmethod
+    def remove_system_folder_paths_from_code_diff(code_diff: dict):
+        for file_name in list(code_diff.keys()):
+            if file_utils.is_system_folder_path(file_name):
+                del code_diff[file_name]
+
+        return code_diff
+
+    @staticmethod
+    def get_code_diff(build_folder: str, plain_source_tree: dict, frid: str):
+        previous_frid_code_diff = git_utils.diff(
+            build_folder,
+            plain_spec.get_previous_frid(plain_source_tree, frid),
+        )
+
+        return ImplementationCodeHelpers.remove_system_folder_paths_from_code_diff(previous_frid_code_diff)
+
+    @staticmethod
+    def get_fixed_implementation_code_diff(build_folder: str, frid: str):
+        fixed_implementation_code_diff = git_utils.get_fixed_implementation_code_diff(build_folder, frid)
+        if fixed_implementation_code_diff is None:
+            return None
+
+        return ImplementationCodeHelpers.remove_system_folder_paths_from_code_diff(fixed_implementation_code_diff)
+
+    @staticmethod
+    def get_implementation_code_diff(build_folder: str, frid: str, previous_frid: str):
+        implementation_code_diff = git_utils.get_implementation_code_diff(build_folder, frid, previous_frid)
+
+        return ImplementationCodeHelpers.remove_system_folder_paths_from_code_diff(implementation_code_diff)

{codeplain-0.2.11 → codeplain-0.2.12}/standard_template_library/python-console-app-template.plain

@@ -2,8 +2,6 @@
 
 - :App: is a console application.
 
-- :Unittests: are the unit tests of :App: and are part of :Implementation:.
-
 - :MainExecutableFile: is the main executable code file of :App:.
 
 
@@ -11,7 +9,7 @@
 
 - :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.
+- :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 reqs***
 

{codeplain-0.2.11 → codeplain-0.2.12}/system_config.py

@@ -3,6 +3,7 @@ import sys
 
 import yaml
 
+from _version import __version__
 from plain2code_console import console
 
 
@@ -11,12 +12,10 @@ class SystemConfig:
 
     def __init__(self):
         self.config = self._load_config()
-        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.client_version = self.config["client_version"]
+        self.client_version = __version__
         self.error_messages = self.config["error_messages"]
 
     def _load_config(self):

{codeplain-0.2.11 → codeplain-0.2.12}/tests/data/imports/circular_imports_2.plain

@@ -5,4 +5,4 @@ import:
 
 ***implementation reqs***
 
-- :Implementation: should include :Unittests: using Unittest framework!
+- :Implementation: should include :UnitTests: using Unittest framework!

codeplain-0.2.11/render_machine/implementation_code_helpers.py

@@ -1,26 +0,0 @@
-import json
-
-import file_utils
-import git_utils
-import plain_spec
-
-
-class ImplementationCodeHelpers:
-    @staticmethod
-    def calculate_build_folder_hash(build_folder: str) -> str:
-        _, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(build_folder)
-        return plain_spec.hash_text(f"folder={build_folder}|{json.dumps(existing_files_content)}")
-
-    @staticmethod
-    def fetch_existing_files(build_folder: str):
-        existing_files = file_utils.list_all_text_files(build_folder)
-        existing_files_content = file_utils.get_existing_files_content(build_folder, existing_files)
-        return existing_files, existing_files_content
-
-    @staticmethod
-    def get_code_diff(build_folder: str, plain_source_tree: dict, frid: str):
-        previous_frid_code_diff = git_utils.diff(
-            build_folder,
-            plain_spec.get_previous_frid(plain_source_tree, frid),
-        )
-        return previous_frid_code_diff