jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/tests/fixtures/semstr.jac

@@ -0,0 +1,33 @@
+enum 'enum'
+emotion {
+    Happy: 'Happy Person',
+    Sad: 'Sad Person' = 1,
+    Calm,
+    Angry
+}
+
+glob name: 'name of the user': str = 'John Doe',
+    age: 'age of the user': int = 25;
+
+let something: 'something': str;
+
+node 'personality'
+personality{
+    has niceness: 'how nice the user is': int,
+        likes : 'what kind of things they like': list[str];
+    has currentMood: 'current mood of the user': mood;
+    has apple: str;
+}
+
+walker  'users personal journal '
+journal {
+    has count: 'Daily Entry': int;
+}
+
+can add() -> 'no of': int {}
+
+can 'update user mood'
+updateMood(* mood: 'Moo of the Person': str,  something:'Something':str, something_else: 'Something Else': int = 5, without_semstr: float) -> 'mood selection': str {}
+
+
+ can get_personality (person: 'Person Object': list[Person]) -> 'Personality of the Person': dict[Personality, PersonalityIndex] by llm(reason=True, incl_info=(personality_examples, self.diary_entries));

jaclang/tests/fixtures/simple_archs.jac

@@ -0,0 +1,26 @@
+"""A Ninja Myca"""
+
+obj SimpleObj {
+    has var1: int,
+        var2: int,
+        var3: int = 0;
+
+    can postinit {
+        print(self.var1, self.var2, self.var3);
+    }
+}
+
+class SimpleClass {
+    has var1: int,
+        var2: int,
+        var3: int = 0;
+
+    can init {
+        print(self.var3);
+    }
+}
+
+with entry {
+    SimpleObj(1, 2);
+    SimpleClass();
+}

jaclang/tests/fixtures/slice_vals.jac

@@ -0,0 +1,7 @@
+obj MyObj {
+    has a: Annotated[Str, INT, BLAH] = "a";
+    can foo(edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype;
+}
+
+:obj:MyObj:can:foo
+(edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {}

jaclang/tests/fixtures/sub_abil_sep.jac

@@ -0,0 +1,15 @@
+"""A Ninja Myca"""
+
+can plan {
+    can say_hi(m: str);
+
+    print("Hello, world!");
+    say_hi("I'm a ninja Myca!");
+
+    :can:say_hi
+    (m: str) {
+        print(m);
+    }
+}
+
+with entry { plan(); }

jaclang/tests/fixtures/sub_abil_sep_multilev.jac

@@ -0,0 +1,17 @@
+"""A Ninja Myca"""
+
+can plan {
+    can say_hi(m: str);
+
+    print("Hello, world!");
+    say_hi("I'm a ninja Myca!");
+
+
+}
+
+:c:plan:c:say_hi
+(m: str) {
+    print(m);
+}
+
+with entry { plan(); }

jaclang/tests/fixtures/try_finally.jac

@@ -0,0 +1,34 @@
+with entry{
+
+    # try and finally stmt
+    try{
+        print("try block");
+    }finally{
+        print("finally block");
+    }
+
+
+
+    #  try except else finally
+    try{
+        print("try block");
+    }
+    # except{
+    #     print("except block");
+    # }
+
+    # except_def: KW_EXCEPT expression (KW_AS NAME)? code_block
+    # is there any intention why here we compulsorily need to write type of exception in
+
+    except exception{
+        print("except block");
+    }
+    else{
+        print("else block");
+    }
+    finally{
+        print("finally block");
+    }
+
+
+}

jaclang/tests/fixtures/tupleunpack.jac

@@ -0,0 +1,6 @@
+with entry{
+
+    (x,*y)=[1,2,3,4];
+    print(x);
+    print(y);
+}

jaclang/tests/fixtures/tuplytuples.jac

@@ -0,0 +1,8 @@
+with entry {
+    x = {"a": "apple", "b": "banana"};
+    ((a, apple), (b, banana)) = x.items();
+    [[a2, apple2], [b2, banana2]] = x.items();
+    ([a3, apple3], [b3, banana3]) = x.items();
+    [(a4, apple4), (b4, banana4)] = x.items();
+    print(a, apple, b, banana, a2, apple2, b2, banana2, a3, apple3, b3, banana3, a4, apple4, b4, banana4);
+}

jaclang/tests/fixtures/type_info.jac

@@ -0,0 +1,19 @@
+import:py pygame;
+
+obj Spritesheet {
+    can init(file: str);
+    can get_sprite(x: int, y: int, width: int, height: int) -> pygame.Surface;
+}
+
+:obj:Spritesheet:can:init
+(file: str) {
+    self.sheet = pygame.image.load(file).convert();
+}
+
+:obj:Spritesheet:can:get_sprite
+(x: int, y: int, width: int, height: int) -> pygame.Surface {
+    sprite = pygame.Surface([width, height]);
+    sprite.blit(self.sheet, (0, 0), (x, y, width, height));
+    sprite.set_colorkey(BLACK);
+    return sprite;
+}

jaclang/tests/fixtures/with_context.jac

@@ -0,0 +1,30 @@
+can init;
+
+obj TestType {
+    can __enter__ {
+        print("im in");
+    }
+
+    can __exit__(exc_type: object, exc_value: object, traceback: object) {
+        print("im out");
+    }
+}
+
+with entry {
+    x = TestType();
+    with x {
+        print("in the middle");
+    }
+    init();
+}
+
+:can:init {
+    print("init");
+}
+
+
+with entry {
+    x = ["apple", "banana", "cherry"];
+    nums = [1, 2, 3, 4, 5, 6];
+    print({fruit: nums[0:3] for (i, fruit) in enumerate(x)});
+}

jaclang/tests/fixtures/with_llm_function.jac

@@ -0,0 +1,33 @@
+import:py from jaclang.core.llms, BaseLLM;
+
+obj model:BaseLLM: {
+    can init {
+        self.verbose = False;
+        self.max_tries = 1;
+    }
+    can __infer__(meaning_in: str, **kwargs: dict) {
+        print(kwargs);
+        print(meaning_in);
+        return "[Output] Something";
+    }
+}
+glob llm = model();
+
+glob emoji_examples: 'Examples of Text to Emoji': list[dict[str, str]] = [
+    {
+         "input": "I love tp drink pina coladas",
+         "output": "👤 ❤️ 🥤 🍍🥥"
+    },
+    {
+        "input": "Mime Person",
+        "output": "👤🤲🚷"
+    }
+
+];
+
+can 'Get Emoji Representation'
+get_emoji(input: 'Text Input': str) -> 'Emoji Representation': str by llm(temperature=0.7,  incl_info=(emoji_examples),excl_info=());
+
+with entry {
+    print(get_emoji('Lets move to paris'));
+}

jaclang/tests/fixtures/with_llm_lower.jac

@@ -0,0 +1,45 @@
+import:py from jaclang.core.llms, BaseLLM;
+
+obj model:BaseLLM: {
+    can init {
+        self.verbose = False;
+        self.max_tries = 1;
+    }
+    can __infer__(meaning_in: str, **kwargs: dict) {
+        print(meaning_in);
+        return '[Reasoning] J. Robert Oppenheimer, also known as the "father of the atomic bomb," was a brilliant '
+        'theoretical physicist and the director of the Manhattan Project during World War II. He played a crucial '
+        'role in developing the first nuclear weapons. However, after witnessing the devastation caused by the '
+        'atomic bombs dropped on Hiroshima and Nagasaki, he expressed deep regret and became an advocate for nuclear '
+        'disarmament. While he was an exceptional scientist, he was also known for his introspective and philosophical '
+        'nature, which suggests an introverted personality.\n'
+        '[Output] Person(full_name="J. Robert Oppenheimer", yod=1967, personality=Personality.INTROVERT)';
+    }
+}
+glob llm = model();
+
+enum 'Personality of the Person'
+Personality {
+   INTROVERT: 'Person who is shy and reticent' = "Introvert",
+   EXTROVERT: 'Person who is outgoing and socially confident' = "Extrovert"
+}
+
+obj 'Person'
+Person {
+    has full_name: 'Fullname of the Person': str,
+        yod: 'Year of Death': int,
+        personality: 'Personality of the Person': Personality;
+}
+
+glob personality_examples: 'Personality Information of Famous People': dict[str, Personality] = {
+    'Albert Einstein': Personality.INTROVERT,
+    'Barack Obama': Personality.EXTROVERT
+};
+
+can 'Get Person Information use common knowledge'
+get_person_info(name: 'Name of the Person': str) -> 'Person': Person by llm(method="Reason");
+
+with entry {
+    person_obj = get_person_info('Oppenheimer');
+    print(f"{person_obj.full_name} was a {person_obj.personality.value} person who died in {person_obj.yod}");
+}

jaclang/tests/fixtures/with_llm_method.jac

@@ -0,0 +1,51 @@
+import:py from jaclang.core.llms, BaseLLM;
+
+obj model:BaseLLM: {
+    can init {
+        self.verbose = False;
+        self.max_tries = 1;
+    }
+    can __infer__(meaning_in: str, **kwargs: dict) {
+        print(meaning_in);
+        return "[Output] Something";
+    }
+}
+glob llm = model();
+
+class 'Personality Index of a Person'
+PersonalityIndex {
+    has index: 'Personality Index': int;
+}
+
+enum 'Personality of the Person'
+Personality {
+   INTROVERT: 'Person who is shy and reticent',
+   EXTROVERT: 'Person who is outgoing and socially confident'
+}
+
+glob personality_examples: 'Personality Information of Famous People': dict[str, Personality|None] = {
+    'Albert Einstein': Personality.INTROVERT,
+    'Barack Obama': Personality.EXTROVERT
+};
+
+obj 'Person'
+Person {
+    has name: 'Name of the Person': str,
+        age: 'Age of the Person': int;
+}
+
+obj 'main object '
+outer{
+    obj 'inner object'
+    inner {
+        has diary_entries :'Diary Entries': list[str];
+        can 'Get Personality of the Person'
+        get_personality (person: 'Person Object': list[Person]) -> 'Personality of the Person': dict[Personality, PersonalityIndex] by llm(method="Reason", incl_info=(personality_examples, self.diary_entries));
+    }
+}
+
+with entry{
+    obj1=outer.inner(["I won noble prize in Physics", "I am popular for my theory of relativity"]);
+    pp=Person('Albert Einstein', 76);
+    print(obj1.get_personality(pp));
+}

jaclang/tests/fixtures/with_llm_type.jac

@@ -0,0 +1,52 @@
+import:py from jaclang.core.llms, BaseLLM;
+
+obj model:BaseLLM: {
+    can init(output_str: str) {
+        self.verbose = False;
+        self.max_tries = 1;
+        self.output_str = output_str;
+    }
+    can __infer__(meaning_in: str, **kwargs: dict) {
+        print("Meaning in: ", meaning_in);
+        return f"[Output] {self.output_str}";
+    }
+}
+glob llm1 = model(output_str="Person(name='Albert Einstein', dob='14/03/1879', age=76)");
+
+obj 'Person'
+Person {
+    has name: 'Name of the Person': str,
+        dob: 'Date of Birth': str,
+        age: 'Age of the Person': int;
+}
+
+with entry {
+    einstein: 'Einstein Object': Person = Person(name="Albert Einstein" by llm1());
+    print(einstein.dob); #14/03/1879
+}
+
+glob llm2 = model(output_str="University.Department(name='Computer Science', head=Person(name='Jason Mars', dob='1994-01-01', age=30))");
+
+obj 'University'
+University {
+    has name: 'Name of the University': str,
+        location: 'Location of the University': str,
+        departments: 'Departments in the University': list[self.Department] = [];
+
+    obj 'Department'
+    Department {
+        has name: 'Name of the Department': str,
+            head: 'Head of the Department': Person;
+    }
+}
+
+with entry {
+    umich: 'Univeristy of Michigan': University = University(name="University of Michigan", location="Ann Arbor, Michigan");
+    cs_department: 'Computer Science Department': University.Department = University.Department(
+        name="Computer Science" by llm2(incl_info=(umich))
+    );
+    print(cs_department.head); # Person(name='Jason Mars', dob='1994-01-01', age=30)
+
+    umich.departments.append(umich.Department(name="Computer Science" by llm2()));
+    print(umich.departments[0].head); # Person(name='Jason Mars', dob='1994-01-01', age=30)
+}

jaclang/tests/test_cli.py

@@ -0,0 +1,239 @@
+"""Test Jac cli module."""
+
+import inspect
+import io
+import os
+import subprocess
+import sys
+
+from jaclang.cli import cli
+from jaclang.plugin.builtin import dotgen
+from jaclang.utils.test import TestCase
+
+
+class JacCliTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_jac_cli_run(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        # Execute the function
+        cli.run(self.fixture_abs_path("hello.jac"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("Hello World!", stdout_value)
+
+    def test_jac_cli_alert_based_err(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        # Execute the function
+        # try:
+        cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])  # type: ignore
+        # except Exception as e:
+        #     print(f"Error: {e}")
+
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        # print(stdout_value)
+        self.assertIn("Errors occurred", stdout_value)
+
+    def test_jac_ast_tool_pass_template(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("pass_template")
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        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()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('hello.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("+-- Token", stdout_value)
+
+    def test_ast_dotgen(self) -> None:
+        """Testing for print AstTool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast.", f"{self.fixture_abs_path('hello.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn('[label="MultiString"]', stdout_value)
+
+    def test_type_check(self) -> None:
+        """Testing for print AstTool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.check(f"{self.fixture_abs_path('game1.jac')}")
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Errors: 0, Warnings: 1", stdout_value)
+
+    def test_type_info(self) -> None:
+        """Testing for type info inside the ast tool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('type_info.jac')}"])
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual(stdout_value.count("type_info.Spritesheet"), 7)
+        self.assertEqual(stdout_value.count("builtins.int"), 28)
+        self.assertEqual(stdout_value.count("pygame.surface.Surface"), 12)
+
+    def test_build_and_run(self) -> None:
+        """Testing for print AstTool."""
+        if os.path.exists(f"{self.fixture_abs_path('needs_import.jir')}"):
+            os.remove(f"{self.fixture_abs_path('needs_import.jir')}")
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.build(f"{self.fixture_abs_path('needs_import.jac')}")
+        cli.run(f"{self.fixture_abs_path('needs_import.jir')}")
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Errors: 0, Warnings: 0", stdout_value)
+        self.assertIn("<module 'pyfunc' from", stdout_value)
+
+    def test_cache_no_cache_on_run(self) -> None:
+        """Basic test for pass."""
+        process = subprocess.Popen(
+            ["jac", "run", f"{self.fixture_abs_path('hello_nc.jac')}", "-nc"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, _ = process.communicate()
+        self.assertFalse(
+            os.path.exists(
+                f"{self.fixture_abs_path(os.path.join('__jac_gen__', 'hello_nc.jbc'))}"
+            )
+        )
+        self.assertIn("Hello World!", stdout)
+        process = subprocess.Popen(
+            ["jac", "run", f"{self.fixture_abs_path('hello_nc.jac')}", "-c"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, _ = process.communicate()
+        self.assertIn("Hello World!", stdout)
+        self.assertTrue(
+            os.path.exists(
+                f"{self.fixture_abs_path(os.path.join('__jac_gen__', 'hello_nc.jbc'))}"
+            )
+        )
+        os.remove(
+            f"{self.fixture_abs_path(os.path.join('__jac_gen__', 'hello_nc.jbc'))}"
+        )
+
+    def test_run_test(self) -> None:
+        """Basic test for pass."""
+        process = subprocess.Popen(
+            ["jac", "test", f"{self.fixture_abs_path('run_test.jac')}", "-m 2"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Ran 3 tests", stderr)
+        self.assertIn("FAILED (failures=2)", stderr)
+        self.assertIn("F.F", stderr)
+
+        process = subprocess.Popen(
+            [
+                "jac",
+                "test",
+                "-d" + f"{self.fixture_abs_path('../../../')}",
+                "-f" + "circle*",
+                "-x",
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("circle", stdout)
+        self.assertNotIn("circle_purfe.test", stdout)
+        self.assertNotIn("circle_pure.impl", stdout)
+
+        process = subprocess.Popen(
+            ["jac", "test", "-f" + "*run_test.jac", "-m 3"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("...F", stderr)
+        self.assertIn("F.F", stderr)
+
+    def test_graph_coverage(self) -> None:
+        """Test for coverage of graph cmd."""
+        graph_params = set(inspect.signature(cli.dot).parameters.keys())
+        dotgen_params = set(inspect.signature(dotgen).parameters.keys())
+        dotgen_params = dotgen_params - {"node", "dot_file", "edge_type"}
+        dotgen_params.update({"initial", "saveto", "connection", "session"})
+        self.assertTrue(dotgen_params.issubset(graph_params))
+        self.assertEqual(len(dotgen_params) + 1, len(graph_params))
+
+    def test_graph(self) -> None:
+        """Test for graph CLI cmd."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.dot(
+            f"{self.fixture_abs_path('../../../examples/reference/connect_expressions.jac')}"
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        if os.path.exists("connect_expressions.dot"):
+            os.remove("connect_expressions.dot")
+        self.assertIn("11\n13\n15\n>>> Graph content saved to", stdout_value)
+        self.assertIn("connect_expressions.dot\n", stdout_value)
+
+    def test_py_to_jac(self) -> None:
+        """Test for graph CLI cmd."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.py_to_jac(f"{self.fixture_abs_path('../../tests/fixtures/pyfunc.py')}")
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("can my_print(x: object) -> None", stdout_value)