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

jaclang/plugin/default.py

@@ -8,7 +8,7 @@ import pickle
 import types
 from dataclasses import field
 from functools import wraps
-from typing import Any, Callable, Optional, Type
+from typing import Any, Callable, Optional, Type, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
@@ -37,7 +37,7 @@ from jaclang.core.construct import (
     root,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.registry import SemScope
+from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -167,17 +167,25 @@ class JacFeatureDefaults:
     def jac_import(
         target: str,
         base_path: str,
+        absorb: bool,
         cachable: bool,
+        mdl_alias: Optional[str],
         override_name: Optional[str],
         mod_bundle: Optional[Module],
+        lng: Optional[str],
+        items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
         """Core Import Process."""
         result = jac_importer(
             target=target,
             base_path=base_path,
+            absorb=absorb,
             cachable=cachable,
+            mdl_alias=mdl_alias,
             override_name=override_name,
             mod_bundle=mod_bundle,
+            lng=lng,
+            items=items,
         )
         return result
 
@@ -435,6 +443,110 @@ class JacFeatureDefaults:
 
         return builder
 
+    @staticmethod
+    @hookimpl
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> Optional[str]:
+        """Jac's get_semstr_type feature."""
+        _scope = SemScope.get_scope_from_str(scope)
+        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: SemRegistry = pickle.load(f)
+        _, attr_seminfo = mod_registry.lookup(_scope, attr)
+        if attr_seminfo and isinstance(attr_seminfo, SemInfo):
+            return attr_seminfo.semstr if return_semstr else attr_seminfo.type
+        return None
+
+    @staticmethod
+    @hookimpl
+    def obj_scope(file_loc: str, attr: str) -> str:
+        """Jac's gather_scope 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: SemRegistry = pickle.load(f)
+
+        attr_scope = None
+        for x in attr.split("."):
+            attr_scope, attr_sem_info = mod_registry.lookup(attr_scope, x)
+            if isinstance(attr_sem_info, SemInfo) and attr_sem_info.type not in [
+                "class",
+                "obj",
+                "node",
+                "edge",
+            ]:
+                attr_scope, attr_sem_info = mod_registry.lookup(
+                    None, attr_sem_info.type
+                )
+                if isinstance(attr_sem_info, SemInfo) and isinstance(
+                    attr_sem_info.type, str
+                ):
+                    attr_scope = SemScope(
+                        attr_sem_info.name, attr_sem_info.type, attr_scope
+                    )
+            else:
+                if isinstance(attr_sem_info, SemInfo) and isinstance(
+                    attr_sem_info.type, str
+                ):
+                    attr_scope = SemScope(
+                        attr_sem_info.name, attr_sem_info.type, attr_scope
+                    )
+        return str(attr_scope)
+
+    @staticmethod
+    @hookimpl
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
+        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: SemRegistry = pickle.load(f)
+
+        attr_scope = None
+        for x in attr.split("."):
+            attr_scope, attr_sem_info = mod_registry.lookup(attr_scope, x)
+            if isinstance(attr_sem_info, SemInfo) and attr_sem_info.type not in [
+                "class",
+                "obj",
+                "node",
+                "edge",
+            ]:
+                attr_scope, attr_sem_info = mod_registry.lookup(
+                    None, attr_sem_info.type
+                )
+                if isinstance(attr_sem_info, SemInfo) and isinstance(
+                    attr_sem_info.type, str
+                ):
+                    attr_scope = SemScope(
+                        attr_sem_info.name, attr_sem_info.type, attr_scope
+                    )
+            else:
+                if isinstance(attr_sem_info, SemInfo) and isinstance(
+                    attr_sem_info.type, str
+                ):
+                    attr_scope = SemScope(
+                        attr_sem_info.name, attr_sem_info.type, attr_scope
+                    )
+        if isinstance(attr_sem_info, SemInfo) and isinstance(attr_scope, SemScope):
+            return attr_sem_info.semstr, attr_scope.as_type_str
+        return "", ""  #
+
     @staticmethod
     @hookimpl
     def with_llm(
@@ -444,7 +556,7 @@ class JacFeatureDefaults:
         scope: str,
         incl_info: list[tuple[str, str]],
         excl_info: list[tuple[str, str]],
-        inputs: tuple,
+        inputs: list[tuple[str, str, str, Any]],
         outputs: tuple,
         action: str,
     ) -> Any:  # noqa: ANN401
@@ -459,6 +571,7 @@ class JacFeatureDefaults:
         ) as f:
             mod_registry = pickle.load(f)
 
+        outputs = outputs[0] if isinstance(outputs, list) else outputs
         _scope = SemScope.get_scope_from_str(scope)
         assert _scope is not None
 
@@ -469,7 +582,6 @@ class JacFeatureDefaults:
         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])
@@ -479,8 +591,8 @@ class JacFeatureDefaults:
             )
         inputs_information = "\n".join(inputs_information_list)
 
-        output_information = f"{outputs[0]} ({outputs[2]})"
-        type_collector.extend(extract_non_primary_type(outputs[2]))
+        output_information = f"{outputs[0]} ({outputs[1]})"
+        type_collector.extend(extract_non_primary_type(outputs[1]))
 
         type_explanations_list = list(
             get_all_type_explanations(type_collector, mod_registry).values()

jaclang/plugin/feature.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, TypeAlias
+from typing import Any, Callable, Optional, Type, TypeAlias, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.core.construct import (
@@ -77,17 +77,25 @@ class JacFeature:
     def jac_import(
         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."""
         return pm.hook.jac_import(
             target=target,
             base_path=base_path,
+            absorb=absorb,
             cachable=cachable,
+            mdl_alias=mdl_alias,
             override_name=override_name,
             mod_bundle=mod_bundle,
+            lng=lng,
+            items=items,
         )
 
     @staticmethod
@@ -225,6 +233,25 @@ class JacFeature:
             is_undirected=is_undirected, conn_type=conn_type, conn_assign=conn_assign
         )
 
+    @staticmethod
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> Optional[str]:
+        """Jac's get_semstr_type feature."""
+        return pm.hook.get_semstr_type(
+            file_loc=file_loc, scope=scope, attr=attr, return_semstr=return_semstr
+        )
+
+    @staticmethod
+    def obj_scope(file_loc: str, attr: str) -> str:
+        """Jac's get_semstr_type feature."""
+        return pm.hook.obj_scope(file_loc=file_loc, attr=attr)
+
+    @staticmethod
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
+        """Jac's get_semstr_type feature."""
+        return pm.hook.get_sem_type(file_loc=file_loc, attr=attr)
+
     @staticmethod
     def with_llm(
         file_loc: str,
@@ -233,7 +260,7 @@ class JacFeature:
         scope: str,
         incl_info: list[tuple[str, str]],
         excl_info: list[tuple[str, str]],
-        inputs: tuple,
+        inputs: list[tuple[str, str, str, Any]],
         outputs: tuple,
         action: str,
     ) -> Any:  # noqa: ANN401

jaclang/plugin/spec.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, TypeVar
+from typing import Any, Callable, Optional, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.plugin.default import (
@@ -73,9 +73,13 @@ class JacFeatureSpec:
     def jac_import(
         target: str,
         base_path: str,
+        absorb: bool,
         cachable: bool,
+        mdl_alias: Optional[str],
         override_name: Optional[str],
         mod_bundle: Optional[Module],
+        lng: Optional[str],
+        items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
         """Core Import Process."""
         raise NotImplementedError
@@ -208,6 +212,25 @@ class JacFeatureSpec:
         """Jac's root getter."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> Optional[str]:
+        """Jac's get_semstr_type stmt feature."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def obj_scope(file_loc: str, attr: str) -> str:
+        """Jac's get_semstr_type feature."""
+        raise NotImplementedError
+
+    @staticmethod
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
+        """Jac's get_semstr_type feature."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def with_llm(
@@ -217,7 +240,7 @@ class JacFeatureSpec:
         scope: str,
         incl_info: list[tuple[str, str]],
         excl_info: list[tuple[str, str]],
-        inputs: tuple,
+        inputs: list[tuple[str, str, str, Any]],
         outputs: tuple,
         action: str,
     ) -> Any:  # noqa: ANN401

jaclang/utils/helpers.py

@@ -5,6 +5,7 @@ import marshal
 import os
 import pdb
 import re
+from typing import Optional
 
 
 def pascal_to_snake(pascal_string: str) -> str:
@@ -127,19 +128,16 @@ def auto_generate_refs() -> None:
 
 
 def import_target_to_relative_path(
-    import_target: str, base_path: str | None = None, file_extension: str = ".jac"
+    import_level: int,
+    import_target: str,
+    base_path: Optional[str] = None,
+    file_extension: str = ".jac",
 ) -> str:
     """Convert an import target string into a relative file path."""
-    if base_path is None:
+    if not base_path:
         base_path = os.getcwd()
     parts = import_target.split(".")
-    traversal_levels = 0
-    for part in parts:
-        if part == "":
-            traversal_levels += 1
-        else:
-            break  # Stop at the first non-empty part
-    traversal_levels = traversal_levels - 1 if traversal_levels > 0 else 0
+    traversal_levels = import_level - 1 if import_level > 0 else 0
     actual_parts = parts[traversal_levels:]
     for _ in range(traversal_levels):
         base_path = os.path.dirname(base_path)

jaclang/utils/lang_tools.py

@@ -8,6 +8,7 @@ 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.pyast_load_pass import PyastBuildPass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.symtable import SymbolTable
 from jaclang.utils.helpers import auto_generate_refs, pascal_to_snake
@@ -198,20 +199,43 @@ class AstTool:
 
     def ir(self, args: List[str]) -> str:
         """Generate a AST, SymbolTable tree for .jac file, or Python AST for .py file."""
+        error = "Usage: ir <choose one of (sym / sym. / ast / ast. / pyast / py / unparse)> <.py or .jac file_path>"
         if len(args) != 2:
-            return "Usage: ir <choose one of (sym / sym. / ast / ast. / pyast / py)> <file_path>"
+            return error
 
         output, file_name = args
 
         if not os.path.isfile(file_name):
             return f"Error: {file_name} not found"
 
-        if file_name.endswith(".jac"):
+        if file_name.endswith((".jac", ".py")):
             [base, mod] = os.path.split(file_name)
             base = base if base else "./"
-            ir = jac_file_to_pass(
-                file_name, schedule=py_code_gen_typed
-            ).ir  # Assuming jac_file_to_pass is defined elsewhere
+
+            if file_name.endswith(".py"):
+                with open(file_name, "r") as f:
+                    parsed_ast = py_ast.parse(f.read())
+                if output == "pyast":
+                    return f"\n{py_ast.dump(parsed_ast, indent=2)}"
+                try:
+                    rep = PyastBuildPass(
+                        input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    ).ir
+
+                    schedule = py_code_gen_typed
+                    target = schedule[-1]
+                    for i in schedule:
+                        if i == target:
+                            break
+                        ast_ret = i(input_ir=rep, prior=None)
+                    ast_ret = target(input_ir=rep, prior=None)
+                    ir = ast_ret.ir
+                except Exception as e:
+                    return f"Error While Jac to Py AST conversion: {e}"
+            else:
+                ir = jac_file_to_pass(
+                    file_name, schedule=py_code_gen_typed
+                ).ir  # Assuming jac_file_to_pass is defined elsewhere
 
             match output:
                 case "sym":
@@ -245,14 +269,7 @@ class AstTool:
                         else "Compile failed."
                     )
                 case _:
-                    return "Invalid key: Use one of (sym / sym. / ast / ast. / pyast) followed by file_path."
-        elif file_name.endswith(".py") and output == "pyast":
-            [base, mod] = os.path.split(file_name)
-            base = base if base else "./"
-            with open(file_name, "r") as file:
-                code = file.read()
-            parsed_ast = py_ast.parse(code)
-            return f"\n{py_ast.dump(parsed_ast, indent=2)}"
+                    return f"Invalid key: {error}"
         else:
             return "Not a .jac or .py file, or invalid command for file type."
 
@@ -260,3 +277,10 @@ class AstTool:
         """Automate the reference guide generation."""
         auto_generate_refs()
         return "References generated."
+
+    def gen_parser(self) -> str:
+        """Generate static parser."""
+        from jaclang.compiler import generate_static_parser
+
+        generate_static_parser(force=True)
+        return "Parser generated."

jaclang/utils/test.py

@@ -2,7 +2,6 @@
 
 import inspect
 import os
-from abc import ABC, abstractmethod
 from typing import Callable, Optional
 from unittest import TestCase as _TestCase
 
@@ -54,7 +53,7 @@ class TestCase(_TestCase):
         return os.path.abspath(file_path)
 
 
-class TestCaseMicroSuite(ABC, TestCase):
+class TestCaseMicroSuite(TestCase):
     """Base test case for Jaseci."""
 
     test_micro_jac_files_fully_tested: Optional[Callable[[TestCase], None]] = None
@@ -86,7 +85,6 @@ class TestCaseMicroSuite(ABC, TestCase):
 
         cls.test_micro_jac_files_fully_tested = test_micro_jac_files_fully_tested
 
-    @abstractmethod
     def micro_suite_test(self, filename: str) -> None:
         """Test micro jac file."""
         pass

jaclang/utils/tests/test_lang_tools.py

@@ -98,3 +98,9 @@ class JacFormatPassTests(TestCase):
             if file not in created_files
         ]
         self.assertEqual(len(other_reference_files), 0)
+
+    def test_py_jac_mode(self) -> None:
+        """Testing for py_jac_mode support."""
+        file = self.fixture_abs_path("../../../tests/fixtures/pyfunc.py")
+        out = AstTool().ir(["unparse", file])
+        self.assertIn("can my_print(x: object) -> None", out)

jaclang/vendor/lark/grammars/common.lark

@@ -0,0 +1,59 @@
+// Basic terminals for common use
+
+
+//
+// Numbers
+//
+
+DIGIT: "0".."9"
+HEXDIGIT: "a".."f"|"A".."F"|DIGIT
+
+INT: DIGIT+
+SIGNED_INT: ["+"|"-"] INT
+DECIMAL: INT "." INT? | "." INT
+
+// float = /-?\d+(\.\d+)?([eE][+-]?\d+)?/
+_EXP: ("e"|"E") SIGNED_INT
+FLOAT: INT _EXP | DECIMAL _EXP?
+SIGNED_FLOAT: ["+"|"-"] FLOAT
+
+NUMBER: FLOAT | INT
+SIGNED_NUMBER: ["+"|"-"] NUMBER
+
+//
+// Strings
+//
+_STRING_INNER: /.*?/
+_STRING_ESC_INNER: _STRING_INNER /(?<!\\)(\\\\)*?/
+
+ESCAPED_STRING : "\"" _STRING_ESC_INNER "\""
+
+
+//
+// Names (Variables)
+//
+LCASE_LETTER: "a".."z"
+UCASE_LETTER: "A".."Z"
+
+LETTER: UCASE_LETTER | LCASE_LETTER
+WORD: LETTER+
+
+CNAME: ("_"|LETTER) ("_"|LETTER|DIGIT)*
+
+
+//
+// Whitespace
+//
+WS_INLINE: (" "|/\t/)+
+WS: /[ \t\f\r\n]/+
+
+CR : /\r/
+LF : /\n/
+NEWLINE: (CR? LF)+
+
+
+// Comments
+SH_COMMENT: /#[^\n]*/
+CPP_COMMENT: /\/\/[^\n]*/
+C_COMMENT: "/*" /(.|\n)*?/ "*/"
+SQL_COMMENT: /--[^\n]*/

jaclang/vendor/lark/grammars/lark.lark

@@ -0,0 +1,62 @@
+# Lark grammar of Lark's syntax
+# Note: Lark is not bootstrapped, its parser is implemented in load_grammar.py
+
+start: (_item? _NL)* _item?
+
+_item: rule
+     | token
+     | statement
+
+rule: RULE rule_params priority? ":" expansions
+token: TOKEN token_params priority? ":" expansions
+
+rule_params: ["{" RULE ("," RULE)* "}"]
+token_params: ["{" TOKEN ("," TOKEN)* "}"]
+
+priority: "." NUMBER
+
+statement: "%ignore" expansions                    -> ignore
+         | "%import" import_path ["->" name]       -> import
+         | "%import" import_path name_list         -> multi_import
+         | "%override" rule                        -> override_rule
+         | "%declare" name+                        -> declare
+
+!import_path: "."? name ("." name)*
+name_list: "(" name ("," name)* ")"
+
+?expansions: alias (_VBAR alias)*
+
+?alias: expansion ["->" RULE]
+
+?expansion: expr*
+
+?expr: atom [OP | "~" NUMBER [".." NUMBER]]
+
+?atom: "(" expansions ")"
+     | "[" expansions "]" -> maybe
+     | value
+
+?value: STRING ".." STRING -> literal_range
+      | name
+      | (REGEXP | STRING) -> literal
+      | name "{" value ("," value)* "}" -> template_usage
+
+name: RULE
+    | TOKEN
+
+_VBAR: _NL? "|"
+OP: /[+*]|[?](?![a-z])/
+RULE: /!?[_?]?[a-z][_a-z0-9]*/
+TOKEN: /_?[A-Z][_A-Z0-9]*/
+STRING: _STRING "i"?
+REGEXP: /\/(?!\/)(\\\/|\\\\|[^\/])*?\/[imslux]*/
+_NL: /(\r?\n)+\s*/
+
+%import common.ESCAPED_STRING -> _STRING
+%import common.SIGNED_INT -> NUMBER
+%import common.WS_INLINE
+
+COMMENT: /\s*/ "//" /[^\n]/* | /\s*/ "#" /[^\n]/*
+
+%ignore WS_INLINE
+%ignore COMMENT