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

jaclang/plugin/default.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import fnmatch
 import os
+import pickle
 import types
 from dataclasses import field
 from functools import wraps
@@ -10,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,
@@ -27,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
@@ -185,20 +196,58 @@ 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
+            JacTestCheck.failcount = 0
+            print("No test files found.") if not test_file else None
+
         return True
 
     @staticmethod
@@ -389,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

@@ -96,9 +96,23 @@ class JacFeature:
         return pm.hook.create_test(test_fun=test_fun)
 
     @staticmethod
-    def run_test(filename: str) -> bool:
+    def run_test(
+        filepath: str,
+        filter: Optional[str] = None,
+        xit: bool = False,
+        maxfail: Optional[int] = None,
+        directory: Optional[str] = None,
+        verbose: bool = False,
+    ) -> bool:
         """Run the test suite in the specified .jac file."""
-        return pm.hook.run_test(filename=filename)
+        return pm.hook.run_test(
+            filepath=filepath,
+            filter=filter,
+            xit=xit,
+            maxfail=maxfail,
+            directory=directory,
+            verbose=verbose,
+        )
 
     @staticmethod
     def elvis(op1: Optional[T], op2: T) -> T:
@@ -213,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

@@ -88,11 +88,15 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def run_test(filename: str) -> bool:
-        """Run the test suite in the specified .jac file.
-
-        :param filename: The path to the .jac file.
-        """
+    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."""
         raise NotImplementedError
 
     @staticmethod
@@ -207,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,

jaclang/utils/helpers.py

@@ -1,12 +1,12 @@
 """Utility functions and classes for Jac compilation toolchain."""
 
+import dis
+import marshal
 import os
+import pdb
 import re
 
 
-import jaclang.compiler.absyntree as ast
-
-
 def pascal_to_snake(pascal_string: str) -> str:
     """Convert pascal case to snake case."""
     snake_string = re.sub(r"(?<!^)(?=[A-Z])", "_", pascal_string).lower()
@@ -43,6 +43,7 @@ def get_ast_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect
     import sys
+    import jaclang.compiler.absyntree as ast
 
     module_name = ast.__name__
     module = sys.modules[module_name]
@@ -85,6 +86,46 @@ def extract_headings(file_path: str) -> dict[str, tuple[int, int]]:
     return headings
 
 
+def auto_generate_refs() -> None:
+    """Auto generate lang reference for docs."""
+    file_path = os.path.join(
+        os.path.split(os.path.dirname(__file__))[0], "../jaclang/compiler/jac.lark"
+    )
+    result = extract_headings(file_path)
+    created_file_path = os.path.join(
+        os.path.split(os.path.dirname(__file__))[0],
+        "../support/jac-lang.org/docs/learn/jac_ref.md",
+    )
+    destination_folder = os.path.join(
+        os.path.split(os.path.dirname(__file__))[0], "../examples/reference/"
+    )
+    with open(created_file_path, "w") as md_file:
+        md_file.write(
+            '# Jac Language Reference\n\n--8<-- "examples/reference/introduction.md"\n\n'
+        )
+    for heading, lines in result.items():
+        heading = heading.strip()
+        heading_snakecase = heading_to_snake(heading)
+        content = (
+            f'## {heading}\n**Grammar Snippet**\n```yaml linenums="{lines[0]}"\n--8<-- '
+            f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n```\n'
+            f'**Code Example**\n=== "Jac"\n    ```jac linenums="1"\n    --8<-- "examples/reference/'
+            f'{heading_snakecase}.jac"\n'
+            f'    ```\n=== "Python"\n    ```python linenums="1"\n    --8<-- "examples/reference/'
+            f'{heading_snakecase}.py"\n    ```\n'
+            "**Description**\n\n--8<-- "
+            f'"examples/reference/'
+            f'{heading_snakecase}.md"\n'
+        )
+        with open(created_file_path, "a") as md_file:
+            md_file.write(f"{content}\n")
+        md_file_name = f"{heading_snakecase}.md"
+        md_file_path = os.path.join(destination_folder, md_file_name)
+        if not os.path.exists(md_file_path):
+            with open(md_file_path, "w") as md_file:
+                md_file.write("")
+
+
 def import_target_to_relative_path(
     import_target: str, base_path: str | None = None, file_extension: str = ".jac"
 ) -> str:
@@ -104,3 +145,25 @@ def import_target_to_relative_path(
         base_path = os.path.dirname(base_path)
     relative_path = os.path.join(base_path, *actual_parts) + file_extension
     return relative_path
+
+
+class Jdb(pdb.Pdb):
+    """Jac debugger."""
+
+    def __init__(self, *args, **kwargs) -> None:  # noqa
+        """Initialize the Jac debugger."""
+        super().__init__(*args, **kwargs)
+        self.prompt = "Jdb > "
+
+    def has_breakpoint(self, bytecode: bytes) -> bool:
+        """Check for breakpoint."""
+        code = marshal.loads(bytecode)
+        instructions = dis.get_instructions(code)
+        return any(
+            instruction.opname in ("LOAD_GLOBAL", "LOAD_NAME", "LOAD_FAST")
+            and instruction.argval == "breakpoint"
+            for instruction in instructions
+        )
+
+
+debugger = Jdb()

jaclang/utils/lang_tools.py

@@ -8,8 +8,9 @@ from typing import List, Optional, Type
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.symtable import SymbolTable
-from jaclang.utils.helpers import extract_headings, heading_to_snake, pascal_to_snake
+from jaclang.utils.helpers import auto_generate_refs, pascal_to_snake
 
 
 class AstKidInfo:
@@ -209,7 +210,7 @@ class AstTool:
             [base, mod] = os.path.split(file_name)
             base = base if base else "./"
             ir = jac_file_to_pass(
-                file_name
+                file_name, schedule=py_code_gen_typed
             ).ir  # Assuming jac_file_to_pass is defined elsewhere
 
             match output:
@@ -229,6 +230,8 @@ class AstTool:
                     return ir.pp()
                 case "ast.":
                     return ir.dotgen()
+                case "unparse":
+                    return ir.unparse()
                 case "pyast":
                     return (
                         f"\n{py_ast.dump(ir.gen.py_ast[0], indent=2)}"
@@ -255,40 +258,5 @@ class AstTool:
 
     def automate_ref(self) -> str:
         """Automate the reference guide generation."""
-        file_path = os.path.join(
-            os.path.split(os.path.dirname(__file__))[0], "../jaclang/compiler/jac.lark"
-        )
-        result = extract_headings(file_path)
-        created_file_path = os.path.join(
-            os.path.split(os.path.dirname(__file__))[0],
-            "../support/jac-lang.org/docs/learn/jac_ref.md",
-        )
-        destination_folder = os.path.join(
-            os.path.split(os.path.dirname(__file__))[0], "../examples/reference/"
-        )
-        with open(created_file_path, "w") as md_file:
-            md_file.write(
-                '# Jac Language Reference\n\n--8<-- "examples/reference/introduction.md"\n\n'
-            )
-        for heading, lines in result.items():
-            heading = heading.strip()
-            heading_snakecase = heading_to_snake(heading)
-            content = (
-                f'## {heading}\n**Grammar Snippet**\n```yaml linenums="{lines[0]}"\n--8<-- '
-                f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n```\n'
-                f'**Code Example**\n=== "Jac"\n    ```jac linenums="1"\n    --8<-- "examples/reference/'
-                f'{heading_snakecase}.jac"\n'
-                f'    ```\n=== "Python"\n    ```python linenums="1"\n    --8<-- "examples/reference/'
-                f'{heading_snakecase}.py"\n    ```\n'
-                "**Description**\n\n--8<-- "
-                f'"examples/reference/'
-                f'{heading_snakecase}.md"\n'
-            )
-            with open(created_file_path, "a") as md_file:
-                md_file.write(f"{content}\n")
-            md_file_name = f"{heading_snakecase}.md"
-            md_file_path = os.path.join(destination_folder, md_file_name)
-            if not os.path.exists(md_file_path):
-                with open(md_file_path, "w") as md_file:
-                    md_file.write("")
+        auto_generate_refs()
         return "References generated."

jaclang/utils/test.py

@@ -109,6 +109,7 @@ class AstSyncTestMixin:
                 "jac_source",
                 "empty_token",
                 "ast_symbol_node",
+                "ast_impl_needing_node",
                 "ast_access_node",
                 "token_symbol",
                 "literal",

jaclang/utils/tests/test_lang_tools.py

@@ -37,20 +37,14 @@ class JacFormatPassTests(TestCase):
 
     def test_print(self) -> None:
         """Testing for print AstTool."""
-        jac_directory = os.path.join(
-            os.path.dirname(jaclang.__file__), "../examples/reference/"
+        jac_file = os.path.join(
+            os.path.dirname(jaclang.__file__),
+            "../examples/reference/names_and_references.jac",
         )
-        jac_files = [f for f in os.listdir(jac_directory) if f.endswith(".jac")]
-        passed = 0
-        for jac_file in jac_files:
-            msg = "error in " + jac_file
-            out = AstTool().ir(["ast", jac_directory + jac_file])
-            if out == "0:0 - 0:0\tModule\n0:0 - 0:0\t+-- EmptyToken - \n":
-                continue
-            self.assertIn("+-- Token", out, msg)
-            self.assertIsNotNone(out, msg=msg)
-            passed += 1
-        self.assertGreater(passed, 10)
+        msg = "error in " + jac_file
+        out = AstTool().ir(["ast", jac_file])
+        self.assertIn("+-- Token", out, msg)
+        self.assertIsNotNone(out, msg=msg)
 
     def test_print_py(self) -> None:
         """Testing for print_py AstTool."""
@@ -58,8 +52,11 @@ class JacFormatPassTests(TestCase):
             os.path.dirname(jaclang.__file__), "../examples/reference/"
         )
         jac_py_files = [
-            f for f in os.listdir(jac_py_directory) if f.endswith((".jac", ".py"))
+            f
+            for f in os.listdir(jac_py_directory)
+            if f.endswith(("names_and_references.jac", "names_and_references.py"))
         ]
+
         for file in jac_py_files:
             msg = "error in " + file
             out = AstTool().ir(["pyast", jac_py_directory + file])

jaclang/utils/treeprinter.py

@@ -88,10 +88,14 @@ def print_ast_tree(
     from jaclang.compiler.absyntree import AstSymbolNode, Token
 
     def __node_repr_in_tree(node: AstNode) -> str:
-        if isinstance(node, Token):
+        if isinstance(node, Token) and isinstance(node, AstSymbolNode):
+            return (
+                f"{node.__class__.__name__} - {node.value} - Type: {node.sym_info.typ}"
+            )
+        elif isinstance(node, Token):
             return f"{node.__class__.__name__} - {node.value}"
         elif isinstance(node, AstSymbolNode):
-            return f"{node.__class__.__name__} - {node.sym_name}"
+            return f"{node.__class__.__name__} - {node.sym_name} - Type: {node.sym_info.typ}"
         else:
             return f"{node.__class__.__name__}"
 
@@ -211,6 +215,10 @@ def _build_symbol_tree_common(
         symbol_node = SymbolTree(node_name=f"{sym.sym_name}", parent=symbols)
         SymbolTree(node_name=f"{sym.access} {sym.sym_type}", parent=symbol_node)
 
+        # if isinstance(node.owner, ast.AstSymbolNode) and node.owner.sym_info:
+        #     print("From tree printer", id(node.owner))
+        #     SymbolTree(node_name=f"Datatype: {node.owner.sym_info.typ}", parent=symbol_node)
+
         if sym.decl and sym.decl.loc.first_line > 0:
             SymbolTree(
                 node_name=f"decl: line {sym.decl.loc.first_line}, col {sym.decl.loc.col_start}",

{jaclang-0.5.7.dist-info → jaclang-0.5.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.5.7
+Version: 0.5.9
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars
 Author-email: jason@jaseci.org