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

langroid/agent/tools/formatted_model_parse.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar
+
+from parse import parse
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    class Config:
+        arbitrary_types_allowed = True
+
+    START_TOKEN: ClassVar[str] = "<format>"
+    END_TOKEN: ClassVar[str] = "</format>"
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: "FormattingModel") -> str:
+        template = f"{cls.START_TOKEN}\n{{content}}\n{cls.END_TOKEN}"
+        spec_template = cls.format_spec()
+        formatted_content = spec_template.format(**instance.dict())
+        return template.format(content=formatted_content)
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        outer_template = f"{cls.START_TOKEN}\n{{content}}\n{cls.END_TOKEN}"
+        outer_parsed = parse(outer_template, formatted_string, case_sensitive=False)
+        if not outer_parsed:
+            raise ValueError("Invalid outer format")
+
+        content = outer_parsed["content"]
+        parse_template = cls.parse_spec()
+        parsed = parse(parse_template, content, case_sensitive=False)
+        if not parsed:
+            raise ValueError(
+                f"Failed to parse content:\n{content}\nusing spec:\n{parse_template}"
+            )
+
+        return cls(**parsed.named)
+
+
+class PersonModel(FormattingModel):
+    name: str
+    age: int
+    city: str
+
+    START_TOKEN: ClassVar[str] = "<person>"
+    END_TOKEN: ClassVar[str] = "</person>"
+
+    @classmethod
+    def format_spec(cls):
+        return "name: {name}\n{age} is the age\nlives in {city}"
+
+    @classmethod
+    def parse_spec(cls):
+        return "name: {name:S}\n{age:d} is the age\nlives in {city:S}"
+
+
+# Tests
+if __name__ == "__main__":
+    # Test instance
+    person = PersonModel(name="John Doe", age=30, city="New York")
+
+    # Test formatting
+    formatted_string = PersonModel.format(person)
+    print("Formatted string:")
+    print(formatted_string)
+    assert formatted_string == (
+        "<person>\n"
+        "name: John Doe\n"
+        "30 is the age\n"
+        "lives in New York\n"
+        "</person>"
+    )
+
+    # Test parsing
+    parsed_person = PersonModel.parse(formatted_string)
+    print("\nParsed person:", parsed_person)
+    assert parsed_person == person
+
+    # Test round trip
+    round_trip_person = PersonModel.parse(PersonModel.format(person))
+    assert round_trip_person == person
+
+    # Test parsing with extra whitespace and different casing
+    extra_whitespace_string = """
+    <PERSON>
+        Name:    John Doe   
+        30    IS THE AGE  
+        Lives    in    New York   
+    </person>
+    """
+    parsed_extra_whitespace = PersonModel.parse(extra_whitespace_string)
+    assert parsed_extra_whitespace == person
+
+    print("All tests passed!")

langroid/agent/tools/formatted_model_parse.py-e

@@ -0,0 +1,98 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar
+from pydantic import BaseModel
+from parse import parse
+
+class FormattingModel(BaseModel, ABC):
+    class Config:
+        arbitrary_types_allowed = True
+
+    START_TOKEN: ClassVar[str] = "<format>"
+    END_TOKEN: ClassVar[str] = "</format>"
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def format(cls, instance: 'FormattingModel') -> str:
+        template = f"{cls.START_TOKEN}\n{{content}}\n{cls.END_TOKEN}"
+        spec_template = cls.format_spec()
+        formatted_content = spec_template.format(**instance.dict())
+        return template.format(content=formatted_content)
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> 'FormattingModel':
+        outer_template = f"{cls.START_TOKEN}\n{{content}}\n{cls.END_TOKEN}"
+        outer_parsed = parse(outer_template, formatted_string, case_sensitive=False)
+        if not outer_parsed:
+            raise ValueError("Invalid outer format")
+        
+        content = outer_parsed['content']
+        parse_template = cls.parse_spec()
+        parsed = parse(parse_template, content, case_sensitive=False)
+        if not parsed:
+            raise ValueError(f"Failed to parse content:\n{content}\nusing spec:\n{parse_template}")
+        
+        return cls(**parsed.named)
+
+class PersonModel(FormattingModel):
+    name: str
+    age: int
+    city: str
+
+    START_TOKEN: ClassVar[str] = "<person>"
+    END_TOKEN: ClassVar[str] = "</person>"
+
+    @classmethod
+    def format_spec(cls):
+        return "name: {name}\n{age} is the age\nlives in {city}"
+
+    @classmethod
+    def parse_spec(cls):
+        return "name: {name:S}\n{age:d} is the age\nlives in {city:S}"
+
+# Tests
+if __name__ == "__main__":
+    # Test instance
+    person = PersonModel(name="John Doe", age=30, city="New York")
+
+    # Test formatting
+    formatted_string = PersonModel.format(person)
+    print("Formatted string:")
+    print(formatted_string)
+    assert formatted_string == (
+        "<person>\n"
+        "name: John Doe\n"
+        "30 is the age\n"
+        "lives in New York\n"
+        "</person>"
+    )
+
+    # Test parsing
+    parsed_person = PersonModel.parse(formatted_string)
+    print("\nParsed person:", parsed_person)
+    assert parsed_person == person
+
+    # Test round trip
+    round_trip_person = PersonModel.parse(PersonModel.format(person))
+    assert round_trip_person == person
+
+    # Test parsing with extra whitespace and different casing
+    extra_whitespace_string = """
+    <PERSON>
+        Name:    John Doe   
+        30    IS THE AGE  
+        Lives    in    New York   
+    </person>
+    """
+    parsed_extra_whitespace = PersonModel.parse(extra_whitespace_string)
+    assert parsed_extra_whitespace == person
+
+    print("All tests passed!")

langroid/agent/tools/formatted_model_parse2.py

@@ -0,0 +1,113 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar, Dict
+
+import parse
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+    field_token_map: ClassVar[Dict[str, str]] = {}
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        parser = parse.compile(cls.parse_spec())
+        result = parser.parse(formatted_string)
+        if result is None:
+            raise ValueError(f"Unable to parse: {formatted_string}")
+        return cls(**result.named)
+
+    def format(self) -> str:
+        format_string = self.format_spec()
+        field_values = {k: getattr(self, k) for k in self.__annotations__}
+        return format_string.format(**field_values)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+
+    @classmethod
+    def format_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+    @classmethod
+    def parse_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+
+# Informal tests
+if __name__ == "__main__":
+    # Test CodeFileModel
+    my_model = CodeFileModel(
+        language="python",
+        file_path="src/main.py",
+        code='def hello():\n    print("hello world")',
+    )
+
+    formatted = my_model.format()
+    print("Formatted:")
+    print(formatted)
+
+    parsed = CodeFileModel.parse(formatted)
+    print("\nParsed:")
+    print(parsed)
+
+    assert my_model == parsed, "Round trip failed"
+
+    # Test more lenient parsing
+    lenient_formatted = """<format>
+code_file_model
+src/test.py
+```javascript
+function test() {
+    console.log("Hello, world!");
+}
+```
+</format>"""
+
+    parsed_lenient = CodeFileModel.parse(lenient_formatted)
+    print("\nParsed lenient:")
+    print(parsed_lenient)
+
+    # Test invalid format
+    try:
+        CodeFileModel.parse("Invalid format")
+    except ValueError as e:
+        print(f"\nCaught expected ValueError: {e}")
+    else:
+        assert False, "Expected ValueError was not raised"
+
+    print("\nAll tests passed!")

langroid/agent/tools/formatted_model_parse2.py-e

@@ -0,0 +1,109 @@
+from abc import ABC, abstractmethod
+from typing import Dict, ClassVar
+from pydantic import BaseModel
+import parse
+
+class FormattingModel(BaseModel, ABC):
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+    field_token_map: ClassVar[Dict[str, str]] = {}
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> 'FormattingModel':
+        parser = parse.compile(cls.parse_spec())
+        result = parser.parse(formatted_string)
+        if result is None:
+            raise ValueError(f"Unable to parse: {formatted_string}")
+        return cls(**result.named)
+
+    def format(self) -> str:
+        format_string = self.format_spec()
+        field_values = {k: getattr(self, k) for k in self.__annotations__}
+        return format_string.format(**field_values)
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+
+    @classmethod
+    def format_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+    @classmethod
+    def parse_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+# Informal tests
+if __name__ == "__main__":
+    # Test CodeFileModel
+    my_model = CodeFileModel(
+        language="python",
+        file_path="src/main.py",
+        code="def hello():\n    print(\"hello world\")"
+    )
+
+    formatted = my_model.format()
+    print("Formatted:")
+    print(formatted)
+
+    parsed = CodeFileModel.parse(formatted)
+    print("\nParsed:")
+    print(parsed)
+
+    assert my_model == parsed, "Round trip failed"
+
+    # Test more lenient parsing
+    lenient_formatted = """<format>
+code_file_model
+src/test.py
+```javascript
+function test() {
+    console.log("Hello, world!");
+}
+```
+</format>"""
+
+    parsed_lenient = CodeFileModel.parse(lenient_formatted)
+    print("\nParsed lenient:")
+    print(parsed_lenient)
+
+    # Test invalid format
+    try:
+        CodeFileModel.parse("Invalid format")
+    except ValueError as e:
+        print(f"\nCaught expected ValueError: {e}")
+    else:
+        assert False, "Expected ValueError was not raised"
+
+    print("\nAll tests passed!")
+    

langroid/agent/tools/formatted_model_parse3.py

@@ -0,0 +1,114 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar, Dict
+
+import parse
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class FormattingModel(BaseModel, ABC):
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+    field_token_map: ClassVar[Dict[str, str]] = {}
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> "FormattingModel":
+        parser = parse.compile(cls.parse_spec())
+        result = parser.parse(formatted_string)
+        if result is None:
+            raise ValueError(f"Unable to parse: {formatted_string}")
+        return cls(**result.named)
+
+    def format(self) -> str:
+        format_string = self.format_spec()
+        field_values = {k: getattr(self, k) for k in self.__annotations__}
+        return format_string.format(**field_values)
+
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+
+    @classmethod
+    def format_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+    @classmethod
+    def parse_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path:^}\n"
+            "```{language:^}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+
+# Informal tests
+if __name__ == "__main__":
+    # Test CodeFileModel
+    my_model = CodeFileModel(
+        language="python",
+        file_path="src/main.py",
+        code='def hello():\n    print("hello world")',
+    )
+
+    formatted = my_model.format()
+    print("Formatted:")
+    print(formatted)
+
+    parsed = CodeFileModel.parse(formatted)
+    print("\nParsed:")
+    print(parsed)
+
+    assert my_model == parsed, "Round trip failed"
+
+    # Test more lenient parsing
+    lenient_formatted = """<format>
+code_file_model
+   src/test.py   
+   
+```   javascript   
+function test() {
+    console.log("Hello, world!");
+}
+```
+</format>"""
+
+    parsed_lenient = CodeFileModel.parse(lenient_formatted)
+    print("\nParsed lenient:")
+    print(parsed_lenient)
+
+    # Test invalid format
+    try:
+        CodeFileModel.parse("Invalid format")
+    except ValueError as e:
+        print(f"\nCaught expected ValueError: {e}")
+    else:
+        assert False, "Expected ValueError was not raised"
+
+    print("\nAll tests passed!")

langroid/agent/tools/formatted_model_parse3.py-e

@@ -0,0 +1,110 @@
+from abc import ABC, abstractmethod
+from typing import Dict, ClassVar
+from pydantic import BaseModel
+import parse
+
+class FormattingModel(BaseModel, ABC):
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+    field_token_map: ClassVar[Dict[str, str]] = {}
+
+    @classmethod
+    @abstractmethod
+    def format_spec(cls) -> str:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse_spec(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, formatted_string: str) -> 'FormattingModel':
+        parser = parse.compile(cls.parse_spec())
+        result = parser.parse(formatted_string)
+        if result is None:
+            raise ValueError(f"Unable to parse: {formatted_string}")
+        return cls(**result.named)
+
+    def format(self) -> str:
+        format_string = self.format_spec()
+        field_values = {k: getattr(self, k) for k in self.__annotations__}
+        return format_string.format(**field_values)
+
+class CodeFileModel(FormattingModel):
+    language: str
+    file_path: str
+    code: str
+
+    start_token: ClassVar[str] = "<format>"
+    end_token: ClassVar[str] = "</format>"
+
+    @classmethod
+    def format_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path}\n"
+            "```{language}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+    @classmethod
+    def parse_spec(cls) -> str:
+        return (
+            f"{cls.start_token}\n"
+            "code_file_model\n"
+            "{file_path:^}\n"
+            "```{language:^}\n"
+            "{code}\n"
+            "```\n"
+            f"{cls.end_token}"
+        )
+
+# Informal tests
+if __name__ == "__main__":
+    # Test CodeFileModel
+    my_model = CodeFileModel(
+        language="python",
+        file_path="src/main.py",
+        code="def hello():\n    print(\"hello world\")"
+    )
+
+    formatted = my_model.format()
+    print("Formatted:")
+    print(formatted)
+
+    parsed = CodeFileModel.parse(formatted)
+    print("\nParsed:")
+    print(parsed)
+
+    assert my_model == parsed, "Round trip failed"
+
+    # Test more lenient parsing
+    lenient_formatted = """<format>
+code_file_model
+   src/test.py   
+   
+```   javascript   
+function test() {
+    console.log("Hello, world!");
+}
+```
+</format>"""
+
+    parsed_lenient = CodeFileModel.parse(lenient_formatted)
+    print("\nParsed lenient:")
+    print(parsed_lenient)
+
+    # Test invalid format
+    try:
+        CodeFileModel.parse("Invalid format")
+    except ValueError as e:
+        print(f"\nCaught expected ValueError: {e}")
+    else:
+        assert False, "Expected ValueError was not raised"
+
+    print("\nAll tests passed!")
+