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

langroid/agent/tools/grammar_based_model_parsimonious.py-e

@@ -1,120 +0,0 @@
-from typing import Dict, ClassVar
-from pydantic import BaseModel
-from parsimonious import Grammar, NodeVisitor
-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':
-        grammar = Grammar(cls.get_grammar())
-        tree = grammar.parse(text[len(cls.start_token):-len(cls.end_token)].strip())
-
-        class ModelVisitor(NodeVisitor):
-            def __init__(self, field_mappings):
-                self.field_mappings = field_mappings
-                self.data = {}
-
-            def generic_visit(self, node, visited_children):
-                return visited_children or node.text
-
-            def visit_start(self, node, visited_children):
-                return self.data
-
-            def __getattr__(self, name):
-                if name.startswith('visit_'):
-                    field = name[6:]
-                    if field in self.field_mappings.values():
-                        def visit_method(node, visited_children):
-                            model_field = next(k for k, v in self.field_mappings.items() if v == field)
-                            self.data[model_field] = node.text.strip()
-                            return node.text
-                        return visit_method
-                return super().__getattribute__(name)
-
-        visitor = ModelVisitor(cls.field_mappings)
-        model_dict = visitor.visit(tree)
-        return cls(**model_dict)
-
-    def generate(self) -> str:
-        grammar = Grammar(self.get_grammar())
-
-        class ModelGenerator(NodeVisitor):
-            def __init__(self, model):
-                self.model = model
-
-            def generic_visit(self, node, visited_children):
-                return ''.join(filter(None, visited_children))
-
-            def __getattr__(self, name):
-                if name.startswith('visit_'):
-                    field = name[6:]
-                    if field in self.model.field_mappings.values():
-                        model_field = next(k for k, v in self.model.field_mappings.items() if v == field)
-                        return lambda node, children: str(getattr(self.model, model_field))
-                return lambda node, children: node.text
-
-        generator = ModelGenerator(self)
-        generated_content = generator.visit(grammar['start'])
-        return f"{self.start_token}\n{generated_content}\n{self.end_token}"
-
-class PersonSpec(GrammarBasedModel):
-    name: str
-    age: int
-    city: str
-
-    grammar = r"""
-        start = name_line age_line city_line
-        name_line = "name:" ws name newline
-        age_line = "age is" ws age newline
-        city_line = "lives in" ws city newline?
-        name = ~r"[^\n]+"
-        age = ~r"\d+"
-        city = ~r"[^\n]+"
-        ws = ~r"\s+"
-        newline = ~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_pyparsing.py

@@ -1,105 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict
-
-from pyparsing import *
-
-from langroid.pydantic_v1 import BaseModel
-
-
-class GrammarBasedModel(BaseModel, ABC):
-    @classmethod
-    @abstractmethod
-    def grammar(cls) -> ParserElement:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def start_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def end_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        pass
-
-    @classmethod
-    def parse(cls, text: str) -> "GrammarBasedModel":
-        full_grammar = (
-            Suppress(cls.start_token()) + cls.grammar() + Suppress(cls.end_token())
-        )
-        parsed = full_grammar.parseString(text, parseAll=True)
-        return cls(
-            **{
-                field: parsed[token][-1]
-                for field, token in cls.field_mappings().items()
-            }
-        )
-
-    def generate(self) -> str:
-        result = [self.start_token()]
-        for field, token in self.field_mappings().items():
-            value = getattr(self, field)
-            if token == "name":
-                result.append(f"name: {value}")
-            elif token == "age":
-                result.append(f"age is {value}")
-            elif token == "city":
-                result.append(f"lives in {value}")
-        result.append(self.end_token())
-        return "\n".join(result)
-
-
-class PersonSpec(GrammarBasedModel):
-    name: str
-    age: int
-    city: str
-
-    @classmethod
-    def grammar(cls):
-        name = Group(Literal("name:") + Word(alphas))("name")
-        age = Group(Literal("age is") + Word(nums))("age")
-        city = Group(Literal("lives in") + Word(alphas))("city")
-        return name + age + city
-
-    @classmethod
-    def start_token(cls):
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls):
-        return "</spec>"
-
-    @classmethod
-    def field_mappings(cls):
-        return {"name": "name", "age": "age", "city": "city"}
-
-
-if __name__ == "__main__":
-    # Test parsing
-    test_string = """
-    <spec>
-    name: John
-    age is 30
-    lives in Tokyo
-    </spec>
-    """
-    parsed_person = PersonSpec.parse(test_string)
-    print("Parsed person:", parsed_person)
-
-    # Test generating
-    new_person = PersonSpec(name="Alice", age=25, city="NewYork")
-    generated_string = new_person.generate()
-    print("\nGenerated string:")
-    print(generated_string)
-
-    # Test round-trip
-    round_trip_person = PersonSpec.parse(generated_string)
-    print("\nRound-trip parsed person:", round_trip_person)
-
-    assert new_person == round_trip_person, "Round-trip parsing failed"
-    print("\nRound-trip test passed!")

langroid/agent/tools/grammar_based_model_pyparsing.py-e

@@ -1,103 +0,0 @@
-from pydantic import BaseModel
-from pyparsing import *
-from abc import ABC, abstractmethod
-from typing import Dict, Any
-
-class GrammarBasedModel(BaseModel, ABC):
-    @classmethod
-    @abstractmethod
-    def grammar(cls) -> ParserElement:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def start_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def end_token(cls) -> str:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        pass
-
-    @classmethod
-    def parse(cls, text: str) -> 'GrammarBasedModel':
-        full_grammar = (
-            Suppress(cls.start_token()) +
-            cls.grammar() +
-            Suppress(cls.end_token())
-        )
-        parsed = full_grammar.parseString(text, parseAll=True)
-        return cls(**{field: parsed[token][-1] for field, token in cls.field_mappings().items()})
-
-    def generate(self) -> str:
-        result = [self.start_token()]
-        for field, token in self.field_mappings().items():
-            value = getattr(self, field)
-            if token == "name":
-                result.append(f"name: {value}")
-            elif token == "age":
-                result.append(f"age is {value}")
-            elif token == "city":
-                result.append(f"lives in {value}")
-        result.append(self.end_token())
-        return "\n".join(result)
-
-class PersonSpec(GrammarBasedModel):
-    name: str
-    age: int
-    city: str
-
-    @classmethod
-    def grammar(cls):
-        name = Group(Literal("name:") + Word(alphas))("name")
-        age = Group(Literal("age is") + Word(nums))("age")
-        city = Group(Literal("lives in") + Word(alphas))("city")
-        return name + age + city
-
-    @classmethod
-    def start_token(cls):
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls):
-        return "</spec>"
-
-    @classmethod
-    def field_mappings(cls):
-        return {
-            "name": "name",
-            "age": "age",
-            "city": "city"
-        }
-
-if __name__ == "__main__":
-    # Test parsing
-    test_string = """
-    <spec>
-    name: John
-    age is 30
-    lives in Tokyo
-    </spec>
-    """
-    parsed_person = PersonSpec.parse(test_string)
-    print("Parsed person:", parsed_person)
-
-    # Test generating
-    new_person = PersonSpec(name="Alice", age=25, city="NewYork")
-    generated_string = new_person.generate()
-    print("\nGenerated string:")
-    print(generated_string)
-
-    # Test round-trip
-    round_trip_person = PersonSpec.parse(generated_string)
-    print("\nRound-trip parsed person:", round_trip_person)
-
-    assert new_person == round_trip_person, "Round-trip parsing failed"
-    print("\nRound-trip test passed!")
-    
-    

langroid/agent/tools/grammar_based_model_regex.py

@@ -1,139 +0,0 @@
-import re
-from abc import ABC, abstractmethod
-from typing import Dict
-
-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
-    @abstractmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        pass
-
-    @classmethod
-    def _create_regex_pattern(cls) -> str:
-        spec = cls.format_spec()
-        for field, placeholder in cls.field_mappings().items():
-            spec = spec.replace(placeholder, f"(?P<{field}>.*?)")
-        pattern = (
-            f"{re.escape(cls.start_token())}\\s*{spec}\\s*{re.escape(cls.end_token())}"
-        )
-        return pattern
-
-    @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()
-        # Remove \s* patterns
-        content = re.sub(r"\\s\*", " ", content)
-        for field, placeholder in self.field_mappings().items():
-            content = content.replace(placeholder, str(getattr(self, field)))
-        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:\\s*{name}\\s*age is\\s*{age}\\s*lives in\\s*{city}"
-
-    @classmethod
-    def start_token(cls) -> str:
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls) -> str:
-        return "</spec>"
-
-    @classmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        return {"name": "{name}", "age": "{age}", "city": "{city}"}
-
-
-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_regex.py-e

@@ -1,130 +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
-    @abstractmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        pass
-
-    @classmethod
-    def _create_regex_pattern(cls) -> str:
-        spec = cls.format_spec()
-        for field, placeholder in cls.field_mappings().items():
-            spec = spec.replace(placeholder, f"(?P<{field}>.*?)")
-        pattern = f"{re.escape(cls.start_token())}\\s*{spec}\\s*{re.escape(cls.end_token())}"
-        return pattern
-
-    @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()
-        # Remove \s* patterns
-        content = re.sub(r'\\s\*', ' ', content)
-        for field, placeholder in self.field_mappings().items():
-            content = content.replace(placeholder, str(getattr(self, field)))
-        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:\\s*{name}\\s*age is\\s*{age}\\s*lives in\\s*{city}"
-
-    @classmethod
-    def start_token(cls) -> str:
-        return "<spec>"
-
-    @classmethod
-    def end_token(cls) -> str:
-        return "</spec>"
-
-    @classmethod
-    def field_mappings(cls) -> Dict[str, str]:
-        return {
-            "name": "{name}",
-            "age": "{age}",
-            "city": "{city}"
-        }
-
-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!")