jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/runtimelib/{architype.py → archetype.py}

@@ -15,7 +15,7 @@ from uuid import UUID, uuid4
 
 logger = getLogger(__name__)
 
-TARCH = TypeVar("TARCH", bound="Architype")
+TARCH = TypeVar("TARCH", bound="Archetype")
 TANCH = TypeVar("TANCH", bound="Anchor")
 
 
@@ -70,7 +70,7 @@ class AnchorReport:
 class Anchor:
     """Object Anchor."""
 
-    architype: Architype
+    archetype: Archetype
     id: UUID = field(default_factory=uuid4)
     root: Optional[UUID] = None
     access: Permission = field(default_factory=Permission)
@@ -79,7 +79,7 @@ class Anchor:
 
     def is_populated(self) -> bool:
         """Check if state."""
-        return "architype" in self.__dict__
+        return "archetype" in self.__dict__
 
     def make_stub(self: TANCH) -> TANCH:
         """Return unsynced copy of anchor."""
@@ -90,8 +90,8 @@ class Anchor:
         return self
 
     def populate(self) -> None:
-        """Retrieve the Architype from db and return."""
-        from jaclang.plugin.feature import JacFeature as Jac
+        """Retrieve the Archetype from db and return."""
+        from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
         jsrc = Jac.get_context().mem
 
@@ -117,13 +117,13 @@ class Anchor:
     def __getstate__(self) -> dict[str, Any]:  # NOTE: May be better type hinting
         """Serialize Anchor."""
         if self.is_populated():
-            unlinked = object.__new__(self.architype.__class__)
-            unlinked.__dict__.update(self.architype.__dict__)
+            unlinked = object.__new__(self.archetype.__class__)
+            unlinked.__dict__.update(self.archetype.__dict__)
             unlinked.__dict__.pop("__jac__", None)
 
             return {
                 "id": self.id,
-                "architype": unlinked,
+                "archetype": unlinked,
                 "root": self.root,
                 "access": self.access,
                 "persistent": self.persistent,
@@ -135,8 +135,8 @@ class Anchor:
         """Deserialize Anchor."""
         self.__dict__.update(state)
 
-        if self.is_populated() and self.architype:
-            self.architype.__jac__ = self
+        if self.is_populated() and self.archetype:
+            self.archetype.__jac__ = self
             self.hash = hash(dumps(self))
 
     def __repr__(self) -> str:
@@ -157,8 +157,8 @@ class Anchor:
         return AnchorReport(
             id=self.id.hex,
             context=(
-                asdict(self.architype)
-                if is_dataclass(self.architype) and not isinstance(self.architype, type)
+                asdict(self.archetype)
+                if is_dataclass(self.archetype) and not isinstance(self.archetype, type)
                 else {}
             ),
         )
@@ -179,7 +179,7 @@ class Anchor:
 class NodeAnchor(Anchor):
     """Node Anchor."""
 
-    architype: NodeArchitype
+    archetype: NodeArchetype
     edges: list[EdgeAnchor]
 
     def __getstate__(self) -> dict[str, object]:
@@ -196,7 +196,7 @@ class NodeAnchor(Anchor):
 class EdgeAnchor(Anchor):
     """Edge Anchor."""
 
-    architype: EdgeArchitype
+    archetype: EdgeArchetype
     source: NodeAnchor
     target: NodeAnchor
     is_undirected: bool
@@ -221,9 +221,9 @@ class EdgeAnchor(Anchor):
 class WalkerAnchor(Anchor):
     """Walker Anchor."""
 
-    architype: WalkerArchitype
+    archetype: WalkerArchetype
     path: list[NodeAnchor] = field(default_factory=list)
-    next: list[NodeAnchor] = field(default_factory=list)
+    next: list[NodeAnchor | EdgeAnchor] = field(default_factory=list)
     ignores: list[NodeAnchor] = field(default_factory=list)
     disengaged: bool = False
 
@@ -232,90 +232,114 @@ class WalkerAnchor(Anchor):
 class ObjectAnchor(Anchor):
     """Edge Anchor."""
 
-    architype: ObjectArchitype
+    archetype: ObjectArchetype
 
 
-class Architype:
-    """Architype Protocol."""
+@dataclass(eq=False, repr=False, kw_only=True)
+class Archetype:
+    """Archetype Protocol."""
+
+    _jac_entry_funcs_: ClassVar[list[DataSpatialFunction]] = []
+    _jac_exit_funcs_: ClassVar[list[DataSpatialFunction]] = []
 
-    _jac_entry_funcs_: ClassVar[list[DSFunc]]
-    _jac_exit_funcs_: ClassVar[list[DSFunc]]
+    @cached_property
+    def __jac__(self) -> Anchor:
+        """Create default anchor."""
+        return Anchor(archetype=self)
 
-    def __init__(self) -> None:
-        """Create default architype."""
-        self.__jac__ = Anchor(architype=self)
+    def __init_subclass__(cls) -> None:
+        """Configure subclasses."""
+        if not cls.__dict__.get("__jac_base__", False):
+            from jaclang import JacMachineInterface as _
+
+            _.make_archetype(cls)
 
     def __repr__(self) -> str:
-        """Override repr for architype."""
+        """Override repr for archetype."""
         return f"{self.__class__.__name__}"
 
 
-class NodeArchitype(Architype):
-    """Node Architype Protocol."""
+class NodeArchetype(Archetype):
+    """Node Archetype Protocol."""
 
-    __jac__: NodeAnchor
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create node architype."""
-        self.__jac__ = NodeAnchor(architype=self, edges=[])
+    @cached_property
+    def __jac__(self) -> NodeAnchor:
+        """Create default anchor."""
+        return NodeAnchor(archetype=self, edges=[])
 
 
-class EdgeArchitype(Architype):
-    """Edge Architype Protocol."""
+class EdgeArchetype(Archetype):
+    """Edge Archetype Protocol."""
 
+    __jac_base__: ClassVar[bool] = True
     __jac__: EdgeAnchor
 
 
-class WalkerArchitype(Architype):
-    """Walker Architype Protocol."""
+class WalkerArchetype(Archetype):
+    """Walker Archetype Protocol."""
 
-    __jac__: WalkerAnchor
+    __jac_async__: ClassVar[bool] = False
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create walker architype."""
-        self.__jac__ = WalkerAnchor(architype=self)
+    @cached_property
+    def __jac__(self) -> WalkerAnchor:
+        """Create default anchor."""
+        return WalkerAnchor(archetype=self)
 
 
-class ObjectArchitype(Architype):
-    """Walker Architype Protocol."""
+class ObjectArchetype(Archetype):
+    """Walker Archetype Protocol."""
 
-    __jac__: ObjectAnchor
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create walker architype."""
-        self.__jac__ = ObjectAnchor(architype=self)
+    @cached_property
+    def __jac__(self) -> ObjectAnchor:
+        """Create default anchor."""
+        return ObjectAnchor(archetype=self)
 
 
-class GenericEdge(EdgeArchitype):
+@dataclass(eq=False)
+class GenericEdge(EdgeArchetype):
     """Generic Edge."""
 
+    __jac_base__: ClassVar[bool] = True
 
-class Root(NodeArchitype):
+    def __repr__(self) -> str:
+        """Override repr for archetype."""
+        return f"{self.__class__.__name__}()"
+
+
+@dataclass(eq=False)
+class Root(NodeArchetype):
     """Generic Root Node."""
 
-    def __init__(self) -> None:
-        """Create root node."""
-        self.__jac__ = NodeAnchor(architype=self, persistent=True, edges=[])
+    __jac_base__: ClassVar[bool] = True
+
+    @cached_property
+    def __jac__(self) -> NodeAnchor:
+        """Create default anchor."""
+        return NodeAnchor(archetype=self, persistent=True, edges=[])
+
+    def __repr__(self) -> str:
+        """Override repr for archetype."""
+        return f"{self.__class__.__name__}()"
 
 
 @dataclass(eq=False)
-class DSFunc:
+class DataSpatialFunction:
     """Data Spatial Function."""
 
     name: str
-    func: Callable[[Any, Any], Any] | None = None
+    func: Callable[[Any, Any], Any]
 
     @cached_property
     def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
         """Get function parameter annotations."""
-        if self.func:
-            parameters = inspect.signature(self.func, eval_str=True).parameters
-            if len(parameters) >= 2:
-                second_param = list(parameters.values())[1]
-                ty = second_param.annotation
-                return ty if ty != inspect._empty else None
+        parameters = inspect.signature(self.func, eval_str=True).parameters
+        if len(parameters) >= 2:
+            second_param = list(parameters.values())[1]
+            ty = second_param.annotation
+            return ty if ty != inspect._empty else None
         return None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)

jaclang/runtimelib/builtin.py

@@ -0,0 +1,95 @@
+"""Jac specific builtins."""
+
+from __future__ import annotations
+
+import json
+from abc import abstractmethod
+from typing import ClassVar, Optional, override
+
+from jaclang.runtimelib.constructs import Archetype, NodeArchetype, Root
+from jaclang.runtimelib.machine import JacMachineInterface as Jac
+
+
+def printgraph(
+    node: Optional[NodeArchetype] = None,
+    depth: int = -1,
+    traverse: bool = False,
+    edge_type: Optional[list[str]] = None,
+    bfs: bool = True,
+    edge_limit: int = 512,
+    node_limit: int = 512,
+    file: Optional[str] = None,
+    format: str = "dot",
+) -> str:
+    """Print the graph in different formats."""
+    from jaclang.runtimelib.machine import JacMachineInterface as Jac
+
+    fmt = format.lower()
+    if fmt == "json":
+        return _jac_graph_json(file)
+
+    return Jac.printgraph(
+        edge_type=edge_type,
+        node=node or Jac.root(),
+        depth=depth,
+        traverse=traverse,
+        bfs=bfs,
+        edge_limit=edge_limit,
+        node_limit=node_limit,
+        file=file,
+        format=fmt,
+    )
+
+
+def jid(obj: Archetype) -> str:
+    """Get the id of the object."""
+    return Jac.object_ref(obj)
+
+
+def jobj(id: str) -> Archetype | None:
+    """Get the object from the id."""
+    return Jac.get_object(id)
+
+
+def _jac_graph_json(file: Optional[str] = None) -> str:
+    """Get the graph in json string."""
+    processed: list[Root | NodeArchetype] = []
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    working_set: list[tuple] = []
+
+    root = Jac.root()
+    nodes.append({"id": id(root), "label": "root"})
+
+    processed.append(root)
+    working_set = [(root, ref) for ref in Jac.refs(root)]
+
+    while working_set:
+        start, end = working_set.pop(0)
+        edges.append({"from": id(start), "to": id(end)})
+        nodes.append({"id": id(end), "label": repr(end)})
+        processed.append(end)
+        for ref in Jac.refs(end):
+            if ref not in processed:
+                working_set.append((end, ref))
+    output = json.dumps(
+        {
+            "version": "1.0",
+            "nodes": nodes,
+            "edges": edges,
+        }
+    )
+    if file:
+        with open(file, "w") as f:
+            f.write(output)
+    return output
+
+
+__all__ = [
+    "abstractmethod",
+    "ClassVar",
+    "override",
+    "printgraph",
+    "jid",
+    "jobj",
+]

jaclang/runtimelib/constructs.py

@@ -3,21 +3,20 @@
 from __future__ import annotations
 
 
-from .architype import (
+from .archetype import (
     AccessLevel,
     Anchor,
-    Architype,
-    DSFunc,
+    Archetype,
+    DataSpatialFunction,
     EdgeAnchor,
-    EdgeArchitype,
+    EdgeArchetype,
     GenericEdge,
     NodeAnchor,
-    NodeArchitype,
+    NodeArchetype,
     Root,
     WalkerAnchor,
-    WalkerArchitype,
+    WalkerArchetype,
 )
-from .context import ExecutionContext
 from .memory import Memory, ShelfStorage
 from .test import JacTestCheck, JacTestResult, JacTextTestRunner
 
@@ -27,16 +26,15 @@ __all__ = [
     "NodeAnchor",
     "EdgeAnchor",
     "WalkerAnchor",
-    "Architype",
-    "NodeArchitype",
-    "EdgeArchitype",
-    "WalkerArchitype",
+    "Archetype",
+    "NodeArchetype",
+    "EdgeArchetype",
+    "WalkerArchetype",
     "GenericEdge",
     "Root",
-    "DSFunc",
+    "DataSpatialFunction",
     "Memory",
     "ShelfStorage",
-    "ExecutionContext",
     "JacTestResult",
     "JacTextTestRunner",
     "JacTestCheck",

jaclang/runtimelib/importer.py

@@ -5,16 +5,20 @@ from __future__ import annotations
 import importlib
 import importlib.util
 import os
+import site
 import sys
 import types
 from os import getcwd, path
-from typing import Optional, Union
+from typing import Optional, TYPE_CHECKING, Union
 
-from jaclang.runtimelib.machine import JacMachine
+from jaclang.runtimelib.machine import JacMachineInterface
 from jaclang.runtimelib.utils import sys_path_context
 from jaclang.utils.helpers import dump_traceback
 from jaclang.utils.log import logging
 
+if TYPE_CHECKING:
+    from jaclang.runtimelib.machine import JacMachine
+
 logger = logging.getLogger(__name__)
 
 
@@ -26,7 +30,6 @@ class ImportPathSpec:
         target: str,
         base_path: str,
         absorb: bool,
-        cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
         lng: Optional[str],
@@ -36,7 +39,6 @@ class ImportPathSpec:
         self.target = target
         self.base_path = base_path
         self.absorb = absorb
-        self.cachable = cachable
         self.mdl_alias = mdl_alias
         self.override_name = override_name
         self.language = lng
@@ -82,9 +84,7 @@ class ImportReturn:
         self,
         module: types.ModuleType,
         items: dict[str, Union[str, Optional[str]]],
-        caller_dir: str,
         lang: Optional[str],
-        cachable: bool = True,
     ) -> None:
         """Process items within a module by handling renaming and potentially loading missing attributes."""
 
@@ -102,20 +102,38 @@ class ImportReturn:
                 item = getattr(module, name)
                 handle_item_loading(item, alias)
             except AttributeError:
+                found = False
                 if lang == "jac":
                     jac_file_path = (
                         os.path.join(module.__path__[0], f"{name}.jac")
                         if hasattr(module, "__path__")
                         else module.__file__
                     )
-
-                    if jac_file_path and os.path.isfile(jac_file_path):
+                    if hasattr(module, "__path__"):
+                        init_jac = os.path.join(module.__path__[0], "__init__.jac")
+                        if os.path.isfile(init_jac):
+                            package_name = module.__name__
+                            init_mod = self.importer.jac_machine.loaded_modules.get(
+                                package_name,
+                                self.load_jac_mod_as_item(
+                                    module=module,
+                                    name="__init__",
+                                    jac_file_path=init_jac,
+                                ),
+                            )
+                            # Attach all public names from __init__.jac to the package module
+                            for k, v in init_mod.__dict__.items():
+                                if not k.startswith("_"):
+                                    setattr(module, k, v)
+                            if hasattr(module, name):
+                                item = getattr(module, name)
+                                handle_item_loading(item, alias)
+                                found = True
+                    if not found and jac_file_path and os.path.isfile(jac_file_path):
                         item = self.load_jac_mod_as_item(
                             module=module,
                             name=name,
                             jac_file_path=jac_file_path,
-                            cachable=cachable,
-                            caller_dir=caller_dir,
                         )
                         handle_item_loading(item, alias)
                 else:
@@ -129,8 +147,6 @@ class ImportReturn:
         module: types.ModuleType,
         name: str,
         jac_file_path: str,
-        cachable: bool,
-        caller_dir: str,
     ) -> Optional[types.ModuleType]:
         """Load a single .jac file into the specified module component."""
         try:
@@ -148,8 +164,8 @@ class ImportReturn:
                         jac_file_path,
                     ),
                 )
-            codeobj = self.importer.jac_machine.get_bytecode(
-                name, jac_file_path, caller_dir=caller_dir, cachable=cachable
+            codeobj = self.importer.jac_machine.program.get_bytecode(
+                full_target=jac_file_path
             )
             if not codeobj:
                 raise ImportError(f"No bytecode found for {jac_file_path}")
@@ -176,7 +192,7 @@ class Importer:
     def update_sys(self, module: types.ModuleType, spec: ImportPathSpec) -> None:
         """Update sys.modules with the newly imported module."""
         if spec.module_name not in self.jac_machine.loaded_modules:
-            self.jac_machine.load_module(spec.module_name, module)
+            JacMachineInterface.load_module(self.jac_machine, spec.module_name, module)
 
 
 class PythonImporter(Importer):
@@ -262,13 +278,22 @@ class JacImporter(Importer):
         self.jac_machine = jac_machine
 
     def get_sys_mod_name(self, full_target: str) -> str:
-        """Generate the system module name based on full target path and package path."""
-        if full_target == self.jac_machine.base_path_dir:
-            return path.basename(self.jac_machine.base_path_dir)
-        relative_path = path.relpath(full_target, start=self.jac_machine.base_path_dir)
-        base_name = path.splitext(relative_path)[0]
-        sys_mod_name = base_name.replace(os.sep, ".").strip(".")
-        return sys_mod_name
+        """Generate proper module names from file paths."""
+        full_target = os.path.abspath(full_target)
+
+        # If the file is located within a site-packages directory, strip that prefix.
+        sp_index = full_target.find("site-packages")
+        if sp_index != -1:
+            # Remove the site-packages part and any leading separator.
+            rel = full_target[sp_index + len("site-packages") :]
+            rel = rel.lstrip(os.sep)
+        else:
+            rel = path.relpath(full_target, start=self.jac_machine.base_path_dir)
+        rel = os.path.splitext(rel)[0]
+        if os.path.basename(rel) == "__init__":
+            rel = os.path.dirname(rel)
+        mod_name = rel.replace(os.sep, ".").strip(".")
+        return mod_name
 
     def handle_directory(
         self, module_name: str, full_mod_path: str
@@ -279,9 +304,10 @@ class JacImporter(Importer):
         module.__name__ = module_name
         module.__path__ = [full_mod_path]
         module.__file__ = None
+        module.__dict__["__jac_mach__"] = self.jac_machine
 
         if module_name not in self.jac_machine.loaded_modules:
-            self.jac_machine.load_module(module_name, module)
+            JacMachineInterface.load_module(self.jac_machine, module_name, module)
         return module
 
     def create_jac_py_module(
@@ -294,6 +320,7 @@ class JacImporter(Importer):
         module = types.ModuleType(module_name)
         module.__file__ = full_target
         module.__name__ = module_name
+        module.__dict__["__jac_mach__"] = self.jac_machine
         if package_path:
             base_path = full_target.split(package_path.replace(".", path.sep))[0]
             parts = package_path.split(".")
@@ -307,7 +334,7 @@ class JacImporter(Importer):
                         module_name=package_name,
                         full_mod_path=full_mod_path,
                     )
-        self.jac_machine.load_module(module_name, module)
+        JacMachineInterface.load_module(self.jac_machine, module_name, module)
         return module
 
     def run_import(
@@ -319,29 +346,40 @@ class JacImporter(Importer):
         # Gather all possible search paths
         jacpaths = os.environ.get("JACPATH", "")
         search_paths = [spec.caller_dir]
+        for site_dir in site.getsitepackages():
+            if site_dir and site_dir not in search_paths:
+                search_paths.append(site_dir)
+        user_site = getattr(site, "getusersitepackages", None)
+        if user_site:
+            user_dir = site.getusersitepackages()
+            if user_dir and user_dir not in search_paths:
+                search_paths.append(user_dir)
         if jacpaths:
-            for p in jacpaths.split(os.pathsep):
+            for p in jacpaths.split(":"):
                 p = p.strip()
                 if p and p not in search_paths:
                     search_paths.append(p)
 
-            # Attempt to locate the module file or directory
-            found_path = None
-            target_path_components = spec.target.split(".")
-            for search_path in search_paths:
-                candidate = os.path.join(search_path, "/".join(target_path_components))
-                # Check if the candidate is a directory or a .jac file
-                if (os.path.isdir(candidate)) or (os.path.isfile(candidate + ".jac")):
-                    found_path = candidate
-                    break
-
-            # If a suitable path was found, update spec.full_target; otherwise, raise an error
-            if found_path:
-                spec.full_target = os.path.abspath(found_path)
-            else:
-                raise ImportError(
-                    f"Unable to locate module '{spec.target}' in {search_paths}"
-                )
+        found_path = None
+        target_path_components = spec.target.split(".")
+        for search_path in search_paths:
+            candidate = os.path.join(search_path, "/".join(target_path_components))
+            # Check if the candidate is a directory or a .jac file
+            if (os.path.isdir(candidate)) or (os.path.isfile(candidate + ".jac")):
+                found_path = candidate
+                break
+
+        # If a suitable path was found, update spec.full_target; otherwise, raise an error
+        if found_path:
+            spec.full_target = os.path.abspath(found_path)
+        elif os.path.exists(spec.full_target) or os.path.exists(
+            spec.full_target + ".jac"
+        ):
+            pass
+        else:
+            raise ImportError(
+                f"Unable to locate module '{spec.target}' in {search_paths}"
+            )
         if os.path.isfile(spec.full_target + ".jac"):
             module_name = self.get_sys_mod_name(spec.full_target + ".jac")
             module_name = spec.override_name if spec.override_name else module_name
@@ -360,12 +398,8 @@ class JacImporter(Importer):
                     spec.package_path,
                     spec.full_target,
                 )
-                codeobj = self.jac_machine.get_bytecode(
-                    module_name,
-                    spec.full_target,
-                    caller_dir=spec.caller_dir,
-                    cachable=spec.cachable,
-                    reload=reload if reload else False,
+                codeobj = self.jac_machine.program.get_bytecode(
+                    full_target=spec.full_target
                 )
 
                 # Since this is a compile time error, we can safely raise an exception here.
@@ -383,11 +417,7 @@ class JacImporter(Importer):
         import_return = ImportReturn(module, unique_loaded_items, self)
         if spec.items:
             import_return.process_items(
-                module=module,
-                items=spec.items,
-                caller_dir=spec.caller_dir,
-                cachable=spec.cachable,
-                lang=spec.language,
+                module=module, items=spec.items, lang=spec.language
             )
         self.result = import_return
         return self.result