jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/runtimelib/builtin.py

@@ -0,0 +1,92 @@
+"""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
+
+
+# FIXME: Retname this to something common, doing this way so this doesn't break
+# the existing code. Currently it can return the jac graph in both dot and json format.
+# So the name shuouldn't be dotgen but something more generic.
+def dotgen(
+    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,
+    dot_file: Optional[str] = None,
+    as_json: bool = False,
+) -> str:
+    """Print the dot graph."""
+    from jaclang.runtimelib.machine import JacMachineInterface as Jac
+
+    if as_json:
+        return _jac_graph_json()
+
+    return Jac.dotgen(
+        edge_type=edge_type,
+        node=node or Jac.root(),
+        depth=depth,
+        traverse=traverse,
+        bfs=bfs,
+        edge_limit=edge_limit,
+        node_limit=node_limit,
+        dot_file=dot_file,
+    )
+
+
+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() -> 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))
+    return json.dumps(
+        {
+            "version": "1.0",
+            "nodes": nodes,
+            "edges": edges,
+        }
+    )
+
+
+__all__ = [
+    "abstractmethod",
+    "ClassVar",
+    "override",
+    "dotgen",
+    "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."""
 
@@ -114,8 +114,6 @@ class ImportReturn:
                             module=module,
                             name=name,
                             jac_file_path=jac_file_path,
-                            cachable=cachable,
-                            caller_dir=caller_dir,
                         )
                         handle_item_loading(item, alias)
                 else:
@@ -129,8 +127,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 +144,9 @@ 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.jac_program.get_bytecode(
+                full_target=jac_file_path,
+                full_compile=not self.importer.jac_machine.interp_mode,
             )
             if not codeobj:
                 raise ImportError(f"No bytecode found for {jac_file_path}")
@@ -176,7 +173,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 +259,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 +285,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 +301,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 +315,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 +327,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 +379,9 @@ 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.jac_program.get_bytecode(
+                    full_target=spec.full_target,
+                    full_compile=not self.jac_machine.interp_mode,
                 )
 
                 # Since this is a compile time error, we can safely raise an exception here.
@@ -383,11 +399,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