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

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

@@ -0,0 +1,68 @@
+"""
+AOTT: Automated Operational Type Transformation.
+
+This has all the necessary functions to perform the AOTT operations.
+"""
+
+from typing import Any
+
+
+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.
+
+[Information]
+{information_str}
+
+[Inputs and Input Type Information]
+{input_types_n_information_str}
+
+[Output Type]
+{output_type_str}
+
+[Output Type Explanations]
+{output_type_info_str}
+
+[Action]
+{action}
+
+{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
+
+[Output] <result>
+"""
+
+
+def aott_raise(
+    information_str: str,
+    input_types_n_information_str: str,
+    output_type_str: str,
+    output_type_info_str: 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,
+        action=action,
+        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

jaclang/core/construct.py

@@ -141,14 +141,14 @@ class EdgeAnchor(ObjectAnchor):
 
     def detach(
         self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
-    ) -> EdgeAnchor:
+    ) -> None:
         """Detach edge from nodes."""
-        self.source = src  # TODO: Delete me, don't keep attached
-        self.target = trg  # TODO: Delete me, don't keep attached
         self.is_undirected = is_undirected
         src._jac_.edges.remove(self.obj)
         trg._jac_.edges.remove(self.obj)
-        return self
+        self.source = None
+        self.target = None
+        del self
 
     def spawn_call(self, walk: WalkerArchitype) -> WalkerArchitype:
         """Invoke data spatial call."""
@@ -328,11 +328,57 @@ 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 = 0
+        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
 
     @staticmethod
     def reset() -> None:
@@ -341,9 +387,15 @@ 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:
+            JacTestCheck.breaker = True
 
     @staticmethod
     def add_test(test_fun: Callable) -> None:

jaclang/core/importer.py

@@ -46,24 +46,23 @@ def jac_importer(
             codeobj = marshal.loads(codeobj)
     else:
         gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
-        py_file_path = path.join(gen_dir, module_name + ".py")
         pyc_file_path = path.join(gen_dir, module_name + ".jbc")
         if (
             cachable
-            and path.exists(py_file_path)
-            and path.getmtime(py_file_path) > path.getmtime(full_target)
+            and path.exists(pyc_file_path)
+            and path.getmtime(pyc_file_path) > path.getmtime(full_target)
         ):
             with open(pyc_file_path, "rb") as f:
                 codeobj = marshal.load(f)
         else:
-            if error := compile_jac(full_target):
-                if error:
-                    for e in error:
-                        print(e)
-                        logging.error(e)
+            result = compile_jac(full_target, cache_result=cachable)
+            if result.errors_had or not result.ir.gen.py_bytecode:
+                for e in result.errors_had:
+                    print(e)
+                    logging.error(e)
                 return None
-            with open(pyc_file_path, "rb") as f:
-                codeobj = marshal.load(f)
+            else:
+                codeobj = marshal.loads(result.ir.gen.py_bytecode)
 
     module_name = override_name if override_name else module_name
     module = types.ModuleType(module_name)

jaclang/core/utils.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import NodeAnchor
+    from jaclang.core.construct import NodeAnchor, NodeArchitype
 
 
 def collect_node_connections(
@@ -18,7 +18,6 @@ def collect_node_connections(
     if current_node not in visited_nodes:
         visited_nodes.add(current_node)
         edges = current_node.edges
-
         for edge_ in edges:
             target = edge_._jac_.target
             if target:
@@ -26,3 +25,66 @@ def collect_node_connections(
                     (current_node.obj, target._jac_.obj, edge_.__class__.__name__)
                 )
                 collect_node_connections(target._jac_, visited_nodes, connections)
+
+
+def traverse_graph(
+    node: NodeArchitype,
+    cur_depth: int,
+    depth: int,
+    edge_type: list[str],
+    traverse: bool,
+    connections: list,
+    node_depths: dict[NodeArchitype, int],
+    visited_nodes: list,
+    queue: list,
+    bfs: bool,
+    dfs: Callable,
+    node_limit: int,
+    edge_limit: int,
+) -> None:
+    """Traverse the graph using Breadth-First Search (BFS) or Depth-First Search (DFS)."""
+    for edge in node._jac_.edges:
+        is_self_loop = id(edge._jac_.source) == id(edge._jac_.target)
+        is_in_edge = edge._jac_.target == node
+        if (traverse and is_in_edge) or edge._jac_.obj.__class__.__name__ in edge_type:
+            continue
+        if is_self_loop:
+            continue  # lets skip self loop for a while, need to handle it later
+        else:
+            other_nd = edge._jac_.target if not is_in_edge else edge._jac_.source
+            new_con = (
+                (node, other_nd, edge) if not is_in_edge else (other_nd, node, edge)
+            )
+            if node in node_depths and node_depths[node] is not None:
+                if other_nd in node_depths:
+                    node_depths[node] = min(
+                        cur_depth, node_depths[node], node_depths[other_nd] + 1
+                    )
+                    node_depths[other_nd] = min(
+                        cur_depth + 1, node_depths[node] + 1, node_depths[other_nd]
+                    )
+                else:
+                    if other_nd:
+                        node_depths[other_nd] = min(
+                            cur_depth + 1, node_depths[node] + 1
+                        )
+                    else:
+                        raise ValueError("Edge is detached from node in graph")
+            if (
+                other_nd
+                and new_con not in connections
+                and (
+                    (
+                        depth < 0
+                        or min(node_depths[node], node_depths[other_nd]) + 1 <= depth
+                    )
+                    and node_limit > len(visited_nodes)
+                    and edge_limit > len(connections)
+                )
+            ):
+                connections.append(new_con)
+                if bfs:
+                    queue.append([other_nd, cur_depth + 1])
+                else:
+
+                    dfs(other_nd, cur_depth + 1)

jaclang/plugin/builtin.py

@@ -0,0 +1,42 @@
+"""Jac specific builtins."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from jaclang.core.construct import NodeArchitype
+
+
+def dotgen(
+    node: Optional[NodeArchitype] = None,
+    depth: Optional[int] = None,
+    traverse: Optional[bool] = None,
+    edge_type: Optional[list[str]] = None,
+    bfs: Optional[bool] = None,
+    edge_limit: Optional[int] = None,
+    node_limit: Optional[int] = None,
+    dot_file: Optional[str] = None,
+) -> str:
+    """Print the dot graph."""
+    from jaclang.core.construct import root
+    from jaclang.plugin.feature import pm
+
+    node = node if node is not None else root
+    depth = depth if depth is not None else -1
+    traverse = traverse if traverse is not None else False
+    bfs = bfs if bfs is not None else True
+    edge_limit = edge_limit if edge_limit is not None else 512
+    node_limit = node_limit if node_limit is not None else 512
+
+    return pm.hook.dotgen(
+        edge_type=edge_type,
+        node=node,
+        depth=depth,
+        traverse=traverse,
+        bfs=bfs,
+        edge_limit=edge_limit,
+        node_limit=node_limit,
+        dot_file=dot_file,
+    )

jaclang/plugin/default.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import fnmatch
 import os
 import types
 from dataclasses import field
@@ -9,7 +10,8 @@ from functools import wraps
 from typing import Any, Callable, Optional, Type
 
 from jaclang.compiler.absyntree import Module
-from jaclang.compiler.constant import EdgeDir
+from jaclang.compiler.constant import EdgeDir, colors
+from jaclang.core.aott import aott_lower, aott_raise
 from jaclang.core.construct import (
     Architype,
     DSFunc,
@@ -26,7 +28,7 @@ from jaclang.core.construct import (
     root,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.jacbuiltins import dotgen
+from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
 
@@ -184,20 +186,57 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def run_test(filename: str) -> bool:
-        """Run the test suite in the specified .jac file.
-
-        :param filename: The path to the .jac file.
-        """
-        if filename.endswith(".jac"):
-            base, mod_name = os.path.split(filename)
-            base = base if base else "./"
-            mod_name = mod_name[:-4]
-            JacTestCheck.reset()
-            Jac.jac_import(target=mod_name, base_path=base)
-            JacTestCheck.run_test()
+    def run_test(
+        filepath: str,
+        filter: Optional[str],
+        xit: bool,
+        maxfail: Optional[int],
+        directory: Optional[str],
+        verbose: bool,
+    ) -> bool:
+        """Run the test suite in the specified .jac file."""
+        test_file = False
+        if filepath:
+            if filepath.endswith(".jac"):
+                base, mod_name = os.path.split(filepath)
+                base = base if base else "./"
+                mod_name = mod_name[:-4]
+                JacTestCheck.reset()
+                Jac.jac_import(target=mod_name, base_path=base)
+                JacTestCheck.run_test(xit, maxfail, verbose)
+            else:
+                print("Not a .jac file.")
         else:
-            print("Not a .jac file.")
+            directory = directory if directory else os.getcwd()
+
+        if filter or directory:
+            current_dir = directory if directory else os.getcwd()
+            for root_dir, _, files in os.walk(current_dir, topdown=True):
+                files = (
+                    [file for file in files if fnmatch.fnmatch(file, filter)]
+                    if filter
+                    else files
+                )
+                files = [
+                    file
+                    for file in files
+                    if not file.endswith((".test.jac", ".impl.jac"))
+                ]
+                for file in files:
+                    if file.endswith(".jac"):
+                        test_file = True
+                        print(f"\n\n\t\t* Inside {root_dir}" + "/" + f"{file} *")
+                        JacTestCheck.reset()
+                        Jac.jac_import(target=file[:-4], base_path=root_dir)
+                        JacTestCheck.run_test(xit, maxfail, verbose)
+
+                    if JacTestCheck.breaker and (xit or maxfail):
+                        break
+                if JacTestCheck.breaker and (xit or maxfail):
+                    break
+            JacTestCheck.breaker = False
+            print("No test files found.") if not test_file else None
+
         return True
 
     @staticmethod
@@ -385,15 +424,121 @@ class JacFeatureDefaults:
 
         return builder
 
+    @staticmethod
+    @hookimpl
+    def with_llm(
+        model: Any,  # noqa: ANN401
+        model_params: dict[str, Any],
+        incl_info: tuple,
+        excl_info: tuple,
+        inputs: tuple,
+        outputs: tuple,
+        action: str,
+    ) -> Any:  # noqa: ANN401
+        """Jac's with_llm feature."""
+        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
+        meaning_in = aott_raise(
+            information_str,
+            input_types_n_information_str,
+            output_type_str,
+            output_type_info_str,
+            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)
+
 
 class JacBuiltin:
     """Jac Builtins."""
 
     @staticmethod
     @hookimpl
-    def dotgen(node: NodeArchitype, radius: int = 0) -> str:
-        """Print the dot graph."""
-        return dotgen(node, radius)
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: list[str],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: Optional[str],
+    ) -> str:
+        """Generate Dot file for visualizing nodes and edges."""
+        edge_type = edge_type if edge_type else []
+        visited_nodes: list[NodeArchitype] = []
+        node_depths: dict[NodeArchitype, int] = {node: 0}
+        queue: list = [[node, 0]]
+        connections: list[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = []
+
+        def dfs(node: NodeArchitype, cur_depth: int) -> None:
+            """Depth first search."""
+            if node not in visited_nodes:
+                visited_nodes.append(node)
+                traverse_graph(
+                    node,
+                    cur_depth,
+                    depth,
+                    edge_type,
+                    traverse,
+                    connections,
+                    node_depths,
+                    visited_nodes,
+                    queue,
+                    bfs,
+                    dfs,
+                    node_limit,
+                    edge_limit,
+                )
+
+        if bfs:
+            cur_depth = 0
+            while queue:
+                current_node, cur_depth = queue.pop(0)
+                if current_node not in visited_nodes:
+                    visited_nodes.append(current_node)
+                    traverse_graph(
+                        current_node,
+                        cur_depth,
+                        depth,
+                        edge_type,
+                        traverse,
+                        connections,
+                        node_depths,
+                        visited_nodes,
+                        queue,
+                        bfs,
+                        dfs,
+                        node_limit,
+                        edge_limit,
+                    )
+        else:
+            dfs(node, cur_depth=0)
+        dot_content = (
+            'digraph {\nnode [style="filled", shape="ellipse", '
+            'fillcolor="invis", fontcolor="black"];\n'
+        )
+        for source, target, edge in connections:
+            dot_content += (
+                f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
+                f' [label="{edge._jac_.obj.__class__.__name__} "];\n'
+            )
+        for node_ in visited_nodes:
+            color = (
+                colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
+            )
+            dot_content += f'{visited_nodes.index(node_)} [label="{node_._jac_.obj}" fillcolor="{color}"];\n'
+        if dot_file:
+            with open(dot_file, "w") as f:
+                f.write(dot_content + "}")
+        return dot_content + "}"
 
 
 class JacCmdDefaults: