jaclang 0.5.8__py3-none-any.whl → 0.5.9__py3-none-any.whl

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -25,19 +25,41 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
                 schedule=without_format,
             )
             before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
+            x = code_gen_pure.ir.unparse()
+            # print(x)
+            # print(f"Testing {code_gen_pure.ir.name}")
+            # print(code_gen_pure.ir.pp())
             code_gen_jac = jac_str_to_pass(
-                jac_str=code_gen_pure.ir.unparse(),
+                jac_str=x,
                 file_path=filename,
                 target=PyastGenPass,
                 schedule=without_format,
             )
             after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
-            self.assertEqual(
-                len("\n".join(unified_diff(before.splitlines(), after.splitlines()))),
-                0,
-            )
+            if "circle_clean_tests.jac" in filename:
+                self.assertEqual(
+                    len(
+                        [
+                            i
+                            for i in unified_diff(
+                                before.splitlines(), after.splitlines(), n=0
+                            )
+                            if "test" not in i
+                        ]
+                    ),
+                    5,
+                )
+            else:
+                self.assertEqual(
+                    len(
+                        "\n".join(unified_diff(before.splitlines(), after.splitlines()))
+                    ),
+                    0,
+                )
+
         except Exception as e:
-            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+            raise e
+            # self.skipTest(f"Test failed, but skipping instead of failing: {e}")
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/core/aott.py

@@ -4,65 +4,230 @@ AOTT: Automated Operational Type Transformation.
 This has all the necessary functions to perform the AOTT operations.
 """
 
+import re
+from enum import Enum
 from typing import Any
 
+from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 
-prompt_template = """
+
+PROMPT_TEMPLATE = """
 [System Prompt]
-This is an operation you must perform and return the output values. Neither, the methodology,
-extra sentences nor the code are not needed.
+This is an operation you must perform and return the output values. Neither, the methodology, extra sentences nor the code are not needed.
+Input/Type formatting: Explanation of the Input (variable_name) (type) = value
 
 [Information]
-{information_str}
+{information}
 
-[Inputs and Input Type Information]
-{input_types_n_information_str}
+[Inputs Information]
+{inputs_information}
 
-[Output Type]
-{output_type_str}
+[Output Information]
+{output_information}
 
-[Output Type Explanations]
-{output_type_info_str}
+[Type Explanations]
+{type_explanations}
 
 [Action]
 {action}
 
 {reason_suffix}
-"""
+"""  # noqa E501
 
-with_reason_suffix = """
+WITH_REASON_SUFFIX = """
 Reason and return the output result(s) only, adhering to the provided Type in the following format
 
 [Reasoning] <Reason>
 [Output] <Result>
 """
 
-without_reason_suffix = """Generate and return the output result(s) only, adhering to the provided Type in the
- following format
+WITHOUT_REASON_SUFFIX = """Generate and return the output result(s) only, adhering to the provided Type in the following format
 
 [Output] <result>
-"""
+"""  # noqa E501
 
 
 def aott_raise(
-    information_str: str,
-    input_types_n_information_str: str,
-    output_type_str: str,
-    output_type_info_str: str,
+    information: str,
+    inputs_information: str,
+    output_information: str,
+    type_explanations: str,
     action: str,
     reason: bool,
 ) -> str:
     """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
-    return prompt_template.format(
-        information_str=information_str,
-        input_types_n_information_str=input_types_n_information_str,
-        output_type_str=output_type_str,
-        output_type_info_str=output_type_info_str,
+    return PROMPT_TEMPLATE.format(
+        information=information,
+        inputs_information=inputs_information,
+        output_information=output_information,
+        type_explanations=type_explanations,
         action=action,
-        reason_suffix=with_reason_suffix if reason else without_reason_suffix,
+        reason_suffix=WITH_REASON_SUFFIX if reason else WITHOUT_REASON_SUFFIX,
     )
 
 
-def aott_lower(meaning_out: str, output_type_info: tuple) -> Any:  # noqa: ANN401
-    """AOTT Lower uses the meaning out provided by the language model and return the result in the desired type."""
-    return meaning_out
+def get_reasoning_output(s: str) -> tuple:
+    """Get the reasoning and output from the meaning out string."""
+    reasoning_match = re.search(r"\[Reasoning\](.*)\[Output\]", s)
+    output_match = re.search(r"\[Output\](.*)", s)
+
+    if reasoning_match and output_match:
+        reasoning = reasoning_match.group(1)
+        output = output_match.group(1)
+        return (reasoning.strip(), output.strip())
+    elif output_match:
+        output = output_match.group(1)
+        return (None, output.strip())
+    else:
+        return (None, None)
+
+
+def get_info_types(
+    scope: SemScope, mod_registry: SemRegistry, incl_info: list[tuple[str, str]]
+) -> tuple[str, list[str]]:
+    """Filter the registry data based on the scope and return the info string."""
+    collected_types = []
+    avail_scopes = []
+    while True:
+        avail_scopes.append(str(scope))
+        if not scope.parent:
+            break
+        scope = scope.parent
+
+    filtered_registry = SemRegistry()
+    for _scope, sem_info_list in mod_registry.registry.items():
+        if str(_scope) in avail_scopes:
+            filtered_registry.registry[_scope] = sem_info_list
+
+    info_str = []
+    for incl in incl_info:
+        _, sem_info = filtered_registry.lookup(name=incl[0])
+        if sem_info and isinstance(sem_info, SemInfo):
+            (
+                collected_types.extend(extract_non_primary_type(sem_info.type))
+                if sem_info.type
+                else None
+            )
+            info_str.append(
+                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}"
+            )
+    return ("\n".join(info_str), collected_types)
+
+
+def get_object_string(obj: Any) -> Any:  # noqa: ANN401
+    """Get the string representation of the input object."""
+    if isinstance(obj, str):
+        return f'"{obj}"'
+    elif isinstance(obj, (int, float, bool)):
+        return str(obj)
+    elif isinstance(obj, list):
+        return "[" + ", ".join(get_object_string(item) for item in obj) + "]"
+    elif isinstance(obj, tuple):
+        return "(" + ", ".join(get_object_string(item) for item in obj) + ")"
+    elif isinstance(obj, dict):
+        return (
+            "{"
+            + ", ".join(
+                f"{get_object_string(key)}: {get_object_string(value)}"
+                for key, value in obj.items()
+            )
+            + "}"
+        )
+    elif isinstance(obj, Enum):
+        return f"{obj.__class__.__name__}.{obj.name}"
+    elif hasattr(obj, "__dict__"):
+        args = ", ".join(
+            f"{key}={get_object_string(value)}"
+            for key, value in vars(obj).items()
+            if key != "_jac_"
+        )
+        return f"{obj.__class__.__name__}({args})"
+    else:
+        return str(obj)
+
+
+def get_all_type_explanations(type_list: list, mod_registry: SemRegistry) -> dict:
+    """Get all type explanations from the input type list."""
+    collected_type_explanations = {}
+    for type_item in type_list:
+        type_explanation = get_type_explanation(type_item, mod_registry)
+        if type_explanation is not None:
+            type_explanation_str, nested_types = type_explanation
+            if type_item not in collected_type_explanations:
+                collected_type_explanations[type_item] = type_explanation_str
+            if nested_types:
+                nested_collected_type_explanations = get_all_type_explanations(
+                    list(nested_types), mod_registry
+                )
+                for k, v in nested_collected_type_explanations.items():
+                    if k not in collected_type_explanations:
+                        collected_type_explanations[k] = v
+    return collected_type_explanations
+
+
+def get_type_explanation(
+    type_str: str, mod_registry: SemRegistry
+) -> tuple[str | None, set[str] | None]:
+    """Get the type explanation of the input type string."""
+    scope, sem_info = mod_registry.lookup(name=type_str)
+    if isinstance(sem_info, SemInfo) and sem_info.type:
+        sem_info_scope = SemScope(sem_info.name, sem_info.type, scope)
+        _, type_info = mod_registry.lookup(scope=sem_info_scope)
+        type_info_str = []
+        type_info_types = []
+        if sem_info.type == "Enum" and isinstance(type_info, list):
+            for enum_item in type_info:
+                type_info_str.append(
+                    f"{enum_item.semstr} (EnumItem) ({enum_item.name})"
+                )
+        elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
+            type_info, list
+        ):
+            for arch_item in type_info:
+                type_info_str.append(
+                    f"{arch_item.semstr} ({arch_item.type}) ({arch_item.name})"
+                )
+                if arch_item.type and extract_non_primary_type(arch_item.type):
+                    type_info_types.extend(extract_non_primary_type(arch_item.type))
+        return (
+            f"{sem_info.semstr} ({sem_info.type}) ({sem_info.name}) = {', '.join(type_info_str)}",
+            set(type_info_types),
+        )
+    return None, None
+
+
+def extract_non_primary_type(type_str: str) -> list:
+    """Extract non-primary types from the type string."""
+    if not type_str:
+        return []
+    pattern = r"(?:\[|,\s*|\|)([a-zA-Z_][a-zA-Z0-9_]*)|([a-zA-Z_][a-zA-Z0-9_]*)"
+    matches = re.findall(pattern, type_str)
+    primary_types = [
+        "str",
+        "int",
+        "float",
+        "bool",
+        "list",
+        "dict",
+        "tuple",
+        "set",
+        "Any",
+        "None",
+    ]
+    non_primary_types = [m for t in matches for m in t if m and m not in primary_types]
+    return non_primary_types
+
+
+def get_type_annotation(data: Any) -> str:  # noqa: ANN401
+    """Get the type annotation of the input data."""
+    if isinstance(data, dict):
+        class_name = next(
+            (value.__class__.__name__ for value in data.values() if value is not None),
+            None,
+        )
+        if class_name:
+            return f"dict[str, {class_name}]"
+        else:
+            return "dict[str, Any]"
+    else:
+        return str(type(data).__name__)

jaclang/core/construct.py

@@ -340,7 +340,7 @@ class JacTestResult(unittest.TextTestResult):
     ) -> None:
         """Initialize FailFastTestResult object."""
         super().__init__(stream, descriptions, verbosity)  # noqa
-        self.failures_count = 0
+        self.failures_count = JacTestCheck.failcount
         self.max_failures = max_failures
 
     def addFailure(self, test, err) -> None:  # noqa
@@ -379,6 +379,7 @@ class JacTestCheck:
     test_case = unittest.TestCase()
     test_suite = unittest.TestSuite()
     breaker = False
+    failcount = 0
 
     @staticmethod
     def reset() -> None:
@@ -395,7 +396,11 @@ class JacTestCheck:
         if result.wasSuccessful():
             print("Passed successfully.")
         else:
-            JacTestCheck.breaker = True
+            fails = len(result.failures)
+            JacTestCheck.failcount += fails
+            JacTestCheck.breaker = (
+                (JacTestCheck.failcount >= maxfail) if maxfail else True
+            )
 
     @staticmethod
     def add_test(test_fun: Callable) -> None:

jaclang/core/registry.py

@@ -0,0 +1,115 @@
+"""Registry Utilities.
+
+This module contains classes and functions for managing the registry of
+semantic information.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class SemInfo:
+    """Semantic information class."""
+
+    def __init__(
+        self, name: str, type: Optional[str] = None, semstr: Optional[str] = None
+    ) -> None:
+        """Initialize the class."""
+        self.name = name
+        self.type = type
+        self.semstr = semstr
+
+    def __repr__(self) -> str:
+        """Return the string representation of the class."""
+        return f"{self.semstr} ({self.type}) ({self.name})"
+
+
+class SemScope:
+    """Scope class."""
+
+    def __init__(
+        self, scope: str, type: str, parent: Optional[SemScope] = None
+    ) -> None:
+        """Initialize the class."""
+        self.parent = parent
+        self.type = type
+        self.scope = scope
+
+    def __str__(self) -> str:
+        """Return the string representation of the class."""
+        if self.parent:
+            return f"{self.parent}.{self.scope}({self.type})"
+        return f"{self.scope}({self.type})"
+
+    def __repr__(self) -> str:
+        """Return the string representation of the class."""
+        return self.__str__()
+
+    @staticmethod
+    def get_scope_from_str(scope_str: str) -> Optional[SemScope]:
+        """Get scope from string."""
+        scope_list = scope_str.split(".")
+        parent = None
+        for scope in scope_list:
+            scope_name, scope_type = scope.split("(")
+            scope_type = scope_type[:-1]
+            parent = SemScope(scope_name, scope_type, parent)
+        return parent
+
+
+class SemRegistry:
+    """Registry class."""
+
+    def __init__(self) -> None:
+        """Initialize the class."""
+        self.registry: dict[SemScope, list[SemInfo]] = {}
+
+    def add(self, scope: SemScope, seminfo: SemInfo) -> None:
+        """Add semantic information to the registry."""
+        for k in self.registry.keys():
+            if str(k) == str(scope):
+                scope = k
+                break
+        else:
+            self.registry[scope] = []
+        self.registry[scope].append(seminfo)
+
+    def lookup(
+        self,
+        scope: Optional[SemScope] = None,
+        name: Optional[str] = None,
+        type: Optional[str] = None,
+    ) -> tuple[Optional[SemScope], Optional[SemInfo | list[SemInfo]]]:
+        """Lookup semantic information in the registry."""
+        if scope:
+            for k, v in self.registry.items():
+                if str(k) == str(scope):
+                    if name:
+                        for i in v:
+                            if i.name == name:
+                                return k, i
+                    elif type:
+                        for i in v:
+                            if i.type == type:
+                                return k, i
+                    else:
+                        return k, v
+        else:
+            for k, v in self.registry.items():
+                if name:
+                    for i in v:
+                        if i.name == name:
+                            return k, i
+                elif type:
+                    for i in v:
+                        if i.type == type:
+                            return k, i
+        return None, None
+
+    def pp(self) -> None:
+        """Pretty print the registry."""
+        for k, v in self.registry.items():
+            print(k)
+            for i in v:
+                print(f"  {i.name} {i.type} {i.semstr}")

jaclang/core/utils.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import Callable, TYPE_CHECKING
 
+import jaclang.compiler.absyntree as ast
+from jaclang.core.registry import SemScope
 
 if TYPE_CHECKING:
     from jaclang.core.construct import NodeAnchor, NodeArchitype
@@ -88,3 +90,26 @@ def traverse_graph(
                 else:
 
                     dfs(other_nd, cur_depth + 1)
+
+
+def get_sem_scope(node: ast.AstNode) -> SemScope:
+    """Get scope of the node."""
+    a = (
+        node.name
+        if isinstance(node, ast.Module)
+        else node.name.value if isinstance(node, (ast.Enum, ast.Architype)) else ""
+    )
+    if isinstance(node, ast.Module):
+        return SemScope(a, "Module", None)
+    elif isinstance(node, (ast.Enum, ast.Architype)):
+        node_type = (
+            node.__class__.__name__
+            if isinstance(node, ast.Enum)
+            else node.arch_type.value
+        )
+        if node.parent:
+            return SemScope(a, node_type, get_sem_scope(node.parent))
+    else:
+        if node.parent:
+            return get_sem_scope(node.parent)
+    return SemScope("", "", None)

jaclang/plugin/default.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import fnmatch
 import os
+import pickle
 import types
 from dataclasses import field
 from functools import wraps
@@ -11,7 +12,15 @@ from typing import Any, Callable, Optional, Type
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
-from jaclang.core.aott import aott_lower, aott_raise
+from jaclang.core.aott import (
+    aott_raise,
+    extract_non_primary_type,
+    get_all_type_explanations,
+    get_info_types,
+    get_object_string,
+    get_reasoning_output,
+    get_type_annotation,
+)
 from jaclang.core.construct import (
     Architype,
     DSFunc,
@@ -28,6 +37,7 @@ from jaclang.core.construct import (
     root,
 )
 from jaclang.core.importer import jac_importer
+from jaclang.core.registry import SemScope
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -235,6 +245,7 @@ class JacFeatureDefaults:
                 if JacTestCheck.breaker and (xit or maxfail):
                     break
             JacTestCheck.breaker = False
+            JacTestCheck.failcount = 0
             print("No test files found.") if not test_file else None
 
         return True
@@ -427,33 +438,66 @@ class JacFeatureDefaults:
     @staticmethod
     @hookimpl
     def with_llm(
+        file_loc: str,
         model: Any,  # noqa: ANN401
         model_params: dict[str, Any],
-        incl_info: tuple,
-        excl_info: tuple,
+        scope: str,
+        incl_info: list[tuple[str, str]],
+        excl_info: list[tuple[str, str]],
         inputs: tuple,
         outputs: tuple,
         action: str,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
+        with open(
+            os.path.join(
+                os.path.dirname(file_loc),
+                "__jac_gen__",
+                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
+            ),
+            "rb",
+        ) as f:
+            mod_registry = pickle.load(f)
+
+        _scope = SemScope.get_scope_from_str(scope)
+        assert _scope is not None
+
         reason = False
         if "reason" in model_params:
             reason = model_params.pop("reason")
-        input_types_n_information_str = ""  # TODO: We have to generate this
-        output_type_str = ""  # TODO: We have to generate this
-        output_type_info_str = ""  # TODO: We have to generate this
-        information_str = ""  # TODO: We have to generate this
+
+        type_collector: list = []
+        information, collected_types = get_info_types(_scope, mod_registry, incl_info)
+        type_collector.extend(collected_types)
+
+        inputs_information_list = []
+        for i in inputs:
+            typ_anno = get_type_annotation(i[3])
+            type_collector.extend(extract_non_primary_type(typ_anno))
+            inputs_information_list.append(
+                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
+            )
+        inputs_information = "\n".join(inputs_information_list)
+
+        output_information = f"{outputs[0]} ({outputs[2]})"
+        type_collector.extend(extract_non_primary_type(outputs[2]))
+
+        type_explanations_list = list(
+            get_all_type_explanations(type_collector, mod_registry).values()
+        )
+        type_explanations = "\n".join(type_explanations_list)
+
         meaning_in = aott_raise(
-            information_str,
-            input_types_n_information_str,
-            output_type_str,
-            output_type_info_str,
+            information,
+            inputs_information,
+            output_information,
+            type_explanations,
             action,
             reason,
         )
         meaning_out = model.__infer__(meaning_in, **model_params)
-        output_type_info = (None, None)  # TODO: We have to generate this
-        return aott_lower(meaning_out, output_type_info)
+        reasoning, output = get_reasoning_output(meaning_out)
+        return output
 
 
 class JacBuiltin:

jaclang/plugin/feature.py

@@ -227,18 +227,22 @@ class JacFeature:
 
     @staticmethod
     def with_llm(
+        file_loc: str,
         model: Any,  # noqa: ANN401
         model_params: dict[str, Any],
-        incl_info: tuple,
-        excl_info: tuple,
+        scope: str,
+        incl_info: list[tuple[str, str]],
+        excl_info: list[tuple[str, str]],
         inputs: tuple,
         outputs: tuple,
         action: str,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
         return pm.hook.with_llm(
+            file_loc=file_loc,
             model=model,
             model_params=model_params,
+            scope=scope,
             incl_info=incl_info,
             excl_info=excl_info,
             inputs=inputs,

jaclang/plugin/spec.py

@@ -211,10 +211,12 @@ class JacFeatureSpec:
     @staticmethod
     @hookspec(firstresult=True)
     def with_llm(
+        file_loc: str,
         model: Any,  # noqa: ANN401
         model_params: dict[str, Any],
-        incl_info: tuple,
-        excl_info: tuple,
+        scope: str,
+        incl_info: list[tuple[str, str]],
+        excl_info: list[tuple[str, str]],
         inputs: tuple,
         outputs: tuple,
         action: str,