sqa 0.0.24 → 0.0.31

data/examples/rails_app/config/application.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'boot'
+
+require 'rails'
+require 'active_model/railtie'
+require 'active_job/railtie'
+require 'active_record/railtie'
+require 'action_controller/railtie'
+require 'action_view/railtie'
+require 'action_cable/railtie'
+require 'rails/test_unit/railtie'
+
+# Require the gems listed in Gemfile
+Bundler.require(*Rails.groups)
+
+module SqaRailsApp
+  class Application < Rails::Application
+    # Initialize configuration defaults for Rails 7.1
+    config.load_defaults 7.1
+
+    # Configuration for the application, engines, and railties
+    config.autoload_lib(ignore: %w(assets tasks))
+
+    # Add SQA library to load path
+    lib_path = File.expand_path('../../../lib', __dir__)
+    $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+    # API-only mode for API namespace
+    config.api_only = false
+
+    # Enable sessions
+    config.session_store :cookie_store, key: '_sqa_rails_session'
+
+    # Assets
+    config.assets.paths << Rails.root.join('app', 'assets', 'stylesheets')
+    config.assets.paths << Rails.root.join('app', 'assets', 'javascripts')
+
+    # Time zone
+    config.time_zone = 'UTC'
+
+    # Eager load in production
+    config.eager_load = Rails.env.production?
+  end
+end

data/examples/rails_app/config/boot.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require 'bundler/setup' # Set up gems listed in the Gemfile.

data/examples/rails_app/config/database.yml

@@ -0,0 +1,18 @@
+# SQLite3 database configuration
+
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+
+test:
+  <<: *default
+  database: db/test.sqlite3
+
+production:
+  <<: *default
+  database: db/production.sqlite3

data/examples/rails_app/config/environment.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Load the Rails application
+require_relative 'application'
+
+# Initialize SQA
+require 'sqa'
+SQA.init
+
+# Initialize the Rails application
+Rails.application.initialize!

data/examples/rails_app/config/routes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  # Root route
+  root 'dashboard#index'
+
+  # Dashboard routes
+  get 'dashboard/:ticker', to: 'dashboard#show', as: :stock_dashboard
+  get 'analyze/:ticker', to: 'analysis#show', as: :stock_analysis
+  get 'backtest/:ticker', to: 'backtest#show', as: :stock_backtest
+  get 'portfolio', to: 'portfolio#index', as: :portfolio
+
+  # API routes
+  namespace :api do
+    namespace :v1 do
+      get 'stock/:ticker', to: 'stocks#show'
+      get 'indicators/:ticker', to: 'stocks#indicators'
+      post 'backtest/:ticker', to: 'stocks#backtest'
+      get 'analyze/:ticker', to: 'stocks#analyze'
+      post 'compare/:ticker', to: 'stocks#compare'
+    end
+  end
+
+  # Health check
+  get 'up', to: 'rails/health#show', as: :rails_health_check
+end

data/examples/rails_app/config.ru

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file is used by Rack-based servers to start the application.
+
+require_relative 'config/environment'
+
+run Rails.application
+Rails.application.load_server

data/examples/realtime_stream_example.rb

@@ -0,0 +1,274 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Real-Time Stock Price Streaming
+#
+# This example shows how to use SQA::Stream to process live stock
+# price updates and generate trading signals in real-time.
+
+require 'sqa'
+
+SQA.init
+
+puts "=" * 60
+puts "Real-Time Stock Price Streaming Example"
+puts "=" * 60
+puts
+
+# Example 1: Basic Streaming with Single Strategy
+puts "\n" + "=" * 60
+puts "Example 1: Basic Streaming Setup"
+puts "=" * 60
+puts
+
+stream = SQA::Stream.new(
+  ticker: 'AAPL',
+  window_size: 100,
+  strategies: [SQA::Strategy::RSI]
+)
+
+puts "Stream initialized:"
+puts "  Ticker: #{stream.ticker}"
+puts "  Window Size: #{stream.window_size}"
+puts "  Strategies: #{stream.strategies.size}"
+puts
+
+# Add signal callback
+stream.on_signal do |signal, data|
+  puts "🔔 SIGNAL: #{signal.upcase}"
+  puts "   Price: $#{data[:price].round(2)}"
+  puts "   Time: #{data[:timestamp]}"
+  puts "   Strategy Votes: #{data[:strategies_vote]}"
+  puts
+end
+
+# Add update callback (optional - for monitoring)
+update_count = 0
+stream.on_update do |data|
+  update_count += 1
+  if update_count % 10 == 0
+    puts "📊 Update ##{update_count}: Price=$#{data[:price].round(2)}"
+  end
+end
+
+puts "Callbacks registered. Simulating price updates..."
+puts "-" * 60
+
+# Simulate real-time price updates
+# In production, these would come from a WebSocket or API
+stock = SQA::Stock.new(ticker: 'AAPL')
+prices = stock.df["adj_close_price"].to_a
+volumes = stock.df["volume"].to_a
+highs = stock.df["high_price"].to_a
+lows = stock.df["low_price"].to_a
+
+# Stream the last 150 data points as if they were real-time
+prices.last(150).each_with_index do |price, i|
+  stream.update(
+    price: price,
+    volume: volumes.last(150)[i],
+    high: highs.last(150)[i],
+    low: lows.last(150)[i],
+    timestamp: Time.now - (150 - i) * 60 # 1-minute intervals
+  )
+
+  # Simulate delay (in production, this happens naturally)
+  # sleep(0.01) # Uncomment for slower demo
+end
+
+puts "-" * 60
+puts "Streaming complete. Final statistics:"
+stats = stream.stats
+puts "  Total Updates: #{stats[:updates]}"
+puts "  Current Price: $#{stats[:current_price].round(2)}"
+puts "  Price Range: $#{stats[:price_range][:min].round(2)} - $#{stats[:price_range][:max].round(2)}"
+puts "  Last Signal: #{stats[:last_signal].upcase}"
+puts
+
+# Example 2: Multi-Strategy Streaming
+puts "\n" + "=" * 60
+puts "Example 2: Multi-Strategy Consensus"
+puts "=" * 60
+puts
+
+multi_stream = SQA::Stream.new(
+  ticker: 'MSFT',
+  window_size: 100,
+  strategies: [
+    SQA::Strategy::RSI,
+    SQA::Strategy::MACD,
+    SQA::Strategy::BollingerBands,
+    SQA::Strategy::Stochastic
+  ]
+)
+
+puts "Multi-strategy stream configured with:"
+multi_stream.strategies.each_with_index do |strategy, i|
+  puts "  #{i + 1}. #{strategy}"
+end
+puts
+
+signal_log = []
+
+multi_stream.on_signal do |signal, data|
+  signal_log << { signal: signal, price: data[:price], votes: data[:strategies_vote] }
+  puts "🎯 CONSENSUS SIGNAL: #{signal.upcase}"
+  puts "   Price: $#{data[:price].round(2)}"
+  puts "   Strategy Votes: #{data[:strategies_vote]}"
+  puts "   Time: #{data[:timestamp].strftime('%Y-%m-%d %H:%M:%S')}"
+  puts
+end
+
+puts "Simulating market data stream..."
+puts "-" * 60
+
+# Simulate streaming
+stock2 = SQA::Stock.new(ticker: 'MSFT')
+prices2 = stock2.df["adj_close_price"].to_a
+volumes2 = stock2.df["volume"].to_a
+
+prices2.last(100).each_with_index do |price, i|
+  multi_stream.update(
+    price: price,
+    volume: volumes2.last(100)[i],
+    timestamp: Time.now - (100 - i) * 60
+  )
+end
+
+puts "-" * 60
+puts "Multi-strategy streaming complete."
+puts "Signal summary:"
+signal_log.each_with_index do |log, i|
+  puts "  #{i + 1}. #{log[:signal].to_s.upcase} at $#{log[:price].round(2)} (votes: #{log[:votes]})"
+end
+puts
+
+# Example 3: Custom Indicator Access
+puts "\n" + "=" * 60
+puts "Example 3: Accessing Real-Time Indicators"
+puts "=" * 60
+puts
+
+indicator_stream = SQA::Stream.new(
+  ticker: 'GOOGL',
+  window_size: 50
+)
+
+# Stream some data first
+stock3 = SQA::Stock.new(ticker: 'GOOGL')
+stock3.df["adj_close_price"].to_a.last(50).each do |price|
+  indicator_stream.update(price: price)
+end
+
+puts "Current market data:"
+puts "  Current Price: $#{indicator_stream.current_price.round(2)}"
+puts "  Recent Prices (last 5): #{indicator_stream.recent_prices(5).map { |p| p.round(2) }}"
+puts
+
+puts "Real-time indicators:"
+rsi = indicator_stream.indicator(:rsi, period: 14)
+sma_20 = indicator_stream.indicator(:sma, period: 20)
+ema_12 = indicator_stream.indicator(:ema, period: 12)
+macd_data = indicator_stream.indicator(:macd)
+
+puts "  RSI(14): #{rsi.last.round(2)}"
+puts "  SMA(20): $#{sma_20.last.round(2)}"
+puts "  EMA(12): $#{ema_12.last.round(2)}"
+puts "  MACD: #{macd_data[0].last.round(4)}"
+puts "  Signal: #{macd_data[1].last.round(4)}"
+puts
+
+# Example 4: Production-Style WebSocket Simulation
+puts "\n" + "=" * 60
+puts "Example 4: Production WebSocket Pattern"
+puts "=" * 60
+puts
+
+class MockWebSocket
+  def initialize(ticker)
+    @ticker = ticker
+    @stock = SQA::Stock.new(ticker: ticker)
+    @prices = @stock.df["adj_close_price"].to_a
+    @index = @prices.size - 100
+  end
+
+  def on_message(&block)
+    @message_handler = block
+  end
+
+  def start
+    puts "📡 WebSocket connected to #{@ticker} market data feed"
+    puts "   Streaming live prices..."
+    puts
+
+    # Simulate receiving messages
+    (@index...@prices.size).each do |i|
+      # Simulate WebSocket message
+      message = {
+        symbol: @ticker,
+        price: @prices[i],
+        volume: rand(1_000_000..10_000_000),
+        timestamp: Time.now
+      }
+
+      @message_handler.call(message) if @message_handler
+
+      # sleep(0.1) # Uncomment for slower demo
+    end
+
+    puts "   WebSocket closed"
+  end
+end
+
+# Initialize stream for production pattern
+production_stream = SQA::Stream.new(
+  ticker: 'TSLA',
+  window_size: 100,
+  strategies: [
+    SQA::Strategy::RSI,
+    SQA::Strategy::MACD,
+    SQA::Strategy::BollingerBands
+  ]
+)
+
+# Set up signal handling
+production_stream.on_signal do |signal, data|
+  # In production, this would trigger:
+  # - Alert notifications
+  # - Automated trading execution
+  # - Logging to database
+  # - Risk management checks
+
+  puts "⚡ TRADING SIGNAL: #{signal.upcase}"
+  puts "   Execute #{signal} order for #{data[:price]}"
+  puts "   Consensus: #{data[:strategies_vote]}"
+  puts
+end
+
+# Set up WebSocket (mock)
+ws = MockWebSocket.new('TSLA')
+
+ws.on_message do |message|
+  # Feed WebSocket data into stream processor
+  production_stream.update(
+    price: message[:price],
+    volume: message[:volume],
+    timestamp: message[:timestamp]
+  )
+end
+
+# Start streaming
+ws.start
+
+puts "-" * 60
+puts "Production simulation complete."
+puts
+
+puts "All streaming examples complete!"
+puts
+puts "In production, connect to real WebSocket feeds from:"
+puts "  - Alpha Vantage WebSocket API"
+puts "  - Yahoo Finance Streaming"
+puts "  - Interactive Brokers TWS API"
+puts "  - Polygon.io WebSocket"
+puts "  - Alpaca Markets WebSocket"

data/examples/sinatra_app/Gemfile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+ruby '>= 3.2.0'
+
+# Web framework
+gem 'sinatra', '~> 4.0'
+gem 'sinatra-contrib', '~> 4.0'
+gem 'puma', '~> 6.0'
+
+# JSON handling
+gem 'json', '~> 2.7'
+
+# SQA library (assumes it's in parent directory)
+# In production, this would be:
+# gem 'sqa'
+# For development, we'll load from local path via require in app.rb
+
+group :development do
+  gem 'rerun'  # Auto-reload on file changes
+end

data/examples/sinatra_app/QUICKSTART.md

@@ -0,0 +1,159 @@
+# SQA Web App - Quick Start Guide
+
+Get the SQA web application running in 5 minutes.
+
+## 1. Prerequisites
+
+```bash
+# Install TA-Lib (macOS)
+brew install ta-lib
+
+# Start Redis
+redis-server
+
+# Set API key (optional, uses Yahoo Finance as fallback)
+export AV_API_KEY="your_key_here"
+```
+
+## 2. Install Dependencies
+
+```bash
+cd examples/sinatra_app
+bundle install
+```
+
+## 3. Start the Application
+
+```bash
+ruby app.rb
+```
+
+The app will start on http://localhost:4567
+
+## 4. Quick Tour
+
+### Home Page
+- Click on any quick link ticker (AAPL, MSFT, etc.)
+- Or enter a custom ticker in the search box
+
+### Dashboard
+- View interactive price charts (candlestick or line)
+- See volume chart
+- Check RSI and MACD indicators
+- View key metrics (52-week high/low, current RSI, market regime)
+- Compare all strategies at once
+
+### Analysis Page
+- Market regime detection (bull/bear/sideways)
+- Seasonal patterns (best months and quarters)
+- FPOP (Future Period) analysis
+- Risk metrics (VaR, Sharpe ratio, max drawdown)
+
+### Backtest Page
+- Select a strategy (RSI, MACD, SMA, EMA, Bollinger Bands, KBS)
+- View detailed backtest results
+- Compare all strategies side-by-side
+
+## 5. Keyboard Shortcuts
+
+- `Ctrl/Cmd + K` - Open ticker search
+- `Escape` - Close modal
+
+## 6. API Examples
+
+### Get Stock Data
+```bash
+curl http://localhost:4567/api/stock/AAPL
+```
+
+### Get Technical Indicators
+```bash
+curl http://localhost:4567/api/indicators/AAPL
+```
+
+### Run Backtest
+```bash
+curl -X POST http://localhost:4567/api/backtest/AAPL \
+  -d "strategy=RSI"
+```
+
+### Get Market Analysis
+```bash
+curl http://localhost:4567/api/analyze/AAPL
+```
+
+### Compare Strategies
+```bash
+curl -X POST http://localhost:4567/api/compare/AAPL
+```
+
+## 7. Development Mode
+
+Auto-reload on file changes:
+
+```bash
+gem install rerun
+rerun 'ruby app.rb'
+```
+
+## 8. Troubleshooting
+
+**Port already in use:**
+```bash
+# Kill process on port 4567
+lsof -ti:4567 | xargs kill -9
+```
+
+**TA-Lib not found:**
+```bash
+# Reinstall TA-Lib
+brew reinstall ta-lib
+```
+
+**Redis connection error:**
+```bash
+# Start Redis
+redis-server &
+```
+
+**Stock data not loading:**
+- Check internet connection
+- Verify ticker symbol is valid
+- Try a different ticker (e.g., AAPL, MSFT, GOOGL)
+
+## 9. Popular Tickers
+
+Try these popular stocks:
+
+**Tech:**
+- AAPL (Apple)
+- MSFT (Microsoft)
+- GOOGL (Google)
+- AMZN (Amazon)
+- NVDA (NVIDIA)
+- TSLA (Tesla)
+
+**Finance:**
+- JPM (JP Morgan)
+- BAC (Bank of America)
+- GS (Goldman Sachs)
+
+**ETFs:**
+- SPY (S&P 500)
+- QQQ (NASDAQ 100)
+- DIA (Dow Jones)
+
+## 10. Next Steps
+
+- Explore different strategies on the Backtest page
+- Compare seasonal patterns across multiple stocks
+- Check market regime before making trade decisions
+- Use FPOP analysis to identify high-probability setups
+
+## Support
+
+See README.md for full documentation and API reference.
+
+---
+
+Happy analyzing! 📊