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

langroid/agent/tools/formatted_model_xml.py

@@ -0,0 +1,178 @@
+import xml.etree.ElementTree as ET
+from abc import ABC, abstractmethod
+from xml.dom import minidom
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def format_spec(cls):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls):
+        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(**instance.dict())
+        return f"{cls.start_token()}\n{formatted}\n{cls.end_token()}"
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        content = formatted_string.strip()
+        start_token = cls.start_token().strip()
+        end_token = cls.end_token().strip()
+
+        if not content.lower().startswith(
+            start_token.lower()
+        ) or not content.lower().endswith(end_token.lower()):
+            raise ValueError("Invalid start or end token")
+
+        content = content[len(start_token) :].strip()
+        content = content[: -len(end_token)].strip()
+
+        spec = cls.parse_spec()
+        parsed = spec(content)
+        return cls(**parsed)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def format_spec(cls):
+        def xml_formatter(file_path: str, language: str, code: str) -> str:
+            root = ET.Element("code_file_model")
+
+            file_path_elem = ET.SubElement(root, "file_path")
+            file_path_elem.text = file_path
+
+            language_elem = ET.SubElement(root, "language")
+            language_elem.text = language
+
+            code_elem = ET.SubElement(root, "code")
+            code_elem.text = f"\n{code}\n"
+
+            xml_str = ET.tostring(root, encoding="unicode")
+            pretty_xml = minidom.parseString(xml_str).toprettyxml(indent="  ")
+
+            # Remove the XML declaration
+            pretty_xml = "\n".join(pretty_xml.split("\n")[1:])
+
+            return pretty_xml.strip()
+
+        return xml_formatter
+
+    @classmethod
+    def parse_spec(cls):
+        def parse_xml(content: str) -> dict:
+            # Parse the XML
+            root = ET.fromstring(content)
+
+            # Extract the values, allowing for whitespace
+            file_path = root.find("file_path").text.strip()
+            language = root.find("language").text.strip()
+
+            # Handle code section more carefully
+            code_element = root.find("code")
+            if code_element is not None:
+                code = code_element.text
+                if code:
+                    # Remove leading and trailing newlines, but preserve internal ones
+                    code = code.strip()
+            else:
+                code = ""
+
+            return {"file_path": file_path, "language": language, "code": code}
+
+        return parse_xml
+
+    @classmethod
+    def start_token(cls):
+        return "<format>"
+
+    @classmethod
+    def end_token(cls):
+        return "</format>"
+
+
+# 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 output:")
+    print(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(
+        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 = """<format>
+  <code_file_model>
+    <file_path>  src/main.py  </file_path>
+    <language>  Python  </language>
+    <code>
+def hello():
+    print('Hello, World!')
+    </code>
+  </code_file_model>
+</format>"""
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\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_xml2.py

@@ -0,0 +1,178 @@
+import xml.etree.ElementTree as ET
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+from xml.dom import minidom
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def format_spec(cls):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> Dict[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(**instance.dict())
+        return f"{cls.start_token()}\n{formatted}\n{cls.end_token()}"
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        content = formatted_string.strip()
+        start_token = cls.start_token().strip()
+        end_token = cls.end_token().strip()
+
+        if not content.lower().startswith(
+            start_token.lower()
+        ) or not content.lower().endswith(end_token.lower()):
+            raise ValueError("Invalid start or end token")
+
+        content = content[len(start_token) :].strip()
+        content = content[: -len(end_token)].strip()
+
+        spec = cls.parse_spec()
+        parsed = cls._parse_xml(content, spec)
+        return cls(**parsed)
+
+    @staticmethod
+    def _parse_xml(content: str, spec: Dict[str, str]) -> Dict[str, Any]:
+        root = ET.fromstring(content)
+        result = {}
+        for field, xpath in spec.items():
+            element = root.find(xpath)
+            if element is not None:
+                if field == "code":
+                    result[field] = element.text.strip() if element.text else ""
+                else:
+                    result[field] = element.text.strip() if element.text else ""
+            else:
+                raise ValueError(f"Required field '{field}' not found in XML")
+        return result
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def format_spec(cls):
+        def xml_formatter(file_path: str, language: str, code: str) -> str:
+            root = ET.Element("code_file_model")
+
+            file_path_elem = ET.SubElement(root, "file_path")
+            file_path_elem.text = file_path
+
+            language_elem = ET.SubElement(root, "language")
+            language_elem.text = language
+
+            code_elem = ET.SubElement(root, "code")
+            code_elem.text = f"\n{code}\n"
+
+            xml_str = ET.tostring(root, encoding="unicode")
+            pretty_xml = minidom.parseString(xml_str).toprettyxml(indent="  ")
+
+            # Remove the XML declaration
+            pretty_xml = "\n".join(pretty_xml.split("\n")[1:])
+
+            return pretty_xml.strip()
+
+        return xml_formatter
+
+    @classmethod
+    def parse_spec(cls) -> Dict[str, str]:
+        return {
+            "file_path": ".//file_path",
+            "language": ".//language",
+            "code": ".//code",
+        }
+
+    @classmethod
+    def start_token(cls):
+        return "<format>"
+
+    @classmethod
+    def end_token(cls):
+        return "</format>"
+
+
+# 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 output:")
+    print(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(
+        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 = """<format>
+  <code_file_model>
+    <file_path>  src/main.py  </file_path>
+    <language>  Python  </language>
+    <code>
+def hello():
+    print('Hello, World!')
+    </code>
+  </code_file_model>
+</format>"""
+    parsed_tolerant = CodeFileModel.parse(tolerant_input)
+    expected_tolerant = CodeFileModel(
+        language="Python",
+        file_path="src/main.py",
+        code="def hello():\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_xml3.py

@@ -0,0 +1,132 @@
+import xml.etree.ElementTree as ET
+from abc import ABC, abstractmethod
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def spec(cls):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = ET.Element(cls.root_element())
+        for field, field_type in cls.spec().items():
+            value = getattr(instance, field)
+            elem = ET.SubElement(root, field)
+            if field_type == "cdata":
+                elem.text = f"<![CDATA[{value}]]>"
+            else:
+                elem.text = value
+        return ET.tostring(root, encoding="unicode", method="xml")
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        root = ET.fromstring(formatted_string)
+        if root.tag != cls.root_element():
+            raise ValueError(
+                f"Invalid root element: expected {cls.root_element()}, got {root.tag}"
+            )
+
+        data = {}
+        for field, field_type in cls.spec().items():
+            elem = root.find(field)
+            if elem is None:
+                raise ValueError(f"Missing field: {field}")
+            if field_type == "cdata":
+                # Extract CDATA content
+                cdata_start = elem.text.find("<![CDATA[")
+                cdata_end = elem.text.rfind("]]>")
+                if cdata_start != -1 and cdata_end != -1:
+                    data[field] = elem.text[cdata_start + 9 : cdata_end]
+                else:
+                    data[field] = elem.text
+            else:
+                data[field] = elem.text.strip() if elem.text else ""
+
+        return cls(**data)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def spec(cls):
+        return {"language": "text", "file_path": "text", "code": "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_xml4.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 spec(cls):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def root_element(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        root = etree.Element(cls.root_element())
+        for field, field_type in cls.spec().items():
+            value = getattr(instance, field)
+            elem = etree.SubElement(root, field)
+            if field_type == "cdata":
+                elem.text = etree.CDATA(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, field_type in cls.spec().items():
+            elem = root.find(field)
+            if elem is None:
+                raise ValueError(f"Missing field: {field}")
+            if field_type == "cdata":
+                data[field] = elem.text
+            elif field_type == "text":
+                data[field] = elem.text.strip() if elem.text else ""
+            else:
+                # Handle other field types as needed
+                data[field] = elem.text
+
+        return cls(**data)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    @classmethod
+    def spec(cls):
+        return {"language": "text", "file_path": "text", "code": "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!")