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

langroid/agent/tools/lark_example.py

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

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

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

@@ -1,42 +0,0 @@
-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!")