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

jaclang/compiler/tests/test_parser.py

@@ -90,5 +90,58 @@ class TestLarkParser(TestCaseMicroSuite):
                 continue
             self.assertIn(i, rules)
 
+    def test_all_ast_has_normalize(self) -> None:
+        """Test for enter/exit name diffs with parser."""
+        import jaclang.compiler.absyntree as ast
+        import inspect
+        import sys
+
+        exclude = [
+            "AstNode",
+            "WalkerStmtOnlyNode",
+            "JacSource",
+            "EmptyToken",
+            "AstSymbolNode",
+            "AstImplNeedingNode",
+            "AstAccessNode",
+            "TokenSymbol",
+            "Literal",
+            "AstDocNode",
+            "AstSemStrNode",
+            "PythonModuleAst",
+            "AstAsyncNode",
+            "AstElseBodyNode",
+            "AstTypedVarNode",
+            "AstImplOnlyNode",
+            "Expr",
+            "AtomExpr",
+            "ElementStmt",
+            "ArchBlockStmt",
+            "EnumBlockStmt",
+            "CodeBlockStmt",
+            "NameSpec",
+            "ArchSpec",
+            "MatchPattern",
+        ]
+        module_name = ast.__name__
+        module = sys.modules[module_name]
+
+        # Retrieve the source code of the module
+        source_code = inspect.getsource(module)
+
+        classes = inspect.getmembers(module, inspect.isclass)
+        ast_node_classes = [
+            cls
+            for _, cls in classes
+            if issubclass(cls, ast.AstNode) and not issubclass(cls, ast.Token)
+        ]
+
+        ordered_classes = sorted(
+            ast_node_classes, key=lambda cls: source_code.find(f"class {cls.__name__}")
+        )
+        for cls in ordered_classes:
+            if cls.__name__ not in exclude:
+                self.assertIn("normalize", cls.__dict__)
+
 
 TestLarkParser.self_attach_micro_tests()

jaclang/compiler/workspace.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Sequence
+from typing import Optional, Sequence
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_str_to_pass
@@ -33,7 +33,7 @@ class ModuleInfo:
 
     def __init__(
         self,
-        ir: ast.Module,
+        ir: Optional[ast.Module],
         errors: Sequence[Alert],
         warnings: Sequence[Alert],
     ) -> None:
@@ -46,10 +46,11 @@ class ModuleInfo:
 class Workspace:
     """Class for managing workspace."""
 
-    def __init__(self, path: str) -> None:
+    def __init__(self, path: str, lazy_parse: bool = False) -> None:
         """Initialize workspace."""
         self.path = path
         self.modules: dict[str, ModuleInfo] = {}
+        self.lazy_parse = lazy_parse
         self.rebuild_workspace()
 
     def rebuild_workspace(self) -> None:
@@ -63,6 +64,15 @@ class Workspace:
         ]:
             if file in self.modules:
                 continue
+            if self.lazy_parse:
+                # If lazy_parse is True, add the file to modules with empty IR
+                self.modules[file] = ModuleInfo(
+                    ir=None,
+                    errors=[],
+                    warnings=[],
+                )
+                continue
+
             with open(file, "r") as f:
                 source = f.read()
             build = jac_str_to_pass(
@@ -98,10 +108,13 @@ class Workspace:
                         warnings=build.warnings_had,
                     )
 
-    def rebuild_file(self, file_path: str, deep: bool = False) -> bool:
+    def rebuild_file(
+        self, file_path: str, deep: bool = False, source: str = ""
+    ) -> bool:
         """Rebuild a file."""
-        with open(file_path, "r") as f:
-            source = f.read()
+        if source == "":
+            with open(file_path, "r") as f:
+                source = f.read()
         build = jac_str_to_pass(
             jac_str=source,
             file_path=file_path,
@@ -152,30 +165,40 @@ class Workspace:
         self, file_path: str, deep: bool = False
     ) -> list[ast.ModulePath]:
         """Return a list of dependencies for a file."""
+        mod_ir = self.modules[file_path].ir
         if deep:
-            return [
-                i
-                for i in self.modules[file_path].ir.get_all_sub_nodes(ast.ModulePath)
-                if i.parent
-                and isinstance(i.parent, ast.Import)
-                and i.parent.lang.tag.value == "jac"
-            ]
+            return (
+                [
+                    i
+                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
+                    if i.parent
+                    and isinstance(i.parent, ast.Import)
+                    and i.parent.lang.tag.value == "jac"
+                ]
+                if mod_ir
+                else []
+            )
         else:
-            return [
-                i
-                for i in self.modules[file_path].ir.get_all_sub_nodes(ast.ModulePath)
-                if i.loc.mod_path == file_path
-                and i.parent
-                and isinstance(i.parent, ast.Import)
-                and i.parent.lang.tag.value == "jac"
-            ]
+            return (
+                [
+                    i
+                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
+                    if i.loc.mod_path == file_path
+                    and i.parent
+                    and isinstance(i.parent, ast.Import)
+                    and i.parent.lang.tag.value == "jac"
+                ]
+                if mod_ir
+                else []
+            )
 
     def get_symbols(self, file_path: str) -> Sequence[Symbol]:
         """Return a list of symbols for a file."""
         symbols = []
+        mod_ir = self.modules[file_path].ir
         if file_path in self.modules:
-            root_table = self.modules[file_path].ir.sym_tab
-            if file_path in self.modules and isinstance(root_table, SymbolTable):
+            root_table = mod_ir.sym_tab if mod_ir else None
+            if file_path in self.modules and root_table:
                 for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
                     symbols += list(i.tab.values())
         return symbols
@@ -191,10 +214,13 @@ class Workspace:
 
     def get_uses(self, file_path: str) -> Sequence[ast.AstSymbolNode]:  # need test
         """Return a list of definitions for a file."""
-        uses = []
+        mod_ir = self.modules[file_path].ir
+        uses: list[ast.AstSymbolNode] = []
+        if self.lazy_parse:
+            return uses
         if file_path in self.modules:
-            root_table = self.modules[file_path].ir.sym_tab
-            if file_path in self.modules and isinstance(root_table, SymbolTable):
+            root_table = mod_ir.sym_tab if mod_ir else None
+            if file_path in self.modules and root_table:
                 for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
                     uses += i.uses
         return uses

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

@@ -328,11 +328,58 @@ class DSFunc:
         self.func = getattr(cls, self.name)
 
 
+class JacTestResult(unittest.TextTestResult):
+    """Jac test result class."""
+
+    def __init__(
+        self,
+        stream,  # noqa
+        descriptions,  # noqa
+        verbosity: int,
+        max_failures: Optional[int] = None,
+    ) -> None:
+        """Initialize FailFastTestResult object."""
+        super().__init__(stream, descriptions, verbosity)  # noqa
+        self.failures_count = JacTestCheck.failcount
+        self.max_failures = max_failures
+
+    def addFailure(self, test, err) -> None:  # noqa
+        """Count failures and stop."""
+        super().addFailure(test, err)
+        self.failures_count += 1
+        if self.max_failures is not None and self.failures_count >= self.max_failures:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop the test execution."""
+        self.shouldStop = True
+
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    """Jac test runner class."""
+
+    def __init__(self, max_failures: Optional[int] = None, **kwargs) -> None:  # noqa
+        """Initialize JacTextTestRunner object."""
+        self.max_failures = max_failures
+        super().__init__(**kwargs)
+
+    def _makeResult(self) -> JacTestResult:  # noqa
+        """Override the method to return an instance of JacTestResult."""
+        return JacTestResult(
+            self.stream,
+            self.descriptions,
+            self.verbosity,
+            max_failures=self.max_failures,
+        )
+
+
 class JacTestCheck:
     """Jac Testing and Checking."""
 
     test_case = unittest.TestCase()
     test_suite = unittest.TestSuite()
+    breaker = False
+    failcount = 0
 
     @staticmethod
     def reset() -> None:
@@ -341,9 +388,19 @@ class JacTestCheck:
         JacTestCheck.test_suite = unittest.TestSuite()
 
     @staticmethod
-    def run_test() -> None:
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
         """Run the test suite."""
-        unittest.TextTestRunner().run(JacTestCheck.test_suite)
+        verb = 2 if verbose else 1
+        runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
+        result = runner.run(JacTestCheck.test_suite)
+        if result.wasSuccessful():
+            print("Passed successfully.")
+        else:
+            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)