sqa_demo-sinatra 0.1.0 → 0.2.2

data/lib/sqa_demo/sinatra/helpers/api_helpers.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module SqaDemo
+  module Sinatra
+    module Helpers
+      module ApiHelpers
+        # Resolve strategy name to class
+        def resolve_strategy(strategy_name)
+          case strategy_name.upcase
+          when 'RSI' then SQA::Strategy::RSI
+          when 'SMA' then SQA::Strategy::SMA
+          when 'EMA' then SQA::Strategy::EMA
+          when 'MACD' then SQA::Strategy::MACD
+          when 'BOLLINGERBANDS' then SQA::Strategy::BollingerBands
+          when 'KBS' then SQA::Strategy::KBS
+          else SQA::Strategy::RSI
+          end
+        end
+
+        # Calculate all technical indicators
+        def calculate_all_indicators(opens, highs, lows, prices, volumes, n)
+          pad_array = ->(arr) { Array.new(n - arr.length, nil) + arr }
+
+          # Price indicators
+          rsi = pad_array.call(SQAI.rsi(prices, period: 14))
+          macd_result = SQAI.macd(prices)
+          macd_line = pad_array.call(macd_result[0])
+          macd_signal = pad_array.call(macd_result[1])
+          macd_hist = pad_array.call(macd_result[2])
+
+          bb_result = SQAI.bbands(prices)
+          bb_upper = pad_array.call(bb_result[0])
+          bb_middle = pad_array.call(bb_result[1])
+          bb_lower = pad_array.call(bb_result[2])
+
+          # Moving averages
+          sma_12 = pad_array.call(SQAI.sma(prices, period: 12))
+          sma_20 = pad_array.call(SQAI.sma(prices, period: 20))
+          sma_50 = pad_array.call(SQAI.sma(prices, period: 50))
+          ema_20 = pad_array.call(SQAI.ema(prices, period: 20))
+          wma_20 = pad_array.call(SQAI.wma(prices, period: 20))
+          dema_20 = pad_array.call(SQAI.dema(prices, period: 20))
+          tema_20 = pad_array.call(SQAI.tema(prices, period: 20))
+          kama_30 = pad_array.call(SQAI.kama(prices, period: 30))
+
+          # Momentum indicators
+          stoch_result = SQAI.stoch(highs, lows, prices)
+          stoch_slowk = pad_array.call(stoch_result[0])
+          stoch_slowd = pad_array.call(stoch_result[1])
+          mom_10 = pad_array.call(SQAI.mom(prices, period: 10))
+          cci_14 = pad_array.call(SQAI.cci(highs, lows, prices, period: 14))
+          willr_14 = pad_array.call(SQAI.willr(highs, lows, prices, period: 14))
+          roc_10 = pad_array.call(SQAI.roc(prices, period: 10))
+          adx_14 = pad_array.call(SQAI.adx(highs, lows, prices, period: 14))
+
+          # Volatility indicators
+          atr_14 = pad_array.call(SQAI.atr(highs, lows, prices, period: 14))
+
+          # Volume indicators
+          obv = pad_array.call(SQAI.obv(prices, volumes))
+          ad = pad_array.call(SQAI.ad(highs, lows, prices, volumes))
+          vol_sma_12 = pad_array.call(SQAI.sma(volumes, period: 12))
+          vol_sma_20 = pad_array.call(SQAI.sma(volumes, period: 20))
+          vol_sma_50 = pad_array.call(SQAI.sma(volumes, period: 50))
+          vol_ema_12 = pad_array.call(SQAI.ema(volumes, period: 12))
+          vol_ema_20 = pad_array.call(SQAI.ema(volumes, period: 20))
+
+          {
+            rsi: rsi, macd: macd_line, macd_signal: macd_signal, macd_hist: macd_hist,
+            bb_upper: bb_upper, bb_middle: bb_middle, bb_lower: bb_lower,
+            sma_12: sma_12, sma_20: sma_20, sma_50: sma_50, ema_20: ema_20,
+            wma_20: wma_20, dema_20: dema_20, tema_20: tema_20, kama_30: kama_30,
+            stoch_slowk: stoch_slowk, stoch_slowd: stoch_slowd, mom_10: mom_10,
+            cci_14: cci_14, willr_14: willr_14, roc_10: roc_10, adx_14: adx_14,
+            atr_14: atr_14, obv: obv, ad: ad,
+            vol_sma_12: vol_sma_12, vol_sma_20: vol_sma_20, vol_sma_50: vol_sma_50,
+            vol_ema_12: vol_ema_12, vol_ema_20: vol_ema_20
+          }
+        end
+
+        # Detect candlestick patterns
+        def detect_candlestick_patterns(opens, highs, lows, prices, dates, n)
+          pad_array = ->(arr) { Array.new(n - arr.length, nil) + arr }
+
+          cdl_doji = pad_array.call(SQAI.cdl_doji(opens, highs, lows, prices))
+          cdl_hammer = pad_array.call(SQAI.cdl_hammer(opens, highs, lows, prices))
+          cdl_shootingstar = pad_array.call(SQAI.cdl_shootingstar(opens, highs, lows, prices))
+          cdl_engulfing = pad_array.call(SQAI.cdl_engulfing(opens, highs, lows, prices))
+          cdl_morningstar = pad_array.call(SQAI.cdl_morningstar(opens, highs, lows, prices))
+          cdl_eveningstar = pad_array.call(SQAI.cdl_eveningstar(opens, highs, lows, prices))
+          cdl_harami = pad_array.call(SQAI.cdl_harami(opens, highs, lows, prices))
+          cdl_3whitesoldiers = pad_array.call(SQAI.cdl_3whitesoldiers(opens, highs, lows, prices))
+          cdl_3blackcrows = pad_array.call(SQAI.cdl_3blackcrows(opens, highs, lows, prices))
+          cdl_piercing = pad_array.call(SQAI.cdl_piercing(opens, highs, lows, prices))
+          cdl_darkcloudcover = pad_array.call(SQAI.cdl_darkcloudcover(opens, highs, lows, prices))
+          cdl_marubozu = pad_array.call(SQAI.cdl_marubozu(opens, highs, lows, prices))
+
+          pattern_defs = {
+            doji: { data: cdl_doji, name: 'Doji', type: :neutral },
+            hammer: { data: cdl_hammer, name: 'Hammer', type: :fixed, signal: 'bullish' },
+            shootingstar: { data: cdl_shootingstar, name: 'Shooting Star', type: :fixed, signal: 'bearish' },
+            engulfing: { data: cdl_engulfing, name: 'Engulfing', type: :directional },
+            morningstar: { data: cdl_morningstar, name: 'Morning Star', type: :fixed, signal: 'bullish' },
+            eveningstar: { data: cdl_eveningstar, name: 'Evening Star', type: :fixed, signal: 'bearish' },
+            harami: { data: cdl_harami, name: 'Harami', type: :directional },
+            whitesoldiers: { data: cdl_3whitesoldiers, name: 'Three White Soldiers', type: :fixed, signal: 'bullish' },
+            blackcrows: { data: cdl_3blackcrows, name: 'Three Black Crows', type: :fixed, signal: 'bearish' },
+            piercing: { data: cdl_piercing, name: 'Piercing', type: :fixed, signal: 'bullish' },
+            darkcloudcover: { data: cdl_darkcloudcover, name: 'Dark Cloud Cover', type: :fixed, signal: 'bearish' },
+            marubozu: { data: cdl_marubozu, name: 'Marubozu', type: :directional }
+          }
+
+          detected_patterns = []
+          pattern_defs.each do |_key, pdef|
+            pdef[:data].each_with_index do |val, i|
+              next if val.nil? || val == 0
+
+              signal = case pdef[:type]
+                       when :neutral then 'neutral'
+                       when :fixed then pdef[:signal]
+                       when :directional then val > 0 ? 'bullish' : 'bearish'
+                       end
+
+              detected_patterns << {
+                date: dates[i],
+                pattern: pdef[:name],
+                signal: signal,
+                strength: val.abs
+              }
+            end
+          end
+
+          detected_patterns.sort_by! { |p| p[:date] }.reverse!
+          detected_patterns.first(20)
+        end
+
+        # Filter indicators by period
+        def filter_indicators_by_period(dates, indicators, period)
+          all_arrays = [dates] + indicators.values
+          filtered = filter_by_period(*all_arrays, period: period)
+
+          result = { dates: filtered[0] }
+          indicators.keys.each_with_index do |key, i|
+            result[key] = filtered[i + 1]
+          end
+          result
+        end
+
+        # Analyze FPOP (Future Period Loss/Profit)
+        def analyze_fpop(stock, prices)
+          dates = stock.df["timestamp"].to_a.map(&:to_s)
+          last_date = Date.parse(dates.last)
+          fpop_period = 10
+          fpop_data = SQA::FPOP.fpl_analysis(prices, fpop: fpop_period)
+
+          # Generate future trading dates (skip weekends)
+          future_dates = []
+          current_date = last_date + 1
+          while future_dates.length < fpop_period
+            unless current_date.saturday? || current_date.sunday?
+              future_dates << current_date.to_s
+            end
+            current_date += 1
+          end
+
+          # Show last 5 historical predictions + 10 future predictions
+          num_historical = [5, dates.length - 1].min
+          recent_fpop = []
+
+          # Historical predictions with verification
+          hist_start = dates.length - num_historical - 1
+          (0...num_historical).each do |i|
+            idx = hist_start + i
+            target_idx = idx + 1
+            next if idx < 0 || idx >= fpop_data.length || target_idx >= prices.length
+
+            prev_price = prices[idx]
+            actual_price = prices[target_idx]
+            actual_change = ((actual_price - prev_price) / prev_price) * 100
+            actual_direction = actual_change > 0.1 ? 'UP' : (actual_change < -0.1 ? 'DOWN' : 'FLAT')
+
+            predicted_magnitude = fpop_data[idx][:magnitude]
+            difference = (predicted_magnitude - actual_change).abs
+            correct = difference <= 1.0
+
+            recent_fpop << {
+              date: dates[target_idx],
+              direction: fpop_data[idx][:direction],
+              magnitude: fpop_data[idx][:magnitude],
+              risk: fpop_data[idx][:risk],
+              interpretation: fpop_data[idx][:interpretation],
+              actual_change: actual_change.round(2),
+              actual_direction: actual_direction,
+              correct: correct,
+              is_future: false
+            }
+          end
+
+          # Future predictions
+          fpop_data.last(fpop_period).each_with_index do |f, i|
+            recent_fpop << {
+              date: future_dates[i],
+              direction: f[:direction],
+              magnitude: f[:magnitude],
+              risk: f[:risk],
+              interpretation: f[:interpretation],
+              actual_change: nil,
+              actual_direction: nil,
+              correct: nil,
+              is_future: true
+            }
+          end
+
+          recent_fpop
+        end
+      end
+    end
+  end
+end

data/lib/sqa_demo/sinatra/helpers/filters.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module SqaDemo
+  module Sinatra
+    module Helpers
+      module Filters
+        # Filter data arrays by time period
+        # period can be: "30d", "60d", "90d", "1q", "2q", "3q", "4q", "all"
+        def filter_by_period(dates, *data_arrays, period: 'all')
+          return [dates, *data_arrays] if period == 'all' || dates.empty?
+
+          # Parse dates (they're strings in YYYY-MM-DD format)
+          parsed_dates = dates.map { |d| Date.parse(d) }
+          latest_date = parsed_dates.max
+
+          # Calculate cutoff date based on period
+          cutoff_date = case period
+                        when '30d'
+                          latest_date - 30
+                        when '60d'
+                          latest_date - 60
+                        when '90d'
+                          latest_date - 90
+                        when '1q'
+                          latest_date - 63  # ~3 months = 1 quarter (63 trading days)
+                        when '2q'
+                          latest_date - 126 # ~6 months = 2 quarters
+                        when '3q'
+                          latest_date - 189 # ~9 months = 3 quarters
+                        when '4q'
+                          latest_date - 252 # ~12 months = 4 quarters
+                        else
+                          parsed_dates.min # "all" - keep everything
+                        end
+
+          # Find indices where date >= cutoff_date
+          indices = parsed_dates.each_with_index.select { |d, _i| d >= cutoff_date }.map(&:last)
+
+          # Filter all arrays by the same indices
+          filtered_dates = indices.map { |i| dates[i] }
+          filtered_data = data_arrays.map { |arr| indices.map { |i| arr[i] } }
+
+          [filtered_dates, *filtered_data]
+        end
+      end
+    end
+  end
+end

data/lib/sqa_demo/sinatra/helpers/formatting.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SqaDemo
+  module Sinatra
+    module Helpers
+      module Formatting
+        def format_percent(value)
+          sprintf("%.2f%%", value)
+        end
+
+        def format_currency(value)
+          sprintf("$%.2f", value)
+        end
+
+        def format_number(value)
+          value.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+        end
+
+        # Format comparison value based on type
+        def format_compare_value(value, format_type)
+          return '-' if value.nil?
+
+          case format_type
+          when :currency
+            sprintf('$%.2f', value)
+          when :currency_billions
+            sprintf('$%.2fB', value / 1_000_000_000.0)
+          when :percent
+            sprintf('%.2f%%', value)
+          when :percent_sign
+            prefix = value >= 0 ? '+' : ''
+            "#{prefix}#{sprintf('%.2f', value)}%"
+          when :percent_from_decimal
+            sprintf('%.1f%%', value * 100)
+          when :decimal2
+            sprintf('%.2f', value)
+          when :decimal3
+            sprintf('%.3f', value)
+          when :number
+            value.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+          else
+            value.to_s
+          end
+        end
+
+        # Find best/worst tickers for a given metric
+        def find_extremes(stocks_data, key, higher_is_better)
+          return [nil, nil] if higher_is_better.nil?
+
+          values = stocks_data.map { |t, d| [t, d[key]] }.reject { |_, v| v.nil? }
+          return [nil, nil] if values.empty?
+
+          sorted = values.sort_by { |_, v| v }
+          if higher_is_better
+            [sorted.last[0], sorted.first[0]]  # best is highest, worst is lowest
+          else
+            [sorted.first[0], sorted.last[0]]  # best is lowest, worst is highest
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sqa_demo/sinatra/helpers/stock_loader.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'sqa'
+require 'date'
+
+module SqaDemo
+  module Sinatra
+    module Helpers
+      module StockLoader
+        # Central method to load stock data and company info
+        # Returns a hash with :stock, :ticker, :company_name
+        # Raises an error if loading fails
+        def load_stock(ticker)
+          ticker = ticker.upcase
+          stock = SQA::Stock.new(ticker: ticker)
+          ticker_info = SQA::Ticker.lookup(ticker)
+          company_name = ticker_info[:name] if ticker_info
+
+          {
+            stock: stock,
+            ticker: ticker,
+            company_name: company_name
+          }
+        end
+
+        # Load stock with company overview (for company page and comparison)
+        # Returns extended hash with :overview, :exchange
+        def load_stock_with_overview(ticker)
+          result = load_stock(ticker)
+          stock = result[:stock]
+
+          # Get comprehensive company overview (convert string keys to symbols)
+          raw_overview = stock.overview || {}
+          overview = raw_overview.transform_keys(&:to_sym)
+
+          # Fallback to ticker lookup if overview is empty
+          if overview.empty?
+            ticker_info = SQA::Ticker.lookup(result[:ticker])
+            company_name = ticker_info[:name]&.strip if ticker_info
+            exchange = ticker_info[:exchange] if ticker_info
+          else
+            company_name = overview[:name]&.strip
+            exchange = overview[:exchange]
+          end
+
+          result.merge(
+            company_name: company_name,
+            overview: overview,
+            exchange: exchange
+          )
+        end
+
+        # Extract common price/volume data from stock dataframe
+        def extract_ohlcv(stock)
+          df = stock.df
+          {
+            dates: df["timestamp"].to_a.map(&:to_s),
+            opens: df["open_price"].to_a,
+            highs: df["high_price"].to_a,
+            lows: df["low_price"].to_a,
+            closes: df["adj_close_price"].to_a,
+            volumes: df["volume"].to_a
+          }
+        end
+
+        # Calculate basic price metrics
+        def calculate_price_metrics(prices)
+          current_price = prices.last
+          prev_price = prices[-2] || prices.last
+          change = current_price - prev_price
+          change_pct = prev_price > 0 ? (change / prev_price * 100) : 0
+
+          {
+            current_price: current_price,
+            prev_price: prev_price,
+            change: change,
+            change_pct: change_pct,
+            high_52w: prices.last(252).max,
+            low_52w: prices.last(252).min
+          }
+        end
+
+        # Calculate YTD return
+        def calculate_ytd_return(dates, prices)
+          current_year = Date.today.year
+          ytd_prices = dates.each_with_index
+                            .select { |d, _| Date.parse(d).year == current_year }
+                            .map { |_, i| prices[i] }
+
+          if ytd_prices.length > 1
+            ((ytd_prices.last - ytd_prices.first) / ytd_prices.first * 100).round(2)
+          end
+        end
+
+        # Calculate technical indicators for a stock
+        # Returns a hash of indicator values (last value for each)
+        def calculate_indicators(highs, lows, prices)
+          {
+            rsi: safe_indicator { SQAI.rsi(prices, period: 14).last },
+            macd: safe_indicator { SQAI.macd(prices)[0].last },
+            macd_signal: safe_indicator { SQAI.macd(prices)[1].last },
+            macd_hist: safe_indicator { SQAI.macd(prices)[2].last },
+            stoch_k: safe_indicator { SQAI.stoch(highs, lows, prices)[0].last },
+            stoch_d: safe_indicator { SQAI.stoch(highs, lows, prices)[1].last },
+            sma_50: safe_indicator { SQAI.sma(prices, period: 50).last },
+            sma_200: safe_indicator { SQAI.sma(prices, period: 200).last },
+            ema_20: safe_indicator { SQAI.ema(prices, period: 20).last },
+            bb_upper: safe_indicator { SQAI.bbands(prices)[0].last },
+            bb_middle: safe_indicator { SQAI.bbands(prices)[1].last },
+            bb_lower: safe_indicator { SQAI.bbands(prices)[2].last },
+            adx: safe_indicator { SQAI.adx(highs, lows, prices, period: 14).last },
+            atr: safe_indicator { SQAI.atr(highs, lows, prices, period: 14).last },
+            cci: safe_indicator { SQAI.cci(highs, lows, prices, period: 14).last },
+            willr: safe_indicator { SQAI.willr(highs, lows, prices, period: 14).last },
+            mom: safe_indicator { SQAI.mom(prices, period: 10).last },
+            roc: safe_indicator { SQAI.roc(prices, period: 10).last }
+          }
+        end
+
+        # Calculate risk metrics
+        def calculate_risk_metrics(prices)
+          returns = prices.each_cons(2).map { |a, b| (b - a) / a }
+          sharpe = safe_indicator { SQA::RiskManager.sharpe_ratio(returns) }
+          max_dd = safe_indicator { SQA::RiskManager.max_drawdown(prices) }
+          max_drawdown = max_dd ? max_dd[:max_drawdown] : nil
+
+          {
+            sharpe_ratio: sharpe,
+            max_drawdown: max_drawdown
+          }
+        end
+
+        # Fetch all comparison data for a single ticker
+        # This is used by the compare route for parallel fetching
+        def fetch_comparison_data(ticker)
+          data = load_stock_with_overview(ticker)
+          stock = data[:stock]
+          overview = data[:overview]
+
+          ohlcv = extract_ohlcv(stock)
+          prices = ohlcv[:closes]
+          volumes = ohlcv[:volumes]
+          dates = ohlcv[:dates]
+          highs = ohlcv[:highs]
+          lows = ohlcv[:lows]
+
+          # Calculate metrics
+          price_metrics = calculate_price_metrics(prices)
+          indicators = calculate_indicators(highs, lows, prices)
+          risk_metrics = calculate_risk_metrics(prices)
+
+          # Average volume
+          avg_volume = (volumes.sum.to_f / volumes.length).round
+
+          [ticker, {
+            ticker: ticker,
+            company_name: data[:company_name],
+            current_price: price_metrics[:current_price],
+            change: price_metrics[:change],
+            change_pct: price_metrics[:change_pct],
+            high_52w: price_metrics[:high_52w],
+            low_52w: price_metrics[:low_52w],
+            ytd_return: calculate_ytd_return(dates, prices),
+            avg_volume: avg_volume,
+            # Technical indicators
+            rsi: indicators[:rsi],
+            macd: indicators[:macd],
+            macd_signal: indicators[:macd_signal],
+            macd_hist: indicators[:macd_hist],
+            stoch_k: indicators[:stoch_k],
+            stoch_d: indicators[:stoch_d],
+            sma_50: indicators[:sma_50],
+            sma_200: indicators[:sma_200],
+            ema_20: indicators[:ema_20],
+            bb_upper: indicators[:bb_upper],
+            bb_middle: indicators[:bb_middle],
+            bb_lower: indicators[:bb_lower],
+            adx: indicators[:adx],
+            atr: indicators[:atr],
+            cci: indicators[:cci],
+            willr: indicators[:willr],
+            mom: indicators[:mom],
+            roc: indicators[:roc],
+            # Fundamental data from overview
+            pe_ratio: overview[:pe_ratio],
+            forward_pe: overview[:forward_pe],
+            peg_ratio: overview[:peg_ratio],
+            price_to_book: overview[:price_to_book_ratio],
+            eps: overview[:eps],
+            dividend_yield: overview[:dividend_yield],
+            profit_margin: overview[:profit_margin],
+            operating_margin: overview[:operating_margin_ttm],
+            roe: overview[:return_on_equity_ttm],
+            roa: overview[:return_on_assets_ttm],
+            market_cap: overview[:market_capitalization],
+            beta: overview[:beta],
+            analyst_target: overview[:analyst_target_price],
+            # Risk metrics
+            sharpe_ratio: risk_metrics[:sharpe_ratio],
+            max_drawdown: risk_metrics[:max_drawdown]
+          }]
+        rescue => e
+          [ticker, { error: e.message }]
+        end
+
+        # Safely execute indicator calculation, returning nil on error
+        def safe_indicator
+          yield
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end