jaclang 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

jaclang/core/llms/anthropic.py

@@ -45,12 +45,41 @@ class Anthropic(BaseLLM):
         self.client = anthropic.Anthropic()
         self.verbose = verbose
         self.max_tries = max_tries
-        self.model_name = kwargs.get("model_name", "claude-3-sonnet-20240229")
+        self.model_name = str(kwargs.get("model_name", "claude-3-sonnet-20240229"))
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        if not isinstance(meaning_in, str):
+            assert self.model_name.startswith(
+                ("claude-3-opus", "claude-3-sonnet", "claude-3-haiku")
+            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
+
+            import re
+
+            formatted_meaning_in = []
+            for item in meaning_in:
+                if item["type"] == "image_url":
+                    # "data:image/jpeg;base64,base64_string"
+                    img_match = re.match(
+                        r"data:(image/[a-zA-Z]*);base64,(.*)", item["source"]
+                    )
+                    if img_match:
+                        media_type, base64_string = img_match.groups()
+                    formatted_meaning_in.append(
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": media_type,
+                                "data": base64_string,
+                            },
+                        }
+                    )
+                    continue
+                formatted_meaning_in.append(item)
+            meaning_in = formatted_meaning_in
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.messages.create(
             model=kwargs.get("model_name", self.model_name),

jaclang/core/llms/base.py

@@ -112,11 +112,11 @@ class BaseLLM:
         self.max_tries = max_tries
         raise NotImplementedError
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
         raise NotImplementedError
 
-    def __call__(self, input_text: str, **kwargs: dict) -> str:
+    def __call__(self, input_text: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input text."""
         if self.verbose:
             logger.info(f"Meaning In\n{input_text}")
@@ -131,7 +131,7 @@ class BaseLLM:
     ) -> str:
         """Resolve the output string to return the reasoning and output."""
         if self.verbose:
-            logger.opt(colors=True).info(f"Meaning Out\n<green>{meaning_out}</green>")
+            logger.info(f"Meaning Out\n{meaning_out}")
         output_match = re.search(r"\[Output\](.*)", meaning_out)
         output = output_match.group(1).strip() if output_match else None
         if not output_match:

jaclang/core/llms/groq.py

@@ -49,8 +49,11 @@ class Groq(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         model_params = {
             k: v

jaclang/core/llms/huggingface.py

@@ -61,8 +61,11 @@ class Huggingface(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_new_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.pipe(
             messages,

jaclang/core/llms/ollama.py

@@ -51,8 +51,11 @@ class Ollama(BaseLLM):
             k: v for k, v in kwargs.items() if k not in ["model_name", "host"]
         }
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         model = str(kwargs.get("model_name", self.model_name))
         if not self.check_model(model):
             self.download_model(model)

jaclang/core/llms/openai.py

@@ -45,12 +45,16 @@ class OpenAI(BaseLLM):
         self.client = openai.OpenAI()
         self.verbose = verbose
         self.max_tries = max_tries
-        self.model_name = kwargs.get("model_name", "gpt-3.5-turbo")
+        self.model_name = str(kwargs.get("model_name", "gpt-3.5-turbo"))
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        if not isinstance(meaning_in, str):
+            assert self.model_name.startswith(
+                ("gpt-4o", "gpt-4-turbo")
+            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.chat.completions.create(
             model=kwargs.get("model_name", self.model_name),

jaclang/core/llms/togetherai.py

@@ -48,8 +48,11 @@ class TogetherAI(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.chat.completions.create(
             model=kwargs.get("model_name", self.model_name),

jaclang/langserve/engine.py

@@ -2,74 +2,79 @@
 
 from __future__ import annotations
 
+import logging
+from enum import IntEnum
 from hashlib import md5
-from typing import Sequence, Type
+from typing import Optional, Sequence
 
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_pass_to_pass, jac_str_to_pass
+from jaclang.compiler.compile import jac_ir_to_pass, jac_str_to_pass
 from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.passes.main.schedules import (
-    AccessCheckPass,
-    PyBytecodeGenPass,
-    py_code_gen_typed,
-)
+from jaclang.compiler.passes.main.schedules import type_checker_sched
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
 from jaclang.compiler.passes.transform import Alert
-from jaclang.compiler.symtable import Symbol
-from jaclang.langserve.utils import sym_tab_list
+from jaclang.langserve.utils import (
+    collect_symbols,
+    create_range,
+    find_deepest_symbol_node_at_pos,
+)
+from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
-from jaclang.vendor.pygls.workspace.text_document import TextDocument
 
 import lsprotocol.types as lspt
 
 
+class ALev(IntEnum):
+    """Analysis Level."""
+
+    QUICK = 1
+    DEEP = 2
+    TYPE = 3
+
+
 class ModuleInfo:
     """Module IR and Stats."""
 
     def __init__(
         self,
         ir: ast.Module,
-        to_pass: Pass,
         errors: Sequence[Alert],
         warnings: Sequence[Alert],
+        alev: ALev,
+        parent: Optional[ModuleInfo] = None,
     ) -> None:
         """Initialize module info."""
         self.ir = ir
-        self.at_pass = to_pass
         self.errors = errors
         self.warnings = warnings
+        self.alev = alev
+        self.parent: Optional[ModuleInfo] = parent
         self.diagnostics = self.gen_diagnostics()
 
+    @property
+    def uri(self) -> str:
+        """Return uri."""
+        return uris.from_fs_path(self.ir.loc.mod_path)
+
+    @property
+    def has_syntax_error(self) -> bool:
+        """Return if there are syntax errors."""
+        return len(self.errors) > 0 and self.alev == ALev.QUICK
+
     def gen_diagnostics(self) -> list[lspt.Diagnostic]:
         """Return diagnostics."""
         return [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=error.loc.first_line, character=error.loc.col_start
-                    ),
-                    end=lspt.Position(
-                        line=error.loc.last_line,
-                        character=error.loc.col_end,
-                    ),
-                ),
+                range=create_range(error.loc),
                 message=error.msg,
                 severity=lspt.DiagnosticSeverity.Error,
             )
             for error in self.errors
         ] + [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=warning.loc.first_line, character=warning.loc.col_start
-                    ),
-                    end=lspt.Position(
-                        line=warning.loc.last_line,
-                        character=warning.loc.col_end,
-                    ),
-                ),
+                range=create_range(warning.loc),
                 message=warning.msg,
                 severity=lspt.DiagnosticSeverity.Warning,
             )
@@ -85,18 +90,17 @@ class JacLangServer(LanguageServer):
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
 
-    def module_not_diff(self, doc: TextDocument) -> bool:
+    def module_not_diff(self, uri: str, alev: ALev) -> bool:
         """Check if module was changed."""
+        doc = self.workspace.get_text_document(uri)
         return (
             doc.uri in self.modules
             and self.modules[doc.uri].ir.source.hash
             == md5(doc.source.encode()).hexdigest()
-        )
-
-    def module_reached_pass(self, doc: TextDocument, target: Type[Pass]) -> bool:
-        """Check if module reached a pass."""
-        return doc.uri in self.modules and isinstance(
-            self.modules[doc.uri].at_pass, target
+            and (
+                self.modules[doc.uri].alev >= alev
+                or self.modules[doc.uri].has_syntax_error
+            )
         )
 
     def push_diagnostics(self, file_path: str) -> None:
@@ -107,73 +111,101 @@ class JacLangServer(LanguageServer):
                 self.modules[file_path].diagnostics,
             )
 
-    def quick_check(self, file_path: str) -> None:
+    def unwind_to_parent(self, file_path: str) -> str:
+        """Unwind to parent."""
+        orig_file_path = file_path
+        if file_path in self.modules:
+            while cur := self.modules[file_path].parent:
+                file_path = cur.uri
+            if file_path == orig_file_path and (
+                discover := self.modules[file_path].ir.annexable_by
+            ):
+                file_path = uris.from_fs_path(discover)
+                self.quick_check(file_path)
+        return file_path
+
+    def update_modules(self, file_path: str, build: Pass, alev: ALev) -> None:
+        """Update modules."""
+        if not isinstance(build.ir, ast.Module):
+            self.log_error("Error with module build.")
+            return
+        save_parent = (
+            self.modules[file_path].parent if file_path in self.modules else None
+        )
+        self.modules[file_path] = ModuleInfo(
+            ir=build.ir,
+            errors=[
+                i
+                for i in build.errors_had
+                if i.loc.mod_path == uris.to_fs_path(file_path)
+            ],
+            warnings=[
+                i
+                for i in build.warnings_had
+                if i.loc.mod_path == uris.to_fs_path(file_path)
+            ],
+            alev=alev,
+        )
+        self.modules[file_path].parent = save_parent
+        for p in build.ir.mod_deps.keys():
+            uri = uris.from_fs_path(p)
+            self.modules[uri] = ModuleInfo(
+                ir=build.ir.mod_deps[p],
+                errors=[i for i in build.errors_had if i.loc.mod_path == p],
+                warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
+                alev=alev,
+            )
+            self.modules[uri].parent = (
+                self.modules[file_path] if file_path != uri else None
+            )
+
+    def quick_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file."""
-        document = self.workspace.get_document(file_path)
-        if self.module_not_diff(document):
+        if not force and self.module_not_diff(file_path, ALev.QUICK):
             return
         try:
+            document = self.workspace.get_text_document(file_path)
             build = jac_str_to_pass(
                 jac_str=document.source, file_path=document.path, schedule=[]
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        if isinstance(build.ir, ast.Module):
-            self.modules[file_path] = ModuleInfo(
-                ir=build.ir,
-                to_pass=build,
-                errors=build.errors_had,
-                warnings=build.warnings_had,
-            )
+        self.update_modules(file_path, build, ALev.QUICK)
 
-    def deep_check(self, file_path: str) -> None:
+    def deep_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file and its dependencies."""
-        document = self.workspace.get_document(file_path)
-        if self.module_not_diff(document) and self.module_reached_pass(
-            document, PyBytecodeGenPass
-        ):
+        if file_path in self.modules:
+            self.quick_check(file_path, force=force)
+        if not force and self.module_not_diff(file_path, ALev.DEEP):
             return
         try:
-            build = jac_pass_to_pass(in_pass=self.modules[file_path].at_pass)
+            file_path = self.unwind_to_parent(file_path)
+            build = jac_ir_to_pass(ir=self.modules[file_path].ir)
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        if isinstance(build.ir, ast.Module):
-            self.modules[file_path] = ModuleInfo(
-                ir=build.ir,
-                to_pass=build,
-                errors=build.errors_had,
-                warnings=build.warnings_had,
-            )
+        self.update_modules(file_path, build, ALev.DEEP)
 
-    def type_check(self, file_path: str) -> None:
+    def type_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file and its dependencies."""
-        document = self.workspace.get_document(file_path)
-        if self.module_not_diff(document) and self.module_reached_pass(
-            document, AccessCheckPass
-        ):
+        if file_path not in self.modules:
+            self.deep_check(file_path, force=force)
+        if not force and self.module_not_diff(file_path, ALev.TYPE):
             return
         try:
-            build = jac_pass_to_pass(
-                in_pass=self.modules[file_path].at_pass,
-                target=AccessCheckPass,
-                schedule=py_code_gen_typed,
+            file_path = self.unwind_to_parent(file_path)
+            build = jac_ir_to_pass(
+                ir=self.modules[file_path].ir, schedule=type_checker_sched
             )
         except Exception as e:
             self.log_error(f"Error during type check: {e}")
-        if isinstance(build.ir, ast.Module):
-            self.modules[file_path] = ModuleInfo(
-                ir=build.ir,
-                to_pass=build,
-                errors=build.errors_had,
-                warnings=build.warnings_had,
-            )
+        self.update_modules(file_path, build, ALev.TYPE)
 
     def get_completion(
         self, file_path: str, position: lspt.Position
     ) -> lspt.CompletionList:
         """Return completion for a file."""
         items = []
-        document = self.workspace.get_document(file_path)
+        document = self.workspace.get_text_document(file_path)
         current_line = document.lines[position.line].strip()
         if current_line.endswith("hello."):
 
@@ -197,7 +229,7 @@ class JacLangServer(LanguageServer):
     def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]:
         """Return formatted jac."""
         try:
-            document = self.workspace.get_document(file_path)
+            document = self.workspace.get_text_document(file_path)
             format = jac_str_to_pass(
                 jac_str=document.source,
                 file_path=document.path,
@@ -224,52 +256,88 @@ class JacLangServer(LanguageServer):
             )
         ]
 
-    def get_dependencies(
-        self, file_path: str, deep: bool = False
-    ) -> list[ast.ModulePath]:
-        """Return a list of dependencies for a file."""
-        mod_ir = self.modules[file_path].ir
-        if deep:
-            return (
-                [
-                    i
-                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.parent_of_type(ast.Import).hint.tag.value == "jac"
-                ]
-                if mod_ir
-                else []
+    def get_hover_info(
+        self, file_path: str, position: lspt.Position
+    ) -> Optional[lspt.Hover]:
+        """Return hover information for a file."""
+        node_selected = find_deepest_symbol_node_at_pos(
+            self.modules[file_path].ir, position.line, position.character
+        )
+        value = self.get_node_info(node_selected) if node_selected else None
+        if value:
+            return lspt.Hover(
+                contents=lspt.MarkupContent(
+                    kind=lspt.MarkupKind.PlainText, value=f"{value}"
+                ),
             )
-        else:
-            return (
-                [
-                    i
-                    for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.loc.mod_path == file_path
-                    and i.parent_of_type(ast.Import).hint.tag.value == "jac"
-                ]
-                if mod_ir
-                else []
+        return None
+
+    def get_node_info(self, node: ast.AstSymbolNode) -> Optional[str]:
+        """Extract meaningful information from the AST node."""
+        try:
+            if isinstance(node, ast.NameSpec):
+                node = node.name_of
+            access = node.sym_link.access.value + " " if node.sym_link else None
+            node_info = (
+                f"({access if access else ''}{node.sym_type.value}) {node.sym_name}"
             )
+            if node.sym_info.clean_type:
+                node_info += f": {node.sym_info.clean_type}"
+            if isinstance(node, ast.AstSemStrNode) and node.semstr:
+                node_info += f"\n{node.semstr.value}"
+            if isinstance(node, ast.AstDocNode) and node.doc:
+                node_info += f"\n{node.doc.value}"
+            if isinstance(node, ast.Ability) and node.signature:
+                node_info += f"\n{node.signature.unparse()}"
+            self.log_py(node.pp())
+            self.log_py(f"mypy_node: {node.gen.mypy_ast}")
+        except AttributeError as e:
+            self.log_warning(f"Attribute error when accessing node attributes: {e}")
+        return node_info.strip()
 
-    def get_symbols(self, file_path: str) -> list[Symbol]:
-        """Return a list of symbols for a file."""
-        symbols = []
-        mod_ir = self.modules[file_path].ir
-        if file_path in self.modules:
-            root_table = mod_ir.sym_tab if mod_ir else None
-            if file_path in self.modules and root_table:
-                for i in sym_tab_list(sym_tab=root_table, file_path=file_path):
-                    symbols += list(i.tab.values())
-        return symbols
-
-    def get_definitions(
-        self, file_path: str
-    ) -> Sequence[ast.AstSymbolNode]:  # need test
-        """Return a list of definitions for a file."""
-        defs = []
-        for i in self.get_symbols(file_path):
-            defs += i.defn
-        return defs
+    def get_document_symbols(self, file_path: str) -> list[lspt.DocumentSymbol]:
+        """Return document symbols for a file."""
+        root_node = self.modules[file_path].ir.sym_tab
+        if root_node:
+            return collect_symbols(root_node)
+        return []
+
+    def get_definition(
+        self, file_path: str, position: lspt.Position
+    ) -> Optional[lspt.Location]:
+        """Return definition location for a file."""
+        node_selected: Optional[ast.AstSymbolNode] = find_deepest_symbol_node_at_pos(
+            self.modules[file_path].ir, position.line, position.character
+        )
+        if node_selected:
+            if isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+                return None
+            decl_node = (
+                node_selected.parent.body.target
+                if node_selected.parent
+                and isinstance(node_selected.parent, ast.AstImplNeedingNode)
+                and isinstance(node_selected.parent.body, ast.AstImplOnlyNode)
+                else (
+                    node_selected.sym_link.decl
+                    if (node_selected.sym_link and node_selected.sym_link.decl)
+                    else node_selected
+                )
+            )
+            self.log_py(f"{node_selected}, {decl_node}")
+            decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
+            try:
+                decl_range = create_range(decl_node.loc)
+            except ValueError:  # 'print' name has decl in 0,0,0,0
+                return None
+            decl_location = lspt.Location(
+                uri=decl_uri,
+                range=decl_range,
+            )
+
+            return decl_location
+        else:
+            self.log_info("No declaration found for the selected node.")
+            return None
 
     def log_error(self, message: str) -> None:
         """Log an error message."""
@@ -285,3 +353,7 @@ class JacLangServer(LanguageServer):
         """Log an info message."""
         self.show_message_log(message, lspt.MessageType.Info)
         self.show_message(message, lspt.MessageType.Info)
+
+    def log_py(self, message: str) -> None:
+        """Log a message."""
+        logging.info(message)

jaclang/langserve/server.py

@@ -15,21 +15,22 @@ analysis_thread: Optional[threading.Thread] = None
 analysis_stop_event = threading.Event()
 
 
-def analyze_and_publish(ls: JacLangServer, uri: str) -> None:
+def analyze_and_publish(ls: JacLangServer, uri: str, level: int = 2) -> None:
     """Analyze and publish diagnostics."""
     global analysis_thread, analysis_stop_event
 
     def run_analysis() -> None:
         ls.quick_check(uri)
         ls.push_diagnostics(uri)
-        ls.deep_check(uri)
-        ls.push_diagnostics(uri)
-        ls.type_check(uri)
-        ls.push_diagnostics(uri)
+        if not analysis_stop_event.is_set() and level > 0:
+            ls.deep_check(uri)
+            ls.push_diagnostics(uri)
+            if not analysis_stop_event.is_set() and level > 1:
+                ls.type_check(uri)
+                ls.push_diagnostics(uri)
 
     analysis_thread = threading.Thread(target=run_analysis)
     analysis_thread.start()
-    ls.log_info("Analysis restarted")
 
 
 def stop_analysis() -> None:
@@ -130,6 +131,34 @@ def formatting(
     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
+) -> Optional[lspt.Hover]:
+    """Provide hover information for the given hover request."""
+    return ls.get_hover_info(params.text_document.uri, params.position)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+async def document_symbol(
+    ls: JacLangServer, params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol]:
+    """Provide document symbols."""
+    stop_analysis()
+    analyze_and_publish(ls, params.text_document.uri)
+    return ls.get_document_symbols(params.text_document.uri)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
+async def definition(
+    ls: JacLangServer, params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Location]:
+    """Provide definition."""
+    stop_analysis()
+    analyze_and_publish(ls, params.text_document.uri, level=1)
+    return ls.get_definition(params.text_document.uri, params.position)
+
+
 def run_lang_server() -> None:
     """Run the language server."""
     server.start_io()