codeplain 0.1.0__py3-none-any.whl

plain2code_nodes.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from typing import Mapping, Sequence, TextIO
+
+from liquid2 import Environment, RenderContext, Template, TemplateNotFoundError
+from liquid2.builtin import IncludeTag
+from liquid2.builtin.tags.include_tag import IncludeNode
+
+
+class Plain2CodeIncludeNode(IncludeNode):
+    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
+        """Render the node to the output buffer."""
+        name = self.name.evaluate(context)
+        whitespaces = 0
+        is_comment = False
+        i = self.token.start
+        while self.token.source[i] != "\n" and i >= 0:
+            if self.token.source[i] == " ":
+                whitespaces += 1
+            elif self.token.source[i] == ">":
+                is_comment = True
+                break
+            else:
+                whitespaces = 0
+            i -= 1
+
+        if is_comment:
+            return buffer.write(str(self))
+
+        try:
+            template = context.env.get_template(str(name), context=context, tag=self.tag, whitespaces=whitespaces)
+        except TemplateNotFoundError as err:
+            err.token = self.name.token
+            err.template_name = context.template.full_name()
+            raise
+
+        namespace: dict[str, object] = dict(arg.evaluate(context) for arg in self.args)
+
+        character_count = 0
+
+        with context.extend(namespace, template=template):
+            if self.var:
+                val = self.var.evaluate(context)
+                key = self.alias or template.name.split(".")[0]
+
+                if isinstance(val, Sequence) and not isinstance(val, str):
+                    context.raise_for_loop_limit(len(val))
+                    for itm in val:
+                        namespace[key] = itm
+                        character_count += template.render_with_context(context, buffer, partial=True)
+                else:
+                    namespace[key] = val
+                    character_count = template.render_with_context(context, buffer, partial=True)
+            else:
+
+                character_count = template.render_with_context(context, buffer, partial=True)
+
+        return character_count
+
+
+class Plain2CodeIncludeTag(IncludeTag):
+    node_class = Plain2CodeIncludeNode
+
+
+class Plain2CodeLoaderMixin:
+    def __init__(self, *args, **kwargs):
+        if not hasattr(self, "get_source"):
+            raise NotImplementedError("Class must implement get_source")
+        super().__init__(*args, **kwargs)
+
+    def load(
+        self,
+        env: Environment,
+        name: str,
+        *,
+        globals: Mapping[str, object] | None = None,
+        context: RenderContext | None = None,
+        **kwargs: object,
+    ) -> Template:
+        """
+        Find and parse template source code.
+
+        Args:
+            env: The `Environment` attempting to load the template source text.
+            name: A name or identifier for a template's source text.
+            globals: A mapping of render context variables attached to the
+                resulting template.
+            context: An optional render context that can be used to narrow the template
+                source search space.
+            kwargs: Arbitrary arguments that can be used to narrow the template source
+                search space.
+        """
+        source, full_name, uptodate, matter = self.get_source(env, name, context=context, **kwargs)
+        whitespaces = kwargs.get("whitespaces", 0)
+        assert isinstance(whitespaces, int)
+        source = source.rstrip().replace("\n", "\n" + " " * whitespaces)
+
+        path = Path(full_name)
+
+        template = env.from_string(
+            source,
+            name=path.name,
+            path=path,
+            globals=globals,
+            overlay_data=matter,
+        )
+
+        template.uptodate = uptodate
+        return template

plain2code_read_config.py

@@ -0,0 +1,74 @@
+import os
+from argparse import ArgumentParser, Namespace
+from typing import Any, Dict
+
+import yaml
+
+from plain2code_console import console
+
+
+def load_config(config_file: str) -> Dict[str, Any]:
+    """Load configuration from YAML file."""
+    try:
+        with open(config_file, "r") as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        console.error(f"Error loading config file: {e}. Please check the config file path and the config file content.")
+        raise e
+
+
+def validate_config(config: Dict[str, Any], parser: ArgumentParser) -> None:
+    """Validate the configuration against the parser."""
+    actions = [action.dest for action in parser._actions]
+    for action in parser._actions:
+        if hasattr(action, "option_strings"):
+            actions.extend(opt.lstrip("-") for opt in action.option_strings)
+
+    for key in config.keys():
+        if key not in actions:
+            raise KeyError(f"Invalid configuration key: {key}")
+    return config
+
+
+def get_args_from_config(config_file: str, parser: ArgumentParser) -> Namespace:
+    """
+    Read configuration from YAML file and return args compatible with plain2code_arguments.py.
+
+    Args:
+        config_file: Path to the YAML config file
+    Returns:
+        Namespace object with arguments as defined in plain2code_arguments.py
+
+    Raises:
+        FileNotFoundError: If config file doesn't exist
+        KeyError: If argument not found in parser arguments
+    """
+
+    args = Namespace()
+
+    if config_file == "config.yaml":
+        if not os.path.exists(config_file):
+            console.info(f"Default config file {config_file} not found. No config file is read.")
+            return args
+
+    # Load config
+    config = load_config(config_file)
+    config = validate_config(config, parser)
+
+    for action in parser._actions:
+        # Create a list of possible config keys for this argument
+        possible_keys = [action.dest]
+        if hasattr(action, "option_strings"):
+            # Add all option strings without leading dashes
+            possible_keys.extend(opt.lstrip("-") for opt in action.option_strings)
+
+        # Handling multi-named arguments like --verbose and -v
+        config_value = None
+        for key in possible_keys:
+            if key in config:
+                config_value = config[key]
+                break
+
+        if config_value is not None:
+            setattr(args, action.dest, config_value)
+    return args

plain2code_state.py

@@ -0,0 +1,75 @@
+"""Contains all state and context information we need for the rendering process."""
+
+import json
+import os
+import uuid
+from typing import Optional
+
+from plain2code_console import console
+
+CONFORMANCE_TESTS_DEFINITION_FILE_NAME = "conformance_tests.json"
+
+
+class ConformanceTestsUtils:
+    """Manages the state of conformance tests."""
+
+    def __init__(
+        self,
+        conformance_tests_folder: str,
+        conformance_tests_definition_file_name: str,
+        verbose: bool,
+    ):
+        self.conformance_tests_folder = conformance_tests_folder
+        self.full_conformance_tests_definition_file_name = os.path.join(
+            self.conformance_tests_folder, conformance_tests_definition_file_name
+        )
+        self.verbose = verbose
+
+    def get_conformance_tests_json(self):
+        try:
+            with open(self.full_conformance_tests_definition_file_name, "r") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            return {}
+
+    def dump_conformance_tests_json(self, conformance_tests_json: dict):
+        """Dump the conformance tests definition to the file."""
+        if os.path.exists(self.conformance_tests_folder):
+            if self.verbose:
+                console.info(
+                    f"Storing conformance tests definition to {self.full_conformance_tests_definition_file_name}"
+                )
+            with open(self.full_conformance_tests_definition_file_name, "w") as f:
+                json.dump(conformance_tests_json, f, indent=4)
+
+
+class RunState:
+    """Contains information about the identifiable state of the rendering process."""
+
+    def __init__(self, spec_filename: str, replay_with: Optional[str] = None):
+        self.replay: bool = replay_with is not None
+        if replay_with:
+            self.render_id: str = replay_with
+        else:
+            self.render_id: str = str(uuid.uuid4())
+        self.spec_filename: str = spec_filename
+        self.call_count: int = 0
+        self.unittest_batch_id: int = 0
+        self.frid_render_anaysis: dict[str, str] = {}
+
+    def increment_call_count(self):
+        self.call_count += 1
+
+    def increment_unittest_batch_id(self):
+        self.unittest_batch_id += 1
+
+    def add_rendering_analysis_for_frid(self, frid, rendering_analysis) -> None:
+        self.frid_render_anaysis[frid] = rendering_analysis
+
+    def to_dict(self):
+        return {
+            "render_id": self.render_id,
+            "call_count": self.call_count,
+            "replay": self.replay,
+            "spec_filename": self.spec_filename,
+        }

plain2code_utils.py

@@ -0,0 +1,56 @@
+import logging
+from typing import Optional
+
+import plain_spec
+from plain2code_console import console
+
+AMBIGUITY_CAUSES = {
+    "reference_resource_ambiguity": "Ambiguity is in the reference resources",
+    "definition_ambiguity": "Ambiguity is in the definitions",
+    "non_functional_requirement_ambiguity": "Ambiguity is in the non-functional requirements",
+    "functional_requirement_ambiguity": "Ambiguity is in the functional requirements",
+    "other": "Ambiguity in the other parts of the specification",
+}
+
+
+class RetryOnlyFilter(logging.Filter):
+    def filter(self, record):
+        # Allow all logs with level > DEBUG (i.e., INFO and above)
+        if record.levelno > logging.DEBUG:
+            return True
+        # For DEBUG logs, only allow if message matches retry-related patterns
+        msg = record.getMessage().lower()
+        return (
+            "retrying due to" in msg
+            or "raising timeout error" in msg
+            or "raising connection error" in msg
+            or "encountered exception" in msg
+            or "retrying request" in msg
+            or "retry left" in msg
+            or "1 retry left" in msg
+            or "retries left" in msg
+        )
+
+
+def print_dry_run_output(plain_source_tree: dict, render_range: Optional[list[str]]):
+    frid = plain_spec.get_first_frid(plain_source_tree)
+
+    while frid is not None:
+        is_inside_range = render_range is None or frid in render_range
+
+        if is_inside_range:
+            specifications, _ = plain_spec.get_specifications_for_frid(plain_source_tree, frid)
+            functional_requirement_text = specifications[plain_spec.FUNCTIONAL_REQUIREMENTS][-1]
+            console.info("\n-------------------------------------")
+            console.info(f"Rendering functional requirement {frid}")
+            console.info(f"[b]{functional_requirement_text}[/b]")
+            console.info("-------------------------------------\n")
+            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}")
+        else:
+            console.info("\n-------------------------------------")
+            console.info(f"Skipping rendering iteration: {frid}")
+            console.info("-------------------------------------\n")
+
+        frid = plain_spec.get_next_frid(plain_source_tree, frid)

plain_spec.py

@@ -0,0 +1,360 @@
+import hashlib
+import json
+import uuid
+from typing import Optional
+
+from liquid2.filter import with_context
+
+DEFINITIONS = "Definitions:"
+NON_FUNCTIONAL_REQUIREMENTS = "Non-Functional Requirements:"
+TEST_REQUIREMENTS = "Test Requirements:"
+FUNCTIONAL_REQUIREMENTS = "Functional Requirements:"
+ACCEPTANCE_TESTS = "acceptance_tests"
+ACCEPTANCE_TEST_HEADING = "Acceptance Tests:"
+
+ALLOWED_SPECIFICATION_HEADINGS = [
+    DEFINITIONS,
+    NON_FUNCTIONAL_REQUIREMENTS,
+    TEST_REQUIREMENTS,
+    FUNCTIONAL_REQUIREMENTS,
+    ACCEPTANCE_TEST_HEADING,
+]
+
+
+class InvalidLiquidVariableName(Exception):
+    pass
+
+
+def collect_specification_linked_resources(specification, specification_heading, linked_resources_list):
+    linked_resources = []
+    if "linked_resources" in specification:
+        linked_resources.extend(specification["linked_resources"])
+
+    for resource in linked_resources:
+        resource_found = False
+        for resource_map in linked_resources_list:
+            if resource["text"] == resource_map["text"]:
+                if resource["target"] != resource_map["target"]:
+                    raise Exception(
+                        f"The file {resource['target']} is linked to multiple linked resources with the same text: {resource['text']}"
+                    )
+            elif resource["target"] == resource_map["target"]:
+                if resource["text"] != resource_map["text"]:
+                    raise Exception(
+                        f"The linked resource {resource['text']} is linked to multiple files: {resource_map['target']}"
+                    )
+            else:
+                continue
+
+            if resource_found:
+                raise Exception(
+                    "Duplicate linked resource found: " + resource["text"] + " (" + resource["target"] + ")"
+                )
+
+            resource_found = True
+            resource_map["sections"].append(specification_heading)
+
+        if not resource_found:
+            linked_resources_list.append(
+                {"text": resource["text"], "target": resource["target"], "sections": [specification_heading]}
+            )
+
+
+def collect_linked_resources_in_section(
+    section, linked_resources_list, specifications_list, include_acceptance_tests, frid=Optional[str]
+):
+    # When should we collect specification headings in the current section. Either when one of the following holds true:
+    # - frid wasn't specified
+    # - section has no ID (and that's exactly when it's the root section)
+    # - section has ID, frid was specified and the specified frid inside the current section tree
+    should_collect_specification_headings_in_current_section = (
+        frid is None or "ID" not in section or frid.startswith(section["ID"])
+    )
+    if should_collect_specification_headings_in_current_section:
+        specifications_to_collect = list(set([DEFINITIONS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS]))
+        if specifications_list:
+            specifications_to_collect = list(set(specifications_to_collect) & set(specifications_list))
+        for specification_heading in specifications_to_collect:
+            if specification_heading in section:
+                for requirement in section[specification_heading]:
+                    collect_specification_linked_resources(requirement, specification_heading, linked_resources_list)
+
+    if FUNCTIONAL_REQUIREMENTS in section and (
+        not specifications_list or FUNCTIONAL_REQUIREMENTS in specifications_list
+    ):
+        functional_requirement_count = 0
+        for requirement in section[FUNCTIONAL_REQUIREMENTS]:
+            collect_specification_linked_resources(requirement, FUNCTIONAL_REQUIREMENTS, linked_resources_list)
+
+            functional_requirement_count += 1
+            section_id = section.get("ID", None)
+            current_frid = get_current_frid(section_id, functional_requirement_count)
+
+            if ACCEPTANCE_TESTS in requirement and include_acceptance_tests and (frid is None or frid == current_frid):
+                for acceptance_test in requirement[ACCEPTANCE_TESTS]:
+                    collect_specification_linked_resources(
+                        acceptance_test, FUNCTIONAL_REQUIREMENTS, linked_resources_list
+                    )
+
+            if frid is not None and current_frid == frid:
+                # here, we rely on the fact that FRIDs are incrementing. And if we have reached the current FRID, we should
+                # not collect any FRIDs after the current one.
+                return True
+
+    if "sections" in section:
+        for subsection in section["sections"]:
+            if collect_linked_resources_in_section(
+                subsection, linked_resources_list, specifications_list, include_acceptance_tests, frid
+            ):
+                return True
+
+    return False
+
+
+# TODO: check if this function can be refactored to return the list of linked resources instead of modifying it in place
+def collect_linked_resources(
+    plain_source_tree, linked_resources_list, specifications_list, include_acceptance_tests, frid=None
+):
+
+    if not isinstance(plain_source_tree, dict):
+        raise ValueError("[plain_source_tree must be a dictionary.")
+
+    if frid is not None:
+        functional_requirements = get_frids(plain_source_tree)
+        if frid not in functional_requirements:
+            raise ValueError(f"frid {frid} does not exist.")
+
+    result = collect_linked_resources_in_section(
+        plain_source_tree, linked_resources_list, specifications_list, include_acceptance_tests, frid
+    )
+
+    # Sort linked_resources_list by the "text" field
+    linked_resources_list.sort(key=lambda x: x["text"])
+
+    return result
+
+
+def get_frids(plain_source_tree):
+    if FUNCTIONAL_REQUIREMENTS in plain_source_tree:
+        for functional_requirement_id in range(1, len(plain_source_tree[FUNCTIONAL_REQUIREMENTS]) + 1):
+            if "ID" in plain_source_tree:
+                yield plain_source_tree["ID"] + "." + str(functional_requirement_id)
+            else:
+                yield str(functional_requirement_id)
+
+    if "sections" in plain_source_tree:
+        for section in plain_source_tree["sections"]:
+            yield from get_frids(section)
+
+
+def get_first_frid(plain_source_tree):
+    return next(get_frids(plain_source_tree), None)
+
+
+def get_current_frid(section_id: Optional[str], functional_requirement_count: int) -> str:
+    if section_id is None:
+        return str(functional_requirement_count)
+    else:
+        return section_id + "." + str(functional_requirement_count)
+
+
+def get_next_frid(plain_source_tree, frid):
+    functional_requirements = get_frids(plain_source_tree)
+    for temp_frid in functional_requirements:
+        if temp_frid == frid:
+            return next(functional_requirements, None)
+
+    raise Exception(f"Functional requirement {frid} does not exist.")
+
+
+def get_previous_frid(plain_source_tree, frid):
+    previous_frid = None
+    for temp_frid in get_frids(plain_source_tree):
+        if temp_frid == frid:
+            return previous_frid
+
+        previous_frid = temp_frid
+
+    raise Exception(f"Functional requirement {frid} does not exist.")
+
+
+def get_specification_item_markdown(specification_item, code_variables, replace_code_variables):
+    markdown = specification_item["markdown"]
+    if "code_variables" in specification_item:
+        for code_variable in specification_item["code_variables"]:
+            if code_variable["name"] in code_variables:
+                if code_variables[code_variable["name"]] != code_variable["value"]:
+                    raise Exception(
+                        f"Code variable {code_variable['name']} has multiple values: {code_variables[code_variable['name']]} and {code_variable['value']}"
+                    )
+            else:
+                code_variables[code_variable["name"]] = code_variable["value"]
+
+            if replace_code_variables:
+                markdown = markdown.replace(f"{{{{ {code_variable['name']} }}}}", code_variable["value"])
+
+    return markdown
+
+
+def get_specifications_from_plain_source_tree(
+    frid,
+    plain_source_tree,
+    definitions,
+    non_functional_requirements,
+    test_requirements,
+    functional_requirements,
+    acceptance_tests,
+    code_variables,
+    replace_code_variables,
+    section_id=None,
+):
+    return_frid = None
+    if FUNCTIONAL_REQUIREMENTS in plain_source_tree and len(plain_source_tree[FUNCTIONAL_REQUIREMENTS]) > 0:
+        functional_requirement_count = 0
+        for functional_requirement in plain_source_tree[FUNCTIONAL_REQUIREMENTS]:
+            functional_requirement_count += 1
+            if section_id is None:
+                current_frid = str(functional_requirement_count)
+            else:
+                current_frid = section_id + "." + str(functional_requirement_count)
+
+            functional_requirements.append(
+                get_specification_item_markdown(functional_requirement, code_variables, replace_code_variables)
+            )
+
+            if current_frid == frid:
+                if ACCEPTANCE_TESTS in functional_requirement:
+                    for acceptance_test in functional_requirement[ACCEPTANCE_TESTS]:
+                        acceptance_tests.append(
+                            get_specification_item_markdown(acceptance_test, code_variables, replace_code_variables)
+                        )
+
+                return_frid = current_frid
+                break
+
+    if "sections" in plain_source_tree:
+        for section in plain_source_tree["sections"]:
+            sub_frid = get_specifications_from_plain_source_tree(
+                frid,
+                section,
+                definitions,
+                non_functional_requirements,
+                test_requirements,
+                functional_requirements,
+                acceptance_tests,
+                code_variables,
+                replace_code_variables,
+                section["ID"],
+            )
+            if sub_frid is not None:
+                return_frid = sub_frid
+                break
+
+    if return_frid is not None:
+        if DEFINITIONS in plain_source_tree and plain_source_tree[DEFINITIONS] is not None:
+            definitions[0:0] = [
+                get_specification_item_markdown(specification, code_variables, replace_code_variables)
+                for specification in plain_source_tree[DEFINITIONS]
+            ]
+        if (
+            NON_FUNCTIONAL_REQUIREMENTS in plain_source_tree
+            and plain_source_tree[NON_FUNCTIONAL_REQUIREMENTS] is not None
+        ):
+            non_functional_requirements[0:0] = [
+                get_specification_item_markdown(specification, code_variables, replace_code_variables)
+                for specification in plain_source_tree[NON_FUNCTIONAL_REQUIREMENTS]
+            ]
+        if TEST_REQUIREMENTS in plain_source_tree and plain_source_tree[TEST_REQUIREMENTS] is not None:
+            test_requirements[0:0] = [
+                get_specification_item_markdown(specification, code_variables, replace_code_variables)
+                for specification in plain_source_tree[TEST_REQUIREMENTS]
+            ]
+
+    return return_frid
+
+
+def get_specifications_for_frid(plain_source_tree, frid, replace_code_variables=True):
+    definitions = []
+    non_functional_requirements = []
+    test_requirements = []
+    functional_requirements = []
+    acceptance_tests = []
+
+    code_variables = {}
+
+    result = get_specifications_from_plain_source_tree(
+        frid,
+        plain_source_tree,
+        definitions,
+        non_functional_requirements,
+        test_requirements,
+        functional_requirements,
+        acceptance_tests,
+        code_variables,
+        replace_code_variables,
+    )
+    if result is None:
+        raise Exception(f"Functional requirement {frid} does not exist.")
+
+    specifications = {
+        DEFINITIONS: definitions,
+        NON_FUNCTIONAL_REQUIREMENTS: non_functional_requirements,
+        TEST_REQUIREMENTS: test_requirements,
+        FUNCTIONAL_REQUIREMENTS: functional_requirements,
+    }
+
+    if acceptance_tests:
+        specifications[ACCEPTANCE_TESTS] = acceptance_tests
+
+    if code_variables:
+        return specifications, code_variables
+    else:
+        return specifications, None
+
+
+@with_context
+def code_variable_liquid_filter(value, *, context):
+    if len(context.scope) == 0:
+        raise Exception("Invalid use of code_variable filter!")
+
+    if "code_variables" in context.globals:
+        code_variables = context.globals["code_variables"]
+
+        variable = next(iter(context.scope.items()))
+
+        unique_str = uuid.uuid4().hex
+
+        code_variables[unique_str] = {variable[0]: value}
+
+        return unique_str
+    else:
+
+        return value
+
+
+@with_context
+def prohibited_chars_liquid_filter(value, prohibited_chars, *, context):
+    if not isinstance(value, str):
+        value = str(value)
+
+    if len(context.scope) == 0:
+        raise Exception("Invalid use of prohibited_chars filter!")
+
+    variable = next(iter(context.scope.items()))
+    variable_name = variable[0]
+
+    for char in prohibited_chars:
+        if char in value:
+            raise InvalidLiquidVariableName(
+                f"'{char}' is not a valid character for variable '{variable_name}' (value: '{value}')."
+            )
+
+    return value
+
+
+def hash_text(text):
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+def get_hash_value(specifications):
+    return hash_text(json.dumps(specifications, indent=4))