langroid 0.16.5__py3-none-any.whl → 0.16.7__py3-none-any.whl

langroid/agent/tools/code_file_tool_pyparsing.py

@@ -0,0 +1,194 @@
+""""
+Non-JSON Tool for LLM to specify contents of a code file.
+
+Why Non-JSON?  Because there are numerous issues with even the best LLMs trying
+to return code within JSON strings (e.g. unescaped newlines, quotes, etc.),
+and the problem is even worse with weak LLMs. Json repair methods exist, but
+can't deal with all possible cases.
+
+E.g. see this study from Aider: https://aider.chat/2024/08/14/code-in-json.html
+
+Note: We express the formatting rules with a template since it has several benefits:
+    - all of the formatting rules are in one place, 
+    - we get a parser for free, and don't have to write parsing code,
+    - we get a formatting example generator for free, and don't have to write
+        example generation code.
+    - consistency between the parser and the example generator is guaranteed.        
+"""
+
+from typing import Any, Callable, Dict, List, Tuple, Type
+
+from pyparsing import (
+    LineEnd,
+    Literal,
+    Optional,
+    ParserElement,
+    SkipTo,
+    White,
+    Word,
+    alphanums,
+    lineEnd,
+    printables,
+)
+
+from langroid.agent.tool_message import ToolMessage
+from langroid.utils.constants import TOOL, TOOL_END
+
+CODE_FENCE_START = "`" * 3
+CODE_FENCE_END = "`" * 3
+
+
+class CodeFileTool(ToolMessage):
+    """
+    Used by LLM to specify contents of a code file.
+    """
+
+    request: str = "code_file_tool"
+    purpose: str = """
+        To specify the contents of a code file.
+        """
+    file_path: str
+    contents: str
+    language: str
+
+    @classmethod
+    def create_parser(cls):
+        TOOL_START = Literal(TOOL + ":")
+        CODE_FENCE = Literal("```")
+
+        file_path = SkipTo(lineEnd)("file_path")
+        language = Word(alphanums)("language")
+        contents = SkipTo(CODE_FENCE)("contents")
+
+        parser = (
+            TOOL_START
+            + Optional(Word(printables), default=cls.default_value("request"))(
+                "request"
+            )
+            + lineEnd
+            + file_path
+            + lineEnd
+            + CODE_FENCE
+            + Optional(White())  # Allow space after ```
+            + language
+            + lineEnd
+            + contents
+            + CODE_FENCE
+            + lineEnd  # Add this line to expect a newline after the closing fence
+            + Literal(TOOL_END)
+        )
+        return parser
+
+    @classmethod
+    def parse(cls, string) -> Dict[str, Any]:
+        parser = cls.create_parser()
+        try:
+            result = parser.parseString(string, parseAll=True)
+            return {
+                "request": result["request"],
+                "file_path": result["file_path"].strip(),
+                "language": result["language"],
+                "contents": result["contents"].strip(),
+            }
+        except Exception as e:
+            print(f"Parsing failed: {e}")
+            return {}
+
+    @classmethod
+    def format(cls, instance) -> str:
+        parser = cls.create_parser()
+
+        def format_element(element):
+            if isinstance(element, Literal):
+                return element.match
+            elif element.resultsName:
+                if element.resultsName == "request":
+                    return instance.request
+                elif element.resultsName == "file_path":
+                    return instance.file_path
+                elif element.resultsName == "language":
+                    return instance.language
+                elif element.resultsName == "contents":
+                    return f"{instance.contents}\n"  # Add newline after contents
+            elif isinstance(element, LineEnd):
+                return "\n"
+            return ""
+
+        def traverse_parser(parser_element):
+            if isinstance(parser_element, ParserElement):
+                if isinstance(parser_element, SkipTo):
+                    return format_element(parser_element)
+                elif hasattr(parser_element, "exprs"):
+                    return "".join(
+                        traverse_parser(expr) for expr in parser_element.exprs
+                    )
+                else:
+                    return format_element(parser_element)
+            return str(parser_element)
+
+        formatted_string = traverse_parser(parser)
+
+        return formatted_string.strip()
+
+    @classmethod
+    def create(cls, get_directory: Callable[[], str]) -> Type["CodeFileTool"]:
+        """
+        Create a subclass of CodeFileTool with a static method get_directory,
+        which returns the current directory path, so that all file paths are
+        interpreted as relative to the current directory.
+        """
+
+        class SubCodeFileTool(cls):
+            get_directory: Callable[[], str] = staticmethod(get_directory)
+
+        return SubCodeFileTool
+
+    @classmethod
+    def examples(cls) -> List[ToolMessage | Tuple[str, ToolMessage]]:
+        return [
+            cls(
+                file_path="src/lib.rs",
+                language="rust",
+                contents="""
+                    // function to add two numbers
+                    pub fn add(a: i32, b: i32) -> i32 {
+                        a + b
+                    }
+                    """,
+            )
+        ]
+
+    @classmethod
+    def find_candidates(cls, input_str: str) -> List[str]:
+        """
+        Find all possible (top-level) candidates for
+        CodeFileTool in the input string.
+        """
+        # Use parse.findall to find all instances of the CodeFileTool pattern
+        parser = compile(cls.get_template())
+        matches = list(parser.findall(input_str))
+        candidates = [match.fixed for match in matches]
+        return candidates
+
+    @classmethod
+    def from_string(cls, input_string: str) -> "CodeFileTool":
+        """Parse a string into a CodeFileTool object, using the TEMPLATE."""
+        parsed_data = cls.parse(input_string)
+        if parsed_data:
+            return cls(**parsed_data)
+        raise ValueError("Invalid input string format")
+
+    @classmethod
+    def to_string(cls, instance) -> str:
+        """Convert a CodeFileTool object to a string, using the TEMPLATE."""
+        return cls.format(instance)
+
+    def __str__(self):
+        return self.to_string()
+
+    def __repr__(self):
+        return f"""CodeFileTool(
+            file_path='{self.file_path}', 
+            language='{self.language}',
+            contents='{self.contents}')
+            """

langroid/agent/tools/code_file_tool_pyparsing2.py

@@ -0,0 +1,199 @@
+""""
+Non-JSON Tool for LLM to specify contents of a code file.
+
+Why Non-JSON?  Because there are numerous issues with even the best LLMs trying
+to return code within JSON strings (e.g. unescaped newlines, quotes, etc.),
+and the problem is even worse with weak LLMs. Json repair methods exist, but
+can't deal with all possible cases.
+
+E.g. see this study from Aider: https://aider.chat/2024/08/14/code-in-json.html
+
+Note: We express the formatting rules with a template since it has several benefits:
+    - all of the formatting rules are in one place, 
+    - we get a parser for free, and don't have to write parsing code,
+    - we get a formatting example generator for free, and don't have to write
+        example generation code.
+    - consistency between the parser and the example generator is guaranteed.        
+"""
+
+from typing import Callable, List, Tuple, Type
+
+from pyparsing import (
+    Literal,
+    Optional,
+    SkipTo,
+    White,
+    Word,
+    alphanums,
+    lineEnd,
+    printables,
+)
+
+from langroid.agent.tool_message import ToolMessage
+from langroid.agent.tools.generic_tool import GenericTool
+from langroid.utils.constants import TOOL, TOOL_END
+
+CODE_FENCE_START = "`" * 3
+CODE_FENCE_END = "`" * 3
+
+
+class CodeFileTool(GenericTool):
+    """
+    Used by LLM to specify contents of a code file.
+    """
+
+    request: str = "code_file_tool"
+    purpose: str = """
+    To specify the <contents> of a code file at <file_path>,
+    containing code in a specific <language>.
+    """
+    file_path: str
+    contents: str
+    language: str
+
+    @classmethod
+    def define_grammar(cls):
+        TOOL_START = Literal(TOOL + ":")
+        CODE_FENCE = Literal("```")
+
+        file_path = SkipTo(lineEnd)("file_path")
+        language = Word(alphanums)("language")
+        contents = SkipTo(lineEnd + CODE_FENCE)("contents")
+
+        grammar = (
+            TOOL_START
+            + Optional(White())
+            + Optional(Word(printables), default=cls.default_value("request"))(
+                "request"
+            )
+            + lineEnd
+            + Optional(White())
+            + file_path
+            + lineEnd
+            + CODE_FENCE
+            + Optional(White())
+            + language
+            + lineEnd
+            + contents
+            + lineEnd
+            + CODE_FENCE
+            + lineEnd
+            + Optional(White())
+            + Literal(TOOL_END)
+            + Optional(White())
+        )
+        return grammar
+
+    @classmethod
+    def create(cls, get_directory: Callable[[], str]) -> Type["CodeFileTool"]:
+        """
+        Create a subclass of CodeFileTool with a static method get_directory,
+        which returns the current directory path, so that all file paths are
+        interpreted as relative to the current directory.
+        """
+
+        class SubCodeFileTool(cls):
+            get_directory: Callable[[], str] = staticmethod(get_directory)
+
+        return SubCodeFileTool
+
+    @classmethod
+    def examples(cls) -> List[ToolMessage | Tuple[str, ToolMessage]]:
+        return [
+            cls(
+                file_path="src/lib.rs",
+                language="rust",
+                contents="""
+                    // function to add two numbers
+                    pub fn add(a: i32, b: i32) -> i32 {
+                        a + b
+                    }
+                    """,
+            )
+        ]
+
+    def __repr__(self):
+        return f"""CodeFileTool(
+            file_path='{self.file_path}', 
+            language='{self.language}',
+            contents='{self.contents}')
+            """
+
+
+if __name__ == "__main__":
+    # Informal test to print instructions for CodeFileTool
+    print("Testing CodeFileTool instructions:")
+    print("-" * 50)
+
+    instructions = CodeFileTool.instructions()
+    print(instructions)
+
+    print("-" * 50)
+    print("End of instructions test")
+
+    # You can add more informal tests here if needed
+    # For example, testing the parse method:
+    print("\nTesting CodeFileTool parse method:")
+    print("-" * 50)
+
+    test_input = """TOOL: code_file_tool
+    src/main.py
+    ```python
+    def hello_world():
+        print("Hello, World!")
+    
+    if __name__ == "__main__":
+        hello_world()
+    ```
+    TOOL_END"""
+
+    parsed_result = CodeFileTool.parse(test_input)
+    print("Parsed result:")
+    for key, value in parsed_result.items():
+        print(f"{key}: {value}")
+
+    print("-" * 50)
+    print("End of parse test")
+
+    # Test format method
+    print("\nTesting CodeFileTool format method:")
+    print("-" * 50)
+    test_instance = CodeFileTool(
+        request="code_file_tool",
+        file_path="tests/test_file.py",
+        language="python",
+        contents="""
+def test_function():
+    assert 1 + 1 == 2
+
+if __name__ == "__main__":
+    test_function()
+""",
+    )
+    formatted_output = CodeFileTool.format(test_instance)
+    print("Formatted output:")
+    print(formatted_output)
+    print("-" * 50)
+    print("End of format test")
+
+    # Additional test: Round-trip (parse -> format -> parse)
+    print("\nTesting CodeFileTool round-trip (parse -> format -> parse):")
+    print("-" * 50)
+    initial_parse = CodeFileTool.parse(test_input)
+    initial_instance = CodeFileTool(**initial_parse)
+    formatted_output = CodeFileTool.format(initial_instance)
+    final_parse = CodeFileTool.parse(formatted_output)
+
+    print("Initial parse:")
+    print(initial_parse)
+    print("\nFormatted output:")
+    print(formatted_output)
+    print("\nFinal parse:")
+    print(final_parse)
+
+    if initial_parse == final_parse:
+        print("\nRound-trip test passed: Initial and final parses match.")
+    else:
+        print("\nRound-trip test failed: Initial and final parses do not match.")
+    print("-" * 50)
+    print("End of round-trip test")

langroid/agent/tools/formatted_model_custom.py

@@ -0,0 +1,150 @@
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> List[Tuple[str, str, str]]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def start_token(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def end_token(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        spec = cls.format_spec()
+        formatted = spec.format(**instance.dict())
+        return f"{cls.start_token()}\n{formatted}\n{cls.end_token()}"
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        lines = formatted_string.strip().split("\n")
+        if lines[0] != cls.start_token() or lines[-1] != cls.end_token():
+            raise ValueError("Invalid start or end token")
+        content = "\n".join(lines[1:-1])
+
+        parsed_data = {}
+        for field, start, end in cls.parse_spec():
+            start_index = content.find(start)
+            if start_index == -1:
+                raise ValueError(f"Could not find start of {field}")
+            end_index = content.find(end, start_index + len(start))
+            if end_index == -1:
+                raise ValueError(f"Could not find end of {field}")
+            value = content[start_index + len(start) : end_index].strip()
+            parsed_data[field] = value
+
+        return cls(**parsed_data)
+
+
+class CodeFileModel(FormattingModel):
+    file_path: str
+    language: str
+    code: str
+
+    @classmethod
+    def format_spec(cls):
+        return "file_path: {file_path}\nlanguage: {language}\n```\n{code}\n```"
+
+    @classmethod
+    def parse_spec(cls):
+        return [
+            ("file_path", "file_path:", "\n"),
+            ("language", "language:", "\n"),
+            ("code", "```\n", "\n```"),
+        ]
+
+    @classmethod
+    def start_token(cls):
+        return "<code_file>"
+
+    @classmethod
+    def end_token(cls):
+        return "</code_file>"
+
+
+# Test cases
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        file_path="src/main.py",
+        language="python",
+        code="def main():\n    print('Hello, World!')",
+    )
+    formatted = CodeFileModel.format(code_file)
+    expected_format = """<code_file>
+file_path: src/main.py
+language: python
+```
+def main():
+    print('Hello, World!')
+```
+</code_file>"""
+    assert (
+        formatted == expected_format
+    ), f"Formatting failed. Expected:\n{expected_format}\nGot:\n{formatted}"
+    print("Formatting test passed.")
+
+    # Test parsing
+    parsed = CodeFileModel.parse(formatted)
+    assert (
+        parsed == code_file
+    ), f"Parsing failed. Expected:\n{code_file}\nGot:\n{parsed}"
+    print("Parsing test passed.")
+
+    # Test round-trip
+    round_trip = CodeFileModel.parse(CodeFileModel.format(code_file))
+    assert (
+        round_trip == code_file
+    ), f"Round-trip failed. Expected:\n{code_file}\nGot:\n{round_trip}"
+    print("Round-trip test passed.")
+
+    # Test with different values
+    code_file2 = CodeFileModel(
+        file_path="src/app.js",
+        language="javascript",
+        code="function greet() {\n  console.log('Hello, World!');\n}",
+    )
+    formatted2 = CodeFileModel.format(code_file2)
+    parsed2 = CodeFileModel.parse(formatted2)
+    assert (
+        parsed2 == code_file2
+    ), f"Parsing failed for different values. Expected:\n{code_file2}\nGot:\n{parsed2}"
+    print("Different values test passed.")
+
+    # Test tolerant parsing
+    tolerant_input = """<code_file>
+file_path:    src/main.py   
+language:   python  
+```
+def main():
+    print('Hello, World!')
+```
+</code_file>"""
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        file_path="src/main.py",
+        language="python",
+        code="def main():\n    print('Hello, World!')",
+    )
+    assert (
+        parsed_tolerant == expected_tolerant
+    ), f"Tolerant parsing failed. Expected:\n{expected_tolerant}\nGot:\n{parsed_tolerant}"
+    print("Tolerant parsing test passed.")
+
+    print("All tests passed successfully!")

langroid/agent/tools/formatted_model_custom2.py

@@ -0,0 +1,168 @@
+from abc import ABC
+from typing import Dict
+
+from langroid.pydantic_v1 import BaseModel, Field
+
+
+class FormatMetadata(BaseModel):
+    prefix: str = ""
+    suffix: str = ""
+    multiline: bool = False
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    def format_spec(cls) -> str:
+        lines = []
+        for name, field in cls.__fields__.items():
+            metadata: FormatMetadata = field.field_info.extra.get(
+                "format_metadata", FormatMetadata()
+            )
+            if metadata.multiline:
+                lines.append(f"{metadata.prefix}{{{name}}}{metadata.suffix}")
+            else:
+                lines.append(f"{metadata.prefix}{{{name}}}{metadata.suffix}")
+        return "\n".join(lines)
+
+    @classmethod
+    def parse_spec(cls) -> Dict[str, FormatMetadata]:
+        return {
+            name: field.field_info.extra.get("format_metadata", FormatMetadata())
+            for name, field in cls.__fields__.items()
+        }
+
+    @classmethod
+    def start_token(cls) -> str:
+        return getattr(cls.Config, "start_token", "<format>")
+
+    @classmethod
+    def end_token(cls) -> str:
+        return getattr(cls.Config, "end_token", "</format>")
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        spec = cls.format_spec()
+        formatted = spec.format(**instance.dict())
+        return f"{cls.start_token()}\n{formatted}\n{cls.end_token()}"
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        lines = formatted_string.strip().split("\n")
+        if lines[0] != cls.start_token() or lines[-1] != cls.end_token():
+            raise ValueError("Invalid start or end token")
+        content = "\n".join(lines[1:-1])
+
+        parsed_data = {}
+        parse_spec = cls.parse_spec()
+
+        for field, metadata in parse_spec.items():
+            if metadata.multiline:
+                start = f"{metadata.prefix}"
+                end = f"{metadata.suffix}"
+                start_index = content.find(start)
+                if start_index == -1:
+                    raise ValueError(f"Could not find start of {field}")
+                end_index = content.find(end, start_index + len(start))
+                if end_index == -1:
+                    raise ValueError(f"Could not find end of {field}")
+                value = content[start_index + len(start) : end_index].strip()
+            else:
+                line_start = f"{metadata.prefix}"
+                line_end = metadata.suffix or "\n"
+                start_index = content.find(line_start)
+                if start_index == -1:
+                    raise ValueError(f"Could not find {field}")
+                end_index = content.find(line_end, start_index + len(line_start))
+                if end_index == -1:
+                    end_index = len(content)
+                value = content[start_index + len(line_start) : end_index].strip()
+
+            parsed_data[field] = value
+
+        return cls(**parsed_data)
+
+
+class CodeFileModel(FormattingModel):
+    file_path: str = Field(..., format_metadata=FormatMetadata(prefix="file_path: "))
+    language: str = Field(..., format_metadata=FormatMetadata(prefix="language: "))
+    code: str = Field(
+        ...,
+        format_metadata=FormatMetadata(prefix="```\n", suffix="\n```", multiline=True),
+    )
+
+    class Config:
+        start_token = "<code_file>"
+        end_token = "</code_file>"
+
+
+# Test cases
+#
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        file_path="src/main.py",
+        language="python",
+        code="def main():\n    print('Hello, World!')",
+    )
+    formatted = CodeFileModel.format(code_file)
+    expected_format = """<code_file>
+file_path: src/main.py
+language: python
+```
+def main():
+    print('Hello, World!')
+```
+</code_file>"""
+    assert (
+        formatted == expected_format
+    ), f"Formatting failed. Expected:\n{expected_format}\nGot:\n{formatted}"
+    print("Formatting test passed.")
+
+    # Test parsing
+    parsed = CodeFileModel.parse(formatted)
+    assert (
+        parsed == code_file
+    ), f"Parsing failed. Expected:\n{code_file}\nGot:\n{parsed}"
+    print("Parsing test passed.")
+
+    # Test round-trip
+    round_trip = CodeFileModel.parse(CodeFileModel.format(code_file))
+    assert (
+        round_trip == code_file
+    ), f"Round-trip failed. Expected:\n{code_file}\nGot:\n{round_trip}"
+    print("Round-trip test passed.")
+
+    # Test with different values
+    code_file2 = CodeFileModel(
+        file_path="src/app.js",
+        language="javascript",
+        code="function greet() {\n  console.log('Hello, World!');\n}",
+    )
+    formatted2 = CodeFileModel.format(code_file2)
+    parsed2 = CodeFileModel.parse(formatted2)
+    assert (
+        parsed2 == code_file2
+    ), f"Parsing failed for different values. Expected:\n{code_file2}\nGot:\n{parsed2}"
+    print("Different values test passed.")
+
+    # Test tolerant parsing
+    tolerant_input = """<code_file>
+file_path:    src/main.py   
+language:   python  
+```
+def main():
+    print('Hello, World!')
+```
+</code_file>"""
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        file_path="src/main.py",
+        language="python",
+        code="def main():\n    print('Hello, World!')",
+    )
+    assert (
+        parsed_tolerant == expected_tolerant
+    ), f"Tolerant parsing failed. Expected:\n{expected_tolerant}\nGot:\n{parsed_tolerant}"
+    print("Tolerant parsing test passed.")
+
+    print("All tests passed successfully!")