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

langroid/agent/tools/formatted_model_xml5.py

@@ -0,0 +1,130 @@
+from abc import ABC, abstractmethod
+
+from lxml import etree
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = etree.Element(cls.root_element())
+        for field_name, field in cls.__fields__.items():
+            value = getattr(instance, field_name)
+            elem = etree.SubElement(root, field_name)
+            xml_type = field.field_info.extra.get("xml", {}).get("type", "text")
+            if xml_type == "cdata":
+                elem.text = etree.CDATA(str(value))
+            else:
+                elem.text = str(value)
+        return etree.tostring(root, encoding="unicode", pretty_print=True)
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        root = etree.fromstring(formatted_string.encode("utf-8"))
+        if root.tag != cls.root_element():
+            raise ValueError(
+                f"Invalid root element: expected {cls.root_element()}, got {root.tag}"
+            )
+
+        data = {}
+        for field_name, field in cls.__fields__.items():
+            elem = root.find(field_name)
+            if elem is None:
+                raise ValueError(f"Missing field: {field_name}")
+            xml_type = field.field_info.extra.get("xml", {}).get("type", "text")
+            if xml_type == "cdata":
+                data[field_name] = elem.text
+            elif xml_type == "text":
+                data[field_name] = elem.text.strip() if elem.text else ""
+            else:
+                # Handle other field types as needed
+                data[field_name] = elem.text
+
+        return cls(**data)
+
+
+from langroid.pydantic_v1 import Field
+
+
+def XmlField(*args, xml_type: str = "text", **kwargs):
+    return Field(*args, xml={"type": xml_type}, **kwargs)
+
+
+class CodeFileModel(FormattingModel):
+    language: str = XmlField(xml_type="text")
+    file_path: str = XmlField(xml_type="text")
+    code: str = XmlField(xml_type="cdata")
+
+    @classmethod
+    def root_element(cls):
+        return "code_file_model"
+
+
+# Test cases
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\n    print('Hello, World!')",
+    )
+    formatted = CodeFileModel.format(code_file)
+    print("Formatted XML:")
+    print(formatted)
+
+    # 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(
+        language="JavaScript",
+        file_path="src/app.js",
+        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_model>
+        <language>  Python  </language>
+        <file_path>   src/main.py   </file_path>
+        <code><![CDATA[
+def hello():
+    print('Hello, World!')
+        ]]></code>
+    </code_file_model>
+    """
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="\ndef hello():\n    print('Hello, World!')\n        ",
+    )
+    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_xml6.py

@@ -0,0 +1,113 @@
+from abc import ABC, abstractmethod
+
+from lxml import etree
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = etree.Element(cls.root_element())
+        for name, value in instance.dict().items():
+            elem = etree.SubElement(root, name)
+            elem.text = str(value)
+        return etree.tostring(root, encoding="unicode", pretty_print=True)
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        root = etree.fromstring(formatted_string.encode("utf-8"))
+        if root.tag != cls.root_element():
+            raise ValueError(
+                f"Invalid root element: expected {cls.root_element()}, got {root.tag}"
+            )
+
+        data = {}
+        for elem in root:
+            if elem.tag == "code":
+                # Preserve whitespace for 'code' field
+                data[elem.tag] = elem.text if elem.text else ""
+            else:
+                # Strip whitespace for other fields
+                data[elem.tag] = elem.text.strip() if elem.text else ""
+
+        return cls(**data)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def root_element(cls):
+        return "code_file_model"
+
+
+# Test cases
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\n    print('Hello, World!')",
+    )
+    formatted = CodeFileModel.format(code_file)
+    print("Formatted XML:")
+    print(formatted)
+
+    # 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(
+        language="JavaScript",
+        file_path="src/app.js",
+        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_model>
+        <language>  Python  </language>
+        <file_path>   src/main.py   </file_path>
+        <code>
+def hello():
+    print('Hello, World!')
+        </code>
+    </code_file_model>
+    """
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="\ndef hello():\n    print('Hello, World!')\n        ",
+    )
+    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_xml7.py

@@ -0,0 +1,117 @@
+from abc import ABC, abstractmethod
+
+from lxml import etree
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        parser = etree.XMLParser(strip_cdata=False)
+        root = etree.fromstring(formatted_string.encode("utf-8"), parser=parser)
+        if root.tag != cls.root_element():
+            raise ValueError(
+                f"Invalid root element: expected {cls.root_element()}, got {root.tag}"
+            )
+
+        data = {}
+        for elem in root:
+            if elem.tag == "code":
+                # Extract CDATA content
+                data[elem.tag] = elem.text if elem.text else ""
+            else:
+                # Strip whitespace for other fields
+                data[elem.tag] = elem.text.strip() if elem.text else ""
+
+        return cls(**data)
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = etree.Element(cls.root_element())
+        for name, value in instance.dict().items():
+            elem = etree.SubElement(root, name)
+            if name == "code":
+                elem.text = etree.CDATA(value)
+            else:
+                elem.text = str(value)
+        return etree.tostring(root, encoding="unicode", pretty_print=True)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def root_element(cls):
+        return "code_file_model"
+
+
+# Test cases
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\n    print('Hello, World!')",
+    )
+    formatted = CodeFileModel.format(code_file)
+    print("Formatted XML:")
+    print(formatted)
+
+    # 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(
+        language="JavaScript",
+        file_path="src/app.js",
+        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_model>
+        <language>  Python  </language>
+        <file_path>   src/main.py   </file_path>
+        <code>
+def hello():
+    print('Hello, World!')
+        </code>
+    </code_file_model>
+    """
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="\ndef hello():\n    print('Hello, World!')\n        ",
+    )
+    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_xml8.py

@@ -0,0 +1,164 @@
+from abc import ABC, abstractmethod
+from typing import get_type_hints
+
+from lxml import etree
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        parser = etree.XMLParser(strip_cdata=False)
+        root = etree.fromstring(formatted_string.encode("utf-8"), parser=parser)
+        if root.tag != cls.root_element():
+            raise ValueError(
+                f"Invalid root element: expected {cls.root_element()}, got {root.tag}"
+            )
+
+        data = {}
+        type_hints = get_type_hints(cls)
+        for elem in root:
+            field_type = type_hints.get(elem.tag, str)
+            if elem.tag == "code":
+                data[elem.tag] = elem.text if elem.text else ""
+            else:
+                # Parse according to the field type
+                value = elem.text.strip() if elem.text else ""
+                if field_type == int:
+                    data[elem.tag] = int(value)
+                elif field_type == float:
+                    data[elem.tag] = float(value)
+                elif field_type == bool:
+                    data[elem.tag] = value.lower() in ("true", "1", "yes")
+                else:
+                    data[elem.tag] = value
+
+        return cls(**data)
+
+    @classmethod
+    def instructions(cls) -> str:
+        # Get only the fields defined in the model
+        fields = list(cls.__fields__.keys())
+
+        # Preamble with placeholder variables
+        preamble = "Placeholders:\n"
+        for field in fields:
+            preamble += f"{field.upper()} = [value for {field}]\n"
+
+        # Formatting example
+        example = f"Formatting example:\n\n<{cls.root_element()}>\n"
+        for field in fields:
+            if field == "code":
+                example += f"  <{field}><![CDATA[{{{field.upper()}}}]]></{field}>\n"
+            else:
+                example += f"  <{field}>{{{field.upper()}}}</{field}>\n"
+        example += f"</{cls.root_element()}>"
+
+        return f"{preamble}\n{example}"
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = etree.Element(cls.root_element())
+        for name, value in instance.dict().items():
+            elem = etree.SubElement(root, name)
+            if name == "code":
+                elem.text = etree.CDATA(str(value))
+            else:
+                elem.text = str(value)
+        return etree.tostring(root, encoding="unicode", pretty_print=True)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+    line_count: int
+    average_line_length: float
+    is_executable: bool
+
+    @classmethod
+    def root_element(cls):
+        return "code_file_model"
+
+
+if __name__ == "__main__":
+    # Test formatting
+    code_file = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\n    print('Hello, World!')",
+        line_count=2,
+        average_line_length=20.5,
+        is_executable=True,
+    )
+    formatted = CodeFileModel.format(code_file)
+    print("Formatted XML:")
+    print(formatted)
+
+    # 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(
+        language="JavaScript",
+        file_path="src/app.js",
+        code="function greet() {\n  console.log('Hello, World!');\n}",
+        line_count=3,
+        average_line_length=15.33,
+        is_executable=False,
+    )
+    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_model>
+        <language>  Python  </language>
+        <file_path>   src/main.py   </file_path>
+        <code><![CDATA[
+def hello():
+    print('Hello, World!')
+        ]]></code>
+        <line_count> 2 </line_count>
+        <average_line_length> 20.5 </average_line_length>
+        <is_executable> True </is_executable>
+    </code_file_model>
+    """
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="\ndef hello():\n    print('Hello, World!')\n        ",
+        line_count=2,
+        average_line_length=20.5,
+        is_executable=True,
+    )
+    assert (
+        parsed_tolerant == expected_tolerant
+    ), f"Tolerant parsing failed. Expected:\n{expected_tolerant}\nGot:\n{parsed_tolerant}"
+    print("Tolerant parsing test passed.")
+
+    print(CodeFileModel.instructions())
+
+    print("All tests passed successfully!")

langroid/agent/tools/generic_tool.py

@@ -0,0 +1,165 @@
+from abc import abstractmethod
+from typing import Any, Dict, List
+
+from pyparsing import (
+    LineEnd,
+    Literal,
+    ParserElement,
+)
+
+from langroid.agent.tool_message import ToolMessage
+
+
+class GenericTool(ToolMessage):
+    """
+    Abstract class for a tool whose format is defined by a grammar,
+    and not necessarily JSON-based.
+    Especially useful for tools where we need an LLM to return code.
+    Most LLMs, especially weaker ones, have significant issues
+    (related to unescaped newlines, quotes, etc) when returning code within JSON.
+    """
+
+    @classmethod
+    @abstractmethod
+    def define_grammar(cls):
+        """Define the grammar for the specific tool."""
+        pass
+
+    @classmethod
+    def create_parser(cls):
+        """Create a parser based on the defined grammar."""
+        grammar = cls.define_grammar()
+        # Use the grammar to create and return a parser
+        return grammar
+
+    @classmethod
+    def parse(cls, string) -> Dict[str, Any]:
+        parser = cls.create_parser()
+        try:
+            result = parser.parseString(string, parseAll=True)
+            return {
+                name: result[name]
+                for name in result.keys()
+                if name and not name.startswith("_")
+            }
+        except Exception as e:
+            print(f"Parsing failed: {e}")
+            return {}
+
+    @classmethod
+    def instructions(cls) -> str:
+        preamble = "Preamble:\n"
+        for field, field_info in cls.__dict__["__fields__"].items():
+            preamble += (
+                f"<{field}> denotes the value of the `{field}` field "
+                f"(type: {field_info.type_})\n"
+            )
+
+        parser = cls.create_parser()
+
+        def format_element(element):
+            if isinstance(element, Literal):
+                return element.match
+            elif hasattr(element, "resultsName") and element.resultsName:
+                return f"<{element.resultsName}>"
+            elif isinstance(element, LineEnd):
+                return "\n"
+            return ""
+
+        def traverse_parser(parser_element):
+            if isinstance(parser_element, ParserElement):
+                if 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)
+
+        template = traverse_parser(parser)
+
+        return f"{preamble}\nFormatted Example:\n{template.strip()}"
+
+    @classmethod
+    def parse(cls, string) -> Dict[str, Any]:
+        parser = cls.create_parser()
+        try:
+            result = parser.parseString(string, parseAll=True)
+            return {
+                name: result[name]
+                for name in result.keys()
+                if name and not name.startswith("_")
+            }
+        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 hasattr(element, "resultsName") and element.resultsName:
+                return getattr(instance, element.resultsName, "")
+            elif isinstance(element, LineEnd):
+                return "\n"
+            return ""
+
+        def traverse_parser(parser_element):
+            if isinstance(parser_element, ParserElement):
+                if 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 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)
+
+    @classmethod
+    def find_candidates(cls, input_str: str) -> List[str]:
+        """
+        Find all possible (top-level) candidates for
+        CodeFileTool in the input string.
+        """
+        parser = cls.create_parser()
+        candidates = []
+
+        for tokens, start, end in parser.scanString(input_str):
+            candidates.append(input_str[start:end])
+
+        return candidates
+
+    def __str__(self):
+        return self.to_string()
+
+    # def __repr__(self) -> str:
+    #     class_name = self.__class__.__name__
+    #     attributes = []
+    #     for key, value in self.__dict__.items():
+    #         if not key.startswith('_'):  # Skip private attributes
+    #             if isinstance(value, str):
+    #                 # Escape quotes and newlines in string values
+    #                 value_repr = f"'{value.replace('\\', '\\\\').replace(\"'\", \"\\'\").replace('\\n', '\\n')}'"
+    #             else:
+    #                 value_repr = repr(value)
+    #             attributes.append(f"{key}={value_repr}")
+    #     return f"{class_name}({', '.join(attributes)})"