jaclang 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

jaclang/runtimelib/machine.py

@@ -57,7 +57,6 @@ from jaclang.runtimelib.constructs import (
 from jaclang.runtimelib.memory import Memory, Shelf, ShelfStorage
 from jaclang.runtimelib.utils import (
     all_issubclass,
-    collect_node_connections,
     traverse_graph,
 )
 from jaclang.utils import infer_language
@@ -266,30 +265,6 @@ class JacAccessValidation:
 class JacNode:
     """Jac Node Operations."""
 
-    @staticmethod
-    def node_dot(node: NodeArchetype, dot_file: Optional[str] = None) -> str:
-        """Generate Dot file for visualizing nodes and edges."""
-        visited_nodes: set[NodeAnchor] = set()
-        connections: set[tuple[NodeArchetype, NodeArchetype, str]] = set()
-        unique_node_id_dict = {}
-
-        collect_node_connections(node.__jac__, visited_nodes, connections)
-        dot_content = 'digraph {\nnode [style="filled", shape="ellipse", fillcolor="invis", fontcolor="black"];\n'
-        for idx, i in enumerate([nodes_.archetype 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 + "}"
-
     @staticmethod
     def get_edges(
         origin: list[NodeArchetype], destination: DataSpatialDestination
@@ -879,6 +854,15 @@ class JacBasics:
         """Get current execution context."""
         return JacMachine.exec_ctx
 
+    @staticmethod
+    def commit(anchor: Anchor | Archetype | None = None) -> None:
+        """Commit all data from memory to datasource."""
+        if isinstance(anchor, Archetype):
+            anchor = anchor.__jac__
+
+        mem = JacMachineInterface.get_context().mem
+        mem.commit(anchor)
+
     @staticmethod
     def reset_graph(root: Optional[Root] = None) -> int:
         """Purge current or target graph."""
@@ -987,6 +971,7 @@ class JacBasics:
         override_name: Optional[str] = None,
         items: Optional[dict[str, Union[str, Optional[str]]]] = None,
         reload_module: Optional[bool] = False,
+        lng: Optional[str] = None,
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         from jaclang.runtimelib.importer import (
@@ -995,7 +980,8 @@ class JacBasics:
             PythonImporter,
         )
 
-        lng = infer_language(target, base_path)
+        if lng is None:
+            lng = infer_language(target, base_path)
 
         spec = ImportPathSpec(
             target,
@@ -1358,12 +1344,10 @@ class JacBasics:
         return decorator
 
     @staticmethod
-    def call_llm(
-        model: object, caller: Callable, args: dict[str | int, object]
-    ) -> Any:  # noqa: ANN401
+    def call_llm(model: object, mtir: object) -> Any:  # noqa: ANN401
         """Call the LLM model."""
         raise ImportError(
-            "mtllm is not installed. Please install it with `pip install mtllm` and run `jac clean`."
+            "byLLM is not installed. Please install it with `pip install byllm` and run `jac clean`."
         )
 
 
@@ -1587,40 +1571,6 @@ class JacMachineInterface(
     """Jac Feature."""
 
 
-class JacMachine(JacMachineInterface):
-    """Jac Machine State."""
-
-    loaded_modules: dict[str, types.ModuleType] = {}
-    base_path_dir: str = os.getcwd()
-    program: JacProgram = JacProgram()
-    pool: ThreadPoolExecutor = ThreadPoolExecutor()
-    exec_ctx: ExecutionContext = ExecutionContext()
-
-    @staticmethod
-    def set_base_path(base_path: str) -> None:
-        """Set the base path for the machine."""
-        JacMachine.reset_machine()
-        JacMachine.base_path_dir = (
-            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
-        )
-
-    @staticmethod
-    def set_context(context: ExecutionContext) -> None:
-        """Set the context for the machine."""
-        JacMachine.exec_ctx = context
-
-    @staticmethod
-    def reset_machine() -> None:
-        """Reset the machine."""
-        # for i in JacMachine.loaded_modules.values():
-        #     sys.modules.pop(i.__name__, None)
-        JacMachine.loaded_modules.clear()
-        JacMachine.base_path_dir = os.getcwd()
-        JacMachine.program = JacProgram()
-        JacMachine.pool = ThreadPoolExecutor()
-        JacMachine.exec_ctx = ExecutionContext()
-
-
 def generate_plugin_helpers(
     plugin_class: Type[Any],
 ) -> tuple[Type[Any], Type[Any], Type[Any]]:
@@ -1726,3 +1676,37 @@ def generate_plugin_helpers(
 
 JacMachineSpec, JacMachineImpl, JacMachineInterface = generate_plugin_helpers(JacMachineInterface)  # type: ignore[misc]
 plugin_manager.add_hookspecs(JacMachineSpec)
+
+
+class JacMachine(JacMachineInterface):
+    """Jac Machine State."""
+
+    loaded_modules: dict[str, types.ModuleType] = {}
+    base_path_dir: str = os.getcwd()
+    program: JacProgram = JacProgram()
+    pool: ThreadPoolExecutor = ThreadPoolExecutor()
+    exec_ctx: ExecutionContext = ExecutionContext()
+
+    @staticmethod
+    def set_base_path(base_path: str) -> None:
+        """Set the base path for the machine."""
+        JacMachine.reset_machine()
+        JacMachine.base_path_dir = (
+            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
+        )
+
+    @staticmethod
+    def set_context(context: ExecutionContext) -> None:
+        """Set the context for the machine."""
+        JacMachine.exec_ctx = context
+
+    @staticmethod
+    def reset_machine() -> None:
+        """Reset the machine."""
+        # for i in JacMachine.loaded_modules.values():
+        #     sys.modules.pop(i.__name__, None)
+        JacMachine.loaded_modules.clear()
+        JacMachine.base_path_dir = os.getcwd()
+        JacMachine.program = JacProgram()
+        JacMachine.pool = ThreadPoolExecutor()
+        JacMachine.exec_ctx = ExecutionContext()

jaclang/runtimelib/memory.py

@@ -82,6 +82,9 @@ class Memory(Generic[ID, TANCH]):
             if anchor := self.__mem__.pop(id, None):
                 self.__gc__.add(anchor)
 
+    def commit(self, anchor: TANCH | None = None) -> None:
+        """Commit all data from memory to datasource."""
+
 
 @dataclass
 class ShelfStorage(Memory[UUID, Anchor]):
@@ -94,12 +97,21 @@ class ShelfStorage(Memory[UUID, Anchor]):
         super().__init__()
         self.__shelf__ = open(session) if session else None  # noqa: SIM115
 
-    def close(self) -> None:
-        """Close memory handler."""
+    def commit(self, anchor: Anchor | None = None) -> None:
+        """Commit all data from memory to datasource."""
         if isinstance(self.__shelf__, Shelf):
-            for anchor in self.__gc__:
-                self.__shelf__.pop(str(anchor.id), None)
-                self.__mem__.pop(anchor.id, None)
+            if anchor:
+                if anchor in self.__gc__:
+                    self.__shelf__.pop(str(anchor.id), None)
+                    self.__mem__.pop(anchor.id, None)
+                    self.__gc__.remove(anchor)
+                else:
+                    self.sync_mem_to_db([anchor.id])
+                return
+
+            for anc in self.__gc__:
+                self.__shelf__.pop(str(anc.id), None)
+                self.__mem__.pop(anc.id, None)
 
             keys = set(self.__mem__.keys())
 
@@ -109,7 +121,13 @@ class ShelfStorage(Memory[UUID, Anchor]):
             # additional after memory sync
             self.sync_mem_to_db(set(self.__mem__.keys() - keys))
 
+    def close(self) -> None:
+        """Close memory handler."""
+        self.commit()
+
+        if isinstance(self.__shelf__, Shelf):
             self.__shelf__.close()
+
         super().close()
 
     def sync_mem_to_db(self, keys: Iterable[UUID]) -> None:

jaclang/runtimelib/tests/fixtures/savable_object.jac

@@ -18,7 +18,7 @@ obj SavableObject {
 
 walker create_custom_object {
     can enter1 with `root entry {
-        o = SavableObject(
+        self.obj = SavableObject(
             val=0,
             arr=[],
             json={},
@@ -36,7 +36,15 @@ walker create_custom_object {
             ),
             enum_field = Enum.A
         );
-        _.save(o);
+        save(self.obj);
+
+        # commit the object to db
+        commit(self.obj);
+    }
+
+    can exit1 with `root exit {
+        # get directly from shelf
+        o = _.get_context().mem.__shelf__.get(str(self.obj.__jac__.id)).archetype;
         print(jid(o));
         print(o);
     }

jaclang/runtimelib/utils.py

@@ -11,7 +11,36 @@ from typing import Callable, Iterator, TYPE_CHECKING
 import jaclang.compiler.unitree as uni
 
 if TYPE_CHECKING:
-    from jaclang.runtimelib.constructs import NodeAnchor, NodeArchetype
+    from jaclang.runtimelib.constructs import NodeArchetype
+
+
+def read_file_with_encoding(file_path: str) -> str:
+    """Read file with proper encoding detection."""
+    encodings_to_try = [
+        "utf-8-sig",
+        "utf-8",
+        "utf-16",
+        "utf-16le",
+        "utf-16be",
+        # "latin-1", # TODO: Support reading files with Latin-1 encoding
+    ]
+
+    for encoding in encodings_to_try:
+        try:
+            with open(file_path, "r", encoding=encoding) as f:
+                return f.read()
+        except UnicodeError:
+            continue
+        except Exception as e:
+            raise IOError(
+                f"Could not read file {file_path}: {e}. "
+                f"Report this issue: https://github.com/jaseci-labs/jaseci/issues"
+            ) from e
+
+    raise IOError(
+        f"Could not read file {file_path} with any encoding. "
+        f"Report this issue: https://github.com/jaseci-labs/jaseci/issues"
+    )
 
 
 @contextmanager
@@ -28,25 +57,32 @@ def sys_path_context(path: str) -> Iterator[None]:
 
 
 def collect_node_connections(
-    current_node: NodeAnchor,
+    current_node: NodeArchetype,
     visited_nodes: set,
     connections: set,
+    edge_ids: set,
 ) -> None:
     """Nodes and edges representing the graph are collected in visited_nodes and connections."""
     if current_node not in visited_nodes:
         visited_nodes.add(current_node)
-        edges = current_node.edges
+        edges = current_node.__jac__.edges
         for edge_ in edges:
+            if edge_.id in edge_ids:
+                continue
+            edge_ids.add(edge_.id)
             target = edge_.target
             if target:
                 connections.add(
                     (
-                        current_node.archetype,
+                        edge_.id,
+                        edge_.source.archetype,
                         target.archetype,
-                        edge_.__class__.__name__,
+                        edge_.archetype,
                     )
                 )
-                collect_node_connections(target, visited_nodes, connections)
+                collect_node_connections(
+                    target.archetype, visited_nodes, connections, edge_ids
+                )
 
 
 def traverse_graph(

jaclang/tests/fixtures/edge_node_walk.jac

@@ -37,7 +37,7 @@ impl creator.create {
 
 with entry {
     print(root spawn creator());
-    print(_.node_dot(root));
+    print(printgraph(root));
     print([root->:Edge_a:->]);
     print([root->:Edge_c:->]);
     print([root->:Edge_a:->->:Edge_b:->]);

jaclang/tests/fixtures/edges_walk.jac

@@ -30,7 +30,7 @@ impl creator.create{
 
 with entry{
     print(root spawn creator());
-    print(_.node_dot(root));
+    print(printgraph(root));
     print([root ->:Edge_a:->]);
     print([root ->:Edge_c:->]);
     print([root ->:Edge_a:-> ->:Edge_b:->]);

jaclang/tests/fixtures/gendot_bubble_sort.jac

@@ -73,5 +73,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(_.node_dot(root));
+    print(printgraph(root));
 }

jaclang/tests/fixtures/py_run.jac

@@ -0,0 +1,8 @@
+with entry {
+    print('Hello, Jaseci');
+    a = 10;
+    b = 15;
+    sum_ab = (a + b);
+    print('Sum:', sum_ab);
+}
+

jaclang/tests/fixtures/py_run.py

@@ -0,0 +1,23 @@
+# Print Hello, World!
+print("Hello, World!")
+
+a = 5
+b = 3
+sum_ab = a + b
+print("Sum:", sum_ab)
+
+num = 7
+if num % 2 == 0:
+    print(num, "is even")
+else:
+    print(num, "is odd")
+
+# Loop through a list
+fruits = ["apple", "banana", "cherry"]
+for fruit in fruits:
+    print(fruit)
+
+def greet(name):
+    return f"Hello, {name}!"
+
+print(greet("Alice"))

jaclang/tests/fixtures/pyfunc.py

@@ -4,6 +4,8 @@
 
 from __future__ import annotations
 
+class MyClass:
+    pass
 
 def my_print(x: object) -> None:
     """Print function."""

jaclang/tests/fixtures/pyfunc_fmt.py

@@ -0,0 +1,60 @@
+
+
+
+
+if __name__ == "__main__":
+
+    def foo():
+        print("One")
+        return "foo"
+    foo()
+
+condition = True
+
+if condition:
+
+    print("Two")
+    
+    def bar():
+        return 
+    
+    main_mod = None
+    bar()
+
+def baz():
+    print("Three")
+    return "baz"
+
+print(baz())    
+
+
+try:
+    a = 90
+except FileNotFoundError:
+    pass
+
+
+condition = 10
+
+
+while condition:
+    print("Processing...")
+
+    while condition:
+        print("Four")
+        condition -= 10
+        break 
+
+if condition:
+
+    def foo():
+        return 
+    foo()
+    print("Exiting the loop.")
+
+if condition:
+    print("still +")
+    def foo():
+        return 
+
+print("The End.")

jaclang/tests/fixtures/pyfunc_fstr.py

@@ -0,0 +1,25 @@
+
+
+
+
+
+name = 'Peter'
+relation = 'mother'
+mom_name = 'Mary'
+
+
+print(f"Hello {name}")
+print(f"Hello {name} {name}")
+print(f"{name} squared is {name} {name}")
+
+
+print(f"{name.upper()}!  wrong poem.")
+print(f"Hello {name} , yoo {relation} is {mom_name}. Myself, I am {name}.")
+
+
+
+item = "Apple"
+price = 1.23
+
+print(f"Left aligned: {item:<10} | Price: {price:.2f}")
+print(f"{name = } 🤔") 

jaclang/tests/fixtures/pyfunc_kwesc.py

@@ -0,0 +1,33 @@
+
+
+
+def foo(type= 90):
+    """This is a function with a docstring."""
+    return type
+
+print(foo(type=89))
+
+def bar(node= 12, *args,**kwargs):
+    """This is another function with a docstring."""
+    return node, args, kwargs
+
+print(str(bar(node=13, a=1, b=2)))
+
+
+functions = [
+
+        dict(   
+            name="replace_lines",
+            args=[
+                dict(name="text", type="str", default=None),
+                dict(name="old", type="str", default=None),
+                dict(name="new", type="str", default=None),
+            ],
+            returns=dict(type="str", default=None),
+        ),
+]
+
+print(f"Functions: {functions}")
+
+dict = 90
+print(f"Dict: {dict}")

jaclang/tests/fixtures/python_run_test.py

@@ -0,0 +1,19 @@
+"""Simple Python test file for jac run command."""
+
+print("Hello from Python!")
+print("This is a test Python file.")
+
+def main():
+    """Main function to demonstrate execution."""
+    result = 42
+    print(f"Result: {result}")
+    return result
+
+if __name__ == "__main__":
+    main()
+    print("Python execution completed.")
+
+
+from jaclang.tests.fixtures import py_namedexpr
+
+py_namedexpr.walrus_example()

jaclang/tests/test_cli.py

@@ -35,6 +35,73 @@ class JacCliTests(TestCase):
 
         self.assertIn("Hello World!", stdout_value)
 
+    def test_jac_cli_run_python_file(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("python_run_test.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("Hello from Python!", stdout_value)
+        self.assertIn("This is a test Python file.", stdout_value)
+        self.assertIn("Result: 42", stdout_value)
+        self.assertIn("Python execution completed.", stdout_value)
+        self.assertIn("10", stdout_value)
+
+    def test_jac_run_py_fstr(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_fstr.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("Hello Peter", stdout_value)
+        self.assertIn("Hello Peter Peter", stdout_value)
+        self.assertIn("Peter squared is Peter Peter", stdout_value)
+        self.assertIn("PETER!  wrong poem", stdout_value)
+        self.assertIn("Hello Peter , yoo mother is Mary. Myself, I am Peter.", stdout_value)
+        self.assertIn("Left aligned: Apple | Price: 1.23", stdout_value)
+        self.assertIn("name = Peter 🤔", stdout_value)
+
+    def test_jac_run_py_fmt(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_fmt.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("One", stdout_value)
+        self.assertIn("Two", stdout_value)
+        self.assertIn("Three", stdout_value)
+        self.assertIn("baz", stdout_value)
+        self.assertIn("Processing...", stdout_value)
+        self.assertIn("Four", stdout_value)
+        self.assertIn("The End.", stdout_value)
+
+    def test_jac_run_pyfunc_kwesc(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_kwesc.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        out = stdout_value.split("\n")
+        self.assertIn("89", out[0])
+        self.assertIn("(13, (), {'a': 1, 'b': 2})", out[1])
+        self.assertIn("Functions: [{'name': 'replace_lines'", out[2])
+        self.assertIn("Dict: 90", out[3])
+
     def test_jac_cli_alert_based_err(self) -> None:
         """Basic test for pass."""
         captured_output = io.StringIO()
@@ -203,6 +270,27 @@ class JacCliTests(TestCase):
             '[label="MultiString" shape="oval" style="filled" fillcolor="#fccca4"]',
             stdout_value,
         )
+    
+    def test_cfg_printgraph(self) -> None:
+        """Testing for print CFG."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["cfg.", f"{self.fixture_abs_path('hello.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        correct_graph = (
+            "digraph G {\n"
+            '  0 [label="BB0\\n\\nprint ( \\"im still here\\" ) ;\", shape=box];\n'
+            '  1 [label="BB1\\n\\"Hello World!\\" |> print ;\", shape=box];\n'
+            "}\n\n"
+        )
+
+        self.assertEqual(
+            correct_graph,
+            stdout_value,
+        )
 
     def test_del_clean(self) -> None:
         """Testing for print AstTool."""
@@ -324,6 +412,8 @@ class JacCliTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("def my_print(x: object) -> None", stdout_value)
+        self.assertIn("class MyClass {", stdout_value)
+        self.assertIn('"""Print function."""', stdout_value)
 
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
@@ -453,3 +543,20 @@ class JacCliTests(TestCase):
                     description_pattern,
                     f"Parameter description for '{param_name}' not found in help text for '{cmd_name}'",
                 )
+
+    def test_run_jac_name_py(self) -> None:
+        """Test a specific test case."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                "run",
+                self.fixture_abs_path("py_run.py"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Hello, World!", stdout)
+        self.assertIn("Sum: 8", stdout)