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

langroid/agent/tools/grammar_based_model_regex2.py

@@ -1,124 +0,0 @@
-import re
-from abc import ABC, abstractmethod
-
-from langroid.pydantic_v1 import BaseModel
-
-
-class FormattingModel(BaseModel, ABC):
-    @classmethod
-    @abstractmethod
-    def format_spec(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def start_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def end_token(cls) -> str:
-        pass
-
-    @classmethod
-    def _create_regex_pattern(cls) -> str:
-        spec = cls.format_spec()
-        # Replace {field_name} with (?P<field_name>.*?)
-        pattern = re.sub(r"\{(\w+)\}", lambda m: f"(?P<{m.group(1)}>.*?)", spec)
-        # Replace newlines with \s* to allow flexible whitespace
-        pattern = pattern.replace("\n", r"\s*")
-        return f"{re.escape(cls.start_token())}\\s*{pattern}\\s*{re.escape(cls.end_token())}"
-
-    @classmethod
-    def parse(cls, text: str) -> "FormattingModel":
-        pattern = cls._create_regex_pattern()
-        match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
-        if match:
-            return cls(**{k: v.strip() for k, v in match.groupdict().items()})
-        raise ValueError(
-            f"Text does not match the expected format. Pattern: {pattern}, Text: {text}"
-        )
-
-    def generate(self) -> str:
-        content = self.format_spec().format(**self.dict())
-        return f"{self.start_token()}\n{content}\n{self.end_token()}"
-
-
-class PersonModel(FormattingModel):
-    name: str
-    age: int
-    city: str
-
-    @classmethod
-    def format_spec(cls) -> str:
-        return "name: {name}\nage is {age}\nlives in {city}"
-
-    @classmethod
-    def start_token(cls) -> str:
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls) -> str:
-        return "</spec>"
-
-
-def test_round_trip(model_class, input_string):
-    # Parse the input string
-    parsed_model = model_class.parse(input_string)
-    print(f"Parsed model: {parsed_model}")
-
-    # Generate a string from the parsed model
-    generated_string = parsed_model.generate()
-    print(f"Generated string:\n{generated_string}")
-
-    # Parse the generated string
-    reparsed_model = model_class.parse(generated_string)
-    print(f"Reparsed model: {reparsed_model}")
-
-    # Assert that the original parsed model and the reparsed model are equal
-    assert (
-        parsed_model == reparsed_model
-    ), "Round trip failed: original and reparsed models are not equal"
-
-    # Assert that all fields are present and have the correct types
-    for field, field_type in model_class.__annotations__.items():
-        assert hasattr(parsed_model, field), f"Field {field} is missing"
-        assert isinstance(
-            getattr(parsed_model, field), field_type
-        ), f"Field {field} has incorrect type"
-
-    print("Round trip test passed successfully!")
-
-
-if __name__ == "__main__":
-    # Test case 1: Standard formatting
-    test_string1 = """
-    <spec>
-    name: John Doe
-    age is 30
-    lives in New York
-    </spec>
-    """
-    test_round_trip(PersonModel, test_string1)
-
-    print("\n" + "=" * 50 + "\n")
-
-    # Test case 2: Varying whitespace
-    test_string2 = "<spec>name:   Alice  \nage is    25   \nlives in    Tokyo</spec>"
-    test_round_trip(PersonModel, test_string2)
-
-    print("\n" + "=" * 50 + "\n")
-
-    # Test case 3: Multiline values
-    test_string3 = """
-    <spec>
-    name: Bob
-    Smith
-    age is 40
-    lives in San
-    Francisco
-    </spec>
-    """
-    test_round_trip(PersonModel, test_string3)
-
-    print("All tests passed successfully!")

langroid/agent/tools/grammar_based_model_regex2.py-e

@@ -1,116 +0,0 @@
-import re
-from abc import ABC, abstractmethod
-from typing import Dict, Any
-from pydantic import BaseModel
-
-class FormattingModel(BaseModel, ABC):
-    @classmethod
-    @abstractmethod
-    def format_spec(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def start_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def end_token(cls) -> str:
-        pass
-
-    @classmethod
-    def _create_regex_pattern(cls) -> str:
-        spec = cls.format_spec()
-        # Replace {field_name} with (?P<field_name>.*?)
-        pattern = re.sub(r'\{(\w+)\}', lambda m: f'(?P<{m.group(1)}>.*?)', spec)
-        # Replace newlines with \s* to allow flexible whitespace
-        pattern = pattern.replace('\n', r'\s*')
-        return f"{re.escape(cls.start_token())}\\s*{pattern}\\s*{re.escape(cls.end_token())}"
-
-    @classmethod
-    def parse(cls, text: str) -> 'FormattingModel':
-        pattern = cls._create_regex_pattern()
-        match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
-        if match:
-            return cls(**{k: v.strip() for k, v in match.groupdict().items()})
-        raise ValueError(f"Text does not match the expected format. Pattern: {pattern}, Text: {text}")
-
-    def generate(self) -> str:
-        content = self.format_spec().format(**self.dict())
-        return f"{self.start_token()}\n{content}\n{self.end_token()}"
-
-class PersonModel(FormattingModel):
-    name: str
-    age: int
-    city: str
-
-    @classmethod
-    def format_spec(cls) -> str:
-        return "name: {name}\nage is {age}\nlives in {city}"
-
-    @classmethod
-    def start_token(cls) -> str:
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls) -> str:
-        return "</spec>"
-
-def test_round_trip(model_class, input_string):
-    # Parse the input string
-    parsed_model = model_class.parse(input_string)
-    print(f"Parsed model: {parsed_model}")
-
-    # Generate a string from the parsed model
-    generated_string = parsed_model.generate()
-    print(f"Generated string:\n{generated_string}")
-
-    # Parse the generated string
-    reparsed_model = model_class.parse(generated_string)
-    print(f"Reparsed model: {reparsed_model}")
-
-    # Assert that the original parsed model and the reparsed model are equal
-    assert parsed_model == reparsed_model, "Round trip failed: original and reparsed models are not equal"
-
-    # Assert that all fields are present and have the correct types
-    for field, field_type in model_class.__annotations__.items():
-        assert hasattr(parsed_model, field), f"Field {field} is missing"
-        assert isinstance(getattr(parsed_model, field), field_type), f"Field {field} has incorrect type"
-
-    print("Round trip test passed successfully!")
-
-if __name__ == "__main__":
-    # Test case 1: Standard formatting
-    test_string1 = """
-    <spec>
-    name: John Doe
-    age is 30
-    lives in New York
-    </spec>
-    """
-    test_round_trip(PersonModel, test_string1)
-
-    print("\n" + "="*50 + "\n")
-
-    # Test case 2: Varying whitespace
-    test_string2 = "<spec>name:   Alice  \nage is    25   \nlives in    Tokyo</spec>"
-    test_round_trip(PersonModel, test_string2)
-
-    print("\n" + "="*50 + "\n")
-
-    # Test case 3: Multiline values
-    test_string3 = """
-    <spec>
-    name: Bob
-    Smith
-    age is 40
-    lives in San
-    Francisco
-    </spec>
-    """
-    test_round_trip(PersonModel, test_string3)
-
-    print("All tests passed successfully!")
-    
-    

langroid/agent/tools/grammar_based_model_tatsu.py

@@ -1,80 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import ClassVar, Dict
-
-from tatsu import compile as compile_grammar
-from tatsu.model import ModelBuilder
-
-from langroid.pydantic_v1 import BaseModel
-
-
-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/grammar_based_model_tatsu.py-e

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

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

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