jaclang 0.5.17__py3-none-any.whl → 0.5.18__py3-none-any.whl

jaclang/compiler/jac.lark

@@ -317,9 +317,9 @@ cmp_op: KW_ISN
 
 // Arithmetic expressions
 arithmetic: (arithmetic (MINUS | PLUS))? term
-term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? factor
-factor: (BW_NOT | MINUS | PLUS) factor | power
-power: (power STAR_POW)? connect
+term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
+power: (power STAR_POW)? factor
+factor: (BW_NOT | MINUS | PLUS) factor | connect
 
 // Connect expressions
 connect: (connect (connect_op | disconnect_op))? atomic_pipe
@@ -539,16 +539,16 @@ KW_POST_INIT: "postinit"
 KW_SUPER: "super"
 KW_ROOT: "root"
 
-FLOAT: /(\d+(\.\d*)|\.\d+)([eE][+-]?\d+)?/
+FLOAT: /(\d+(\.\d*)|\.\d+)([eE][+-]?\d+)?|\d+([eE][-+]?\d+)/
 DOC_STRING.1: /"""(.|\n|\r)*?"""|'''(.|\n|\r)*?'''/
 PYNLINE: /::py::(.|\n|\r)*?::py::/
 STRING: /(r?b?|b?r?)"[^"\r\n]*"|(r?b?|b?r?)'[^'\r\n]*'/
 BOOL.1: /True|False/
 KW_NIN.1: /\bnot\s+in\b/
 KW_ISN.1: /\bis\s+not\b/
-HEX: /0[xX][0-9a-fA-F_]+/
-BIN: /0[bB][01_]+/
-OCT: /0[oO][0-7_]+/
+HEX.1: /0[xX][0-9a-fA-F_]+/
+BIN.1: /0[bB][01_]+/
+OCT.1: /0[oO][0-7_]+/
 INT: /[0-9][0-9_]*/
 NULL.1: /None/
 KWESC_NAME: /<>[a-zA-Z_][a-zA-Z0-9_]*/

jaclang/compiler/parser.py

@@ -287,17 +287,22 @@ class JacParser(Pass):
             if len(kid) == 1 and isinstance(kid[0], ast.Import):
                 return self.nu(kid[0])
             lang = kid[1]
-            paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+            from_path = kid[3] if isinstance(kid[3], ast.ModulePath) else None
+            if from_path:
+                items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
+            else:
+                paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+                items = ast.SubNodeList[ast.ModulePath](
+                    items=paths, delim=Tok.COMMA, kid=kid[2:-1]
+                )
+                kid = kid[:2] + [items] + kid[-1:]
 
-            items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
             is_absorb = False
-            if isinstance(lang, ast.SubTag) and (
-                isinstance(items, ast.SubNodeList) or items is None
-            ):
+            if isinstance(lang, ast.SubTag) and (isinstance(items, ast.SubNodeList)):
                 return self.nu(
                     ast.Import(
                         hint=lang,
-                        paths=paths,
+                        from_loc=from_path,
                         items=items,
                         is_absorb=is_absorb,
                         kid=kid,
@@ -342,14 +347,20 @@ class JacParser(Pass):
             include_stmt: KW_INCLUDE sub_name import_path SEMI
             """
             lang = kid[1]
-            paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+            from_path = kid[2]
+            if not isinstance(from_path, ast.ModulePath):
+                raise self.ice()
+            items = ast.SubNodeList[ast.ModulePath](
+                items=[from_path], delim=Tok.COMMA, kid=[from_path]
+            )
+            kid = kid[:2] + [items] + kid[3:]
             is_absorb = True
             if isinstance(lang, ast.SubTag):
                 return self.nu(
                     ast.Import(
                         hint=lang,
-                        paths=paths,
-                        items=None,
+                        from_loc=None,
+                        items=items,
                         is_absorb=is_absorb,
                         kid=kid,
                     )
@@ -1919,13 +1930,17 @@ class JacParser(Pass):
                 sig_kid.append(params)
             if return_type:
                 sig_kid.append(return_type)
-            signature = ast.FuncSignature(
-                params=params,
-                return_type=return_type,
-                kid=sig_kid,
+            signature = (
+                ast.FuncSignature(
+                    params=params,
+                    return_type=return_type,
+                    kid=sig_kid,
+                )
+                if params or return_type
+                else None
             )
             new_kid = [i for i in kid if i != params and i != return_type]
-            new_kid.insert(1, signature)
+            new_kid.insert(1, signature) if signature else None
             if isinstance(chomp[0], ast.Expr):
                 return self.nu(
                     ast.LambdaExpr(

jaclang/compiler/passes/ir_pass.py

@@ -1,16 +1,18 @@
 """Abstract class for IR Passes for Jac."""
 
-from typing import Optional, Type
+from typing import Optional, Type, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.transform import Transform
 from jaclang.utils.helpers import pascal_to_snake
 
+T = TypeVar("T", bound=ast.AstNode)
 
-class Pass(Transform[ast.T]):
+
+class Pass(Transform[T]):
     """Abstract class for IR passes."""
 
-    def __init__(self, input_ir: ast.T, prior: Optional[Transform]) -> None:
+    def __init__(self, input_ir: T, prior: Optional[Transform]) -> None:
         """Initialize parser."""
         self.term_signal = False
         self.prune_signal = False
@@ -45,10 +47,10 @@ class Pass(Transform[ast.T]):
 
     @staticmethod
     def get_all_sub_nodes(
-        node: ast.AstNode, typ: Type[ast.T], brute_force: bool = False
-    ) -> list[ast.T]:
+        node: ast.AstNode, typ: Type[T], brute_force: bool = False
+    ) -> list[T]:
         """Get all sub nodes of type."""
-        result: list[ast.T] = []
+        result: list[T] = []
         # Assumes pass built the sub node table
         if not node:
             return result
@@ -69,7 +71,7 @@ class Pass(Transform[ast.T]):
         return result
 
     @staticmethod
-    def has_parent_of_type(node: ast.AstNode, typ: Type[ast.T]) -> Optional[ast.T]:
+    def has_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
         """Check if node has parent of type."""
         while node.parent:
             if isinstance(node.parent, typ):
@@ -97,7 +99,7 @@ class Pass(Transform[ast.T]):
 
     # Transform Implementations
     # -------------------------
-    def transform(self, ir: ast.T) -> ast.AstNode:
+    def transform(self, ir: T) -> ast.AstNode:
         """Run pass."""
         # Only performs passes on proper ASTs
         if not isinstance(ir, ast.AstNode):

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,15 +6,16 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-import os
 import traceback
 from typing import Callable, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 from jaclang.vendor.mypy.nodes import Node as VNode  # bit of a hack
 
+
 import mypy.nodes as MypyNodes  # noqa N812
 import mypy.types as MypyTypes  # noqa N812
 from mypy.checkexpr import Type as MyType
@@ -29,7 +30,7 @@ class FuseTypeInfoPass(Pass):
     node_type_hash: dict[MypyNodes.Node | VNode, MyType] = {}
 
     def __debug_print(self, *argv: object) -> None:
-        if "FuseTypeInfoDebug" in os.environ:
+        if settings.fuse_type_info_debug:
             print("FuseTypeInfo::", *argv)
 
     def __call_type_handler(

jaclang/compiler/passes/main/import_pass.py

@@ -7,7 +7,6 @@ symbols are available for matching.
 
 import ast as py_ast
 import importlib.util
-import os
 import sys
 from os import path
 from typing import Optional
@@ -16,6 +15,7 @@ from typing import Optional
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
+from jaclang.settings import settings
 from jaclang.utils.helpers import import_target_to_relative_path
 
 
@@ -36,7 +36,8 @@ class ImportPass(Pass):
             self.run_again = False
             all_imports = self.get_all_sub_nodes(node, ast.ModulePath)
             for i in all_imports:
-                if i.parent.hint.tag.value == "jac" and not i.sub_module:
+                lang = i.parent_of_type(ast.Import).hint.tag.value
+                if lang == "jac" and not i.sub_module:
                     self.run_again = True
                     mod = self.import_module(
                         node=i,
@@ -48,9 +49,7 @@ class ImportPass(Pass):
                     self.annex_impl(mod)
                     i.sub_module = mod
                     i.add_kids_right([mod], pos_update=False)
-                elif i.parent.hint.tag.value == "py" and os.environ.get(
-                    "JAC_PROC_DEBUG", False
-                ):
+                elif lang == "py" and settings.jac_proc_debug:
                     mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
                     i.sub_module = mod
                     i.add_kids_right([mod], pos_update=False)

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -492,17 +492,20 @@ class PyastGenPass(Pass):
             py_nodes.append(
                 self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
             )
-        py_compat_path_str = []
-        path_alias = {}
-        for path in node.paths:
-            py_compat_path_str.append(path.path_str.lstrip("."))
-            path_alias[path.path_str] = path.alias.sym_name if path.alias else None
+        path_alias: dict[str, Optional[str]] = (
+            {node.from_loc.path_str: None} if node.from_loc else {}
+        )
         imp_from = {}
         if node.items:
             for item in node.items.items:
-                imp_from[item.name.sym_name] = (
-                    item.alias.sym_name if item.alias else False
-                )
+                if isinstance(item, ast.ModuleItem):
+                    imp_from[item.name.sym_name] = (
+                        item.alias.sym_name if item.alias else False
+                    )
+                elif isinstance(item, ast.ModulePath):
+                    path_alias[item.path_str] = (
+                        item.alias.sym_name if item.alias else None
+                    )
 
         keys = []
         values = []
@@ -594,10 +597,13 @@ class PyastGenPass(Pass):
                 )
             )
         if node.is_absorb:
+            source = node.items.items[0]
+            if not isinstance(source, ast.ModulePath):
+                raise self.ice()
             py_nodes.append(
                 self.sync(
                     py_node=ast3.ImportFrom(
-                        module=py_compat_path_str[0] if py_compat_path_str[0] else None,
+                        module=(source.path_str.lstrip(".") if source else None),
                         names=[self.sync(ast3.alias(name="*"), node)],
                         level=0,
                     ),
@@ -608,15 +614,17 @@ class PyastGenPass(Pass):
                 self.warning(
                     "Includes import * in target module into current namespace."
                 )
-        if not node.items:
-            py_nodes.append(
-                self.sync(ast3.Import(names=[i.gen.py_ast[0] for i in node.paths]))
-            )
+        if not node.from_loc:
+            py_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
         else:
             py_nodes.append(
                 self.sync(
                     ast3.ImportFrom(
-                        module=py_compat_path_str[0] if py_compat_path_str[0] else None,
+                        module=(
+                            node.from_loc.path_str.lstrip(".")
+                            if node.from_loc
+                            else None
+                        ),
                         names=node.items.gen.py_ast,
                         level=0,
                     )
@@ -1674,7 +1682,7 @@ class PyastGenPass(Pass):
             self.sync(
                 ast3.Try(
                     body=self.resolve_stmt_block(node.body),
-                    handlers=node.excepts.gen.py_ast if node.excepts else None,
+                    handlers=node.excepts.gen.py_ast if node.excepts else [],
                     orelse=node.else_body.gen.py_ast if node.else_body else [],
                     finalbody=node.finally_body.gen.py_ast if node.finally_body else [],
                 )
@@ -2376,7 +2384,19 @@ class PyastGenPass(Pass):
         node.gen.py_ast = [
             self.sync(
                 ast3.Lambda(
-                    args=node.signature.gen.py_ast[0],
+                    args=(
+                        node.signature.gen.py_ast[0]
+                        if node.signature
+                        else self.sync(
+                            ast3.arguments(
+                                posonlyargs=[],
+                                args=[],
+                                kwonlyargs=[],
+                                kw_defaults=[],
+                                defaults=[],
+                            )
+                        )
+                    ),
                     body=node.body.gen.py_ast[0],
                 )
             )
@@ -2435,11 +2455,16 @@ class PyastGenPass(Pass):
                 )
             ]
         elif node.op.name in [Tok.STAR_MUL]:
+            ctx_val = (
+                node.operand.py_ctx_func()
+                if isinstance(node.operand, ast.AstSymbolNode)
+                else ast3.Load()
+            )
             node.gen.py_ast = [
                 self.sync(
                     ast3.Starred(
                         value=node.operand.gen.py_ast[0],
-                        ctx=ast3.Load(),
+                        ctx=ctx_val,
                     )
                 )
             ]
@@ -3648,7 +3673,22 @@ class PyastGenPass(Pass):
         pos_start: int,
         pos_end: int,
         """
-        node.gen.py_ast = [self.sync(ast3.Constant(value=int(node.value)))]
+
+        def handle_node_value(value: str) -> int:
+            if value.startswith(("0x", "0X")):
+                return int(value, 16)
+            elif value.startswith(("0b", "0B")):
+                return int(value, 2)
+            elif value.startswith(("0o", "0O")):
+                return int(value, 8)
+            else:
+                return int(value)
+
+        node.gen.py_ast = [
+            self.sync(
+                ast3.Constant(value=handle_node_value(str(node.value)), kind=None)
+            )
+        ]
 
     def exit_string(self, node: ast.String) -> None:
         """Sub objects.

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1372,12 +1372,13 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             pos_end=0,
         )
         pytag = ast.SubTag[ast.Name](tag=lang, kid=[lang])
+        items = ast.SubNodeList[ast.ModulePath](items=paths, delim=Tok.COMMA, kid=paths)
         ret = ast.Import(
             hint=pytag,
-            paths=paths,
-            items=None,
+            from_loc=None,
+            items=items,
             is_absorb=False,
-            kid=[pytag, *paths],
+            kid=[pytag, items],
         )
         return ret
 
@@ -1449,7 +1450,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         pytag = ast.SubTag[ast.Name](tag=lang, kid=[lang])
         ret = ast.Import(
             hint=pytag,
-            paths=[path],
+            from_loc=path,
             items=items,
             is_absorb=False,
             kid=[pytag, path, items],

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -61,14 +61,21 @@ class SymTabPass(Pass):
             node.sym_name_node.py_ctx_func = ast3.Store
         if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
 
-            def fix(item: ast.TupleVal | ast.ListVal) -> None:
-                for i in item.values.items if item.values else []:
-                    if isinstance(i, ast.AstSymbolNode):
-                        i.py_ctx_func = ast3.Store
-                    elif isinstance(i, ast.AtomTrailer):
-                        self.chain_def_insert(self.unwind_atom_trailer(i))
-                    if isinstance(i, (ast.TupleVal, ast.ListVal)):
-                        fix(i)
+            # Handling of UnaryExpr case for item is only necessary for
+            # the generation of Starred nodes in the AST for examples
+            # like `(a, *b) = (1, 2, 3, 4)`.
+            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
+                if isinstance(item, ast.UnaryExpr):
+                    if isinstance(item.operand, ast.AstSymbolNode):
+                        item.operand.py_ctx_func = ast3.Store
+                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
+                    for i in item.values.items if item.values else []:
+                        if isinstance(i, ast.AstSymbolNode):
+                            i.py_ctx_func = ast3.Store
+                        elif isinstance(i, ast.AtomTrailer):
+                            self.chain_def_insert(self.unwind_atom_trailer(i))
+                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
+                            fix(i)
 
             fix(node)
         self.handle_hit_outcome(node)
@@ -381,16 +388,22 @@ class SymTabBuildPass(SymTabPass):
         is_absorb: bool,
         sub_module: Optional[Module],
         """
-        if node.items:
+        if not node.is_absorb:
             for i in node.items.items:
                 self.def_insert(i, single_decl="import item")
         elif node.is_absorb and node.hint.tag.value == "jac":
-            if not node.paths[0].sub_module or not node.paths[0].sub_module.sym_tab:
+            source = node.items.items[0]
+            if (
+                not isinstance(source, ast.ModulePath)
+                or not source.sub_module
+                or not source.sub_module.sym_tab
+            ):
                 self.error(
-                    f"Module {node.paths[0].path_str} not found to include *, or ICE occurred!"
+                    f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
+                    f" not found to include *, or ICE occurred!"
                 )
             else:
-                for v in node.paths[0].sub_module.sym_tab.tab.values():
+                for v in source.sub_module.sym_tab.tab.values():
                     self.def_insert(v.decl, table_override=self.cur_scope())
 
     def enter_module_path(self, node: ast.ModulePath) -> None:

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -1443,10 +1443,10 @@ class JacFormatPass(Pass):
         body: Expr,
         """
         out = ""
-        if node.signature.params:
+        if node.signature and node.signature.params:
             self.comma_sep_node_list(node.signature.params)
             out += node.signature.params.gen.jac
-        if node.signature.return_type:
+        if node.signature and node.signature.return_type:
             out += f" -> {node.signature.return_type.gen.jac}"
         self.emit(node, f"with {out} can {node.body.gen.jac}")
 

jaclang/compiler/workspace.py

@@ -171,9 +171,7 @@ class Workspace:
                 [
                     i
                     for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.parent
-                    and isinstance(i.parent, ast.Import)
-                    and i.parent.hint.tag.value == "jac"
+                    if i.parent_of_type(ast.Import).hint.tag.value == "jac"
                 ]
                 if mod_ir
                 else []
@@ -184,9 +182,7 @@ class Workspace:
                     i
                     for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
                     if i.loc.mod_path == file_path
-                    and i.parent
-                    and isinstance(i.parent, ast.Import)
-                    and i.parent.hint.tag.value == "jac"
+                    and i.parent_of_type(ast.Import).hint.tag.value == "jac"
                 ]
                 if mod_ir
                 else []

jaclang/core/llms.py

@@ -1,7 +1,5 @@
 """LLMs (Large Language Models) module for Jaclang."""
 
-import anthropic
-
 
 class Anthropic:
     """Anthropic API client for Large Language Models (LLMs)."""
@@ -12,6 +10,8 @@ class Anthropic:
 
     def __init__(self, **kwargs: dict) -> None:
         """Initialize the Anthropic API client."""
+        import anthropic
+
         self.client = anthropic.Anthropic()
         self.model_name = kwargs.get("model_name", "claude-3-sonnet-20240229")
         self.temperature = kwargs.get("temperature", 0.7)
@@ -27,3 +27,85 @@ class Anthropic:
             messages=messages,
         )
         return output.content[0].text
+
+
+class Huggingface:
+    """Huggingface API client for Large Language Models (LLMs)."""
+
+    MTLLM_PROMPT: str = ""
+    MTLLM_REASON_SUFFIX: str = ""
+    MTLLM_WO_REASON_SUFFIX: str = ""
+
+    def __init__(self, **kwargs: dict) -> None:
+        """Initialize the Huggingface API client."""
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+        torch.random.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            kwargs.get("model_name", "microsoft/Phi-3-mini-128k-instruct"),
+            device_map=kwargs.get("device_map", "cuda"),
+            torch_dtype="auto",
+            trust_remote_code=True,
+        )
+        tokenizer = AutoTokenizer.from_pretrained(
+            kwargs.get("model_name", "microsoft/Phi-3-mini-128k-instruct")
+        )
+        self.pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+        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:
+        """Infer a response from the input meaning."""
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.pipe(
+            messages,
+            temperature=kwargs.get("temperature", self.temperature),
+            max_length=kwargs.get("max_new_tokens", self.max_tokens),
+            **kwargs
+        )
+        return output[0]["generated_text"][-1]["content"]
+
+
+class Ollama:
+    """Ollama API client for Large Language Models (LLMs)."""
+
+    MTLLM_PROMPT: str = ""
+    MTLLM_REASON_SUFFIX: str = ""
+    MTLLM_WO_REASON_SUFFIX: str = ""
+
+    def __init__(self, **kwargs: dict) -> None:
+        """Initialize the Ollama API client."""
+        import ollama
+
+        self.client = ollama.Client(host=kwargs.get("host", "http://localhost:11434"))
+        self.model_name = kwargs.get("model_name", "phi3")
+        self.default_model_params = {
+            k: v for k, v in kwargs.items() if k not in ["model_name", "host"]
+        }
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        model = str(kwargs.get("model_name", self.model_name))
+        if not self.check_model(model):
+            self.download_model(model)
+        model_params = {k: v for k, v in kwargs.items() if k not in ["model_name"]}
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.client.chat(
+            model=model,
+            messages=messages,
+            options={**self.default_model_params, **model_params},
+        )
+        return output["message"]["content"]
+
+    def check_model(self, model_name: str) -> bool:
+        """Check if the model is available."""
+        try:
+            self.client.show(model_name)
+            return True
+        except Exception:
+            return False
+
+    def download_model(self, model_name: str) -> None:
+        """Download the model."""
+        self.client.pull(model_name)

jaclang/plugin/default.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import fnmatch
+import html
 import os
 import pickle
 import types
@@ -85,7 +86,11 @@ class JacFeatureDefaults:
         for i in on_entry + on_exit:
             i.resolve(cls)
         if not issubclass(cls, arch_base):
+            # Saving the module path and reassign it after creating cls
+            # So the jac modules are part of the correct module
+            cur_module = cls.__module__
             cls = type(cls.__name__, (cls, arch_base), {})
+            cls.__module__ = cur_module
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
@@ -691,13 +696,16 @@ class JacBuiltin:
         for source, target, edge in connections:
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{edge._jac_.obj.__class__.__name__} "];\n'
+                f' [label="{html.escape(str(edge._jac_.obj.__class__.__name__))} "];\n'
             )
         for node_ in visited_nodes:
             color = (
                 colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
             )
-            dot_content += f'{visited_nodes.index(node_)} [label="{node_._jac_.obj}" fillcolor="{color}"];\n'
+            dot_content += (
+                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_._jac_.obj))}"'
+                f'fillcolor="{color}"];\n'
+            )
         if dot_file:
             with open(dot_file, "w") as f:
                 f.write(dot_content + "}")