Add natural translation for DSL

tested/dsl/translate_parser.py

@@ -88,9 +88,22 @@ class ReturnOracle(dict):
     pass
 
 
+class NaturalLanguageMap(dict):
+    pass
+
+
 OptionDict = dict[str, int | bool]
 YamlObject = (
-    YamlDict | list | bool | float | int | str | None | ExpressionString | ReturnOracle
+    YamlDict
+    | list
+    | bool
+    | float
+    | int
+    | str
+    | None
+    | ExpressionString
+    | ReturnOracle
+    | NaturalLanguageMap
 )
 
 
@@ -138,6 +151,14 @@ def _return_oracle(loader: yaml.Loader, node: yaml.Node) -> ReturnOracle:
     return ReturnOracle(result)
 
 
+def _natural_language_map(loader: yaml.Loader, node: yaml.Node) -> NaturalLanguageMap:
+    result = _parse_yaml_value(loader, node)
+    assert isinstance(
+        result, dict
+    ), f"A natural language map must be an object, got {result} which is a {type(result)}."
+    return NaturalLanguageMap(result)
+
+
 def _parse_yaml(yaml_stream: str) -> YamlObject:
     """
     Parse a string or stream to YAML.
@@ -148,6 +169,7 @@ def _parse_yaml(yaml_stream: str) -> YamlObject:
             yaml.add_constructor("!" + actual_type, _custom_type_constructors, loader)
     yaml.add_constructor("!expression", _expression_string, loader)
     yaml.add_constructor("!oracle", _return_oracle, loader)
+    yaml.add_constructor("!natural_language", _natural_language_map, loader)
 
     try:
         return yaml.load(yaml_stream, loader)

tested/nat_translation.py

@@ -0,0 +1,211 @@
+import sys
+
+import yaml
+
+from tested.dsl.translate_parser import (
+    ExpressionString,
+    NaturalLanguageMap,
+    ReturnOracle,
+    YamlDict,
+    YamlObject,
+    _parse_yaml,
+    _validate_testcase_combinations,
+)
+
+
+def translate_testcase(testcase: YamlDict, language: str) -> YamlDict:
+    _validate_testcase_combinations(testcase)
+
+    key_to_set = "statement" if "statement" in testcase else "expression"
+    if (expr_stmt := testcase.get(key_to_set)) is not None:
+        # Must use !natural_language
+        if isinstance(expr_stmt, NaturalLanguageMap):
+            assert language in expr_stmt
+            testcase[key_to_set] = expr_stmt[language]
+    else:
+        if (stdin_stmt := testcase.get("stdin")) is not None:
+            if isinstance(stdin_stmt, dict):
+                assert language in stdin_stmt
+                testcase["stdin"] = stdin_stmt[language]
+
+        arguments = testcase.get("arguments", [])
+        if isinstance(arguments, dict):
+            assert language in arguments
+            testcase["arguments"] = arguments[language]
+
+    if (stdout := testcase.get("stdout")) is not None:
+        # Must use !natural_language
+        if isinstance(stdout, NaturalLanguageMap):
+            assert language in stdout
+            testcase["stdout"] = stdout[language]
+        elif isinstance(stdout, dict):
+            data = stdout["data"]
+            if isinstance(data, dict):
+                assert language in data
+                stdout["data"] = data[language]
+                testcase["stdout"] = stdout
+    if (file := testcase.get("file")) is not None:
+        # Must use !natural_language
+        if isinstance(file, NaturalLanguageMap):
+            assert language in file
+            testcase["file"] = file[language]
+    if (stderr := testcase.get("stderr")) is not None:
+        # Must use !natural_language
+        if isinstance(stderr, NaturalLanguageMap):
+            assert language in stderr
+            testcase["stderr"] = stderr[language]
+        elif isinstance(stderr, dict):
+            data = stderr["data"]
+            if isinstance(data, dict):
+                assert language in data
+                stderr["data"] = data[language]
+                testcase["stderr"] = stderr
+
+    if (exception := testcase.get("exception")) is not None:
+        if isinstance(exception, NaturalLanguageMap):
+            assert language in exception
+            testcase["exception"] = exception[language]
+        elif isinstance(exception, dict):
+            message = exception["message"]
+            if isinstance(message, dict):
+                assert language in message
+                exception["message"] = message[language]
+                testcase["exception"] = exception
+
+    if (result := testcase.get("return")) is not None:
+        if isinstance(result, ReturnOracle):
+            arguments = result.get("arguments", [])
+            if isinstance(arguments, dict):
+                assert language in arguments
+                result["arguments"] = arguments[language]
+
+            value = result.get("value")
+            # Must use !natural_language
+            if isinstance(value, NaturalLanguageMap):
+                assert language in value
+                result["value"] = value[language]
+
+            testcase["return"] = result
+        elif isinstance(result, NaturalLanguageMap):
+            # Must use !natural_language
+            assert language in result
+            testcase["return"] = result[language]
+
+    if (description := testcase.get("description")) is not None:
+        # Must use !natural_language
+        if isinstance(description, NaturalLanguageMap):
+            assert language in description
+            testcase["description"] = description[language]
+        elif isinstance(description, dict):
+            dd = description["description"]
+            if isinstance(dd, dict):
+                assert language in dd
+                description["description"] = dd[language]
+                testcase["description"] = description
+
+    return testcase
+
+
+def translate_testcases(testcases: list, language: str) -> list:
+    result = []
+    for testcase in testcases:
+        assert isinstance(testcase, dict)
+        result.append(translate_testcase(testcase, language))
+
+    return result
+
+
+def translate_contexts(contexts: list, language: str) -> list:
+    result = []
+    for context in contexts:
+        assert isinstance(context, dict)
+        key_to_set = "script" if "script" in context else "testcases"
+        raw_testcases = context.get(key_to_set)
+        assert isinstance(raw_testcases, list)
+        context[key_to_set] = translate_testcases(raw_testcases, language)
+        result.append(context)
+
+    return result
+
+
+def translate_tab(tab: YamlDict, language: str) -> YamlDict:
+    key_to_set = "units" if "units" in tab else "tab"
+    name = tab.get(key_to_set)
+
+    if isinstance(name, dict):
+        assert language in name
+        tab[key_to_set] = name[language]
+
+    # The tab can have testcases or contexts.
+    if "contexts" in tab:
+        assert isinstance(tab["contexts"], list)
+        tab["contexts"] = translate_contexts(tab["contexts"], language)
+    elif "cases" in tab:
+        assert "unit" in tab
+        # We have testcases N.S. / contexts O.S.
+        assert isinstance(tab["cases"], list)
+        tab["cases"] = translate_contexts(tab["cases"], language)
+    elif "testcases" in tab:
+        # We have scripts N.S. / testcases O.S.
+        assert "tab" in tab
+        assert isinstance(tab["testcases"], list)
+        tab["testcases"] = translate_testcases(tab["testcases"], language)
+    else:
+        print(tab)
+        assert "scripts" in tab
+        assert isinstance(tab["scripts"], list)
+        tab["scripts"] = translate_testcases(tab["scripts"], language)
+    return tab
+
+
+def translate_tabs(dsl_list: list, language: str) -> list:
+    result = []
+    for tab in dsl_list:
+        assert isinstance(tab, dict)
+        result.append(translate_tab(tab, language))
+
+    return result
+
+
+def translate_dsl(dsl_object: YamlObject, language: str) -> YamlObject:
+    if isinstance(dsl_object, list):
+        return translate_tabs(dsl_object, language)
+    else:
+        assert isinstance(dsl_object, dict)
+        key_to_set = "units" if "units" in dsl_object else "tabs"
+        tab_list = dsl_object.get(key_to_set)
+        assert isinstance(tab_list, list)
+        dsl_object[key_to_set] = translate_tabs(tab_list, language)
+        return dsl_object
+
+
+def parse_yaml(yaml_path: str) -> YamlObject:
+    with open(yaml_path, "r") as stream:
+        result = _parse_yaml(stream.read())
+
+    return result
+
+
+def convert_to_yaml(yaml_object: YamlObject) -> str:
+    def oracle_representer(dumper, data):
+        return dumper.represent_mapping("!oracle", data)
+
+    def expression_representer(dumper, data):
+        return dumper.represent_scalar("!expression", data)
+
+    # Register the representer for the ReturnOracle object
+    yaml.add_representer(ReturnOracle, oracle_representer)
+    yaml.add_representer(ExpressionString, expression_representer)
+    return yaml.dump(yaml_object, sort_keys=False)
+
+
+# if __name__ == "__main__":
+#     n = len(sys.argv)
+#     assert n > 1, "Expected atleast two argument (path to yaml file and language)."
+#
+#     path = sys.argv[1]
+#     lang = sys.argv[2]
+#     new_yaml = parse_yaml(path)
+#     print(new_yaml)
+#     translated_dsl = translate_dsl(new_yaml, lang)
+#     print(convert_to_yaml(translated_dsl))

tests/test_dsl_yaml.py

@@ -20,7 +20,8 @@
     StringTypes,
 )
 from tested.dsl import parse_dsl, translate_to_test_suite
-from tested.dsl.translate_parser import load_schema_validator
+from tested.dsl.translate_parser import load_schema_validator, _parse_yaml
+from tested.nat_translation import translate_dsl, convert_to_yaml
 from tested.serialisation import (
     FunctionCall,
     NumberType,
@@ -1319,3 +1320,63 @@ def test_editor_json_schema_is_valid():
     validator = load_schema_validator("schema.json")
     assert isinstance(validator.schema, dict)
     validator.check_schema(validator.schema)
+
+def test_natural_translate_unit_test():
+    # Everywhere where !natural_language is used, it is mandatory to do so.
+    # Everywhere else it isn't.
+    yaml_str = """- tab:
+    en: "counting"
+    nl: "tellen"
+  contexts:
+    - testcases:
+      - statement: !natural_language
+          en: 'result = trying(10)'
+          nl: 'resultaat = proberen(10)'
+      - expression: !natural_language
+          en: 'count_words(result)'
+          nl: 'tel_woorden(resultaat)'
+        return: !natural_language
+          en: 'The result is 10'
+          nl: 'Het resultaat is 10'
+      - expression: !natural_language
+          en: !expression "count"
+          nl: !expression "tellen"
+        return: !natural_language
+          en: 'count'
+          nl: 'tellen'
+      - expression: 'ok(10)'
+        return: !oracle
+          value: !natural_language
+            en: "The value 10 is OK!"
+            nl: "De waarde 10 is OK!"
+          oracle: "custom_check"
+          file: "test.py"
+          name: "evaluate_test"
+          arguments:
+            en: ["The value", "is OK!", "is not OK!"]
+            nl: ["De waarde", "is OK!", "is niet OK!"]    
+    """
+    translated_yaml_str = """- tab: counting
+  contexts:
+  - testcases:
+    - statement: result = trying(10)
+    - expression: count_words(result)
+      return: The result is 10
+    - expression: !expression 'count'
+      return: count
+    - expression: ok(10)
+      return: !oracle
+        value: The value 10 is OK!
+        oracle: custom_check
+        file: test.py
+        name: evaluate_test
+        arguments:
+        - The value
+        - is OK!
+        - is not OK!
+"""
+    parsed_yaml = _parse_yaml(yaml_str)
+    translated_dsl = translate_dsl(parsed_yaml, "en")
+    translated_yaml = convert_to_yaml(translated_dsl)
+    print(translated_yaml)
+    assert translated_yaml == translated_yaml_str