DhanHQ 2.8.0 → 3.0.1

data/lib/DhanHQ/events/bus.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Event-driven architecture for the trading system.
+  #
+  # Provides pub/sub event bus, typed events, and async helpers.
+  #
+  # @example Subscribe to events
+  #   DhanHQ::Events.on(:order_filled) do |event|
+  #     puts "Order filled: #{event.order_id}"
+  #   end
+  #
+  # @example Emit events
+  #   DhanHQ::Events.emit(:order_filled, order_id: "123", filled_quantity: 10)
+  #
+  module Events
+    # Simple pub/sub event bus.
+    #
+    # Supports subscribing to specific event types or all events.
+    class Bus
+      def initialize
+        @subscribers = Hash.new { |h, k| h[k] = [] }
+        @global_subscribers = []
+      end
+
+      # Subscribe to an event type.
+      #
+      # @param event_type [Symbol, Class] Event type to subscribe to
+      # @param block [Proc] Handler block
+      # @return [Integer] Subscription ID for unsubscribing
+      def on(event_type, &block)
+        @subscribers[event_type] << block
+        @subscribers[event_type].length - 1
+      end
+
+      # Subscribe to all events.
+      #
+      # @param block [Proc] Handler block
+      # @return [Integer] Subscription ID
+      def subscribe_all(&block)
+        @global_subscribers << block
+        @global_subscribers.length - 1
+      end
+
+      # Unsubscribe from an event type.
+      #
+      # @param event_type [Symbol, Class] Event type
+      # @param subscription_id [Integer] Subscription ID from on()
+      # @return [Boolean] True if unsubscribed
+      # rubocop:disable Naming/PredicateMethod
+      def off(event_type, subscription_id)
+        return false unless @subscribers[event_type]
+
+        @subscribers[event_type].delete_at(subscription_id)
+        true
+      end
+
+      # Unsubscribe from all events.
+      #
+      # @param subscription_id [Integer] Subscription ID
+      # @return [Boolean] True if unsubscribed
+      def unsubscribe_all(subscription_id)
+        @global_subscribers.delete_at(subscription_id)
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # Emit an event to all subscribers.
+      #
+      # @param event_type [Symbol, Class] Event type
+      # @param data [Hash] Event data
+      # @return [void]
+      def emit(event_type, data = {})
+        event = build_event(event_type, data)
+
+        # Notify type-specific subscribers
+        @subscribers[event_type]&.each do |handler|
+          handler.call(event)
+        rescue StandardError => e
+          DhanHQ.logger&.error("[Events] Error in handler for #{event_type}: #{e.message}")
+        end
+
+        # Notify global subscribers
+        @global_subscribers.each do |handler|
+          handler.call(event_type, event)
+        rescue StandardError => e
+          DhanHQ.logger&.error("[Events] Error in global handler: #{e.message}")
+        end
+      end
+
+      # Get count of subscribers for an event type.
+      #
+      # @param event_type [Symbol] Event type
+      # @return [Integer]
+      def subscriber_count(event_type)
+        @subscribers[event_type]&.length || 0
+      end
+
+      # Clear all subscribers.
+      def clear
+        @subscribers.clear
+        @global_subscribers.clear
+      end
+
+      private
+
+      def build_event(event_type, data)
+        case event_type
+        when :order_placed then OrderPlaced.new(data)
+        when :order_filled then OrderFilled.new(data)
+        when :order_cancelled then OrderCancelled.new(data)
+        when :order_rejected then OrderRejected.new(data)
+        when :sl_hit then SLHit.new(data)
+        when :tp_hit then TPHit.new(data)
+        when :tick_updated then TickUpdated.new(data)
+        when :position_opened then PositionOpened.new(data)
+        when :position_closed then PositionClosed.new(data)
+        when :strategy_signal then StrategySignal.new(data)
+        else
+          Base.new(data.merge(event_type: event_type))
+        end
+      end
+    end
+
+    # Default bus instance
+    @bus = Bus.new
+
+    class << self
+      # Get the default event bus.
+      attr_reader :bus
+
+      # Subscribe to an event type (delegates to bus).
+      def on(event_type, &)
+        bus.on(event_type, &)
+      end
+
+      # Subscribe to all events (delegates to bus).
+      def subscribe_all(&)
+        bus.subscribe_all(&)
+      end
+
+      # Emit an event (delegates to bus).
+      def emit(event_type, data = {})
+        bus.emit(event_type, data)
+      end
+
+      # Unsubscribe from an event type (delegates to bus).
+      def off(event_type, subscription_id)
+        bus.off(event_type, subscription_id)
+      end
+
+      # Clear all subscribers (delegates to bus).
+      def clear
+        bus.clear
+      end
+    end
+  end
+end

data/lib/DhanHQ/events.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "events/base"
+require_relative "events/bus"
+
+module DhanHQ
+  # Event-driven architecture for the trading system.
+  #
+  # Provides typed events, pub/sub event bus, and async helpers
+  # for building reactive trading applications.
+  #
+  # @example Subscribe to order events
+  #   DhanHQ::Events.on(:order_filled) do |event|
+  #     puts "Order filled: #{event.order_id}"
+  #     puts "Filled quantity: #{event.filled_quantity}"
+  #   end
+  #
+  # @example Emit events
+  #   DhanHQ::Events.emit(:order_filled, order_id: "123", filled_quantity: 10)
+  #
+  # @example Subscribe to all events
+  #   DhanHQ::Events.subscribe_all do |event_type, event|
+  #     puts "Event: #{event_type} - #{event}"
+  #   end
+  #
+  # Available event types:
+  # - :order_placed - Order placed successfully
+  # - :order_filled - Order fully or partially filled
+  # - :order_cancelled - Order cancelled
+  # - :order_rejected - Order rejected by exchange
+  # - :sl_hit - Stop loss triggered
+  # - :tp_hit - Take profit triggered
+  # - :tick_updated - New market tick received
+  # - :position_opened - New position opened
+  # - :position_closed - Position closed
+  # - :strategy_signal - Strategy generated a signal
+  #
+  module Events
+  end
+end

data/lib/DhanHQ/indicators.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Technical analysis indicators for market data analysis.
+  module Indicators
+    # Simple Moving Average (SMA)
+    #
+    # Calculates the average of a specified number of data points.
+    #
+    # @example Calculate 20-period SMA
+    #   closes = [100, 102, 101, 103, 105, 104, 106, 108, 107, 109]
+    #   sma = DhanHQ::Indicators::SMA.calculate(closes, period: 5)
+    #   #=> [102.2, 103.0, 103.8, 104.6, 105.4, 106.8, 108.2, 107.8]
+    #
+    class SMA
+      # Calculate SMA for the given data.
+      #
+      # @param data [Array<Numeric>] Input price data
+      # @param period [Integer] Number of periods (default: 20)
+      # @return [Array<Float>] SMA values (nil for insufficient data points)
+      def self.calculate(data, period: 20)
+        return [] if data.nil? || data.empty? || period < 1
+
+        data.each_index.map do |i|
+          next nil if i < period - 1
+
+          window = data[(i - period + 1)..i]
+          window.sum.to_f / period
+        end
+      end
+    end
+
+    # Exponential Moving Average (EMA)
+    #
+    # Weighted average that gives more importance to recent prices.
+    #
+    # @example Calculate 12-period EMA
+    #   closes = [100, 102, 101, 103, 105, 104, 106, 108, 107, 109]
+    #   ema = DhanHQ::Indicators::EMA.calculate(closes, period: 5)
+    #
+    class EMA
+      # Calculate EMA for the given data.
+      #
+      # @param data [Array<Numeric>] Input price data
+      # @param period [Integer] Number of periods (default: 20)
+      # @return [Array<Float>] EMA values (nil for insufficient data points)
+      def self.calculate(data, period: 20)
+        return [] if data.nil? || data.empty? || period < 1
+
+        multiplier = 2.0 / (period + 1)
+        ema_values = []
+
+        data.each_with_index do |price, i|
+          if i < period - 1
+            ema_values << nil
+          elsif i == period - 1
+            # First EMA is SMA
+            window = data[0..i]
+            ema_values << (window.sum.to_f / period)
+          else
+            # EMA = (Price - Previous EMA) * Multiplier + Previous EMA
+            previous_ema = ema_values.last
+            ema_values << (((price - previous_ema) * multiplier) + previous_ema)
+          end
+        end
+
+        ema_values
+      end
+    end
+
+    # Relative Strength Index (RSI)
+    #
+    # Momentum oscillator measuring speed and magnitude of price changes.
+    #
+    # @example Calculate 14-period RSI
+    #   closes = [100, 102, 101, 103, 105, 104, 106, 108, 107, 109, 111, 110, 112, 114, 113]
+    #   rsi = DhanHQ::Indicators::RSI.calculate(closes, period: 14)
+    #
+    class RSI
+      # Calculate RSI for the given data.
+      #
+      # @param data [Array<Numeric>] Input price data
+      # @param period [Integer] Number of periods (default: 14)
+      # @return [Array<Float>] RSI values (nil for insufficient data points)
+      def self.calculate(data, period: 14)
+        return [] if data.nil? || data.empty? || period < 1
+        return [] if data.length < period + 1
+
+        # Calculate price changes
+        changes = data.each_cons(2).map { |a, b| b - a }
+
+        # Calculate initial average gains and losses
+        gains = changes[0...period].select(&:positive?)
+        losses = changes[0...period].select(&:negative?).map(&:abs)
+
+        avg_gain = gains.sum.to_f / period
+        avg_loss = losses.sum.to_f / period
+
+        rsi_values = Array.new(period, nil)
+
+        # Calculate RSI for first period
+        rsi_values << calculate_rsi(avg_gain, avg_loss)
+
+        # Calculate subsequent RSI values
+        changes[period..].each do |change|
+          gain = change.positive? ? change : 0
+          loss = change.negative? ? change.abs : 0
+
+          avg_gain = ((avg_gain * (period - 1)) + gain) / period
+          avg_loss = ((avg_loss * (period - 1)) + loss) / period
+
+          rsi_values << calculate_rsi(avg_gain, avg_loss)
+        end
+
+        rsi_values
+      end
+
+      def self.calculate_rsi(avg_gain, avg_loss)
+        return 100.0 if avg_loss.zero?
+        return 0.0 if avg_gain.zero?
+
+        rs = avg_gain / avg_loss
+        100 - (100 / (1 + rs))
+      end
+      private_class_method :calculate_rsi
+    end
+
+    # Moving Average Convergence Divergence (MACD)
+    #
+    # Trend-following momentum indicator showing relationship between two EMAs.
+    #
+    # @example Calculate MACD
+    #   closes = (0..99).map { |i| 100 + Math.sin(i * 0.1) * 10 }
+    #   macd = DhanHQ::Indicators::MACD.calculate(closes)
+    #   #=> { macd_line: [...], signal_line: [...], histogram: [...] }
+    #
+    class MACD
+      # Calculate MACD for the given data.
+      #
+      # @param data [Array<Numeric>] Input price data
+      # @param fast_period [Integer] Fast EMA period (default: 12)
+      # @param slow_period [Integer] Slow EMA period (default: 26)
+      # @param signal_period [Integer] Signal line period (default: 9)
+      # @return [Hash] Hash with :macd_line, :signal_line, and :histogram arrays
+      def self.calculate(data, fast_period: 12, slow_period: 26, signal_period: 9)
+        return { macd_line: [], signal_line: [], histogram: [] } if data.nil? || data.empty?
+
+        # Calculate fast and slow EMAs
+        fast_ema = EMA.calculate(data, period: fast_period)
+        slow_ema = EMA.calculate(data, period: slow_period)
+
+        # Calculate MACD line (fast EMA - slow EMA)
+        macd_line = fast_ema.zip(slow_ema).map do |fast, slow|
+          next nil if fast.nil? || slow.nil?
+
+          fast - slow
+        end
+
+        # Calculate signal line (EMA of MACD line)
+        valid_macd = macd_line.compact
+        signal_line_raw = valid_macd.empty? ? [] : EMA.calculate(valid_macd, period: signal_period)
+
+        # Align signal line with MACD line
+        signal_line = Array.new(macd_line.length - signal_line_raw.length, nil) + signal_line_raw
+
+        # Calculate histogram (MACD line - signal line)
+        histogram = macd_line.zip(signal_line).map do |macd, signal|
+          next nil if macd.nil? || signal.nil?
+
+          macd - signal
+        end
+
+        {
+          macd_line: macd_line,
+          signal_line: signal_line,
+          histogram: histogram
+        }
+      end
+    end
+
+    # Bollinger Bands
+    #
+    # Volatility indicator consisting of three lines: middle band (SMA), upper band, lower band.
+    #
+    # @example Calculate Bollinger Bands
+    #   closes = (0..99).map { |i| 100 + Math.sin(i * 0.1) * 10 }
+    #   bb = DhanHQ::Indicators::BollingerBands.calculate(closes)
+    #   #=> { upper: [...], middle: [...], lower: [...] }
+    #
+    class BollingerBands
+      # Calculate Bollinger Bands for the given data.
+      #
+      # @param data [Array<Numeric>] Input price data
+      # @param period [Integer] Number of periods (default: 20)
+      # @param std_dev [Float] Number of standard deviations (default: 2.0)
+      # @return [Hash] Hash with :upper, :middle, and :lower arrays
+      def self.calculate(data, period: 20, std_dev: 2.0)
+        return { upper: [], middle: [], lower: [] } if data.nil? || data.empty?
+
+        # Calculate middle band (SMA)
+        middle = SMA.calculate(data, period: period)
+
+        # Calculate upper and lower bands
+        upper = []
+        lower = []
+
+        data.each_with_index do |_, i|
+          if i < period - 1
+            upper << nil
+            lower << nil
+          else
+            window = data[(i - period + 1)..i]
+            mean = middle[i]
+            variance = window.sum { |x| (x - mean)**2 } / period
+            std = Math.sqrt(variance)
+
+            upper << (mean + (std_dev * std))
+            lower << (mean - (std_dev * std))
+          end
+        end
+
+        {
+          upper: upper,
+          middle: middle,
+          lower: lower
+        }
+      end
+    end
+
+    # Average True Range (ATR)
+    #
+    # Volatility indicator measuring market volatility.
+    #
+    # @example Calculate ATR
+    #   ohlc = [
+    #     { open: 100, high: 105, low: 98, close: 103 },
+    #     { open: 103, high: 108, low: 101, close: 106 },
+    #     ...
+    #   ]
+    #   atr = DhanHQ::Indicators::ATR.calculate(ohlc, period: 14)
+    #
+    class ATR
+      # Calculate ATR for the given OHLC data.
+      #
+      # @param data [Array<Hash>] Array of OHLC hashes with :open, :high, :low, :close
+      # @param period [Integer] Number of periods (default: 14)
+      # @return [Array<Float>] ATR values (nil for insufficient data points)
+      def self.calculate(data, period: 14)
+        return [] if data.nil? || data.empty? || period < 1
+        return [] if data.length < 2
+
+        # Calculate true ranges
+        true_ranges = data.each_cons(2).map do |prev, curr|
+          high = curr[:high] || curr["high"]
+          low = curr[:low] || curr["low"]
+          prev_close = prev[:close] || prev["close"]
+
+          [high - low, (high - prev_close).abs, (low - prev_close).abs].max
+        end
+
+        # Calculate ATR using smoothed average
+        atr_values = [nil] # First value has no true range
+
+        # First ATR is simple average
+        if true_ranges.length >= period
+          first_atr = true_ranges[0...period].sum.to_f / period
+          atr_values.concat(Array.new(period - 1, nil))
+          atr_values << first_atr
+
+          # Subsequent ATRs use smoothing
+          true_ranges[period..].each do |tr|
+            previous_atr = atr_values.last
+            atr_values << (((previous_atr * (period - 1)) + tr) / period)
+          end
+        else
+          atr_values.concat(Array.new(true_ranges.length, nil))
+        end
+
+        atr_values
+      end
+    end
+  end
+end

data/lib/DhanHQ/market_data/market_snapshot.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Higher-level abstractions for market data consumption.
+  module MarketData
+    # A snapshot of market data for multiple instruments at a point in time.
+    #
+    # Wraps the raw MarketFeed response into a more convenient structure
+    # with typed accessors and helper methods.
+    #
+    # @example Build a snapshot from MarketFeed response
+    #   response = DhanHQ::Models::MarketFeed.ltp("NSE_EQ" => [11536, 3456])
+    #   snapshot = DhanHQ::MarketData::MarketSnapshot.from_response(response)
+    #   snapshot.ltp("NSE_EQ", "11536") #=> 2850.50
+    #
+    class MarketSnapshot
+      attr_reader :data, :fetched_at
+
+      def initialize(data = {})
+        @data = data
+        @fetched_at = Time.now
+      end
+
+      # Build a MarketSnapshot from a raw MarketFeed API response.
+      def self.from_response(response)
+        raw_data = response.is_a?(Hash) ? (response[:data] || response["data"] || {}) : {}
+        new(normalize_data(raw_data))
+      end
+
+      # Get LTP for a specific instrument.
+      def ltp(exchange_segment, security_id)
+        instrument_data(exchange_segment, security_id)&.dig(:last_price)
+      end
+
+      # Get OHLC for a specific instrument.
+      def ohlc(exchange_segment, security_id)
+        instrument_data(exchange_segment, security_id)&.dig(:ohlc)
+      end
+
+      # Get full quote (market depth) for a specific instrument.
+      def quote(exchange_segment, security_id)
+        instrument_data(exchange_segment, security_id)
+      end
+
+      # Get all instruments for a specific exchange segment.
+      def for_segment(exchange_segment)
+        @data[exchange_segment.to_s] || {}
+      end
+
+      # Get all security IDs across all segments.
+      def security_ids
+        @data.each_with_object([]) do |(_segment, instruments), ids|
+          ids.concat(instruments.keys)
+        end
+      end
+
+      # Get total number of instruments in the snapshot.
+      def size
+        @data.values.sum(&:size)
+      end
+
+      # Check if the snapshot is empty.
+      def empty?
+        @data.empty? || @data.values.all?(&:empty?)
+      end
+
+      private
+
+      def instrument_data(exchange_segment, security_id)
+        @data[exchange_segment.to_s]&.dig(security_id.to_s)
+      end
+
+      def self.normalize_data(data)
+        result = {}
+        data.each do |segment, instruments|
+          result[segment.to_s] = {}
+          next unless instruments.is_a?(Hash)
+
+          instruments.each do |sec_id, info|
+            result[segment.to_s][sec_id.to_s] = normalize_instrument(info)
+          end
+        end
+        result
+      end
+      private_class_method :normalize_data
+
+      def self.normalize_instrument(info)
+        return info unless info.is_a?(Hash)
+
+        info.each_with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = value
+        end
+      end
+      private_class_method :normalize_instrument
+    end
+  end
+end