sqa 0.0.24 → 0.0.31

data/lib/sqa/gp.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+=begin
+
+Genetic Programming for Trading Strategy Evolution
+
+This module implements a genetic algorithm to evolve trading strategy parameters.
+It optimizes indicator parameters (like RSI periods, MA lengths, etc.) to find
+profitable trading strategies through natural selection.
+
+Key Concepts:
+- Individual: A set of strategy parameters (chromosome)
+- Population: Collection of individuals
+- Fitness: Profitability measured by backtesting
+- Selection: Choosing best individuals to reproduce
+- Crossover: Combining parameters from two parent strategies
+- Mutation: Random parameter changes for diversity
+
+Example:
+  gp = SQA::GeneticProgram.new(
+    stock: stock,
+    population_size: 50,
+    generations: 100,
+    mutation_rate: 0.1
+  )
+
+  best_strategy = gp.evolve do |params|
+    # Define how to evaluate fitness with given parameters
+    # params might be { indicator: :rsi, period: 14, buy_threshold: 30, sell_threshold: 70 }
+  end
+
+=end
+
+module SQA
+  class GeneticProgram
+    # Represents an individual trading strategy with specific parameters
+    class Individual
+      attr_accessor :genes, :fitness
+
+      def initialize(genes: {}, fitness: nil)
+        @genes = genes.dup
+        @fitness = fitness
+      end
+
+      def clone
+        Individual.new(genes: @genes.dup, fitness: @fitness)
+      end
+
+      def to_s
+        "Individual(fitness=#{fitness&.round(2)}, genes=#{genes})"
+      end
+    end
+
+    attr_reader :stock, :population, :best_individual, :generation, :history
+    attr_accessor :population_size, :generations, :mutation_rate, :crossover_rate, :elitism_count
+
+    def initialize(stock:, population_size: 50, generations: 100, mutation_rate: 0.15, crossover_rate: 0.7, elitism_count: 2)
+      @stock = stock
+      @population_size = population_size
+      @generations = generations
+      @mutation_rate = mutation_rate
+      @crossover_rate = crossover_rate
+      @elitism_count = elitism_count
+
+      @population = []
+      @best_individual = nil
+      @generation = 0
+      @history = []
+      @gene_constraints = {}
+      @fitness_evaluator = nil
+    end
+
+    # Define the parameter space for evolution
+    #
+    # Example:
+    #   gp.define_genes(
+    #     indicator: [:rsi, :macd, :stoch],
+    #     period: (5..30).to_a,
+    #     buy_threshold: (20..40).to_a,
+    #     sell_threshold: (60..80).to_a
+    #   )
+    def define_genes(**constraints)
+      @gene_constraints = constraints
+      self
+    end
+
+    # Define how to evaluate fitness for an individual
+    #
+    # The block receives an individual's genes hash and should return
+    # a numeric fitness value (higher is better)
+    #
+    # Example:
+    #   gp.fitness do |genes|
+    #     backtest = SQA::Backtest.new(
+    #       stock: stock,
+    #       strategy: create_strategy_from_genes(genes),
+    #       initial_capital: 10_000
+    #     )
+    #     results = backtest.run
+    #     results.total_return # Higher return = higher fitness
+    #   end
+    def fitness(&block)
+      @fitness_evaluator = block
+      self
+    end
+
+    # Run the genetic algorithm evolution
+    def evolve
+      raise "Gene constraints not defined. Call define_genes first." if @gene_constraints.empty?
+      raise "Fitness evaluator not defined. Call fitness with a block." unless @fitness_evaluator
+
+      initialize_population
+
+      @generations.times do |gen|
+        @generation = gen + 1
+
+        # Evaluate fitness for each individual
+        evaluate_population
+
+        # Track best individual
+        current_best = @population.max_by(&:fitness)
+        if @best_individual.nil? || current_best.fitness > @best_individual.fitness
+          @best_individual = current_best.clone
+        end
+
+        # Record history
+        avg_fitness = @population.sum(&:fitness) / @population.size.to_f
+        @history << {
+          generation: @generation,
+          best_fitness: current_best.fitness,
+          avg_fitness: avg_fitness,
+          best_genes: current_best.genes.dup
+        }
+
+        # Print progress
+        puts "Generation #{@generation}: Best=#{current_best.fitness.round(2)}%, Avg=#{avg_fitness.round(2)}%"
+
+        # Create next generation
+        @population = create_next_generation
+      end
+
+      # Final evaluation
+      evaluate_population
+      current_best = @population.max_by(&:fitness)
+      if @best_individual.nil? || current_best.fitness > @best_individual.fitness
+        @best_individual = current_best.clone
+      end
+
+      puts "\nEvolution complete!"
+      puts "Best individual: #{@best_individual}"
+
+      @best_individual
+    end
+
+    private
+
+    # Initialize population with random individuals
+    def initialize_population
+      @population = Array.new(@population_size) do
+        Individual.new(genes: random_genes)
+      end
+    end
+
+    # Generate random gene values within constraints
+    def random_genes
+      genes = {}
+      @gene_constraints.each do |gene_name, possible_values|
+        genes[gene_name] = Array(possible_values).sample
+      end
+      genes
+    end
+
+    # Evaluate fitness for all individuals in population
+    def evaluate_population
+      @population.each do |individual|
+        next if individual.fitness # Already evaluated
+
+        begin
+          individual.fitness = @fitness_evaluator.call(individual.genes)
+        rescue => e
+          # If evaluation fails, assign very poor fitness
+          individual.fitness = -Float::INFINITY
+          puts "  Warning: Fitness evaluation failed for #{individual.genes}: #{e.message}"
+        end
+      end
+    end
+
+    # Create next generation through selection, crossover, and mutation
+    def create_next_generation
+      new_population = []
+
+      # Elitism: keep best individuals
+      sorted = @population.sort_by(&:fitness).reverse
+      @elitism_count.times do |i|
+        new_population << sorted[i].clone if sorted[i]
+      end
+
+      # Fill rest of population through crossover and mutation
+      while new_population.size < @population_size
+        # Selection
+        parent1 = tournament_selection
+        parent2 = tournament_selection
+
+        # Crossover
+        if rand < @crossover_rate
+          child1, child2 = crossover(parent1, parent2)
+        else
+          child1, child2 = parent1.clone, parent2.clone
+        end
+
+        # Mutation
+        mutate(child1) if rand < @mutation_rate
+        mutate(child2) if rand < @mutation_rate
+
+        # Reset fitness for new individuals
+        child1.fitness = nil
+        child2.fitness = nil
+
+        new_population << child1
+        new_population << child2 if new_population.size < @population_size
+      end
+
+      new_population[0...@population_size]
+    end
+
+    # Tournament selection: pick best from random sample
+    def tournament_selection(tournament_size: 3)
+      tournament = @population.sample(tournament_size)
+      tournament.max_by(&:fitness)
+    end
+
+    # Single-point crossover: combine genes from two parents
+    def crossover(parent1, parent2)
+      child1_genes = {}
+      child2_genes = {}
+
+      @gene_constraints.keys.each do |gene_name|
+        if rand < 0.5
+          child1_genes[gene_name] = parent1.genes[gene_name]
+          child2_genes[gene_name] = parent2.genes[gene_name]
+        else
+          child1_genes[gene_name] = parent2.genes[gene_name]
+          child2_genes[gene_name] = parent1.genes[gene_name]
+        end
+      end
+
+      [Individual.new(genes: child1_genes), Individual.new(genes: child2_genes)]
+    end
+
+    # Mutation: randomly change some genes
+    def mutate(individual)
+      @gene_constraints.each do |gene_name, possible_values|
+        if rand < 0.3 # 30% chance to mutate each gene
+          individual.genes[gene_name] = Array(possible_values).sample
+        end
+      end
+    end
+  end
+end

data/lib/sqa/indicator.rb

@@ -1,11 +1,8 @@
 # lib/sqa/indicator.rb
+# frozen_string_literal: true
 
-class SQA::Indicator
-end
+require 'sqa/tai'
 
-# setup a shortcut for the namespace
-SQAI = SQA::Indicator
-
-Dir[__dir__ + "/indicator/*.rb"].each do |file|
-  load file
-end
+# Use SQA::TAI directly for all technical analysis indicators
+# SQAI is a shortcut alias for SQA::TAI
+SQAI = SQA::TAI

data/lib/sqa/init.rb

@@ -2,13 +2,8 @@
 
 module SQA
 	class << self
-		@@config 	= nil
-		@@av 			= ApiKeyManager::RateLimited.new(
-									api_keys: 		ENV['AV_API_KEYS'],
-									delay: 				true,
-									rate_count: 	ENV['AV_RATE_CNT'] ||  5,
-									rate_period: 	ENV['AV_RATE_PER'] || 60
-								)
+		@@config = nil
+		@@av_api_key = ENV['AV_API_KEY'] || ENV['ALPHAVANTAGE_API_KEY']
 
 		# Initializes the SQA modules
 		# returns the configuration
@@ -35,7 +30,19 @@ module SQA
 			config
 		end
 
-		def av() 								= @@av
+		def av_api_key
+			@@av_api_key || raise('Alpha Vantage API key not set. Set AV_API_KEY or ALPHAVANTAGE_API_KEY environment variable.')
+		end
+
+		# Legacy accessor for backward compatibility
+		def av
+			self
+		end
+
+		# For compatibility with old SQA.av.key usage
+		def key
+			av_api_key
+		end
 
 		def debug?() 						= @@config.debug?
 		def verbose?() 					= @@config.verbose?

data/lib/sqa/market_regime.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+# SQA::MarketRegime - Detect market regimes (bull/bear/sideways)
+#
+# Market regimes are distinct market conditions that affect trading strategy
+# effectiveness. This module identifies regimes based on:
+# - Trend direction (bull/bear)
+# - Volatility levels (VIX, ATR)
+# - Market breadth
+# - Momentum indicators
+#
+# Example:
+#   regime = SQA::MarketRegime.detect(stock)
+#   # => { type: :bull, volatility: :low, strength: :strong, dates: [...] }
+
+module SQA
+  module MarketRegime
+    class << self
+      # Detect current market regime for a stock
+      #
+      # @param stock [SQA::Stock] Stock to analyze
+      # @param lookback [Integer] Days to look back for regime detection
+      # @param window [Integer] Alias for lookback (for backward compatibility)
+      # @return [Hash] Regime metadata with both symbolic and numeric values
+      #
+      def detect(stock, lookback: nil, window: nil)
+        # Accept both lookback and window for backward compatibility
+        # lookback takes precedence if both provided
+        period = lookback || window || 60
+
+        prices = stock.df["adj_close_price"].to_a
+        return { type: :unknown } if prices.size < period
+
+        recent_prices = prices.last(period)
+
+        # Get both symbolic and numeric classifications
+        trend_data = detect_trend_with_score(recent_prices)
+        volatility_data = detect_volatility_with_score(recent_prices)
+        strength_data = detect_strength_with_score(recent_prices)
+
+        {
+          type: trend_data[:type],
+          trend_score: trend_data[:score],
+          volatility: volatility_data[:type],
+          volatility_score: volatility_data[:score],
+          strength: strength_data[:type],
+          strength_score: strength_data[:score],
+          lookback_days: period,
+          detected_at: Time.now
+        }
+      end
+
+      # Detect market regimes across entire history
+      #
+      # Splits historical data into regime periods
+      #
+      # @param stock [SQA::Stock] Stock to analyze
+      # @param window [Integer] Rolling window for regime detection
+      # @return [Array<Hash>] Array of regime periods
+      #
+      def detect_history(stock, window: 60)
+        prices = stock.df["adj_close_price"].to_a
+        regimes = []
+        current_regime = nil
+        regime_start = 0
+
+        (window...prices.size).each do |i|
+          window_prices = prices[(i - window)..i]
+          regime_type = detect_trend(window_prices)
+          volatility = detect_volatility(window_prices)
+
+          # Check if regime changed
+          if current_regime != regime_type
+            # Save previous regime
+            if current_regime
+              regimes << {
+                type: current_regime,
+                start_index: regime_start,
+                end_index: i - 1,
+                duration: i - regime_start,
+                volatility: volatility
+              }
+            end
+
+            current_regime = regime_type
+            regime_start = i
+          end
+        end
+
+        # Add final regime
+        if current_regime
+          regimes << {
+            type: current_regime,
+            start_index: regime_start,
+            end_index: prices.size - 1,
+            duration: prices.size - regime_start,
+            volatility: detect_volatility(prices[regime_start..-1])
+          }
+        end
+
+        regimes
+      end
+
+      # Classify regime type based on trend with numeric score
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Hash] { type: Symbol, score: Float }
+      #
+      def detect_trend_with_score(prices)
+        return { type: :unknown, score: 0.0 } if prices.size < 20
+
+        # Simple moving averages
+        sma_short = prices.last(20).sum / 20.0
+        sma_long = prices.last(60).sum / 60.0 rescue sma_short
+
+        # Price vs moving averages
+        current_price = prices.last
+
+        # Calculate trend strength (percentage above/below SMA)
+        pct_above_sma = ((current_price - sma_long) / sma_long * 100.0)
+
+        if pct_above_sma > 5 && sma_short > sma_long
+          { type: :bull, score: pct_above_sma }
+        elsif pct_above_sma < -5 && sma_short < sma_long
+          { type: :bear, score: pct_above_sma }
+        else
+          { type: :sideways, score: pct_above_sma }
+        end
+      end
+
+      # Classify regime type based on trend (backward compatibility)
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Symbol] :bull, :bear, or :sideways
+      #
+      def detect_trend(prices)
+        detect_trend_with_score(prices)[:type]
+      end
+
+      # Detect volatility regime with numeric score
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Hash] { type: Symbol, score: Float }
+      #
+      def detect_volatility_with_score(prices)
+        return { type: :unknown, score: 0.0 } if prices.size < 20
+
+        # Calculate daily returns
+        returns = []
+        prices.each_cons(2) do |prev, curr|
+          returns << ((curr - prev) / prev * 100.0).abs
+        end
+
+        avg_volatility = returns.sum / returns.size
+
+        if avg_volatility < 1.0
+          { type: :low, score: avg_volatility }
+        elsif avg_volatility < 2.5
+          { type: :medium, score: avg_volatility }
+        else
+          { type: :high, score: avg_volatility }
+        end
+      end
+
+      # Detect volatility regime (backward compatibility)
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Symbol] :low, :medium, or :high
+      #
+      def detect_volatility(prices)
+        detect_volatility_with_score(prices)[:type]
+      end
+
+      # Detect trend strength with numeric score
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Hash] { type: Symbol, score: Float }
+      #
+      def detect_strength_with_score(prices)
+        return { type: :unknown, score: 0.0 } if prices.size < 20
+
+        # Look at consistency of direction
+        up_days = 0
+        down_days = 0
+
+        prices.each_cons(2) do |prev, curr|
+          if curr > prev
+            up_days += 1
+          else
+            down_days += 1
+          end
+        end
+
+        total_days = up_days + down_days
+        directional_pct = [up_days, down_days].max.to_f / total_days * 100
+
+        if directional_pct > 70
+          { type: :strong, score: directional_pct }
+        elsif directional_pct > 55
+          { type: :moderate, score: directional_pct }
+        else
+          { type: :weak, score: directional_pct }
+        end
+      end
+
+      # Detect trend strength (backward compatibility)
+      #
+      # @param prices [Array<Float>] Price array
+      # @return [Symbol] :weak, :moderate, or :strong
+      #
+      def detect_strength(prices)
+        detect_strength_with_score(prices)[:type]
+      end
+
+      # Split data by regime
+      #
+      # @param stock [SQA::Stock] Stock to analyze
+      # @return [Hash] Data grouped by regime type
+      #
+      def split_by_regime(stock)
+        regimes = detect_history(stock)
+        prices = stock.df["adj_close_price"].to_a
+
+        grouped = { bull: [], bear: [], sideways: [] }
+
+        regimes.each do |regime|
+          regime_prices = prices[regime[:start_index]..regime[:end_index]]
+          grouped[regime[:type]] << {
+            prices: regime_prices,
+            start_index: regime[:start_index],
+            end_index: regime[:end_index],
+            duration: regime[:duration]
+          }
+        end
+
+        grouped
+      end
+    end
+  end
+end