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

langroid/agent/tools/grammar_based_model_tatsu.py-e

@@ -0,0 +1,77 @@
+from typing import Dict, Type, ClassVar
+from pydantic import BaseModel
+from tatsu import compile as compile_grammar
+from tatsu.model import ModelBuilder
+from abc import ABC, abstractmethod
+
+class GrammarBasedModel(BaseModel, ABC):
+    grammar: ClassVar[str]
+    start_token: ClassVar[str]
+    end_token: ClassVar[str]
+    field_mappings: ClassVar[Dict[str, str]]
+
+    @classmethod
+    @abstractmethod
+    def get_grammar(cls) -> str:
+        pass
+
+    @classmethod
+    def parse(cls, text: str) -> 'GrammarBasedModel':
+        parser = compile_grammar(cls.get_grammar())
+        ast = parser.parse(text, start='start')
+        model_dict = {field: getattr(ast, rule) for field, rule in cls.field_mappings.items()}
+        return cls(**model_dict)
+
+    def generate(self) -> str:
+        grammar = compile_grammar(self.get_grammar())
+        model_builder = ModelBuilder()
+        for field, rule in self.field_mappings.items():
+            setattr(model_builder, rule, getattr(self, field))
+        ast = model_builder.start()
+        return f"{self.start_token}\n{grammar.parse(str(ast), start='start')}\n{self.end_token}"
+
+class PersonSpec(GrammarBasedModel):
+    name: str
+    age: int
+    city: str
+
+    grammar = """
+        start = name_line age_line city_line;
+        name_line = 'name:' /\s*/ name:/.+/ EOL;
+        age_line = 'age is' /\s*/ age:/\d+/ EOL;
+        city_line = 'lives in' /\s*/ city:/.+/ EOL;
+        EOL = /\r?\n/;
+    """
+    start_token = "<spec>"
+    end_token = "</spec>"
+    field_mappings = {
+        "name": "name",
+        "age": "age",
+        "city": "city"
+    }
+
+    @classmethod
+    def get_grammar(cls):
+        return cls.grammar
+
+if __name__ == "__main__":
+    # Test parsing
+    input_str = """<spec>
+name: John Doe
+age is 30
+lives in New York
+</spec>"""
+    person = PersonSpec.parse(input_str)
+    print("Parsed person:", person)
+
+    # Test generation
+    generated_str = person.generate()
+    print("\nGenerated string:")
+    print(generated_str)
+
+    # Test round-trip
+    round_trip_person = PersonSpec.parse(generated_str)
+    print("\nRound-trip parsed person:", round_trip_person)
+
+    assert person == round_trip_person, "Round-trip parsing failed"
+    print("\nRound-trip test passed!")

langroid/agent/tools/lark_earley_example.py

@@ -0,0 +1,135 @@
+import pytest
+from lark import Lark, Transformer, Visitor
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+    city: str
+
+
+grammar = """
+    person: "Name:" name "Age:" age "City:" city
+    name: WORD
+    age: NUMBER
+    city: WORD
+    WORD: /\w+/
+    NUMBER: /\d+/
+    %import common.WS
+    %ignore WS
+"""
+
+parser = Lark(grammar, start="person", parser="earley")
+
+
+class PersonTransformer(Transformer):
+    def person(self, items):
+        return Person(name=items[1], age=items[3], city=items[5])
+
+    def name(self, items):
+        return items[0].value
+
+    def age(self, items):
+        return int(items[0].value)
+
+    def city(self, items):
+        return items[0].value
+
+
+class PersonToStringVisitor(Visitor):
+    def __init__(self):
+        self.result = []
+
+    def person(self, tree):
+        self.visit_children(tree)
+        return " ".join(self.result)
+
+    def name(self, tree):
+        self.result.extend(["Name:", str(tree.children[0])])
+
+    def age(self, tree):
+        self.result.extend(["Age:", str(tree.children[0])])
+
+    def city(self, tree):
+        self.result.extend(["City:", str(tree.children[0])])
+
+
+transformer = PersonTransformer()
+to_string_visitor = PersonToStringVisitor()
+
+
+def from_string(cls, string):
+    tree = parser.parse(string)
+    return transformer.transform(tree)
+
+
+def to_string(self):
+    from lark import Token
+
+    tree = parser.parse(
+        f"Name: {Token('WORD', self.name)} "
+        f"Age: {Token('NUMBER', str(self.age))} "
+        f"City: {Token('WORD', self.city)}"
+    )
+    return to_string_visitor.visit(tree)
+
+
+Person.from_string = classmethod(from_string)
+Person.to_string = to_string
+
+# Test functions remain the same as in the previous version
+
+
+# Test functions
+def test_from_string():
+    person_str = "Name: John Age: 30 City: NewYork"
+    person = Person.from_string(person_str)
+    assert person.name == "John"
+    assert person.age == 30
+    assert person.city == "NewYork"
+
+
+def test_to_string():
+    person = Person(name="Alice", age=25, city="London")
+    person_str = person.to_string()
+    assert person_str == "Name: Alice Age: 25 City: London"
+
+
+def test_roundtrip():
+    original_str = "Name: Bob Age: 40 City: Paris"
+    person = Person.from_string(original_str)
+    regenerated_str = person.to_string()
+    assert original_str == regenerated_str
+
+
+def test_different_values():
+    person = Person(name="Charlie", age=35, city="Berlin")
+    person_str = person.to_string()
+    assert person_str == "Name: Charlie Age: 35 City: Berlin"
+
+
+def test_edge_cases():
+    # Test with minimum age
+    person = Person(name="Young", age=0, city="Baby")
+    person_str = person.to_string()
+    assert person_str == "Name: Young Age: 0 City: Baby"
+
+    # Test with very long name and city
+    long_name = "A" * 100
+    long_city = "B" * 100
+    person = Person(name=long_name, age=50, city=long_city)
+    person_str = person.to_string()
+    assert person_str == f"Name: {long_name} Age: 50 City: {long_city}"
+
+
+def test_invalid_input():
+    with pytest.raises(
+        Exception
+    ):  # The exact exception may vary based on Lark's implementation
+        Person.from_string("Invalid: Input")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

langroid/agent/tools/lark_earley_example.py-e

@@ -0,0 +1,117 @@
+import pytest
+from pydantic import BaseModel
+from lark import Lark, Transformer, Visitor
+
+class Person(BaseModel):
+    name: str
+    age: int
+    city: str
+
+grammar = """
+    person: "Name:" name "Age:" age "City:" city
+    name: WORD
+    age: NUMBER
+    city: WORD
+    WORD: /\w+/
+    NUMBER: /\d+/
+    %import common.WS
+    %ignore WS
+"""
+
+parser = Lark(grammar, start='person', parser='earley')
+
+class PersonTransformer(Transformer):
+    def person(self, items):
+        return Person(name=items[1], age=items[3], city=items[5])
+    
+    def name(self, items):
+        return items[0].value
+    
+    def age(self, items):
+        return int(items[0].value)
+    
+    def city(self, items):
+        return items[0].value
+
+class PersonToStringVisitor(Visitor):
+    def __init__(self):
+        self.result = []
+
+    def person(self, tree):
+        self.visit_children(tree)
+        return " ".join(self.result)
+
+    def name(self, tree):
+        self.result.extend(["Name:", str(tree.children[0])])
+
+    def age(self, tree):
+        self.result.extend(["Age:", str(tree.children[0])])
+
+    def city(self, tree):
+        self.result.extend(["City:", str(tree.children[0])])
+
+transformer = PersonTransformer()
+to_string_visitor = PersonToStringVisitor()
+
+def from_string(cls, string):
+    tree = parser.parse(string)
+    return transformer.transform(tree)
+
+def to_string(self):
+    from lark import Token
+    tree = parser.parse(
+        f"Name: {Token('WORD', self.name)} "
+        f"Age: {Token('NUMBER', str(self.age))} "
+        f"City: {Token('WORD', self.city)}"
+    )
+    return to_string_visitor.visit(tree)
+
+Person.from_string = classmethod(from_string)
+Person.to_string = to_string
+
+# Test functions remain the same as in the previous version
+
+# Test functions
+def test_from_string():
+    person_str = "Name: John Age: 30 City: NewYork"
+    person = Person.from_string(person_str)
+    assert person.name == "John"
+    assert person.age == 30
+    assert person.city == "NewYork"
+
+def test_to_string():
+    person = Person(name="Alice", age=25, city="London")
+    person_str = person.to_string()
+    assert person_str == "Name: Alice Age: 25 City: London"
+
+def test_roundtrip():
+    original_str = "Name: Bob Age: 40 City: Paris"
+    person = Person.from_string(original_str)
+    regenerated_str = person.to_string()
+    assert original_str == regenerated_str
+
+def test_different_values():
+    person = Person(name="Charlie", age=35, city="Berlin")
+    person_str = person.to_string()
+    assert person_str == "Name: Charlie Age: 35 City: Berlin"
+
+def test_edge_cases():
+    # Test with minimum age
+    person = Person(name="Young", age=0, city="Baby")
+    person_str = person.to_string()
+    assert person_str == "Name: Young Age: 0 City: Baby"
+
+    # Test with very long name and city
+    long_name = "A" * 100
+    long_city = "B" * 100
+    person = Person(name=long_name, age=50, city=long_city)
+    person_str = person.to_string()
+    assert person_str == f"Name: {long_name} Age: 50 City: {long_city}"
+
+def test_invalid_input():
+    with pytest.raises(Exception):  # The exact exception may vary based on Lark's implementation
+        Person.from_string("Invalid: Input")
+        
+if __name__ == "__main__":
+    pytest.main([__file__])
+    

langroid/agent/tools/lark_example.py

@@ -0,0 +1,72 @@
+from typing import ClassVar
+
+from lark import Lark, Transformer, Tree
+
+from langroid.pydantic_v1 import BaseModel
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+    city: str
+
+    # Class variable to hold the grammar
+    grammar: ClassVar[
+        str
+    ] = """
+    start: "START Person" "\n" field ("---" "\n" field)* "END Person"
+    field: NAME "=" VALUE
+    NAME: "name" | "age" | "city"
+    VALUE: /[^\n]+/
+
+    %import common.WS
+    %ignore WS
+    """
+
+    @classmethod
+    def from_string(cls, string: str) -> "Person":
+        parser = Lark(cls.grammar, parser="lalr", transformer=PersonTransformer())
+        result = parser.parse(string)
+        return cls(**result)
+
+    def to_string(self) -> str:
+        parser = Lark(self.grammar, parser="lalr")
+        tree = Tree(
+            "start",
+            [
+                Tree("field", [Tree("NAME", [name]), Tree("VALUE", [str(value)])])
+                for name, value in self.dict().items()
+            ],
+        )
+        return parser.serialize(tree)
+
+
+class PersonTransformer(Transformer):
+    def start(self, items):
+        return dict(items)
+
+    def field(self, items):
+        name, value = items
+        if name == "age":
+            value = int(value)
+        return name, value
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Create a Person instance
+    p = Person(name="John Doe", age=30, city="New York")
+
+    # Convert to string
+    s = p.to_string()
+    print("To string:")
+    print(s)
+    print()
+
+    # Parse from string
+    p2 = Person.from_string(s)
+    print("Parsed from string:")
+    print(p2)
+
+    # Demonstrate that they're equal
+    print("\nAre equal:", p == p2)

langroid/agent/tools/parse_example.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+
+from parse import compile
+
+
+class PersonFormatter:
+    # Define the grammar/template as a class attribute
+    GRAMMAR = """
+Name: {name}
+Age: {age:d}
+Birthday: {birthday}
+Hobbies: {hobbies}
+"""
+
+    @classmethod
+    def parse(cls, string):
+        parser = compile(cls.GRAMMAR)
+        result = parser.parse(string)
+        if result:
+            return {
+                "name": result["name"],
+                "age": result["age"],
+                "birthday": datetime.strptime(result["birthday"], "%Y-%m-%d").date(),
+                "hobbies": [hobby.strip() for hobby in result["hobbies"].split(",")],
+            }
+        return None
+
+    @classmethod
+    def format(cls, data):
+        hobbies_str = ", ".join(data["hobbies"])
+        return cls.GRAMMAR.format(
+            name=data["name"],
+            age=data["age"],
+            birthday=data["birthday"].strftime("%Y-%m-%d"),
+            hobbies=hobbies_str,
+        )
+
+
+# Example usage
+if __name__ == "__main__":
+    # Parsing
+    input_string = """
+Name: John Doe
+Age: 30
+Birthday: 1993-05-15
+Hobbies: reading, swimming, coding
+"""
+    parsed_data = PersonFormatter.parse(input_string)
+    print("Parsed data:", parsed_data)
+
+    # Formatting
+    person_data = {
+        "name": "Jane Smith",
+        "age": 25,
+        "birthday": datetime(1998, 8, 22).date(),
+        "hobbies": ["painting", "yoga", "traveling"],
+    }
+    formatted_string = PersonFormatter.format(person_data)
+    print("\nFormatted string:")
+    print(formatted_string)
+
+    # Demonstrating bidirectional conversion
+    print("\nBidirectional conversion:")
+    original_string = """
+Name: Alice Johnson
+Age: 35
+Birthday: 1988-12-01
+Hobbies: gardening, photography, cooking
+"""
+    print("Original:")
+    print(original_string)
+    parsed = PersonFormatter.parse(original_string)
+    print("Parsed:", parsed)
+    reformatted = PersonFormatter.format(parsed)
+    print("Reformatted:")
+    print(reformatted)

langroid/agent/tools/parse_example2.py

@@ -0,0 +1,87 @@
+from parse import parse
+
+# Define the format string
+format_string = """
+name:{:s}
+{:d} is the age
+lives in {:s}
+"""
+
+
+def parse_person_info(input_string):
+    # Remove leading/trailing whitespace and split into lines
+    lines = input_string.strip().split("\n")
+
+    # Join the lines with a single newline
+    normalized_input = "\n".join(line.strip() for line in lines if line.strip())
+
+    # Parse the normalized input
+    result = parse(format_string, normalized_input)
+
+    if result:
+        name, age, city = result
+        return f"Name: {name.strip()}, Age: {age}, City: {city.strip()}"
+    else:
+        return "Parsing failed"
+
+
+# Test cases and assertions
+if __name__ == "__main__":
+    # Test case 1: Standard format
+    input1 = """
+    name: Beck
+    30 is the age
+    lives in Tokyo
+    """
+    assert (
+        parse_person_info(input1) == "Name: Beck, Age: 30, City: Tokyo"
+    ), "Test case 1 failed"
+
+    # Test case 2: Extra whitespace
+    input2 = """
+    name:    Beck    
+      30     is    the    age  
+    lives    in    Tokyo
+    """
+    assert (
+        parse_person_info(input2) == "Name: Beck, Age: 30, City: Tokyo"
+    ), "Test case 2 failed"
+
+    # Test case 3: Extra newlines
+    input3 = """
+    name:Beck
+
+
+    30 is the age
+
+    lives in Tokyo
+    """
+    assert (
+        parse_person_info(input3) == "Name: Beck, Age: 30, City: Tokyo"
+    ), "Test case 3 failed"
+
+    # Test case 4: Minimal whitespace
+    input4 = "name:John\n25 is the age\nlives in NewYork"
+    assert (
+        parse_person_info(input4) == "Name: John, Age: 25, City: NewYork"
+    ), "Test case 4 failed"
+
+    # Test case 5: Different name, age, city
+    input5 = """
+    name: Alice Johnson
+    42 is the age
+    lives in San Francisco
+    """
+    assert (
+        parse_person_info(input5) == "Name: Alice Johnson, Age: 42, City: San Francisco"
+    ), "Test case 5 failed"
+
+    # Test case 6: Invalid format (should return "Parsing failed")
+    input6 = """
+    name: Invalid
+    not a number is the age
+    lives in Nowhere
+    """
+    assert parse_person_info(input6) == "Parsing failed", "Test case 6 failed"
+
+    print("All tests passed successfully!")

langroid/agent/tools/parse_example3.py

@@ -0,0 +1,42 @@
+from parse import parse
+
+# Define the parse specification
+parse_spec = """
+<format>
+name{:s}{:>}{}\n
+age{:s}{:>}{}\n
+</format>
+"""
+
+
+def parse_info(input_string):
+    print(f"Input string:\n{input_string}")  # Debug print
+    result = parse(parse_spec, input_string, case_sensitive=False)
+    print(f"Parse result: {result}")  # Debug print
+    if result:
+        name = result[1].strip()  # The actual name value is in the second group
+        age = result[3].strip()  # The actual age value is in the fourth group
+        return name, age
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    # Test case 1: Standard format
+    input_string1 = """
+<format>
+name      beck
+age   30
+</format>
+"""
+    print("\nTest case 1:")
+    result1 = parse_info(input_string1)
+    print(f"Test 1 result: {result1}")
+    assert result1 == (
+        "beck",
+        "30",
+    ), f"Test 1 failed. Expected ('beck', '30'), got {result1}"
+
+    # Additional test cases...
+
+    print("All tests passed successfully!")