jaclang 0.7.7__py3-none-any.whl → 0.7.8__py3-none-any.whl

jaclang/compiler/__init__.py

@@ -6,12 +6,12 @@ import os
 import shutil
 import sys
 
+from jaclang.utils.helpers import auto_generate_refs
+from jaclang.vendor.lark.tools import standalone
+
 
 def generate_static_parser(force: bool = False) -> None:
     """Generate static parser."""
-    from jaclang.utils.helpers import auto_generate_refs
-    from jaclang.vendor.lark.tools import standalone
-
     cur_dir = os.path.dirname(__file__)
     if force or not os.path.exists(os.path.join(cur_dir, "generated", "jac_parser.py")):
         if os.path.exists(os.path.join(cur_dir, "generated")):
@@ -27,25 +27,24 @@ def generate_static_parser(force: bool = False) -> None:
             os.path.join(cur_dir, "generated", "jac_parser.py"),
             "-c",
         ]
-        standalone.main()  # type: ignore
+        standalone.main()
         sys.argv = save_argv
         try:
             auto_generate_refs()
         except Exception as e:
-            print(f"Error generating reference files: {e}")
+            logging.error(f"Error generating reference files: {e}")
 
 
 generate_static_parser()
 try:
-    from jaclang.compiler.generated import jac_parser as jac_lark  # noqa: E402
-
-    jac_lark.logger.setLevel(logging.DEBUG)
-except AttributeError:
+    from jaclang.compiler.generated import jac_parser as jac_lark
+except ModuleNotFoundError:
     generate_static_parser(force=True)
-    from jaclang.compiler.generated import jac_parser as jac_lark  # noqa: E402
+    from jaclang.compiler.generated import jac_parser as jac_lark
+
+jac_lark.logger.setLevel(logging.DEBUG)
+contextlib.suppress(ModuleNotFoundError)
 
-    jac_lark.logger.setLevel(logging.DEBUG)
-contextlib.suppress(AttributeError)
 TOKEN_MAP = {
     x.name: x.pattern.value
     for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -4,14 +4,12 @@ from __future__ import annotations
 
 import ast
 import os
-import pathlib
 
-import jaclang
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main.fuse_typeinfo_pass import (
     FuseTypeInfoPass,
-)  # TODO: Put in better place
+)
 
 import mypy.build as myb
 import mypy.checkexpr as mycke
@@ -31,11 +29,6 @@ from mypy.options import Options
 from mypy.semanal_main import semantic_analysis_for_scc
 
 
-os.environ["MYPYPATH"] = str(
-    pathlib.Path(os.path.dirname(jaclang.__file__)).parent / "stubs"
-)
-
-
 mypy_to_jac_node_map: dict[
     tuple[int, int | None, int | None, int | None], list[AstNode]
 ] = {}

jaclang/plugin/default.py

@@ -15,13 +15,6 @@ from typing import Any, Callable, Optional, Type, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.core.aott import (
-    aott_raise,
-    extract_non_primary_type,
-    get_all_type_explanations,
-    get_info_types,
-    get_input_information,
-)
 from jaclang.core.constructs import (
     Architype,
     DSFunc,
@@ -616,7 +609,7 @@ class JacFeatureDefaults:
                     )
         if isinstance(attr_sem_info, SemInfo) and isinstance(attr_scope, SemScope):
             return attr_sem_info.semstr, attr_scope.as_type_str
-        return "", ""  #
+        return "", ""
 
     @staticmethod
     @hookimpl
@@ -632,68 +625,9 @@ class JacFeatureDefaults:
         action: str,
     ) -> Any:  # noqa: ANN401
         """Jac's with_llm feature."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry = pickle.load(f)
-
-        outputs = outputs[0] if isinstance(outputs, list) else outputs
-        _scope = SemScope.get_scope_from_str(scope)
-        assert _scope is not None
-
-        method = model_params.pop("method") if "method" in model_params else "Normal"
-        available_methods = model.MTLLM_METHOD_PROMPTS.keys()
-        assert (
-            method in available_methods
-        ), f"Invalid method: {method}. Select from {available_methods}"
-
-        context = (
-            "\n".join(model_params.pop("context")) if "context" in model_params else ""
-        )
-
-        type_collector: list = []
-        incl_info = [x for x in incl_info if not isinstance(x[1], type)]
-        information, collected_types = get_info_types(_scope, mod_registry, incl_info)
-        type_collector.extend(collected_types)
-
-        inputs_information = get_input_information(inputs, type_collector)
-
-        output_information = f"{outputs[0]} ({outputs[1]})".strip()
-        type_collector.extend(extract_non_primary_type(outputs[1]))
-        output_type_explanations = "\n".join(
-            list(
-                get_all_type_explanations(
-                    extract_non_primary_type(outputs[1]), mod_registry
-                ).values()
-            )
-        )
-
-        type_explanations_list = list(
-            get_all_type_explanations(type_collector, mod_registry).values()
-        )
-        type_explanations = "\n".join(type_explanations_list)
-
-        meaning_out = aott_raise(
-            model=model,
-            information=information,
-            inputs_information=inputs_information,
-            output_information=output_information,
-            type_explanations=type_explanations,
-            action=action,
-            context=context,
-            method=method,
-            tools=[],
-            model_params=model_params,
-        )
-        output = model.resolve_output(
-            meaning_out, outputs[0], outputs[1], output_type_explanations
+        raise ImportError(
+            "mtllm is not installed. Please install it with `pip install mtllm`."
         )
-        return output
 
 
 class JacBuiltin:

jaclang/tests/test_language.py

@@ -112,106 +112,6 @@ class JacLanguageTests(TestCase):
             "{'a': 'apple', 'b': 'ball', 'c': 'cat', 'd': 'dog', 'e': 'elephant'}\n",
         )
 
-    # TODO: Move these tests to mtllm repo
-    # def test_with_llm_function(self) -> None:
-    #     """Parse micro jac file."""
-    #     captured_output = io.StringIO()
-    #     sys.stdout = captured_output
-    #     jac_import("with_llm_function", base_path=self.fixture_abs_path("./"))
-    #     sys.stdout = sys.__stdout__
-    #     stdout_value = captured_output.getvalue()
-    #     self.assertIn("{'temperature': 0.7}", stdout_value)
-    #     self.assertIn("Emoji Representation (str)", stdout_value)
-    #     self.assertIn('Text Input (input) (str) = "Lets move to paris"', stdout_value)
-    #     self.assertIn(
-    #         ' = [{"input": "I love tp drink pina coladas"',
-    #         stdout_value,
-    #     )
-
-    # def test_with_llm_method(self) -> None:
-    #     """Parse micro jac file."""
-    #     captured_output = io.StringIO()
-    #     sys.stdout = captured_output
-    #     jac_import("with_llm_method", base_path=self.fixture_abs_path("./"))
-    #     sys.stdout = sys.__stdout__
-    #     stdout_value = captured_output.getvalue()
-    #     self.assertIn("[Reasoning] <Reason>", stdout_value)
-    #     self.assertIn("(Enum) eg:- Personality.EXTROVERT ->", stdout_value)
-    #     self.assertIn(
-    #         "Personality Index of a Person (PersonalityIndex) (class) eg:- "
-    #         "PersonalityIndex(index=int) -> Personality Index (index) (int)",
-    #         stdout_value,
-    #     )
-    #     self.assertIn(
-    #         "Personality of the Person (dict[Personality,PersonalityIndex])",
-    #         stdout_value,
-    #     )
-    #     self.assertIn(
-    #         'Diary Entries (diary_entries) (list[str]) = ["I won noble prize in '
-    #         'Physics", "I am popular for my theory of relativity"]',
-    #         stdout_value,
-    #     )
-
-    # def test_with_llm_lower(self) -> None:
-    #     """Parse micro jac file."""
-    #     captured_output = io.StringIO()
-    #     sys.stdout = captured_output
-    #     jac_import("with_llm_lower", base_path=self.fixture_abs_path("./"))
-    #     sys.stdout = sys.__stdout__
-    #     stdout_value = captured_output.getvalue()
-    #     self.assertIn("[Reasoning] <Reason>", stdout_value)
-    #     self.assertIn(
-    #         'Name of the Person (name) (str) = "Oppenheimer"',
-    #         stdout_value,
-    #     )
-    #     self.assertIn(
-    #         "Person (Person) (obj) eg:- Person(full_name=str, yod=int, personality"
-    #         "=Personality) -> Fullname of the Person (full_name) (str), Year of Death"
-    #         " (yod) (int), Personality of the Person (personality) (Personality)",
-    #         stdout_value,
-    #     )
-    #     self.assertIn(
-    #         "J. Robert Oppenheimer was a Introvert person who died in 1967",
-    #         stdout_value,
-    #     )
-
-    # def test_with_llm_type(self) -> None:
-    #     """Parse micro jac file."""
-    #     captured_output = io.StringIO()
-    #     sys.stdout = captured_output
-    #     jac_import("with_llm_type", base_path=self.fixture_abs_path("./"))
-    #     sys.stdout = sys.__stdout__
-    #     stdout_value = captured_output.getvalue()
-    #     self.assertIn("14/03/1879", stdout_value)
-    #     self.assertNotIn(
-    #         'University (University) (obj) = type(__module__="with_llm_type", __doc__=None, '
-    #         "_jac_entry_funcs_`=[`], _jac_exit_funcs_=[], __init__=function(__wrapped__=function()))",
-    #         stdout_value,
-    #     )
-    #     desired_output_count = stdout_value.count(
-    #         "Person(name='Jason Mars', dob='1994-01-01', age=30)"
-    #     )
-    #     self.assertEqual(desired_output_count, 2)
-
-    # def test_with_llm_vision(self) -> None:
-    #     """Test MTLLLM Vision Implementation."""
-    #     try:
-    #         captured_output = io.StringIO()
-    #         sys.stdout = captured_output
-    #         jac_import("with_llm_vision", base_path=self.fixture_abs_path("./"))
-    #         sys.stdout = sys.__stdout__
-    #         stdout_value = captured_output.getvalue()
-    #         self.assertIn(
-    #             "{'type': 'text', 'text': '\\n[System Prompt]\\n", stdout_value[:500]
-    #         )
-    #         self.assertNotIn(
-    #             " {'type': 'text', 'text': 'Image of the Question (question_img) (Image) = '}, "
-    #             "{'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQAB",
-    #             stdout_value[:500],
-    #         )
-    #     except Exception:
-    #         self.skipTest("This test requires Pillow to be installed.")
-
     def test_ignore(self) -> None:
         """Parse micro jac file."""
         Jac.get_root()._jac_.edges.clear()

{jaclang-0.7.7.dist-info → jaclang-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.7
+Version: 0.7.8
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT

{jaclang-0.7.7.dist-info → jaclang-0.7.8.dist-info}/RECORD

@@ -5,7 +5,7 @@ jaclang/cli/cli.md,sha256=4BPJGdcyvs_rXgd_DPEGjkKSGe5ureXXYaQsf-_z_LU,5939
 jaclang/cli/cli.py,sha256=8CbN_oqMhZ71AJhgA9J0Q551GMO3ey273dgaFPckLyI,13582
 jaclang/cli/cmdreg.py,sha256=u0jAd6A8czt7tBgPBBKBhYAG4By1FrjEGaTU2XFKeYs,8372
 jaclang/compiler/.gitignore,sha256=n1k2_xXTorp9PY8hhYM4psHircn-NMaFx95bSgDKopo,10
-jaclang/compiler/__init__.py,sha256=JA3L1ran0PlZI5Pcj2CIrFgrZGRNFHHC5kRh1QYgYlY,3146
+jaclang/compiler/__init__.py,sha256=P8h-q53h-MTK8Wmvpb7sP5R6Ojz94Y2F9nqMwIUt0d4,3064
 jaclang/compiler/absyntree.py,sha256=q3Ma7mGGzPDRoiNEX_H0wJmechx4zGpSYTnYCJpa-WA,134509
 jaclang/compiler/codeloc.py,sha256=YhJcHjhMCOT6mV1qLehwriuFgW0H2-ntq68k_r8yBs4,2800
 jaclang/compiler/compile.py,sha256=0d8p4i2LXg2RCu1XfWx_Jq_dx7pK2Zn2VIj-apvX_nI,3389
@@ -103,7 +103,7 @@ jaclang/compiler/passes/tool/tests/test_jac_format_pass.py,sha256=AKGBEz02bS9REJ
 jaclang/compiler/passes/tool/tests/test_unparse_validate.py,sha256=sIBDl35Cns6vv200GsKyLBbIggKKV2tDy4gq_J8zf6E,2768
 jaclang/compiler/passes/transform.py,sha256=GEHK3zFWrEjbAQ3mIl3D59jBuIrA8DRbw9t_IlUqg3M,2297
 jaclang/compiler/passes/utils/__init__.py,sha256=UsI5rUopTUiStAzup4kbPwIwrnC5ofCrqWBCBbM2-k4,35
-jaclang/compiler/passes/utils/mypy_ast_build.py,sha256=DbTYKwQ2K-3JXS_RybLyvqDz_381Li8JfFKNeEQhbRY,26324
+jaclang/compiler/passes/utils/mypy_ast_build.py,sha256=aPvvdGSwbOGHYiK5kY665bqtfjj7s2YfTONV4EuLai8,26162
 jaclang/compiler/semtable.py,sha256=tW0vY1N377w_WgKalqXe2VR8FJDwd9CpI6jDJi1jhEU,4152
 jaclang/compiler/symtable.py,sha256=oYdYS1PUnNCGPPZsZZOduiDtTYyLVd6tXWAoUyCupUc,9275
 jaclang/compiler/tests/__init__.py,sha256=qiXa5UNRBanGOcplFKTT9a_9GEyiv7goq1OzuCjDCFE,27
@@ -118,7 +118,6 @@ jaclang/compiler/tests/fixtures/stuff.jac,sha256=qOq6WOwhlprMmJpiqQudgqnr4qTd9uh
 jaclang/compiler/tests/test_importer.py,sha256=JNmte5FsHhnng9jzw7N5BenflAFCasuhezN1sytDVyg,1739
 jaclang/compiler/tests/test_parser.py,sha256=Sj9Kz1FghESaPpyx_kEvScs4xvz-vgEdH8yyQJ0iB7M,4820
 jaclang/core/__init__.py,sha256=jDDYBCV82qPhmcDVk3NIvHbhng0ebSrXD3xrojg0-eo,34
-jaclang/core/aott.py,sha256=W-hvfwDxwu1S3jFTWADWNob0-JnYbywdbUklkXIAOUA,11367
 jaclang/core/architype.py,sha256=qBH0W-ALxmK6DALc4_S7gx-3R7C_6o-PGKb3f4RbWbE,16781
 jaclang/core/constructs.py,sha256=ogWc95DEZxQWoxqsfbRrcmt9ldGDqW7zQVu3DWuIAKs,848
 jaclang/core/context.py,sha256=AxGsra9EqokVdOhwIxR9RuAcnm0HmobUnMBezUBY1_s,4774
@@ -152,7 +151,7 @@ jaclang/langserve/tests/test_server.py,sha256=Bmllojot7c40rq0mDMOAiOyowY0-ECh_qA
 jaclang/langserve/utils.py,sha256=JS_XxDAtqTO4r0wSQjxgGqHwx9xTN_JZpNI1YP-kgbY,9868
 jaclang/plugin/__init__.py,sha256=5t2krHKt_44PrCTGojzxEimxpNHYVQcn89jAiCSXE_k,165
 jaclang/plugin/builtin.py,sha256=MEMPUnj_rlwcCNmUkfH5S8iazMnQ6fpp6tls4fh5z7k,1188
-jaclang/plugin/default.py,sha256=kx7rKU7t0PN4z-zF5kLUg_PiQHUV6_90bh3SJldynHY,25837
+jaclang/plugin/default.py,sha256=PBRhDnMChwLbV-Mzuy5Uss1ziRZ3UNCnGfOb1D6fOP4,23533
 jaclang/plugin/feature.py,sha256=fhyQRNYOkcXlYn1ObFPqdOHPhtC_lGQfgd7RD2ooLUY,9792
 jaclang/plugin/spec.py,sha256=CMu6rzi94eIZaqsFz3NIbN3upJgGneb4FE_7Rly7slE,8893
 jaclang/plugin/tests/__init__.py,sha256=rn_tNG8jCHWwBc_rx4yFkGc4N1GISb7aPuTFVRTvrTk,38
@@ -213,7 +212,6 @@ jaclang/tests/fixtures/inherit_check.jac,sha256=FQlbCavN4ryt3mmD6ei1MIt1jMgZ8_Nc
 jaclang/tests/fixtures/jacsamp.jac,sha256=VUHUn-RvHzTA4v0KNIFuciocqAHsgQp9tfsEvh5WHlE,96
 jaclang/tests/fixtures/jp_importer.jac,sha256=Mfn62rwYk8CANIkCoMf5UFt4SKl042jaU0CHnj-Soiw,414
 jaclang/tests/fixtures/lambda.jac,sha256=nU4HbPrBdYe6NegJq4LueequaiLCe3KWyTAbL__ibG0,113
-jaclang/tests/fixtures/math_question.jpg,sha256=YYLzFuCZRmhEcyTNKy-HzOaka4ZSswHExA3a6UMD18E,152545
 jaclang/tests/fixtures/maxfail_run_test.jac,sha256=JSGAM4wXnu5kP5aczcHNDlnn017yZpinRApetQSPhtE,196
 jaclang/tests/fixtures/mtest.impl.jac,sha256=wYsT4feH2JgxxgN217dgbDWooSmD8HBSlzUwJ4jAa8g,76
 jaclang/tests/fixtures/mtest.jac,sha256=i7aQpJuUw4YMXgJOvGn_lRx-TruJdqBClioPKGUd4mw,67
@@ -243,14 +241,9 @@ jaclang/tests/fixtures/tuplytuples.jac,sha256=6qiXn5OV_qn4cqKwROjJ1VuBAh0nbUGpp-
 jaclang/tests/fixtures/type_info.jac,sha256=4Cw31ef5gny6IS0kLzgeSO-7ArEH1HgFFFip1BGQhZM,316
 jaclang/tests/fixtures/walker_override.jac,sha256=Ok58ZAgxuV6aECNxYrjbbyAWSiqIbnly3N3O6cD563o,271
 jaclang/tests/fixtures/with_context.jac,sha256=cDA_4YWe5UVmQRgcpktzkZ_zsswQpV_T2Otf_rFnPy8,466
-jaclang/tests/fixtures/with_llm_function.jac,sha256=Tt5C9rmAtHPGMVWx9A6M9iYLasPZVBecM_bzK_5btz8,797
-jaclang/tests/fixtures/with_llm_lower.jac,sha256=G-aq6uQnRfcnXvv9Jan_WO7X1o0xU_FCKTzk007aXsQ,1871
-jaclang/tests/fixtures/with_llm_method.jac,sha256=_la52GnLVXE5wnF3t8ZaL_72ojXHpzeYLlL-4zUOdM8,1413
-jaclang/tests/fixtures/with_llm_type.jac,sha256=IXXgOaLPz90IbU8az9FqxmzKW9m08t3cq3146QWkXoA,1771
-jaclang/tests/fixtures/with_llm_vision.jac,sha256=2UC_i1ufnXk9uhj4ruEaR_6romR_r2CVN3YwMLDdgGY,672
 jaclang/tests/test_bugs.py,sha256=tBPsIlSPqZDIz4QaScNRT-WdGIdJ0uU-aRBWq1XUZ6o,555
 jaclang/tests/test_cli.py,sha256=tnqdx8W5jTlsDJYR3713EikJqCbcgWEknEwuRHByvWk,8703
-jaclang/tests/test_language.py,sha256=CWEFxvkPI2TnNt_W3zDv737srQ9NQnX2ByLEvxnB-do,39210
+jaclang/tests/test_language.py,sha256=T0DqM3aFjJ5_0oWqKhEkOyY1eruv-uGRgWkjWWcngXE,34671
 jaclang/tests/test_man_code.py,sha256=Kq93zg3hEfiouvpWvmfCgR6lDT5RKDp28k5ZaWe1Xeg,4519
 jaclang/tests/test_reference.py,sha256=FoZQS-U9teiag8mAmX5X6ak4fuCOv00mvOyqJ44Zkc8,3379
 jaclang/tests/test_settings.py,sha256=TIX5uiu8H9IpZN2__uFiclcdCpBpPpcAwtlEHyFC4kk,1999
@@ -1484,7 +1477,7 @@ jaclang/vendor/typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjW
 jaclang/vendor/typing_extensions-4.12.2.dist-info/RECORD,sha256=XS4fBVrPI7kaNZ56Ggl2RGa76jySWLqTzcrUpZIQTVM,418
 jaclang/vendor/typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
 jaclang/vendor/typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451
-jaclang-0.7.7.dist-info/METADATA,sha256=21uv2akbt7s-cQVnyfL563LFygf9EDHSAkEukwhdtuM,4807
-jaclang-0.7.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jaclang-0.7.7.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
-jaclang-0.7.7.dist-info/RECORD,,
+jaclang-0.7.8.dist-info/METADATA,sha256=LTPHZdBbBJASj1F0iU9uv1uY49AgOhQaDMxmfQfTYp0,4807
+jaclang-0.7.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jaclang-0.7.8.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
+jaclang-0.7.8.dist-info/RECORD,,

jaclang/core/aott.py

@@ -1,314 +0,0 @@
-"""
-AOTT: Automated Operational Type Transformation.
-
-This has all the necessary functions to perform the AOTT operations.
-"""
-
-import base64
-import logging
-import re
-from enum import Enum
-from io import BytesIO
-from typing import Any
-
-
-try:
-    from PIL import Image
-except ImportError:
-    Image = None
-
-from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-
-try:
-    from mtllm.llms import BaseLLM
-except ImportError:
-    BaseLLM = None
-
-
-IMG_FORMATS = ["PngImageFile", "JpegImageFile"]
-
-
-def aott_raise(
-    model: BaseLLM,  # type: ignore
-    information: str,
-    inputs_information: str | list[dict],
-    output_information: str,
-    type_explanations: str,
-    action: str,
-    context: str,
-    method: str,
-    tools: list["Tool"],
-    model_params: dict,
-) -> str:
-    """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
-    system_prompt = model.MTLLM_SYSTEM_PROMPT
-    meaning_in: str | list[dict]
-    if method != "ReAct":
-        method_prompt = model.MTLLM_METHOD_PROMPTS[method]
-        if isinstance(inputs_information, str):
-            mtllm_prompt = model.MTLLM_PROMPT.format(
-                information=information,
-                inputs_information=inputs_information,
-                output_information=output_information,
-                type_explanations=type_explanations,
-                action=action,
-                context=context,
-            ).strip()
-            meaning_in = f"{system_prompt}\n{mtllm_prompt}\n{method_prompt}".strip()
-        else:
-            upper_half = model.MTLLM_PROMPT.split("{inputs_information}")[0]
-            lower_half = model.MTLLM_PROMPT.split("{inputs_information}")[1]
-            upper_half = upper_half.format(
-                information=information,
-                context=context,
-            )
-            lower_half = lower_half.format(
-                output_information=output_information,
-                type_explanations=type_explanations,
-                action=action,
-            )
-            meaning_in = (
-                [
-                    {"type": "text", "text": system_prompt},
-                    {"type": "text", "text": upper_half},
-                ]
-                + inputs_information
-                + [
-                    {"type": "text", "text": lower_half},
-                    {"type": "text", "text": method_prompt},
-                ]
-            )
-        return model(meaning_in, **model_params)
-    else:
-        assert tools, "Tools must be provided for the ReAct method."
-        # TODO: Implement ReAct method
-        return ""
-
-
-def get_info_types(
-    scope: SemScope, mod_registry: SemRegistry, incl_info: list[tuple[str, str]]
-) -> tuple[str, list[str]]:
-    """Filter the registry data based on the scope and return the info string."""
-    collected_types = []
-    avail_scopes = []
-    while True:
-        avail_scopes.append(str(scope))
-        if not scope.parent:
-            break
-        scope = scope.parent
-
-    filtered_registry = SemRegistry()
-    for _scope, sem_info_list in mod_registry.registry.items():
-        if str(_scope) in avail_scopes:
-            filtered_registry.registry[_scope] = sem_info_list
-
-    info_str = []
-    for incl in incl_info:
-        _, sem_info = filtered_registry.lookup(name=incl[0])
-        if sem_info and isinstance(sem_info, SemInfo):
-            (
-                collected_types.extend(extract_non_primary_type(sem_info.type))
-                if sem_info.type
-                else None
-            )
-            info_str.append(
-                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}".strip()
-            )
-    return ("\n".join(info_str), collected_types)
-
-
-def get_object_string(obj: Any) -> Any:  # noqa: ANN401
-    """Get the string representation of the input object."""
-    if isinstance(obj, str):
-        return f'"{obj}"'
-    elif isinstance(obj, (int, float, bool)):
-        return str(obj)
-    elif isinstance(obj, list):
-        return "[" + ", ".join(get_object_string(item) for item in obj) + "]"
-    elif isinstance(obj, tuple):
-        return "(" + ", ".join(get_object_string(item) for item in obj) + ")"
-    elif isinstance(obj, dict):
-        return (
-            "{"
-            + ", ".join(
-                f"{get_object_string(key)}: {get_object_string(value)}"
-                for key, value in obj.items()
-            )
-            + "}"
-        )
-    elif isinstance(obj, Enum):
-        return f"{obj.__class__.__name__}.{obj.name}"
-    elif hasattr(obj, "__dict__"):
-        args = ", ".join(
-            f"{key}={get_object_string(value)}"
-            for key, value in vars(obj).items()
-            if key != "_jac_"
-        )
-        return f"{obj.__class__.__name__}({args})"
-    else:
-        return str(obj)
-
-
-def get_all_type_explanations(type_list: list, mod_registry: SemRegistry) -> dict:
-    """Get all type explanations from the input type list."""
-    collected_type_explanations = {}
-    for type_item in type_list:
-        type_explanation_str, nested_types = get_type_explanation(
-            type_item, mod_registry
-        )
-        if type_explanation_str is not None:
-            if type_item not in collected_type_explanations:
-                collected_type_explanations[type_item] = type_explanation_str
-            if nested_types:
-                nested_collected_type_explanations = get_all_type_explanations(
-                    list(nested_types), mod_registry
-                )
-                for k, v in nested_collected_type_explanations.items():
-                    if k not in collected_type_explanations:
-                        collected_type_explanations[k] = v
-    return collected_type_explanations
-
-
-def get_type_explanation(
-    type_str: str, mod_registry: SemRegistry
-) -> tuple[str | None, set[str] | None]:
-    """Get the type explanation of the input type string."""
-    scope, sem_info = mod_registry.lookup(name=type_str)
-    if isinstance(sem_info, SemInfo) and sem_info.type:
-        sem_info_scope = SemScope(sem_info.name, sem_info.type, scope)
-        _, type_info = mod_registry.lookup(scope=sem_info_scope)
-        type_info_str = []
-        type_info_types = []
-        type_example = [f"{sem_info.name}("]
-        if sem_info.type == "Enum" and isinstance(type_info, list):
-            for enum_item in type_info:
-                type_info_str.append(
-                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)".strip()
-                )
-            type_example[0] = type_example[0].replace("(", f".{enum_item.name}")
-        elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
-            type_info, list
-        ):
-            for arch_item in type_info:
-                if arch_item.type in ["obj", "class", "node", "edge"]:
-                    continue
-                type_info_str.append(
-                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})".strip()
-                )
-                type_example.append(f"{arch_item.name}={arch_item.type}, ")
-                if arch_item.type and extract_non_primary_type(arch_item.type):
-                    type_info_types.extend(extract_non_primary_type(arch_item.type))
-            if len(type_example) > 1:
-                type_example[-1] = type_example[-1].replace(", ", ")")
-            else:
-                type_example.append(")")
-        return (
-            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}".strip(),  # noqa: E501
-            set(type_info_types),
-        )
-    return None, None
-
-
-def extract_non_primary_type(type_str: str) -> list:
-    """Extract non-primary types from the type string."""
-    if not type_str:
-        return []
-    pattern = r"(?:\[|,\s*|\|)([a-zA-Z_][a-zA-Z0-9_]*)|([a-zA-Z_][a-zA-Z0-9_]*)"
-    matches = re.findall(pattern, type_str)
-    primary_types = [
-        "str",
-        "int",
-        "float",
-        "bool",
-        "list",
-        "dict",
-        "tuple",
-        "set",
-        "Any",
-        "None",
-    ]
-    non_primary_types = [m for t in matches for m in t if m and m not in primary_types]
-    return non_primary_types
-
-
-def get_type_annotation(data: Any) -> str:  # noqa: ANN401
-    """Get the type annotation of the input data."""
-    if isinstance(data, dict):
-        class_name = next(
-            (value.__class__.__name__ for value in data.values() if value is not None),
-            None,
-        )
-        if class_name:
-            return f"dict[str, {class_name}]"
-        else:
-            return "dict[str, Any]"
-    else:
-        return str(type(data).__name__)
-
-
-class Tool:
-    """Tool class for the AOTT operations."""
-
-    def __init__(self) -> None:
-        """Initialize the Tool class."""
-        # TODO: Implement the Tool class
-        pass
-
-
-def get_input_information(
-    inputs: list[tuple[str, str, str, Any]], type_collector: list
-) -> str | list[dict]:
-    """
-    Get the input information for the AOTT operation.
-
-    Returns:
-        str | list[dict]: If the input does not contain images, returns a string with the input information.
-            If the input contains images, returns a list of dictionaries representing the input information,
-            where each dictionary contains either text or image_url.
-
-    """
-    contains_imgs = any(get_type_annotation(i[3]) in IMG_FORMATS for i in inputs)
-    if not contains_imgs:
-        inputs_information_list = []
-        for i in inputs:
-            typ_anno = get_type_annotation(i[3])
-            type_collector.extend(extract_non_primary_type(typ_anno))
-            inputs_information_list.append(
-                f"{i[0] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip()
-            )
-        return "\n".join(inputs_information_list)
-    else:
-        inputs_information_dict_list: list[dict] = []
-        for i in inputs:
-            if get_type_annotation(i[3]) in IMG_FORMATS:
-                img_base64 = image_to_base64(i[3])
-                image_repr: list[dict] = [
-                    {
-                        "type": "text",
-                        "text": f"{i[0] if i[0] else ''} ({i[2]}) (Image) = ".strip(),
-                    },
-                    {"type": "image_url", "image_url": {"url": img_base64}},
-                ]
-                inputs_information_dict_list.extend(image_repr)
-                continue
-            typ_anno = get_type_annotation(i[3])
-            type_collector.extend(extract_non_primary_type(typ_anno))
-            inputs_information_dict_list.append(
-                {
-                    "type": "text",
-                    "text": f"{i[0] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip(),
-                }
-            )
-        return inputs_information_dict_list
-
-
-def image_to_base64(image: Image) -> str:  # type: ignore
-    """Convert an image to base64 expected by OpenAI."""
-    if not Image:
-        log = logging.getLogger(__name__)
-        log.error("Pillow is not installed. Please install Pillow to use images.")
-        return ""
-    img_format = image.format
-    with BytesIO() as buffer:
-        image.save(buffer, format=img_format, quality=100)
-        return f"data:image/{img_format.lower()};base64,{base64.b64encode(buffer.getvalue()).decode()}"

jaclang/tests/fixtures/with_llm_function.jac

@@ -1,33 +0,0 @@
-import:py from mtllm.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

@@ -1,45 +0,0 @@
-import:py from mtllm.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

@@ -1,51 +0,0 @@
-import:py from mtllm.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

@@ -1,52 +0,0 @@
-import:py from mtllm.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/fixtures/with_llm_vision.jac

@@ -1,25 +0,0 @@
-import:py from mtllm.llms, BaseLLM;
-import:py from PIL, Image;
-import:py os;
-
-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();
-
-can 'Solve the Given Math Question'
-solve_math_question(question_img: 'Image of the Question': Image) -> 'Answer to the Question': str
-by llm(method="Chain-of-Thoughts");
-
-with entry {
-    question_img = Image.open(os.path.join(os.path.dirname(__file__), 'math_question.jpg'));
-    print(solve_math_question(question_img));
-}