jaclang 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

jaclang/runtimelib/utils.py

@@ -11,7 +11,7 @@ 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:
@@ -57,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/jac_run_py_bugs.py

@@ -0,0 +1,18 @@
+from jaclang.tests.fixtures.jac_run_py_import import MyModule
+
+class SimpleClass:
+    def __init__(self, name: str, age: int) -> None:
+        self.name = name
+        self.age = age
+
+    def greet(self):
+        return f"Hello, my name is {self.name} and I am {self.age} years old."
+
+
+# Create an object of the class
+person = SimpleClass("Alice", 30)
+
+# Run the greet method
+print(person.greet())
+
+MyModule.init()

jaclang/tests/fixtures/jac_run_py_import.py

@@ -0,0 +1,13 @@
+class MyModule:
+    @staticmethod
+    def init():
+        print("MyModule initialized!")
+
+    @staticmethod
+    def do_something():
+        print("Doing something...")
+
+
+
+
+

jaclang/tests/fixtures/lambda_arg_annotation.jac

@@ -0,0 +1,15 @@
+
+
+with entry {
+    x = lambda a: int, b: int : b + a;
+    print(x(5, 4));
+    y = lambda : 567;
+    print(y());
+}
+
+
+with entry{
+    f = lambda x:Any :"even" if x % 2 == 0 else "odd";
+    print(f(7));
+
+}

jaclang/tests/fixtures/lambda_self.jac

@@ -0,0 +1,18 @@
+
+
+walker Tourist {
+    can travel with City entry {
+
+        def foo(a:int){}
+        x = lambda a: int, b: int : b + a;
+        y = lambda : 567;
+        sorted_users = sorted(
+            users, 
+            key=lambda x: dict: x["email"], reverse=True
+        );
+
+    }
+    def visit_city(c:City){
+        print("Visiting", c.name);
+    }
+}

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/test_cli.py

@@ -65,7 +65,9 @@ class JacCliTests(TestCase):
         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(
+            "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)
 
@@ -205,19 +207,6 @@ class JacCliTests(TestCase):
         self.assertIn("Sub objects.", stdout_value)
         self.assertGreater(stdout_value.count("def exit_"), 10)
 
-    def test_jac_cmd_line(self) -> None:
-        """Basic test for pass."""
-        process = subprocess.Popen(
-            ["jac"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        stdout_value, _ = process.communicate(input="exit\n")
-        self.assertEqual(process.returncode, 0, "Process did not exit successfully")
-        self.assertIn("Welcome to the Jac CLI!", stdout_value)
-
     def test_ast_print(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -271,6 +260,27 @@ class JacCliTests(TestCase):
             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."""
         captured_output = io.StringIO()
@@ -391,6 +401,36 @@ 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_lambda_arg_annotation(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.jac2py(
+            f"{self.fixture_abs_path('../../tests/fixtures/lambda_arg_annotation.jac')}"
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("x = lambda a, b: b + a", stdout_value)
+        self.assertIn("y = lambda: 567", stdout_value)
+        self.assertIn("f = lambda x: 'even' if x % 2 == 0 else 'odd'", stdout_value)
+
+    def test_lambda_self(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.jac2py(f"{self.fixture_abs_path('../../tests/fixtures/lambda_self.jac')}")
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("def travel(self, here: City) -> None:", stdout_value)
+        self.assertIn("def foo(a: int) -> None:", stdout_value)
+        self.assertIn("x = lambda a, b: b + a", stdout_value)
+        self.assertIn("def visit_city(self, c: City) -> None:", stdout_value)
+        self.assertIn(
+            "sorted(users, key=lambda x: x['email'], reverse=True)", stdout_value
+        )
 
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
@@ -520,3 +560,52 @@ 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)
+
+    def test_jac_run_py_bugs(self) -> None:
+        """Test jac run python files."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                "run",
+                self.fixture_abs_path("jac_run_py_bugs.py"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Hello, my name is Alice and I am 30 years old.", stdout)
+        self.assertIn("MyModule initialized!", stdout)
+
+    def test_cli_defaults_to_run_with_file(self) -> None:
+        """jac myfile.jac should behave like jac run myfile.jac."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                self.fixture_abs_path("hello.jac"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Hello World!", stdout)

jaclang/tests/test_language.py

@@ -122,13 +122,19 @@ class JacLanguageTests(TestCase):
         data = json.loads(stdout_value)
 
         nodes = data["nodes"]
-        self.assertEqual(len(nodes), 7)
+        edges = data["edges"]
+
+        self.assertEqual(len(nodes), 5)
+        self.assertEqual(len(edges), 6)
+
         for node in nodes:
             label = node["label"]
             self.assertIn(label, ["root", "N(val=0)", "N(val=1)"])
 
-        edges = data["edges"]
-        self.assertEqual(len(edges), 6)
+        for edge in edges:
+            label = edge["label"]
+            self.assertIn(label, ["E(val=1)", "E(val=1)", "E(val=1)", "E(val=0)", "E(val=0)", "E(val=0)"])
+
 
     def test_printgraph_mermaid(self) -> None:
         """Test the mermaid gen of builtin function."""
@@ -229,7 +235,7 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
-            '[label="inner_node(main=5, sub=2)"];',
+            '[label="inner_node(main=5, sub=2)"fillcolor="#FFDEAD"];',
             stdout_value,
         )
 

jaclang/utils/lang_tools.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Type
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes.main import PyastBuildPass
+from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
 from jaclang.compiler.passes.tool.doc_ir_gen_pass import DocIRGenPass
 from jaclang.compiler.program import JacProgram
 from jaclang.compiler.unitree import UniScopeNode
@@ -242,6 +243,8 @@ class AstTool:
                     return out
                 case "ast.":
                     return ir.printgraph()
+                case "cfg.":
+                    return cfg_dot_from_file(file_name)
                 case "unparse":
                     return ir.unparse()
                 case "pyast":

jaclang/utils/module_resolver.py

@@ -52,7 +52,7 @@ def resolve_module(target: str, base_path: str) -> Tuple[str, str]:
         level += 1
     actual_parts = parts[level:]
 
-    for sp in site.getsitepackages():
+    for sp in get_jac_search_paths(base_path):
         res = _candidate_from(sp, actual_parts)
         if res:
             return res

{jaclang-0.8.5.dist-info → jaclang-0.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: jaclang
-Version: 0.8.5
+Version: 0.8.7
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
@@ -14,7 +14,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: all
+Provides-Extra: cloud
 Provides-Extra: llm
 Provides-Extra: streamlit
 Requires-Dist: mypy (>=1.15.0,<2.0.0)