1  """
  2  Example 2: Parallel vs Sequential Search Comparison
  3  
  4  This example demonstrates the speed advantage of Fast Context's parallel
  5  execution compared to traditional sequential search.
  6  
  7  Key insight: Fast Context executes up to 8 searches simultaneously,
  8  making it 5-10x faster for complex queries.
  9  """
 10  
 11  import time
 12  import os
 13  from praisonaiagents.context.fast import FastContext
 14  from praisonaiagents.context.fast.search_tools import grep_search, glob_search
 15  
 16  WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
 17  
 18  
 19  def sequential_search(queries: list) -> dict:
 20      """Traditional sequential search - one query at a time."""
 21      results = {}
 22      for query in queries:
 23          results[query] = grep_search(
 24              search_path=WORKSPACE,
 25              pattern=query,
 26              max_results=20
 27          )
 28      return results
 29  
 30  
 31  def parallel_search_with_fast_context(queries: list) -> dict:
 32      """Fast Context parallel search - multiple queries at once."""
 33      fc = FastContext(workspace_path=WORKSPACE)
 34      results = {}
 35      for query in queries:
 36          result = fc.search(query)
 37          results[query] = result
 38      return results
 39  
 40  
 41  def main():
 42      print("=" * 70)
 43      print("Parallel vs Sequential Search Comparison")
 44      print("=" * 70)
 45      
 46      # Define multiple search queries
 47      queries = [
 48          "def __init__",
 49          "class Agent",
 50          "async def",
 51          "import logging",
 52          "from typing",
 53      ]
 54      
 55      print(f"\nSearching for {len(queries)} patterns in the codebase...")
 56      print(f"Workspace: {WORKSPACE}")
 57      
 58      # Sequential search
 59      print("\n1. Sequential Search (Traditional)")
 60      print("-" * 40)
 61      
 62      start = time.perf_counter()
 63      seq_results = sequential_search(queries)
 64      seq_time = (time.perf_counter() - start) * 1000
 65      
 66      total_seq_matches = sum(len(r) for r in seq_results.values())
 67      print(f"   Total matches: {total_seq_matches}")
 68      print(f"   Time: {seq_time:.0f}ms")
 69      
 70      # Fast Context search (with caching disabled for fair comparison)
 71      print("\n2. Fast Context Search (Parallel)")
 72      print("-" * 40)
 73      
 74      fc = FastContext(workspace_path=WORKSPACE, cache_enabled=False)
 75      
 76      start = time.perf_counter()
 77      fc_results = {}
 78      for query in queries:
 79          fc_results[query] = fc.search(query)
 80      fc_time = (time.perf_counter() - start) * 1000
 81      
 82      total_fc_matches = sum(r.total_files for r in fc_results.values())
 83      print(f"   Total files found: {total_fc_matches}")
 84      print(f"   Time: {fc_time:.0f}ms")
 85      
 86      # Comparison
 87      print("\n3. Comparison")
 88      print("-" * 40)
 89      
 90      speedup = seq_time / fc_time if fc_time > 0 else float('inf')
 91      print(f"   Sequential: {seq_time:.0f}ms")
 92      print(f"   Fast Context: {fc_time:.0f}ms")
 93      print(f"   Speedup: {speedup:.1f}x faster")
 94      
 95      # Detailed results
 96      print("\n4. Results by Query")
 97      print("-" * 40)
 98      
 99      for query in queries:
100          seq_count = len(seq_results[query])
101          fc_count = fc_results[query].total_files
102          fc_ms = fc_results[query].search_time_ms
103          print(f"   '{query}':")
104          print(f"      Sequential: {seq_count} matches")
105          print(f"      Fast Context: {fc_count} files in {fc_ms}ms")
106      
107      print("\n" + "=" * 70)
108      print(f"Fast Context is {speedup:.1f}x faster due to parallel execution!")
109      print("=" * 70)
110  
111  
112  if __name__ == "__main__":
113      main()