secondo-py/demo.py

#!/usr/bin/env python3
"""
PySECONDO Demo - Interactive demonstration

This script demonstrates the complete PySECONDO system.
"""

from pysecondo.core.nested_list import atom, list_nl
from pysecondo.core.types import parse_type
from pysecondo.parser.evaluator import Evaluator
from pysecondo.parser.parser import Parser, QueryCommand
from pysecondo.algebras.relation import RelationAlgebra
from pysecondo.algebras.standard import StandardAlgebra
from pysecondo.algebras.base import AlgebraManager
from pysecondo.storage.memory import MemoryStorage
import sys
sys.path.insert(0, '.')


def print_separator():
    print("=" * 60)


def demo_basic_arithmetic():
    """Demonstrate basic arithmetic operations"""
    print("\n" + "» " * 30)
    print("DEMO: Basic Arithmetic Operations")
    print("» " * 30)

    storage = MemoryStorage()
    algebra_manager = AlgebraManager()
    algebra_manager.register_algebra("StandardAlgebra", StandardAlgebra())

    parser = Parser()
    evaluator = Evaluator(algebra_manager, storage)

    queries = [
        "query 5 + 3",
        "query 10 - 4",
        "query 6 * 7",
        "query 20 / 4",
        "query 10 > 5",
        "query 5 = 5",
        "query true and false",
        "query not false",
    ]

    for query in queries:
        print(f"\n> {query}")
        cmd = parser.parse(query)
        if isinstance(cmd, QueryCommand):
            tokens = parser.parse_expression(cmd.expression)
            value, _ = evaluator.evaluate(tokens)
            print(f"Result: {value.to_python()}")


def demo_relation_operations():
    """Demonstrate relation operations"""
    print("\n" + "» " * 30)
    print("DEMO: Relation Operations")
    print("» " * 30)

    storage = MemoryStorage()
    algebra_manager = AlgebraManager()
    algebra_manager.register_algebra("StandardAlgebra", StandardAlgebra())
    algebra_manager.register_algebra(
        "RelationAlgebra", RelationAlgebra(storage))

    parser = Parser()
    evaluator = Evaluator(algebra_manager, storage)

    # Create cities relation
    print("\n> create cities : (rel (tuple ((Name string)(Population int))))")
    cities_type = parse_type('(rel (tuple ((Name string)(Population int))))')
    cities_data = list_nl(
        list_nl("Beijing", 21540000),
        list_nl("Shanghai", 24280000),
        list_nl("Guangzhou", 14040000),
        list_nl("Shenzhen", 17560000),
        list_nl("Hangzhou", 12200000),
    )
    storage.create_object("cities", cities_data, cities_type)
    print("Created: cities")

    # Query all cities
    print("\n> query cities feed consume")
    tokens = parser.parse_expression("cities feed consume")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value}")

    # Count cities
    print("\n> query cities feed count")
    tokens = parser.parse_expression("cities feed count")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value.to_python()}")

    # Filter with true (pass all)
    print("\n> query cities feed filter true consume")
    tokens = parser.parse_expression("cities feed filter true consume")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value}")

    # Filter with false (pass none)
    print("\n> query cities feed filter false count")
    tokens = parser.parse_expression("cities feed filter false count")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value.to_python()}")


def demo_complex_queries():
    """Demonstrate more complex queries"""
    print("\n" + "» " * 30)
    print("DEMO: Complex Queries")
    print("» " * 30)

    storage = MemoryStorage()
    algebra_manager = AlgebraManager()
    algebra_manager.register_algebra("StandardAlgebra", StandardAlgebra())
    algebra_manager.register_algebra(
        "RelationAlgebra", RelationAlgebra(storage))

    parser = Parser()
    evaluator = Evaluator(algebra_manager, storage)

    # Create products relation
    print("\n> create products : (rel (tuple ((Name string)(Price int)(Stock int))))")
    products_type = parse_type(
        '(rel (tuple ((Name string)(Price int)(Stock int))))')
    products_data = list_nl(
        list_nl("Laptop", 1000, 50),
        list_nl("Mouse", 25, 200),
        list_nl("Keyboard", 75, 150),
        list_nl("Monitor", 300, 75),
    )
    storage.create_object("products", products_data, products_type)
    print("Created: products")

    # Count products
    print("\n> query products feed count")
    tokens = parser.parse_expression("products feed count")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value.to_python()}")

    # Arithmetic on stored values (not directly from relation)
    print("\n> query 1000 + 25")
    tokens = parser.parse_expression("1000 + 25")
    value, _ = evaluator.evaluate(tokens)
    print(f"Result: {value.to_python()}")


def demo_system_capabilities():
    """Show system capabilities"""
    print("\n" + "» " * 30)
    print("PySECONDO System Capabilities")
    print("» " * 30)

    storage = MemoryStorage()
    algebra_manager = AlgebraManager()
    algebra_manager.register_algebra("StandardAlgebra", StandardAlgebra())
    algebra_manager.register_algebra(
        "RelationAlgebra", RelationAlgebra(storage))

    print("\nRegistered Algebras:")
    for alg_name in algebra_manager.list_algebras():
        print(f"  - {alg_name}")

    print("\nAvailable Operators:")
    for op_name in sorted(algebra_manager.list_operators()):
        alg = algebra_manager.get_algebra_for_operator(op_name)
        print(f"  - {op_name:15s} (from {alg.__class__.__name__})")

    print(f"\nTotal: {len(algebra_manager.list_operators())} operators")


def main():
    """Run all demos"""
    print_separator()
    print(" PySECONDO - Complete Demonstration")
    print(" A minimal SECONDO implementation in Python")
    print_separator()

    try:
        demo_basic_arithmetic()
        demo_relation_operations()
        demo_complex_queries()
        demo_system_capabilities()

        print("\n" + "» " * 30)
        print("All demos completed successfully!")
        print("» " * 30)

        print("\nTo try the interactive REPL, run:")
        print("  python3 -m pysecondo.repl")

    except Exception as e:
        print(f"\nError during demo: {e}")
        import traceback
        traceback.print_exc()


if __name__ == "__main__":
    main()