jaclang 0.5.11__py3-none-any.whl → 0.5.16__py3-none-any.whl

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

@@ -16,6 +16,22 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     TargetPass = JacFormatPass
 
+    def test_double_unparse(self) -> None:
+        """Parse micro jac file."""
+        filename = "../../../../../../examples/manual_code/circle.jac"
+        try:
+            code_gen_pure = jac_file_to_pass(
+                self.fixture_abs_path(filename),
+                target=PyastGenPass,
+                schedule=without_format,
+            )
+            x = code_gen_pure.ir.unparse()
+            y = code_gen_pure.ir.unparse()
+            self.assertEqual(x, y)
+        except Exception as e:
+            print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
+            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
         try:

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -9,8 +9,12 @@ import pathlib
 import jaclang
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import (
+    FuseTypeInfoPass,
+)  # TODO: Put in better place
 
 import mypy.build as myb
+import mypy.checkexpr as mycke
 import mypy.errors as mye
 import mypy.fastparse as myfp
 from mypy.build import BuildSource
@@ -77,6 +81,70 @@ class BuildManager(myb.BuildManager):
         return tree
 
 
+class ExpressionChecker(mycke.ExpressionChecker):
+    """Overrides to mypy expression checker for direct AST pass through."""
+
+    def __init__(
+        self,
+        tc: mycke.mypy.checker.TypeChecker,
+        msg: mycke.MessageBuilder,
+        plugin: mycke.Plugin,
+        per_line_checking_time_ns: dict[int, int],
+    ) -> None:
+        """Override to mypy expression checker for direct AST pass through."""
+        super().__init__(tc, msg, plugin, per_line_checking_time_ns)
+
+    def visit_list_expr(self, e: mycke.ListExpr) -> mycke.Type:
+        """Type check a list expression [...]."""
+        out = super().visit_list_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_set_expr(self, e: mycke.SetExpr) -> mycke.Type:
+        """Type check a set expression {...}."""
+        out = super().visit_set_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_tuple_expr(self, e: myfp.TupleExpr) -> myb.Type:
+        """Type check a tuple expression (...)."""
+        out = super().visit_tuple_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_dict_expr(self, e: myfp.DictExpr) -> myb.Type:
+        """Type check a dictionary expression {...}."""
+        out = super().visit_dict_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_list_comprehension(self, e: myfp.ListComprehension) -> myb.Type:
+        """Type check a list comprehension."""
+        out = super().visit_list_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_set_comprehension(self, e: myfp.SetComprehension) -> myb.Type:
+        """Type check a set comprehension."""
+        out = super().visit_set_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_generator_expr(self, e: myfp.GeneratorExpr) -> myb.Type:
+        """Type check a generator expression."""
+        out = super().visit_generator_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_dictionary_comprehension(
+        self, e: myfp.DictionaryComprehension
+    ) -> myb.Type:
+        """Type check a dict comprehension."""
+        out = super().visit_dictionary_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+
 class State(myb.State):
     """Overrides to mypy state for direct AST pass through."""
 
@@ -201,6 +269,31 @@ class State(myb.State):
             self.parse_file(temporary=temporary, ast_override=ast_override)
             self.compute_dependencies()
 
+    def type_checker(self) -> myb.TypeChecker:
+        """Return the type checker for this state."""
+        if not self._type_checker:
+            assert (
+                self.tree is not None
+            ), "Internal error: must be called on parsed file only"
+            manager = self.manager
+            self._type_checker = myb.TypeChecker(
+                manager.errors,
+                manager.modules,
+                self.options,
+                self.tree,
+                self.xpath,
+                manager.plugin,
+                self.per_line_checking_time_ns,
+            )
+            self._type_checker.expr_checker = ExpressionChecker(
+                self._type_checker,
+                self._type_checker.msg,
+                self._type_checker.plugin,
+                self.per_line_checking_time_ns,
+            )
+
+        return self._type_checker
+
     def parse_file(
         self, *, temporary: bool = False, ast_override: myb.MypyFile | None = None
     ) -> None:

jaclang/compiler/tests/test_importer.py

@@ -1,8 +1,10 @@
 """Tests for Jac Loader."""
 
+import io
 import sys
 
 from jaclang import jac_import
+from jaclang.cli import cli
 from jaclang.utils.test import TestCase
 
 
@@ -23,3 +25,16 @@ class TestLoader(TestCase):
         jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn("module 'hello_world'", str(sys.modules))
         self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))
+
+    def test_jac_py_import(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("../../../tests/fixtures/jp_importer.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Hello World!", stdout_value)
+        self.assertIn(
+            "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
+            stdout_value,
+        )

jaclang/core/aott.py

@@ -150,9 +150,10 @@ def get_all_type_explanations(type_list: list, mod_registry: SemRegistry) -> dic
     """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
+        type_explanation_str, nested_types = get_type_explanation(
+            type_item, mod_registry
+        )
+        if type_explanation_str is not None:
             if type_item not in collected_type_explanations:
                 collected_type_explanations[type_item] = type_explanation_str
             if nested_types:

jaclang/core/construct.py

@@ -409,7 +409,7 @@ class JacTestCheck:
 
     def __getattr__(self, name: str) -> Union[bool, Any]:
         """Make convenient check.Equal(...) etc."""
-        return getattr(JacTestCheck.test_case, "assert" + name)
+        return getattr(JacTestCheck.test_case, name)
 
 
 root = Root()

jaclang/core/importer.py

@@ -1,10 +1,11 @@
 """Special Imports for Jac Code."""
 
+import importlib
 import marshal
 import sys
 import types
-from os import path
-from typing import Optional
+from os import getcwd, path
+from typing import Optional, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
@@ -15,80 +16,137 @@ from jaclang.utils.log import logging
 def jac_importer(
     target: str,
     base_path: str,
+    absorb: bool = False,
     cachable: bool = True,
+    mdl_alias: Optional[str] = None,
     override_name: Optional[str] = None,
     mod_bundle: Optional[Module] = None,
+    lng: Optional[str] = None,
+    items: Optional[dict[str, Union[str, bool]]] = None,
 ) -> Optional[types.ModuleType]:
     """Core Import Process."""
-    dir_path, file_name = path.split(path.join(*(target.split("."))) + ".jac")
-
+    dir_path, file_name = (
+        path.split(path.join(*(target.split("."))) + ".py")
+        if lng == "py"
+        else path.split(path.join(*(target.split("."))) + ".jac")
+    )
     module_name = path.splitext(file_name)[0]
     package_path = dir_path.replace(path.sep, ".")
 
-    if package_path and f"{package_path}.{module_name}" in sys.modules:
+    if package_path and f"{package_path}.{module_name}" in sys.modules and lng != "py":
         return sys.modules[f"{package_path}.{module_name}"]
-    elif not package_path and module_name in sys.modules:
+    elif not package_path and module_name in sys.modules and lng != "py":
         return sys.modules[module_name]
 
     caller_dir = path.dirname(base_path) if not path.isdir(base_path) else base_path
-    caller_dir = path.dirname(caller_dir) if target.startswith("..") else caller_dir
+    if not caller_dir:
+        caller_dir = getcwd()
+    chomp_target = target
+    if chomp_target.startswith("."):
+        chomp_target = chomp_target[1:]
+        while chomp_target.startswith("."):
+            caller_dir = path.dirname(caller_dir)
+            chomp_target = chomp_target[1:]
     caller_dir = path.join(caller_dir, dir_path)
 
     full_target = path.normpath(path.join(caller_dir, file_name))
-
-    if mod_bundle:
-        codeobj = (
-            mod_bundle.gen.py_bytecode
-            if full_target == mod_bundle.loc.mod_path
-            else mod_bundle.mod_deps[full_target].gen.py_bytecode
-        )
-        if isinstance(codeobj, bytes):
-            codeobj = marshal.loads(codeobj)
-    else:
-        gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
-        pyc_file_path = path.join(gen_dir, module_name + ".jbc")
-        if (
-            cachable
-            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:
-            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
-            else:
-                codeobj = marshal.loads(result.ir.gen.py_bytecode)
+    path_added = False
+    if caller_dir not in sys.path:
+        sys.path.append(caller_dir)
+        path_added = True
 
     module_name = override_name if override_name else module_name
     module = types.ModuleType(module_name)
     module.__file__ = full_target
     module.__name__ = module_name
     module.__dict__["__jac_mod_bundle__"] = mod_bundle
+    if lng != "py":
+        if mod_bundle:
+            codeobj = (
+                mod_bundle.gen.py_bytecode
+                if full_target == mod_bundle.loc.mod_path
+                else mod_bundle.mod_deps[full_target].gen.py_bytecode
+            )
+            if isinstance(codeobj, bytes):
+                codeobj = marshal.loads(codeobj)
+        else:
 
-    if package_path:
-        parts = package_path.split(".")
-        for i in range(len(parts)):
-            package_name = ".".join(parts[: i + 1])
-            if package_name not in sys.modules:
-                sys.modules[package_name] = types.ModuleType(package_name)
+            gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
+            pyc_file_path = path.join(gen_dir, module_name + ".jbc")
+            if (
+                cachable
+                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:
+                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
+                else:
+                    codeobj = marshal.loads(result.ir.gen.py_bytecode)
 
-        setattr(sys.modules[package_path], module_name, module)
-        sys.modules[f"{package_path}.{module_name}"] = module
-    sys.modules[module_name] = module
+        if package_path:
+            parts = package_path.split(".")
+            for i in range(len(parts)):
+                package_name = ".".join(parts[: i + 1])
+                if package_name not in sys.modules:
+                    sys.modules[package_name] = types.ModuleType(package_name)
+
+            setattr(sys.modules[package_path], module_name, module)
+            sys.modules[f"{package_path}.{module_name}"] = module
+        sys.modules[module_name] = module
+
+        if not codeobj:
+            raise ImportError(f"No bytecode found for {full_target}")
+        exec(codeobj, module.__dict__)
+
+    (
+        py_import(target=target, items=items, absorb=absorb, mdl_alias=mdl_alias)
+        if lng == "py" or lng == "jac"
+        else None
+    )
 
-    path_added = False
-    if caller_dir not in sys.path:
-        sys.path.append(caller_dir)
-        path_added = True
-    if not codeobj:
-        raise ImportError(f"No bytecode found for {full_target}")
-    exec(codeobj, module.__dict__)
     if path_added:
         sys.path.remove(caller_dir)
 
     return module
+
+
+def py_import(
+    target: str,
+    items: Optional[dict[str, Union[str, bool]]] = None,
+    absorb: bool = False,
+    mdl_alias: Optional[str] = None,
+) -> None:
+    """Import a Python module."""
+    try:
+        target = target.lstrip(".") if target.startswith("..") else target
+        imported_module = importlib.import_module(target)
+        main_module = __import__("__main__")
+        # importer = importlib.import_module(caller)
+        if absorb:
+            for name in dir(imported_module):
+                if not name.startswith("_"):
+                    setattr(main_module, name, getattr(imported_module, name))
+
+        elif items:
+            for name, alias in items.items():
+                setattr(
+                    main_module,
+                    alias if isinstance(alias, str) else name,
+                    getattr(imported_module, name),
+                )
+
+        else:
+            setattr(
+                __import__("__main__"),
+                mdl_alias if isinstance(mdl_alias, str) else target,
+                imported_module,
+            )
+    except ImportError:
+        print(f"Failed to import module {target}")

jaclang/core/llms.py

@@ -0,0 +1,29 @@
+"""LLMs (Large Language Models) module for Jaclang."""
+
+import anthropic
+
+
+class Anthropic:
+    """Anthropic API client for Large Language Models (LLMs)."""
+
+    MTLLM_PROMPT: str = ""
+    MTLLM_REASON_SUFFIX: str = ""
+    MTLLM_WO_REASON_SUFFIX: str = ""
+
+    def __init__(self, **kwargs: dict) -> None:
+        """Initialize the Anthropic API client."""
+        self.client = anthropic.Anthropic()
+        self.model_name = kwargs.get("model_name", "claude-3-sonnet-20240229")
+        self.temperature = kwargs.get("temperature", 0.7)
+        self.max_tokens = kwargs.get("max_tokens", 1024)
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.client.messages.create(
+            model=kwargs.get("model_name", self.model_name),
+            temperature=kwargs.get("temperature", self.temperature),
+            max_tokens=kwargs.get("max_tokens", self.max_tokens),
+            messages=messages,
+        )
+        return output.content[0].text

jaclang/core/registry.py

@@ -57,6 +57,20 @@ class SemScope:
             parent = SemScope(scope_name, scope_type, parent)
         return parent
 
+    @property
+    def as_type_str(self) -> Optional[str]:
+        """Return the type string representation of the SemsScope."""
+        if self.type not in ["class", "node", "obj"]:
+            return None
+        type_str = self.scope
+        node = self.parent
+        while node and node.parent:
+            if node.type not in ["class", "node", "obj"]:
+                return type_str
+            type_str = f"{node.scope}.{type_str}"
+            node = node.parent
+        return type_str
+
 
 class SemRegistry:
     """Registry class."""
@@ -107,6 +121,14 @@ class SemRegistry:
                             return k, i
         return None, None
 
+    @property
+    def module_scope(self) -> SemScope:
+        """Get the module scope."""
+        for i in self.registry.keys():
+            if not i.parent:
+                break
+        return i
+
     def pp(self) -> None:
         """Pretty print the registry."""
         for k, v in self.registry.items():

jaclang/core/utils.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import ast as ast3
 from typing import Callable, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
@@ -113,3 +114,74 @@ def get_sem_scope(node: ast.AstNode) -> SemScope:
         if node.parent:
             return get_sem_scope(node.parent)
     return SemScope("", "", None)
+
+
+def extract_type(node: ast.AstNode) -> list[str]:
+    """Collect type information in assignment using bfs."""
+    extracted_type = []
+    if isinstance(node, (ast.BuiltinType, ast.Token)):
+        extracted_type.append(node.value)
+    for child in node.kid:
+        extracted_type.extend(extract_type(child))
+    return extracted_type
+
+
+def extract_params(
+    body: ast.FuncCall,
+) -> tuple[dict[str, ast.Expr], list[tuple[str, ast3.AST]], list[tuple[str, ast3.AST]]]:
+    """Extract model parameters, include and exclude information."""
+    model_params = {}
+    include_info = []
+    exclude_info = []
+    if body.params:
+        for param in body.params.items:
+            if isinstance(param, ast.KWPair) and isinstance(param.key, ast.Name):
+                key = param.key.value
+                value = param.value
+                if key not in ["incl_info", "excl_info"]:
+                    model_params[key] = value
+                elif key == "incl_info":
+                    if isinstance(value, ast.AtomUnit):
+                        var_name = (
+                            value.value.right.value
+                            if isinstance(value.value, ast.AtomTrailer)
+                            and isinstance(value.value.right, ast.Name)
+                            else (
+                                value.value.value
+                                if isinstance(value.value, ast.Name)
+                                else ""
+                            )
+                        )
+                        include_info.append((var_name, value.gen.py_ast[0]))
+                    elif isinstance(value, ast.TupleVal) and value.values:
+                        for i in value.values.items:
+                            var_name = (
+                                i.right.value
+                                if isinstance(i, ast.AtomTrailer)
+                                and isinstance(i.right, ast.Name)
+                                else (i.value if isinstance(i, ast.Name) else "")
+                            )
+                            include_info.append((var_name, i.gen.py_ast[0]))
+                elif key == "excl_info":
+                    if isinstance(value, ast.AtomUnit):
+                        var_name = (
+                            value.value.right.value
+                            if isinstance(value.value, ast.AtomTrailer)
+                            and isinstance(value.value.right, ast.Name)
+                            else (
+                                value.value.value
+                                if isinstance(value.value, ast.Name)
+                                else ""
+                            )
+                        )
+                        exclude_info.append((var_name, value.gen.py_ast[0]))
+                    elif isinstance(value, ast.TupleVal) and value.values:
+                        for i in value.values.items:
+                            var_name = (
+                                i.right.value
+                                if isinstance(i, ast.AtomTrailer)
+                                and isinstance(i.right, ast.Name)
+                                else (i.value if isinstance(i, ast.Name) else "")
+                            )
+                            exclude_info.append((var_name, i.gen.py_ast[0]))
+    return model_params, include_info, exclude_info