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

langroid/agent/tools/formatted_model_xml5.py

@@ -1,130 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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/generator_tool.py

@@ -1,20 +0,0 @@
-"""
-A tool to generate a message from previous (numbered) messages in the chat history.
-The idea is that when an LLM is generating text that is a deterministic transformation
-of a previous message, then specifying the transformation can be much cheaper
-than actually generating the transformation.
-"""
-
-from langroid.agent.tool_message import ToolMessage
-
-
-class GeneratorTool(ToolMessage):
-    request: str = ""
-    purpose: str = """
-            To generate a message where the parts within curly braces specify 
-            what should be inserted, using a substitution specification.
-            """
-    rules: str
-
-    def handle(self) -> None:
-        pass