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

jaclang/core/construct.py

@@ -1,4 +1,5 @@
 """Core constructs for Jac Language."""
+
 from __future__ import annotations
 
 import types
@@ -15,7 +16,7 @@ from jaclang.core.utils import collect_node_connections
 class ElementAnchor:
     """Element Anchor."""
 
-    obj: Optional[Architype]
+    obj: Architype
 
 
 @dataclass(eq=False)
@@ -41,30 +42,6 @@ class NodeAnchor(ObjectAnchor):
         edg._jac_.attach(self.obj, nd)
         return self.obj
 
-    # def edges_to_nodes(
-    #     self, dir: EdgeDir, filter_type: Optional[type], filter_func: Optional[Callable]
-    # ) -> list[NodeArchitype]:
-    #     """Get set of nodes connected to this node."""
-    #     filter_func = filter_func if filter_func else lambda x: x
-    #     ret_nodes: list[NodeArchitype] = []
-    #     if dir in [EdgeDir.OUT]:
-    #         edge_list = []
-    #         for x in self.edges[EdgeDir.OUT]:
-    #             if x._jac_.target and (not filter_type or isinstance(x, filter_type)):
-    #                 edge_list.append(x)
-    #         new_edge = filter_func(edge_list)
-    #         for i in new_edge:
-    #             ret_nodes.append(i._jac_.target)
-    #     elif dir in [EdgeDir.IN]:
-    #         edge_list = []
-    #         for i in self.edges[EdgeDir.IN]:
-    #             if i._jac_.source and (not filter_type or isinstance(i, filter_type)):
-    #                 edge_list.append(i)
-    #         new_edge = filter_func(edge_list)
-    #         for i in new_edge:
-    #             ret_nodes.append(i._jac_.source)
-    #     return ret_nodes
-
     def edges_to_nodes(
         self, dir: EdgeDir, filter_type: Optional[type], filter_func: Optional[Callable]
     ) -> list[NodeArchitype]:
@@ -83,8 +60,8 @@ class NodeAnchor(ObjectAnchor):
 
     def gen_dot(self, dot_file: Optional[str] = None) -> str:
         """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes = set()
-        connections = set()
+        visited_nodes: set[NodeAnchor] = set()
+        connections: set[tuple[NodeArchitype, NodeArchitype, str]] = set()
         unique_node_id_dict = {}
 
         collect_node_connections(self, visited_nodes, connections)
@@ -96,7 +73,7 @@ class NodeAnchor(ObjectAnchor):
 
         for pair in list(set(connections)):
             dot_content += (
-                f"{unique_node_id_dict.get(pair[0])[1]} -> {unique_node_id_dict.get(pair[1])[1]}"
+                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
                 f' [label="{pair[2]}"];\n'
             )
         if dot_file:
@@ -246,7 +223,7 @@ class Architype:
 
     def __init__(self) -> None:
         """Create default architype."""
-        self._jac_ = ObjectAnchor(obj=self)
+        self._jac_: ObjectAnchor = ObjectAnchor(obj=self)
 
 
 class NodeArchitype(Architype):
@@ -254,7 +231,7 @@ class NodeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create node architype."""
-        self._jac_ = NodeAnchor(obj=self)
+        self._jac_: NodeAnchor = NodeAnchor(obj=self)
 
 
 class EdgeArchitype(Architype):
@@ -262,7 +239,7 @@ class EdgeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create edge architype."""
-        self._jac_ = EdgeAnchor(obj=self)
+        self._jac_: EdgeAnchor = EdgeAnchor(obj=self)
 
 
 class WalkerArchitype(Architype):
@@ -270,7 +247,7 @@ class WalkerArchitype(Architype):
 
     def __init__(self) -> None:
         """Create walker architype."""
-        self._jac_ = WalkerAnchor(obj=self)
+        self._jac_: WalkerAnchor = WalkerAnchor(obj=self)
 
 
 class Root(NodeArchitype):

jaclang/{compiler → core}/importer.py

@@ -1,85 +1,95 @@
-"""Special Imports for Jac Code."""
-import inspect
-import marshal
-import sys
-import types
-from os import path
-from typing import Optional
-
-from jaclang.compiler.constant import Constants as Con
-from jaclang.compiler.transpiler import transpile_jac
-from jaclang.utils.log import logging
-
-
-def jac_import(
-    target: str,
-    base_path: Optional[str] = None,
-    cachable: bool = True,
-    override_name: Optional[str] = None,
-) -> Optional[types.ModuleType]:
-    """Core Import Process."""
-    dir_path, file_name = 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:
-        return sys.modules[f"{package_path}.{module_name}"]
-    elif not package_path and module_name in sys.modules:
-        return sys.modules[module_name]
-
-    if base_path:
-        caller_dir = path.dirname(base_path) if not path.isdir(base_path) else base_path
-    else:
-        frame = inspect.stack()[1]
-        caller_dir = path.dirname(path.abspath(frame[0].f_code.co_filename))
-    caller_dir = path.dirname(caller_dir) if target.startswith("..") else caller_dir
-    caller_dir = path.join(caller_dir, dir_path)
-
-    gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
-    full_target = path.normpath(path.join(caller_dir, file_name))
-
-    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)
-    ):
-        with open(pyc_file_path, "rb") as f:
-            codeobj = marshal.load(f)
-    else:
-        if error := transpile_jac(full_target):
-            if error:
-                for e in error:
-                    print(e)
-                    logging.error(e)
-            return None
-        with open(pyc_file_path, "rb") as f:
-            codeobj = marshal.load(f)
-
-    module_name = override_name if override_name else module_name
-    module = types.ModuleType(module_name)
-    module.__file__ = full_target
-    module.__name__ = module_name
-
-    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
-
-    path_added = False
-    if caller_dir not in sys.path:
-        sys.path.append(caller_dir)
-        path_added = True
-    exec(codeobj, module.__dict__)
-    if path_added:
-        sys.path.remove(caller_dir)
-
-    return module
+"""Special Imports for Jac Code."""
+
+import marshal
+import sys
+import types
+from os import path
+from typing import Optional
+
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.compile import compile_jac
+from jaclang.compiler.constant import Constants as Con
+from jaclang.utils.log import logging
+
+
+def jac_importer(
+    target: str,
+    base_path: str,
+    cachable: bool = True,
+    override_name: Optional[str] = None,
+    mod_bundle: Optional[Module] = None,
+) -> Optional[types.ModuleType]:
+    """Core Import Process."""
+    dir_path, file_name = 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:
+        return sys.modules[f"{package_path}.{module_name}"]
+    elif not package_path and module_name in sys.modules:
+        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
+    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)
+        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)
+        ):
+            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)
+                return None
+            with open(pyc_file_path, "rb") as f:
+                codeobj = marshal.load(f)
+
+    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 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
+
+    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

jaclang/core/utils.py

@@ -1,15 +1,18 @@
 """Helper for construct."""
+
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from jaclang.compiler.constant import EdgeDir
 
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import NodeArchitype
+    from jaclang.core.construct import NodeAnchor
 
 
 def collect_node_connections(
-    current_node: "NodeArchitype",
+    current_node: NodeAnchor,
     visited_nodes: set,
     connections: set,
 ) -> None:
@@ -20,15 +23,17 @@ def collect_node_connections(
         in_edges = current_node.edges.get(EdgeDir.IN, [])
 
         for edge_ in out_edges:
-            target__ = edge_._jac_.target
-            connections.add(
-                (current_node.obj, target__._jac_.obj, edge_.__class__.__name__)
-            )
-            collect_node_connections(target__._jac_, visited_nodes, connections)
+            target = edge_._jac_.target
+            if target:
+                connections.add(
+                    (current_node.obj, target._jac_.obj, edge_.__class__.__name__)
+                )
+                collect_node_connections(target._jac_, visited_nodes, connections)
 
         for edge_ in in_edges:
-            source__ = edge_._jac_.source
-            connections.add(
-                (source__._jac_.obj, current_node.obj, edge_.__class__.__name__)
-            )
-            collect_node_connections(source__._jac_, visited_nodes, connections)
+            source = edge_._jac_.source
+            if source:
+                connections.add(
+                    (source._jac_.obj, current_node.obj, edge_.__class__.__name__)
+                )
+                collect_node_connections(source._jac_, visited_nodes, connections)

jaclang/plugin/__init__.py

@@ -1,4 +1,5 @@
 """Plugin interface for Jac."""
+
 from __future__ import annotations
 
 from .default import hookimpl

jaclang/plugin/default.py

@@ -1,76 +1,174 @@
 """Jac Language Features."""
+
 from __future__ import annotations
 
 import os
+import types
 from dataclasses import dataclass, field
 from functools import wraps
 from typing import Any, Callable, Optional, Type
 
-from jaclang import jac_import
-from jaclang.plugin.spec import (
-    ArchBound,
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.constant import EdgeDir
+from jaclang.core.construct import (
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
-    EdgeDir,
     GenericEdge,
     JacTestCheck,
+    NodeAnchor,
     NodeArchitype,
-    T,
+    ObjectAnchor,
+    Root,
+    WalkerAnchor,
     WalkerArchitype,
     root,
 )
+from jaclang.core.importer import jac_importer
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.plugin.spec import T
 
 
 import pluggy
 
+
+__all__ = [
+    "EdgeAnchor",
+    "GenericEdge",
+    "JacTestCheck",
+    "NodeAnchor",
+    "ObjectAnchor",
+    "WalkerAnchor",
+    "NodeArchitype",
+    "EdgeArchitype",
+    "WalkerArchitype",
+    "Architype",
+    "DSFunc",
+    "root",
+    "Root",
+    "jac_importer",
+    "T",
+]
+
+
 hookimpl = pluggy.HookimplMarker("jac")
 
 
 class JacFeatureDefaults:
     """Jac Feature."""
 
+    pm = pluggy.PluginManager("jac")
+
     @staticmethod
     @hookimpl
     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 new architype."""
+        cls = dataclass(eq=False)(cls)
+        for i in on_entry + on_exit:
+            i.resolve(cls)
+        if not issubclass(cls, arch_base):
+            cls = type(cls.__name__, (cls, arch_base), {})
+        cls._jac_entry_funcs_ = on_entry
+        cls._jac_exit_funcs_ = on_exit
+        inner_init = cls.__init__
+
+        @wraps(inner_init)
+        def new_init(self: Architype, *args: object, **kwargs: object) -> None:
+            inner_init(self, *args, **kwargs)
+            arch_base.__init__(self)
+
+        cls.__init__ = new_init  # type: ignore
+        return cls
+
+    @staticmethod
+    @hookimpl
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
     ) -> Callable[[type], type]:
         """Create a new architype."""
 
-        def decorator(cls: Type[ArchBound]) -> Type[ArchBound]:
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=Architype, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
+
+        return decorator
+
+    @staticmethod
+    @hookimpl
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a obj architype."""
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=NodeArchitype, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
+
+        return decorator
+
+    @staticmethod
+    @hookimpl
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a edge architype."""
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
             """Decorate class."""
-            cls = dataclass(eq=False)(cls)
-            for i in on_entry + on_exit:
-                i.resolve(cls)
-
-            match arch_type:
-                case "obj":
-                    arch_cls = Architype
-                case "node":
-                    arch_cls = NodeArchitype
-                case "edge":
-                    arch_cls = EdgeArchitype
-                case "walker":
-                    arch_cls = WalkerArchitype
-                case _:
-                    raise TypeError("Invalid archetype type")
-            if not issubclass(cls, arch_cls):
-                cls = type(cls.__name__, (cls, arch_cls), {})
-            cls._jac_entry_funcs_ = on_entry
-            cls._jac_exit_funcs_ = on_exit
-            inner_init = cls.__init__
-
-            @wraps(inner_init)
-            def new_init(self: ArchBound, *args: object, **kwargs: object) -> None:
-                inner_init(self, *args, **kwargs)
-                arch_cls.__init__(self)
-
-            cls.__init__ = new_init
+            cls = Jac.make_architype(
+                cls=cls, arch_base=EdgeArchitype, on_entry=on_entry, on_exit=on_exit
+            )
             return cls
 
         return decorator
 
+    @staticmethod
+    @hookimpl
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]:
+        """Create a walker architype."""
+
+        def decorator(cls: Type[Architype]) -> Type[Architype]:
+            """Decorate class."""
+            cls = Jac.make_architype(
+                cls=cls, arch_base=WalkerArchitype, on_entry=on_entry, on_exit=on_exit
+            )
+            return cls
+
+        return decorator
+
+    @staticmethod
+    @hookimpl
+    def jac_import(
+        target: str,
+        base_path: str,
+        cachable: bool,
+        override_name: Optional[str],
+        mod_bundle: Optional[Module],
+    ) -> Optional[types.ModuleType]:
+        """Core Import Process."""
+        result = jac_importer(
+            target=target,
+            base_path=base_path,
+            cachable=cachable,
+            override_name=override_name,
+            mod_bundle=mod_bundle,
+        )
+        return result
+
     @staticmethod
     @hookimpl
     def create_test(test_fun: Callable) -> Callable:
@@ -86,7 +184,7 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    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.
@@ -96,10 +194,11 @@ class JacFeatureDefaults:
             base = base if base else "./"
             mod_name = mod_name[:-4]
             JacTestCheck.reset()
-            jac_import(target=mod_name, base_path=base)
+            Jac.jac_import(target=mod_name, base_path=base)
             JacTestCheck.run_test()
         else:
             print("Not a .jac file.")
+        return True
 
     @staticmethod
     @hookimpl
@@ -109,15 +208,21 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    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 field(default_factory=lambda: gen_func())
 
     @staticmethod
     @hookimpl
-    def spawn_call(op1: Architype, op2: Architype) -> Architype:
+    def spawn_call(op1: Architype, op2: Architype) -> bool:
         """Jac's spawn operator feature."""
-        return op1._jac_.spawn_call(op2)
+        if isinstance(op1, WalkerArchitype):
+            op1._jac_.spawn_call(op2)
+        elif isinstance(op2, WalkerArchitype):
+            op2._jac_.spawn_call(op1)
+        else:
+            raise TypeError("Invalid walker object")
+        return True
 
     @staticmethod
     @hookimpl
@@ -131,10 +236,7 @@ class JacFeatureDefaults:
         expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
     ) -> bool:
         """Jac's ignore stmt feature."""
-        if isinstance(walker, WalkerArchitype):
-            return walker._jac_.ignore_node(expr)
-        else:
-            raise TypeError("Invalid walker object")
+        return walker._jac_.ignore_node(expr)
 
     @staticmethod
     @hookimpl