#!/usr/bin/env python3 """ Inference Examples for Stack 2.9 Demonstrates model capabilities across diverse coding tasks. Run: python inference_examples.py --provider ollama --model qwen2.5-coder:32b """ from typing import Dict, Any, List import argparse import sys from pathlib import Path # Import the model client (assuming running from project root) sys.path.insert(0, str(Path(__file__).parent / "stack-2.9-eval")) try: from model_client import create_model_client, ChatMessage except ImportError: print("Warning: Could not import model_client. Running in documentation mode.") create_model_client = None ChatMessage = None class InferenceExamples: """Collection of diverse inference examples.""" def __init__(self, client=None): self.client = client self.results = [] def run_example(self, name: str, prompt: str, messages: List[Dict] = None, **kwargs): """Run a single example and record results.""" print(f"\n{'='*60}") print(f"Example: {name}") print(f"{'='*60}") print(f"Prompt/Input:\n{prompt if prompt else 'Chat messages'}") print(f"\n{'─'*40}") if self.client: try: if messages: # Chat mode chat_messages = [ChatMessage(**m) for m in messages] result = self.client.chat(chat_messages, **kwargs) else: # Completion mode result = self.client.generate(prompt, **kwargs) print(f"Response:\n{result.text}") print(f"\n📊 Stats: {result.tokens} tokens, {result.duration:.2f}s") self.results.append({ "name": name, "prompt": prompt, "response": result.text, "tokens": result.tokens, "duration": result.duration }) except Exception as e: print(f"❌ Error: {e}") else: print("[Example would be executed here with a valid model client]") print(f"Expected response: Code generation or tool use for this task") def all_examples(self): """Run all example demonstrations.""" # 1. Simple Code Generation self.run_example( "1. Simple Function", "Write a Python function to calculate the factorial of a number using recursion." ) # 2. Algorithmic Problem self.run_example( "2. Data Structure", "Implement a LRU (Least Recently Used) cache in Python with O(1) operations." ) # 3. Code Explanation self.run_example( "3. Code Explanation", """Explain the following code: ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ```""" ) # 4. Debugging Assistance self.run_example( "4. Debugging", """Find and fix the bug in this code: ```python def find_duplicates(lst): duplicates = [] for i in range(len(lst)): for j in range(len(lst)): if i != j and lst[i] == lst[j] and lst[i] not in duplicates: duplicates.append(lst[i]) return duplicates ```""" ) # 5. Code Refactoring self.run_example( "5. Refactoring", """Refactor this code to be more Pythonic and efficient: ```python result = [] for i in range(10): if i % 2 == 0: result.append(i * i) ```""" ) # 6. API Integration self.run_example( "6. API Use", "Write a Python function that fetches data from a REST API with error handling and retries." ) # 7. File Operations with Tool Use (pattern demonstration) self.run_example( "7. File Operations", """Using OpenClaw tools, read a file named 'config.json' from the current directory, parse it as JSON, and then write a new file 'config_backup.json' with the same content but with an added field 'backup_date' set to today's date.""" ) # 8. Multi-step Workflow self.run_example( "8. Multi-step Workflow", """Task: Initialize a new Python project with proper structure. Steps: 1. Create project directory 'myproject' 2. Inside it, create src/, tests/, docs/ directories 3. Create a requirements.txt file with common packages 4. Create a README.md with project title and description 5. Create a basic Python module in src/ with a main function 6. Create a simple test in tests/ Provide the shell commands or tool calls to accomplish this.""" ) # 9. Complex System Design self.run_example( "9. System Design", """Design a simple task queue system in Python with the following components: - Task representation (with priority, dependencies, retry logic) - Queue management (add, remove, prioritize) - Worker pool that executes tasks concurrently - Result tracking and error handling Provide a high-level architecture and key code snippets.""" ) # 10. Web Development self.run_example( "10. Web Framework", "Create a simple Flask (or FastAPI) application with: - GET endpoint that returns JSON with a welcome message - POST endpoint that accepts user data and stores in memory - Error handling for invalid input - CORS middleware if using FastAPI" ) # 11. Code Translation self.run_example( "11. Code Translation", """Convert this JavaScript function to Python: ```javascript function filterUsers(users, minAge, activeOnly) { return users.filter(user => { if (activeOnly && !user.active) return false; if (user.age >= minAge) return true; return false; }); } ```""" ) # 12. Testing self.run_example( "12. Unit Tests", """Write pytest unit tests for this function: ```python def binary_search(arr, target): low, high = 0, len(arr) - 1 while low <= high: mid = (low + high) // 2 if arr[mid] == target: return mid elif arr[mid] < target: low = mid + 1 else: high = mid - 1 return -1 ```""" ) # 13. Data Processing self.run_example( "13. Data Analysis", """Given a CSV file 'sales.csv' with columns: date, product, quantity, price Write a Python script to: - Read the CSV - Add a 'revenue' column (quantity * price) - Group by product and sum revenue - Output top 10 products by revenue to 'top_products.csv'""" ) # 14. Concurrency self.run_example( "14. Async Programming", "Write an async Python function that concurrently fetches data from multiple URLs and returns results in order." ) # 15. Pattern Memory Retrieval (self-evolution concept) self.run_example( "15. Pattern Learning", """Based on learned patterns for 'recursive tree traversal', implement a function to compute the maximum depth of a binary tree. Use a递归 approach similar to previous successful solutions for tree problems.""" ) # Print summary self.print_summary() def print_summary(self): """Print summary of results.""" print(f"\n{'='*60}") print("SUMMARY") print(f"{'='*60}") print(f"Total Examples: {len(self.results)}") if self.results: total_tokens = sum(r['tokens'] for r in self.results if r['tokens']) total_duration = sum(r['duration'] for r in self.results if r['duration']) print(f"Total Tokens: {total_tokens}") print(f"Total Duration: {total_duration:.2f}s") if total_tokens > 0: tokens_per_sec = total_tokens / total_duration if total_duration > 0 else 0 print(f"Average Throughput: {tokens_per_sec:.1f} tokens/sec") print(f"{'='*60}\n") def main(): parser = argparse.ArgumentParser(description="Run inference examples with Stack 2.9") parser.add_argument("--provider", default="ollama", choices=["ollama", "openai", "anthropic", "openrouter", "together"], help="Model provider") parser.add_argument("--model", type=str, help="Model name (defaults to provider's default)") parser.add_argument("--api-key", type=str, help="API key (or set environment variable)") parser.add_argument("--temperature", type=float, default=0.2, help="Sampling temperature") parser.add_argument("--max-tokens", type=int, default=4096, help="Maximum tokens to generate") parser.add_argument("--list-only", action="store_true", help="List examples without running") args = parser.parse_args() # Create client if not list-only client = None if not args.list_only: if create_model_client: try: client = create_model_client( provider=args.provider, model=args.model, api_key=args.api_key ) print(f"✓ Using model: {client.get_model_name()}") print(f"✓ Provider: {args.provider}") except Exception as e: print(f"Failed to create client: {e}") print("Running in documentation mode...") client = None else: print("Model client not available. Running in documentation mode...") # Run examples examples = InferenceExamples(client) examples.all_examples() if __name__ == "__main__": main()