jaclang 0.7.22__py3-none-any.whl → 0.7.25__py3-none-any.whl

jaclang/runtimelib/architype.py

@@ -7,12 +7,9 @@ from enum import IntEnum
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
-from typing import Any, Callable, ClassVar, Iterable, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Optional, TypeVar
 from uuid import UUID, uuid4
 
-from jaclang.compiler.constant import EdgeDir
-from jaclang.runtimelib.utils import collect_node_connections
-
 logger = getLogger(__name__)
 
 TARCH = TypeVar("TARCH", bound="Architype")
@@ -77,128 +74,6 @@ class Anchor:
     persistent: bool = False
     hash: int = 0
 
-    ##########################################################################
-    #                             ACCESS CONTROL: TODO: Make Base Type       #
-    ##########################################################################
-
-    def allow_root(
-        self, root_id: UUID, level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Allow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-
-        _root_id = str(root_id)
-        if level != access.anchors.get(_root_id, AccessLevel.NO_ACCESS):
-            access.anchors[_root_id] = level
-
-    def disallow_root(
-        self, root_id: UUID, level: AccessLevel | int | str = AccessLevel.READ
-    ) -> None:
-        """Disallow all access from target root graph to current Architype."""
-        level = AccessLevel.cast(level)
-        access = self.access.roots
-
-        access.anchors.pop(str(root_id), None)
-
-    def unrestrict(self, level: AccessLevel | int | str = AccessLevel.READ) -> None:
-        """Allow everyone to access current Architype."""
-        level = AccessLevel.cast(level)
-        if level != self.access.all:
-            self.access.all = level
-
-    def restrict(self) -> None:
-        """Disallow others to access current Architype."""
-        if self.access.all > AccessLevel.NO_ACCESS:
-            self.access.all = AccessLevel.NO_ACCESS
-
-    def has_read_access(self, to: Anchor) -> bool:
-        """Read Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.NO_ACCESS):
-            logger.info(
-                f"Current root doesn't have read access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def has_connect_access(self, to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.READ):
-            logger.info(
-                f"Current root doesn't have connect access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def has_write_access(self, to: Anchor) -> bool:
-        """Write Access Validation."""
-        if not (access_level := self.access_level(to) > AccessLevel.CONNECT):
-            logger.info(
-                f"Current root doesn't have write access to {to.__class__.__name__}[{to.id}]"
-            )
-        return access_level
-
-    def access_level(self, to: Anchor) -> AccessLevel:
-        """Access validation."""
-        if not to.persistent:
-            return AccessLevel.WRITE
-
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        jroot = jctx.root
-
-        # if current root is system_root
-        # if current root id is equal to target anchor's root id
-        # if current root is the target anchor
-        if jroot == jctx.system_root or jroot.id == to.root or jroot == to:
-            return AccessLevel.WRITE
-
-        access_level = AccessLevel.NO_ACCESS
-
-        # if target anchor have set access.all
-        if (to_access := to.access).all > AccessLevel.NO_ACCESS:
-            access_level = to_access.all
-
-        # if target anchor's root have set allowed roots
-        # if current root is allowed to the whole graph of target anchor's root
-        if to.root and isinstance(to_root := jctx.mem.find_one(to.root), Anchor):
-            if to_root.access.all > access_level:
-                access_level = to_root.access.all
-
-            level = to_root.access.roots.check(str(jroot.id))
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-                access_level = level
-
-        # if target anchor have set allowed roots
-        # if current root is allowed to target anchor
-        level = to_access.roots.check(str(jroot.id))
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
-            access_level = level
-
-        return access_level
-
-    # ---------------------------------------------------------------------- #
-
-    def save(self) -> None:
-        """Save Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        self.persistent = True
-        self.root = jctx.root.id
-
-        jctx.mem.set(self.id, self)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            jctx.mem.remove(self.id)
-
     def is_populated(self) -> bool:
         """Check if state."""
         return "architype" in self.__dict__
@@ -304,122 +179,6 @@ class NodeAnchor(Anchor):
     architype: NodeArchitype
     edges: list[EdgeAnchor]
 
-    def get_edges(
-        self,
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-        target_obj: Optional[list[NodeArchitype]],
-    ) -> list[EdgeArchitype]:
-        """Get edges connected to this node."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        root = Jac.get_root().__jac__
-        ret_edges: list[EdgeArchitype] = []
-        for anchor in self.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and self == source
-                    and (not target_obj or target.architype in target_obj)
-                    and root.has_read_access(target)
-                ):
-                    ret_edges.append(anchor.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and self == target
-                    and (not target_obj or source.architype in target_obj)
-                    and root.has_read_access(source)
-                ):
-                    ret_edges.append(anchor.architype)
-        return ret_edges
-
-    def edges_to_nodes(
-        self,
-        dir: EdgeDir,
-        filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
-        target_obj: Optional[list[NodeArchitype]],
-    ) -> list[NodeArchitype]:
-        """Get set of nodes connected to this node."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        root = Jac.get_root().__jac__
-        ret_edges: list[NodeArchitype] = []
-        for anchor in self.edges:
-            if (
-                (source := anchor.source)
-                and (target := anchor.target)
-                and (not filter_func or filter_func([anchor.architype]))
-                and source.architype
-                and target.architype
-            ):
-                if (
-                    dir in [EdgeDir.OUT, EdgeDir.ANY]
-                    and self == source
-                    and (not target_obj or target.architype in target_obj)
-                    and root.has_read_access(target)
-                ):
-                    ret_edges.append(target.architype)
-                if (
-                    dir in [EdgeDir.IN, EdgeDir.ANY]
-                    and self == target
-                    and (not target_obj or source.architype in target_obj)
-                    and root.has_read_access(source)
-                ):
-                    ret_edges.append(source.architype)
-        return ret_edges
-
-    def remove_edge(self, edge: EdgeAnchor) -> None:
-        """Remove reference without checking sync status."""
-        for idx, ed in enumerate(self.edges):
-            if ed.id == edge.id:
-                self.edges.pop(idx)
-                break
-
-    def gen_dot(self, dot_file: Optional[str] = None) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes: set[NodeAnchor] = set()
-        connections: set[tuple[NodeArchitype, NodeArchitype, str]] = set()
-        unique_node_id_dict = {}
-
-        collect_node_connections(self, visited_nodes, connections)
-        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
-        for idx, i in enumerate([nodes_.architype for nodes_ in visited_nodes]):
-            unique_node_id_dict[i] = (i.__class__.__name__, str(idx))
-            dot_content += f'{idx} [label="{i}"];\n'
-        dot_content += 'edge [color="gray", style="solid"];\n'
-
-        for pair in list(set(connections)):
-            dot_content += (
-                f"{unique_node_id_dict[pair[0]][1]} -> {unique_node_id_dict[pair[1]][1]}"
-                f' [label="{pair[2]}"];\n'
-            )
-        if dot_file:
-            with open(dot_file, "w") as f:
-                f.write(dot_content + "}")
-        return dot_content + "}"
-
-    def spawn_call(self, walk: WalkerAnchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        return walk.spawn_call(self)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            for edge in self.edges:
-                edge.destroy()
-
-            jctx.mem.remove(self.id)
-
     def __getstate__(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         state = super().__getstate__()
@@ -439,30 +198,6 @@ class EdgeAnchor(Anchor):
     target: NodeAnchor
     is_undirected: bool
 
-    def __post_init__(self) -> None:
-        """Populate edge to source and target."""
-        self.source.edges.append(self)
-        self.target.edges.append(self)
-
-    def detach(self) -> None:
-        """Detach edge from nodes."""
-        self.source.remove_edge(self)
-        self.target.remove_edge(self)
-
-    def spawn_call(self, walk: WalkerAnchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        return walk.spawn_call(self.target)
-
-    def destroy(self) -> None:
-        """Destroy Anchor."""
-        from jaclang.plugin.feature import JacFeature as Jac
-
-        jctx = Jac.get_context()
-
-        if jctx.root.has_write_access(self):
-            self.detach()
-            jctx.mem.remove(self.id)
-
     def __getstate__(self) -> dict[str, object]:
         """Serialize Node Anchor."""
         state = super().__getstate__()
@@ -489,99 +224,6 @@ class WalkerAnchor(Anchor):
     ignores: list[Anchor] = field(default_factory=list)
     disengaged: bool = False
 
-    def visit_node(self, anchors: Iterable[NodeAnchor | EdgeAnchor]) -> bool:
-        """Walker visits node."""
-        before_len = len(self.next)
-        for anchor in anchors:
-            if anchor not in self.ignores:
-                if isinstance(anchor, NodeAnchor):
-                    self.next.append(anchor)
-                elif isinstance(anchor, EdgeAnchor):
-                    if target := anchor.target:
-                        self.next.append(target)
-                    else:
-                        raise ValueError("Edge has no target.")
-        return len(self.next) > before_len
-
-    def ignore_node(self, anchors: Iterable[NodeAnchor | EdgeAnchor]) -> bool:
-        """Walker ignores node."""
-        before_len = len(self.ignores)
-        for anchor in anchors:
-            if anchor not in self.ignores:
-                if isinstance(anchor, NodeAnchor):
-                    self.ignores.append(anchor)
-                elif isinstance(anchor, EdgeAnchor):
-                    if target := anchor.target:
-                        self.ignores.append(target)
-                    else:
-                        raise ValueError("Edge has no target.")
-        return len(self.ignores) > before_len
-
-    def disengage_now(self) -> None:
-        """Disengage walker from traversal."""
-        self.disengaged = True
-
-    def spawn_call(self, node: Anchor) -> WalkerArchitype:
-        """Invoke data spatial call."""
-        if walker := self.architype:
-            self.path = []
-            self.next = [node]
-            if self.next:
-                current_node = self.next[-1].architype
-                for i in walker._jac_entry_funcs_:
-                    if not i.trigger:
-                        if i.func:
-                            i.func(walker, current_node)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
-            while len(self.next):
-                if current_node := self.next.pop(0).architype:
-                    for i in current_node._jac_entry_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                i.func(current_node, walker)
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_entry_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func and i.trigger:
-                                i.func(walker, current_node)
-                            elif not i.trigger:
-                                continue
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in walker._jac_exit_funcs_:
-                        if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func and i.trigger:
-                                i.func(walker, current_node)
-                            elif not i.trigger:
-                                continue
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-                    for i in current_node._jac_exit_funcs_:
-                        if not i.trigger or isinstance(walker, i.trigger):
-                            if i.func:
-                                i.func(current_node, walker)
-                            else:
-                                raise ValueError(f"No function {i.name} to call.")
-                        if self.disengaged:
-                            return walker
-            for i in walker._jac_exit_funcs_:
-                if not i.trigger:
-                    if i.func:
-                        i.func(walker, current_node)
-                    else:
-                        raise ValueError(f"No function {i.name} to call.")
-            self.ignores = []
-            return walker
-        raise Exception(f"Invalid Reference {self.id}")
-
 
 class Architype:
     """Architype Protocol."""
@@ -613,17 +255,6 @@ class EdgeArchitype(Architype):
 
     __jac__: EdgeAnchor
 
-    def __attach__(
-        self,
-        source: NodeAnchor,
-        target: NodeAnchor,
-        is_undirected: bool,
-    ) -> None:
-        """Attach EdgeAnchor properly."""
-        self.__jac__ = EdgeAnchor(
-            architype=self, source=source, target=target, is_undirected=is_undirected
-        )
-
 
 class WalkerArchitype(Architype):
     """Walker Architype Protocol."""

jaclang/runtimelib/constructs.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 
 from .architype import (
+    AccessLevel,
     Anchor,
     Architype,
     DSFunc,
@@ -21,6 +22,7 @@ from .memory import Memory, ShelfStorage
 from .test import JacTestCheck, JacTestResult, JacTextTestRunner
 
 __all__ = [
+    "AccessLevel",
     "Anchor",
     "NodeAnchor",
     "EdgeAnchor",

jaclang/runtimelib/context.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import unittest
 from contextvars import ContextVar
+from dataclasses import MISSING
 from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
@@ -26,6 +27,7 @@ class ExecutionContext:
 
     mem: Memory
     reports: list[Any]
+    custom: Any = MISSING
     system_root: NodeAnchor
     root: NodeAnchor
     entry_node: NodeAnchor
@@ -42,10 +44,6 @@ class ExecutionContext:
             raise ValueError(f"Invalid anchor id {anchor_id} !")
         return default
 
-    def validate_access(self) -> bool:
-        """Validate access."""
-        return self.root.has_read_access(self.entry_node)
-
     def set_entry_node(self, entry_node: str | None) -> None:
         """Override entry."""
         self.entry_node = self.init_anchor(entry_node, self.root)

jaclang/runtimelib/importer.py

@@ -344,14 +344,19 @@ class JacImporter(Importer):
                     cachable=spec.cachable,
                     reload=reload if reload else False,
                 )
+
+                # Since this is a compile time error, we can safely raise an exception here.
+                if not codeobj:
+                    raise ImportError(f"No bytecode found for {spec.full_target}")
+
                 try:
-                    if not codeobj:
-                        raise ImportError(f"No bytecode found for {spec.full_target}")
                     with sys_path_context(spec.caller_dir):
                         exec(codeobj, module.__dict__)
                 except Exception as e:
+                    logger.error(e)
                     logger.error(dump_traceback(e))
                     raise e
+
         import_return = ImportReturn(module, unique_loaded_items, self)
         if spec.items:
             import_return.process_items(

jaclang/runtimelib/machine.py

@@ -1,9 +1,12 @@
 """Jac Machine module."""
 
+from __future__ import annotations
+
 import inspect
 import marshal
 import os
 import sys
+import tempfile
 import types
 from contextvars import ContextVar
 from typing import Optional, Union
@@ -11,6 +14,7 @@ from typing import Optional, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
+from jaclang.compiler.semtable import SemRegistry
 from jaclang.runtimelib.architype import (
     Architype,
     EdgeArchitype,
@@ -69,6 +73,14 @@ class JacMachine:
             )
         return None
 
+    def get_sem_ir(self, mod_sem_ir: SemRegistry | None) -> None:
+        """Update semtable on the attached JacProgram."""
+        if self.jac_program and mod_sem_ir:
+            if self.jac_program.sem_ir:
+                self.jac_program.sem_ir.registry.update(mod_sem_ir.registry)
+            else:
+                self.jac_program.sem_ir = mod_sem_ir
+
     def load_module(self, module_name: str, module: types.ModuleType) -> None:
         """Load a module into the machine."""
         self.loaded_modules[module_name] = module
@@ -111,6 +123,62 @@ class JacMachine:
             return nodes
         return []
 
+    def create_architype_from_source(
+        self,
+        source_code: str,
+        module_name: Optional[str] = None,
+        base_path: Optional[str] = None,
+        cachable: bool = False,
+        keep_temporary_files: bool = False,
+    ) -> Optional[types.ModuleType]:
+        """Dynamically creates architypes (nodes, walkers, etc.) from Jac source code."""
+        from jaclang.runtimelib.importer import JacImporter, ImportPathSpec
+
+        if not base_path:
+            base_path = self.base_path or os.getcwd()
+
+        if base_path and not os.path.exists(base_path):
+            os.makedirs(base_path)
+        if not module_name:
+            module_name = f"_dynamic_module_{len(self.loaded_modules)}"
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".jac",
+            prefix=module_name + "_",
+            dir=base_path,
+            delete=False,
+        ) as tmp_file:
+            tmp_file_path = tmp_file.name
+            tmp_file.write(source_code)
+
+        try:
+            importer = JacImporter(self)
+            tmp_file_basename = os.path.basename(tmp_file_path)
+            tmp_module_name, _ = os.path.splitext(tmp_file_basename)
+
+            spec = ImportPathSpec(
+                target=tmp_module_name,
+                base_path=base_path,
+                absorb=False,
+                cachable=cachable,
+                mdl_alias=None,
+                override_name=module_name,
+                lng="jac",
+                items=None,
+            )
+
+            import_result = importer.run_import(spec, reload=False)
+            module = import_result.ret_mod
+
+            self.loaded_modules[module_name] = module
+            return module
+        except Exception as e:
+            logger.error(f"Error importing dynamic module '{module_name}': {e}")
+            return None
+        finally:
+            if not keep_temporary_files and os.path.exists(tmp_file_path):
+                os.remove(tmp_file_path)
+
     def update_walker(
         self, module_name: str, items: Optional[dict[str, Union[str, Optional[str]]]]
     ) -> tuple[types.ModuleType, ...]:
@@ -206,14 +274,18 @@ class JacMachine:
 
 
 class JacProgram:
-    """Class to hold the mod_bundle and bytecode for Jac modules."""
+    """Class to hold the mod_bundle bytecode and sem_ir for Jac modules."""
 
     def __init__(
-        self, mod_bundle: Optional[Module], bytecode: Optional[dict[str, bytes]]
+        self,
+        mod_bundle: Optional[Module],
+        bytecode: Optional[dict[str, bytes]],
+        sem_ir: Optional[SemRegistry],
     ) -> None:
         """Initialize the JacProgram object."""
         self.mod_bundle = mod_bundle
         self.bytecode = bytecode or {}
+        self.sem_ir = sem_ir if sem_ir else SemRegistry()
 
     def get_bytecode(
         self,
@@ -235,10 +307,10 @@ class JacProgram:
 
         result = compile_jac(full_target, cache_result=cachable)
         if result.errors_had or not result.ir.gen.py_bytecode:
-            logger.error(
-                f"While importing {len(result.errors_had)} errors"
-                f" found in {full_target}"
-            )
+            for alrt in result.errors_had:
+                # We're not logging here, it already gets logged as the errors were added to the errors_had list.
+                # Regardless of the logging, this needs to be sent to the end user, so we'll printing it to stderr.
+                logger.error(alrt.pretty_print())
             return None
         if result.ir.gen.py_bytecode is not None:
             return marshal.loads(result.ir.gen.py_bytecode)

jaclang/runtimelib/memory.py

@@ -82,8 +82,6 @@ class ShelfStorage(Memory[UUID, Anchor]):
         if isinstance(self.__shelf__, Shelf):
             from jaclang.plugin.feature import JacFeature as Jac
 
-            root = Jac.get_root().__jac__
-
             for anchor in self.__gc__:
                 self.__shelf__.pop(str(anchor.id), None)
                 self.__mem__.pop(anchor.id, None)
@@ -96,14 +94,14 @@ class ShelfStorage(Memory[UUID, Anchor]):
                             isinstance(p_d, NodeAnchor)
                             and isinstance(d, NodeAnchor)
                             and p_d.edges != d.edges
-                            and root.has_connect_access(d)
+                            and Jac.check_connect_access(d)
                         ):
                             if not d.edges:
                                 self.__shelf__.pop(_id, None)
                                 continue
                             p_d.edges = d.edges
 
-                        if root.has_write_access(d):
+                        if Jac.check_write_access(d):
                             if hash(dumps(p_d.access)) != hash(dumps(d.access)):
                                 p_d.access = d.access
                             if hash(dumps(p_d.architype)) != hash(dumps(d.architype)):

jaclang/settings.py

@@ -58,6 +58,9 @@ class Settings:
         """Override settings from environment variables if available."""
         for key in [f.name for f in fields(self)]:
             env_value = os.getenv("JACLANG_" + key.upper())
+            env_value = (
+                env_value if env_value is not None else os.getenv("JAC_" + key.upper())
+            )
             if env_value is not None:
                 setattr(self, key, self.convert_type(env_value))
 

jaclang/tests/fixtures/arch_create_util.jac

@@ -0,0 +1,7 @@
+node UtilityNode {
+    has data: int;
+
+    can display_data with entry {
+        print("UtilityNode Data:", f'{self.data}');
+    }
+}

jaclang/tests/fixtures/arch_rel_import_creation.jac

@@ -0,0 +1,30 @@
+import:py from jaclang.runtimelib.machine { JacMachine }
+
+glob dynamic_module_source = """
+import from .arch_create_util {UtilityNode}
+
+walker DynamicWalker {
+can start with entry {
+print("DynamicWalker Started");
+here ++> UtilityNode(data=42);
+visit [-->](`?UtilityNode);
+}
+
+can UtilityNode {
+here.display_data();
+}
+}
+""";
+
+with entry {
+    node_arch = JacMachine.get().create_architype_from_source(
+        dynamic_module_source,
+        module_name="dynamic_module"
+    );
+    walker_obj = JacMachine.get().spawn_walker(
+        'DynamicWalker',
+        module_name="dynamic_module",
+
+    );
+    root spawn walker_obj;
+}