jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/plugin/feature.py

@@ -1,20 +1,19 @@
 """Jac Language Features."""
+
 from __future__ import annotations
 
-from typing import Any, Callable, Optional, Type
+import types
+from typing import Any, Callable, Optional, Type, TypeAlias
 
-from jaclang.plugin.default import JacFeatureDefaults
-from jaclang.plugin.spec import (
+from jaclang.compiler.absyntree import Module
+from jaclang.core.construct import (
     Architype,
     EdgeArchitype,
-    EdgeDir,
-    JacFeatureSpec,
     NodeArchitype,
     Root,
-    T,
     WalkerArchitype,
 )
-
+from jaclang.plugin.spec import JacFeatureSpec, T
 
 import pluggy
 
@@ -22,22 +21,69 @@ import pluggy
 class JacFeature:
     """Jac Feature."""
 
-    from jaclang.plugin.spec import DSFunc
-
     pm = pluggy.PluginManager("jac")
     pm.add_hookspecs(JacFeatureSpec)
-    pm.register(JacFeatureDefaults)
+    import abc
+    from jaclang.plugin.spec import DSFunc
+    from jaclang.compiler.constant import EdgeDir
 
-    RootType: Type[Root] = Root
-    EdgeDir: Type[EdgeDir] = EdgeDir
+    RootType: TypeAlias = Root
 
     @staticmethod
     def make_architype(
-        arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]
-    ) -> Callable[[type], type]:
-        """Create a new architype."""
+        cls: type,
+        arch_base: Type[Architype],
+        on_entry: list[DSFunc],
+        on_exit: list[DSFunc],
+    ) -> Type[Architype]:
+        """Create a obj architype."""
         return JacFeature.pm.hook.make_architype(
-            arch_type=arch_type, on_entry=on_entry, on_exit=on_exit
+            cls=cls, on_entry=on_entry, on_exit=on_exit, arch_base=arch_base
+        )
+
+    @staticmethod
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a obj architype."""
+        return JacFeature.pm.hook.make_obj(on_entry=on_entry, on_exit=on_exit)
+
+    @staticmethod
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a node architype."""
+        return JacFeature.pm.hook.make_node(on_entry=on_entry, on_exit=on_exit)
+
+    @staticmethod
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a edge architype."""
+        return JacFeature.pm.hook.make_edge(on_entry=on_entry, on_exit=on_exit)
+
+    @staticmethod
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a walker architype."""
+        return JacFeature.pm.hook.make_walker(on_entry=on_entry, on_exit=on_exit)
+
+    @staticmethod
+    def jac_import(
+        target: str,
+        base_path: str,
+        cachable: bool = True,
+        override_name: Optional[str] = None,
+        mod_bundle: Optional[Module] = None,
+    ) -> Optional[types.ModuleType]:
+        """Core Import Process."""
+        return JacFeature.pm.hook.jac_import(
+            target=target,
+            base_path=base_path,
+            cachable=cachable,
+            override_name=override_name,
+            mod_bundle=mod_bundle,
         )
 
     @staticmethod
@@ -46,7 +92,7 @@ class JacFeature:
         return JacFeature.pm.hook.create_test(test_fun=test_fun)
 
     @staticmethod
-    def run_test(filename: str) -> None:
+    def run_test(filename: str) -> bool:
         """Run the test suite in the specified .jac file."""
         return JacFeature.pm.hook.run_test(filename=filename)
 
@@ -56,12 +102,12 @@ class JacFeature:
         return JacFeature.pm.hook.elvis(op1=op1, op2=op2)
 
     @staticmethod
-    def has_instance_default(gen_func: Callable) -> list[Any] | dict[Any, Any]:
+    def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""
         return JacFeature.pm.hook.has_instance_default(gen_func=gen_func)
 
     @staticmethod
-    def spawn_call(op1: Architype, op2: Architype) -> Architype:
+    def spawn_call(op1: Architype, op2: Architype) -> bool:
         """Jac's spawn operator feature."""
         return JacFeature.pm.hook.spawn_call(op1=op1, op2=op2)
 

jaclang/plugin/spec.py

@@ -1,50 +1,25 @@
 """Jac Language Features."""
-from __future__ import annotations
 
+from __future__ import annotations
 
+import types
 from typing import Any, Callable, Optional, Type, TypeVar
 
-from jaclang.core.construct import (
+from jaclang.compiler.absyntree import Module
+from jaclang.plugin.default import (
     Architype,
     DSFunc,
-    EdgeAnchor,
     EdgeArchitype,
     EdgeDir,
-    GenericEdge,
-    JacTestCheck,
-    NodeAnchor,
     NodeArchitype,
-    ObjectAnchor,
-    Root,
-    WalkerAnchor,
     WalkerArchitype,
-    root,
 )
 
-__all__ = [
-    "EdgeAnchor",
-    "GenericEdge",
-    "JacTestCheck",
-    "NodeAnchor",
-    "ObjectAnchor",
-    "WalkerAnchor",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "WalkerArchitype",
-    "Architype",
-    "DSFunc",
-    "EdgeDir",
-    "root",
-    "Root",
-]
-
 import pluggy
 
 hookspec = pluggy.HookspecMarker("jac")
 
-
 T = TypeVar("T")
-ArchBound = TypeVar("ArchBound", bound=Architype)
 
 
 class JacFeatureSpec:
@@ -53,9 +28,56 @@ class JacFeatureSpec:
     @staticmethod
     @hookspec(firstresult=True)
     def make_architype(
-        arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]
+        cls: type,
+        arch_base: Type[Architype],
+        on_entry: list[DSFunc],
+        on_exit: list[DSFunc],
+    ) -> Type[Architype]:
+        """Create a obj architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
-        """Create a new architype."""
+        """Create a obj architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a node architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a edge architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a walker architype."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def jac_import(
+        target: str,
+        base_path: str,
+        cachable: bool,
+        override_name: Optional[str],
+        mod_bundle: Optional[Module],
+    ) -> Optional[types.ModuleType]:
+        """Core Import Process."""
         raise NotImplementedError
 
     @staticmethod
@@ -66,7 +88,7 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def run_test(filename: str) -> None:
+    def run_test(filename: str) -> bool:
         """Run the test suite in the specified .jac file.
 
         :param filename: The path to the .jac file.
@@ -81,13 +103,13 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def has_instance_default(gen_func: Callable) -> list[Any] | dict[Any, Any]:
+    def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""
         raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
-    def spawn_call(op1: Architype, op2: Architype) -> Architype:
+    def spawn_call(op1: Architype, op2: Architype) -> bool:
         """Jac's spawn operator feature."""
         raise NotImplementedError
 

jaclang/plugin/tests/test_features.py

@@ -1,4 +1,5 @@
 """Tests for Jac parser."""
+
 import inspect
 import io
 import sys
@@ -31,6 +32,14 @@ class TestFeatures(TestCase):
 
                     # Get the signature using inspect
                     signature = inspect.signature(value)
+                    new_parameters = []
+                    for (
+                        _,
+                        param,
+                    ) in signature.parameters.items():  # to strip defaults
+                        new_param = param.replace(default=inspect.Parameter.empty)
+                        new_parameters.append(new_param)
+                    signature = signature.replace(parameters=new_parameters)
                     methods.append(f"{name}{signature}")
                 except ValueError:
                     # This can happen if the method is not a Python function (e.g., built-in function)

jaclang/utils/helpers.py

@@ -1,4 +1,5 @@
 """Utility functions and classes for Jac compilation toolchain."""
+
 import os
 import re
 import textwrap

jaclang/utils/lang_tools.py

@@ -7,6 +7,7 @@ import sys
 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 DeclDefMatchPass
 from jaclang.compiler.passes.tool.schedules import (
     SymbolTableDotGraphPass,
@@ -14,7 +15,6 @@ from jaclang.compiler.passes.tool.schedules import (
     sym_tab_dot_gen,
     sym_tab_print,
 )
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.helpers import extract_headings, heading_to_snake, pascal_to_snake
 from jaclang.utils.treeprinter import print_ast_tree
 
@@ -252,13 +252,13 @@ class AstTool:
             with open(file_name, "r") as file:
                 code = file.read()
             parsed_ast = py_ast.parse(code)
-            return print_ast_tree(parsed_ast)
+            return f"{print_ast_tree(parsed_ast)}\n---\n{py_ast.dump(parsed_ast, indent=2)}"
         elif file_name.endswith(".jac"):
             [base, mod] = os.path.split(file_name)
             base = base if base else "./"
-            pyast = jac_file_to_pass(file_name).ir.gen.py_ast
+            pyast = jac_file_to_pass(file_name).ir.gen.py_ast[0]
             return (
-                print_ast_tree(pyast)
+                f"{print_ast_tree(pyast)}\n---\n{py_ast.dump(pyast, indent=2)}"
                 if isinstance(pyast, py_ast.AST)
                 else "Compile failed."
             )
@@ -310,7 +310,6 @@ class AstTool:
 
     def automate_ref(self) -> str:
         """Automate the reference guide generation."""
-        # Jac lark path
         file_path = os.path.join(
             os.path.split(os.path.dirname(__file__))[0], "../jaclang/compiler/jac.lark"
         )
@@ -323,31 +322,26 @@ class AstTool:
             os.path.split(os.path.dirname(__file__))[0], "../examples/reference/"
         )
         with open(created_file_path, "w") as md_file:
-            # Write the content to the destination file
             md_file.write("# Jac Language Reference\n\n## Introduction\n\n")
         for heading, lines in result.items():
             heading = heading.strip()
             heading_snakecase = heading_to_snake(heading)
             content = (
                 f'## {heading}\n```yaml linenums="{lines[0]}"\n--8<-- '
-                f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n```\n--8<-- '
+                f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n```\n'
+                f'=== "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'
+                "--8<-- "
                 f'"examples/reference/'
                 f'{heading_snakecase}.md"\n'
             )
             with open(created_file_path, "a") as md_file:
-                # Write the content to the destination file
                 md_file.write(f"{content}\n")
-            # Generate a Markdown file name based on the heading
             md_file_name = f"{heading_snakecase}.md"
-            # Full path for the new Markdown file
             md_file_path = os.path.join(destination_folder, md_file_name)
-            content = (
-                f'=== "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'
-            )
-            with open(md_file_path, "w") as md_file:
-                # Write the content to the destination file
-                md_file.write(content)
+            if not os.path.exists(md_file_path):
+                with open(md_file_path, "w") as md_file:
+                    md_file.write("")
         return "References generated."

jaclang/utils/tests/test_lang_tools.py

@@ -1,4 +1,5 @@
 """Test ast build pass module."""
+
 import os
 
 import jaclang
@@ -68,7 +69,7 @@ class JacFormatPassTests(TestCase):
                 self.assertIn("+-- ", out, msg)
                 self.assertIsNotNone(out, msg=msg)
             elif file.endswith(".py"):
-                if len(out.splitlines()) == 1:
+                if len(out.splitlines()) <= 4:
                     continue
                 self.assertIn("+-- ", out, msg)
                 self.assertIsNotNone(out, msg=msg)

jaclang/utils/treeprinter.py

@@ -1,4 +1,5 @@
 """Tree Printing Helpers for Jac."""
+
 from __future__ import annotations
 
 import ast as ast3
@@ -122,7 +123,7 @@ def print_ast_tree(
     def get_location_info(node: ast3.AST) -> str:
         if hasattr(node, "lineno"):
             start_pos = f"{node.lineno}:{node.col_offset + 1}"
-            end_pos = f"{node.end_lineno}:{node.end_col_offset + 1}"
+            end_pos = f"{node.end_lineno}:{node.end_col_offset + 1 if node.end_col_offset else node.col_offset}"
             prefix = f"{start_pos} - {end_pos}"
             return prefix
         return "-:- - -:-"

jaclang/vendor/lark/common.py

@@ -24,7 +24,9 @@ from .lexer import TerminalDef, Token
 ###{standalone
 
 _ParserArgType: "TypeAlias" = 'Literal["earley", "lalr", "cyk", "auto"]'
-_LexerArgType: "TypeAlias" = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
+_LexerArgType: "TypeAlias" = (
+    'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
+)
 _LexerCallback = Callable[[Token], Token]
 ParserCallbacks = Dict[str, Callable]
 

jaclang/vendor/lark/lexer.py

@@ -215,8 +215,7 @@ class Token(str):
         end_line: Optional[int] = None,
         end_column: Optional[int] = None,
         end_pos: Optional[int] = None,
-    ) -> "Token":
-        ...
+    ) -> "Token": ...
 
     @overload
     def __new__(
@@ -229,8 +228,7 @@ class Token(str):
         end_line: Optional[int] = None,
         end_column: Optional[int] = None,
         end_pos: Optional[int] = None,
-    ) -> "Token":
-        ...
+    ) -> "Token": ...
 
     def __new__(cls, *args, **kwargs):
         if "type_" in kwargs:
@@ -273,14 +271,12 @@ class Token(str):
     @overload
     def update(
         self, type: Optional[str] = None, value: Optional[Any] = None
-    ) -> "Token":
-        ...
+    ) -> "Token": ...
 
     @overload
     def update(
         self, type_: Optional[str] = None, value: Optional[Any] = None
-    ) -> "Token":
-        ...
+    ) -> "Token": ...
 
     def update(self, *args, **kwargs):
         if "type_" in kwargs:
@@ -607,12 +603,10 @@ class AbstractBasicLexer(Lexer):
     terminals_by_name: Dict[str, TerminalDef]
 
     @abstractmethod
-    def __init__(self, conf: "LexerConf", comparator=None) -> None:
-        ...
+    def __init__(self, conf: "LexerConf", comparator=None) -> None: ...
 
     @abstractmethod
-    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token:
-        ...
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: ...
 
     def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]:
         with suppress(EOFError):

jaclang/vendor/lark/parsers/lalr_parser.py

@@ -1,5 +1,6 @@
 """This module implements a LALR(1) Parser
 """
+
 # Author: Erez Shinan (2017)
 # Email : erezshin@gmail.com
 from typing import Dict, Any, Optional

jaclang/vendor/mypy/applytype.py

@@ -100,7 +100,8 @@ def apply_generic_arguments(
     bound or constraints, instead of giving an error.
     """
     tvars = callable.variables
-    assert len(tvars) == len(orig_types)
+    min_arg_count = sum(not tv.has_default() for tv in tvars)
+    assert min_arg_count <= len(orig_types) <= len(tvars)
     # Check that inferred type variable values are compatible with allowed
     # values and bounds.  Also, promote subtype values to allowed values.
     # Create a map from type variable id to target type.

jaclang/vendor/mypy/binder.py

@@ -311,7 +311,7 @@ class ConditionalTypeBinder:
             self.type_assignments[expr].append((type, declared_type))
             return
         if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
-            return None
+            return
         if not literal(expr):
             return
         self.invalidate_dependencies(expr)

jaclang/vendor/mypy/build.py

@@ -8,6 +8,7 @@ file.  The individual passes are implemented in separate modules.
 
 The function build() is the main interface to this module.
 """
+
 # TODO: More consistent terminology, e.g. path/fnam, module/id, state/file
 
 from __future__ import annotations
@@ -713,10 +714,7 @@ class BuildManager:
         # for efficient lookup
         self.shadow_map: dict[str, str] = {}
         if self.options.shadow_file is not None:
-            self.shadow_map = {
-                source_file: shadow_file
-                for (source_file, shadow_file) in self.options.shadow_file
-            }
+            self.shadow_map = dict(self.options.shadow_file)
         # a mapping from each file being typechecked to its possible shadow file
         self.shadow_equivalence_map: dict[str, str | None] = {}
         self.plugin = plugin
@@ -1175,7 +1173,7 @@ def read_deps_cache(manager: BuildManager, graph: Graph) -> dict[str, FgDepMeta]
     module_deps_metas = deps_meta["deps_meta"]
     assert isinstance(module_deps_metas, dict)
     if not manager.options.skip_cache_mtime_checks:
-        for id, meta in module_deps_metas.items():
+        for meta in module_deps_metas.values():
             try:
                 matched = manager.getmtime(meta["path"]) == meta["mtime"]
             except FileNotFoundError:
@@ -2189,7 +2187,7 @@ class State:
             self.meta.data_json, self.manager, "Load tree ", "Could not load tree: "
         )
         if data is None:
-            return None
+            return
 
         t0 = time.time()
         # TODO: Assert data file wasn't changed.
@@ -2278,8 +2276,8 @@ class State:
                     self.id,
                     self.xpath,
                     source,
-                    self.ignore_all or self.options.ignore_errors,
-                    self.options,
+                    ignore_errors=self.ignore_all or self.options.ignore_errors,
+                    options=self.options,
                 )
 
             else:
@@ -3556,7 +3554,7 @@ def order_ascc(
     strongly_connected_components() below for a reference.
     """
     if len(ascc) == 1:
-        return [s for s in ascc]
+        return list(ascc)
     pri_spread = set()
     for id in ascc:
         state = graph[id]