jaclang 0.7.7__tar.gz → 0.7.9__tar.gz

{jaclang-0.7.7 → jaclang-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.7
+Version: 0.7.9
 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 → jaclang-0.7.9}/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-0.7.7 → jaclang-0.7.9}/jaclang/compiler/absyntree.py

@@ -676,7 +676,7 @@ class Module(AstDocNode):
         if self.doc:
             new_kid.append(self.doc)
         new_kid.extend(self.body)
-        self.set_kids(nodes=new_kid)
+        self.set_kids(nodes=new_kid if len(new_kid) else [EmptyToken()])
         return res
 
     def unparse(self) -> str:

{jaclang-0.7.7 → jaclang-0.7.9}/jaclang/compiler/passes/main/type_check_pass.py

@@ -8,6 +8,7 @@ import os
 import pathlib
 import sys
 
+# import jaclang
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
 from jaclang.compiler.constant import Constants as Con
@@ -93,12 +94,29 @@ class JacTypeCheckPass(Pass):
             mypy_graph[module.name] = st
             new_modules.append(st)
 
+        # def get_stub(mod: str) -> myab.BuildSource:
+        #     """Get stub file path."""
+        #     return myab.BuildSource(
+        #         path=str(
+        #             pathlib.Path(os.path.dirname(jaclang.__file__)).parent
+        #             / "stubs"
+        #             / "jaclang"
+        #             / "plugin"
+        #             / f"{mod}.pyi"
+        #         ),
+        #         module=f"jaclang.plugin.{mod}",
+        #     )
+
         graph = myab.load_graph(
             [
                 myab.BuildSource(
                     path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
                     module="builtins",
-                )
+                ),
+                # get_stub("default"),
+                # get_stub("feature"),
+                # get_stub("spec"),
+                # get_stub("builtin"),
             ],
             manager,
             old_graph=mypy_graph,

{jaclang-0.7.7 → jaclang-0.7.9}/jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -3,7 +3,7 @@
 import ast as ast3
 from difflib import unified_diff
 
-import jaclang.compiler.absyntree as ast
+
 from jaclang.compiler.compile import jac_file_to_pass, jac_str_to_pass
 from jaclang.compiler.passes.main import PyastGenPass
 from jaclang.compiler.passes.main.schedules import py_code_gen as without_format

{jaclang-0.7.7 → jaclang-0.7.9}/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-0.7.7 → jaclang-0.7.9}/jaclang/langserve/engine.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
+from concurrent.futures import ThreadPoolExecutor
 from enum import IntEnum
 from typing import Optional
 
@@ -126,8 +128,9 @@ class JacLangServer(LanguageServer):
         """Initialize workspace."""
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
+        self.executor = ThreadPoolExecutor()
 
-    def push_diagnostics(self, file_path: str) -> None:
+    async def push_diagnostics(self, file_path: str) -> None:
         """Push diagnostics for a file."""
         if file_path in self.modules:
             self.publish_diagnostics(
@@ -230,17 +233,23 @@ class JacLangServer(LanguageServer):
         self.update_modules(file_path, build, ALev.TYPE)
         return len(self.modules[file_path].errors) == 0
 
-    def analyze_and_publish(self, uri: str, level: int = 2) -> None:
+    async def analyze_and_publish(self, uri: str, level: int = 2) -> None:
         """Analyze and publish diagnostics."""
         self.log_py(f"Analyzing {uri}...")
-        success = self.quick_check(uri)
-        self.push_diagnostics(uri)
+        success = await asyncio.get_event_loop().run_in_executor(
+            self.executor, self.quick_check, uri
+        )
+        await self.push_diagnostics(uri)
         if success and level > 0:
-            success = self.deep_check(uri)
-            self.push_diagnostics(uri)
+            success = await asyncio.get_event_loop().run_in_executor(
+                self.executor, self.deep_check, uri
+            )
+            await self.push_diagnostics(uri)
             if level > 1:
-                self.type_check(uri)
-                self.push_diagnostics(uri)
+                await asyncio.get_event_loop().run_in_executor(
+                    self.executor, self.type_check, uri
+                )
+                await self.push_diagnostics(uri)
 
     def get_completion(
         self, file_path: str, position: lspt.Position

{jaclang-0.7.7 → jaclang-0.7.9}/jaclang/langserve/server.py

@@ -18,21 +18,24 @@ server = JacLangServer()
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
 @server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
-def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    ls.analyze_and_publish(params.text_document.uri)
-    # token_params = lspt.SemanticTokensParams(
-    #     text_document=lspt.TextDocumentIdentifier(uri=params.text_document.uri)
-    # )
-    # tokens = semantic_tokens_full(ls, token_params)
-    # ls.send_notification("textDocument/publishSemanticTokens", tokens)
+    await ls.analyze_and_publish(params.text_document.uri)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
-@debounce(0.1)
+@debounce(0.3)
 async def did_change(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    ls.analyze_and_publish(params.text_document.uri, level=0)
+    await ls.analyze_and_publish(params.text_document.uri, level=1)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: JacLangServer, params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit]:
+    """Format the given document."""
+    return ls.formatted_jac(params.text_document.uri)
 
 
 @server.feature(
@@ -86,14 +89,6 @@ def completion(ls: JacLangServer, params: lspt.CompletionParams) -> lspt.Complet
     return ls.get_completion(params.text_document.uri, params.position)
 
 
-@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
-def formatting(
-    ls: JacLangServer, params: lspt.DocumentFormattingParams
-) -> list[lspt.TextEdit]:
-    """Format the given document."""
-    return ls.formatted_jac(params.text_document.uri)
-
-
 @server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
 def hover(
     ls: JacLangServer, params: lspt.TextDocumentPositionParams

{jaclang-0.7.7 → jaclang-0.7.9}/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-0.7.7 → jaclang-0.7.9}/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 → jaclang-0.7.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaclang"
-version = "0.7.7"
+version = "0.7.9"
 description = "Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding."
 authors = ["Jason Mars <jason@jaseci.org>"]
 license = "MIT"