"""Create logic_validator
Generated by Phi-Octopus Eden
2025-11-06 00:27:50.791773
"""

```python
def create_logic_validator(logic_str: str) -> callable:
    """
    Creates a logic validator function from a string representation of logical conditions.
    
    Args:
        logic_str (str): A string representing a logical condition, e.g., "x > 5 and y <= 10"
        
    Returns:
        callable: A function that takes variables as arguments and returns True if the condition is met, False otherwise.

    Example usage:
    >>> validator = create_logic_validator("age >= 18")
    >>> validator(age=21)
    True
    >>> validator(age=17)
    False
    """
    import ast
    
    class ConditionBuilder(ast.NodeVisitor):
        def visit_BoolOp(self, node: ast.BoolOp) -> None:
            if isinstance(node.op, ast.And):
                for value in node.values:
                    self.generic_visit(value)
            else:
                raise ValueError("Only AND operations are supported.")
        
        def visit_Name(self, node: ast.Name) -> None:
            self.var_name = node.id
        
        def visit_Constant(self, node: ast.Constant) -> None:
            self.constant_value = node.value
            
        def visit_Compare(self, node: ast.Compare) -> None:
            self.visit(node.left)
            left_val = locals().get('constant_value', locals().get('var_name'))
            
            for comparator, value in zip(node.ops, node.comparators):
                if isinstance(comparator, (ast.Gt, ast.Lt, ast.GtE, ast.LtE)):
                    result = eval(f"{left_val} {comparator.__class__.__name__[1:]} {value}")
                    self.constant_value = int(result)
                elif comparator == ast.Eq:
                    self.constant_value = left_val == value
                elif comparator == ast.NotEq:
                    self.constant_value = left_val != value
            return self.constant_value
        
        def visit(self, node):
            super().visit(node)
    
    tree = ast.parse(logic_str, mode='eval')
    builder = ConditionBuilder()
    builder.visit(tree.body)

    def validator(*args):
        locals().update(zip(builder.var_name.split(','), args))
        return eval(f"{builder.constant_value}")
    
    return validator


# Example usage
validator = create_logic_validator("x >= 10 and y <= 5")
print(validator(x=12, y=4))  # True
print(validator(x=8, y=6))   # False

validator = create_logic_validator("age >= 18 and income > 50000")
print(validator(age=21, income=55000))  # True
print(validator(age=17, income=49000))  # False
```
```python
# This is a separate test function to demonstrate the usage and validate the logic validator's correctness.
def test_logic_validator():
    validator = create_logic_validator("x >= 10 and y <= 5")
    assert validator(x=12, y=4) == True, "Test case 1 failed"
    assert validator(x=8, y=6) == False, "Test case 2 failed"
    
    validator = create_logic_validator("age >= 18 and income > 50000")
    assert validator(age=21, income=55000) == True, "Test case 3 failed"
    assert validator(age=17, income=49000) == False, "Test case 4 failed"

test_logic_validator()
```