iron_warbler 2.0.7.22 → 2.0.7.24

data/app/controllers/iro/stocks_controller.rb

@@ -2,32 +2,48 @@
 class Iro::StocksController < Iro::ApplicationController
   before_action :set_stock, only: [:show, :edit, :update, :destroy]
 
+  def create
+    @stock = Iro::Stock.new(stock_params)
+    authorize! :create, @stock
+
+    if @stock.save
+      flash_notice @stock
+    else
+      flash_alert @stock
+    end
+    redirect_to action: :index
+  end
+
+  def destroy
+    @stock.destroy
+    redirect_to stocks_url, notice: 'Stock was successfully destroyed.'
+  end
+
+  def edit
+  end
+
   def index
     @stocks = Iro::Stock.all
     authorize! :index, Iro::Stock
   end
 
-  def show
-  end
-
   def new
     @stock = Iro::Stock.new
     authorize! :new, @stock
   end
 
-  def edit
+  def refresh
+    authorize! :refresh, Iro::Stock
+    tickers = Iro::Stock.all.map { |s| s.ticker }.join(',')
+    outs = Tda::Stock.get_quotes tickers
+    outs.map do |out|
+      Iro::Stock.where( ticker: out[:symbol] ).update( last: out[:last] )
+    end
+    flash_notice 'ok'
+    redirect_to request.referrer
   end
 
-  def create
-    @stock = Iro::Stock.new(stock_params)
-    authorize! :create, @stock
-
-    if @stock.save
-      flash_notice @stock
-    else
-      flash_alert @stock
-    end
-    redirect_to action: :index
+  def show
   end
 
   def update
@@ -41,10 +57,6 @@ class Iro::StocksController < Iro::ApplicationController
     redirect_to request.referrer
   end
 
-  def destroy
-    @stock.destroy
-    redirect_to stocks_url, notice: 'Stock was successfully destroyed.'
-  end
 
   ##
   ## private

data/app/controllers/iro/strategies_controller.rb

@@ -32,6 +32,7 @@ class Iro::StrategiesController < Iro::ApplicationController
   def index
     authorize! :index, Iro::Strategy
     @strategies = Iro::Strategy.all
+
     # render '_table'
   end
 
@@ -40,6 +41,13 @@ class Iro::StrategiesController < Iro::ApplicationController
     authorize! :new, @posision
   end
 
+  def show
+    @strategy = Iro::Strategy.find params[:id]
+    authorize! :show, @strategy
+  end
+
+
+
   def update
     @strategy = Iro::Strategy.find params[:id]
     authorize! :update, @strategy
@@ -59,8 +67,11 @@ class Iro::StrategiesController < Iro::ApplicationController
   private
 
   def set_lists
+    super
+
+    @purses_list     = Iro::Purse.list
     @strategies_list = Iro::Strategy.list
-    @tickers_list    = Iro::Stock.list
+    @stocks_list     = Iro::Stock.list
   end
 
 end

data/app/models/iro/alert.rb

@@ -2,6 +2,7 @@
 class Iro::Alert
   include Mongoid::Document
   include Mongoid::Timestamps
+  include Mongoid::Paranoia
   store_in collection: 'iro_alerts'
 
   # SLEEP_TIME_SECONDS = Rails.env.production? ? 60 : 15

data/app/models/iro/datapoint.rb

@@ -138,15 +138,15 @@ class Iro::Datapoint
       flag = create({
         kind:    'STOCK',
         symbol:   symbol,
-        date:     row['date'],
-        quote_at: row['date'],
+        date:     row['Date'],
+        quote_at: row['Date'],
 
-        volume: row['volume'],
+        volume: row['Volume'],
 
-        open:  row['open'],
-        high:  row['high'],
-        low:   row['low'],
-        value: row['close'],
+        open:  row['Open'],
+        high:  row['High'],
+        low:   row['Low'],
+        value: row['Close'],
       })
       print '.' if flag.persisted?
     end

data/app/models/iro/option.rb

@@ -1,15 +1,186 @@
-
+require 'distribution'
+N = Distribution::Normal
+# include Math
+# require 'business_time'
 
 class Iro::Option
   include Mongoid::Document
   include Mongoid::Timestamps
+  include Mongoid::Paranoia
   store_in collection: 'iro_options'
 
-  # field :ticker
-  # validates :ticker, uniqueness: true, presence: true
+  attr_accessor :recompute
+
+  field :ticker
+  validates :ticker, presence: true
 
   field :symbol
   validates :symbol, uniqueness: true, presence: true
 
+  field :put_call, type: :string
+  validates :put_call, presence: true
+
+  field :delta, type: :float
+
+  field :strike, type: :float
+  validates :strike, presence: true
+
+  field :expires_on, type: :date
+  validates :expires_on, presence: true
+
+  belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+
+  def symbol
+    if !self[:symbol]
+      p_c_ = put_call == 'PUT' ? 'P' : 'C'
+      strike_ = strike.to_i == strike ? strike.to_i : strike
+      sym = "#{stock.ticker}_#{expires_on.strftime("%m%d%y")}#{p_c_}#{strike_}" # XYZ_011819P45
+      self[:symbol] = sym
+      save
+    end
+    self[:symbol]
+  end
+
+  ##
+  ## black-scholes pricing
+  ##
+
+=begin
+  ##
+  ##
+  ##
+  annual to daily:
+
+  AR = ((DR + 1)^365 – 1) x 100
+
+  ##
+  ##
+  ##
+  From: https://www.investopedia.com/articles/optioninvestor/07/options_beat_market.asp
+
+  K :: strike price
+  S_t :: last
+  r :: risk-free rate
+  t :: time to maturity
+
+  C = S_t N( d1 ) - K e^-rt N( d2 )
+
+  d1 = ln( St / K ) + (r + theta**2 /  2 )t
+    /{ theta_s * sqrt( t ) }
+
+  d2 = d1 - theta_s sqrt( t )
+
+  ##
+  ## From: https://en.wikipedia.org/wiki/Black%E2%80%93Scholes_model
+  ##
+
+  D  ::  e^(rt)    # discount factor
+  F  ::  e^(rt) S  # forward price of underlying
+
+  C(F,t) = D[ N(d1)F - N(d2)K ]
+
+  d1 = ln(F/K) + stdev**2 t / 2
+    /{ stdev sqrt(t) }
+  d2 = d1 - stdev sqrt(t)
+
+  ##
+  ## From: https://www.daytrading.com/options-pricing-models
+  ##
+  C0 = S0N(d1) – Xe-rtN(d2)
+
+  C0 = current call premium
+  S0 = current stock price
+  N(d1) = the probability that a value in a normal distribution will be less than d
+  N(d2) = the probability that the option will be in the money by expiration
+  X = strike price of the option
+  T = time until expiration (expressed in years)
+  r = risk-free interest rate
+  e = 2.71828, the base of the natural logarithm
+  ln = natural logarithm function
+  σ = standard deviation of the stock’s annualized rate of return (compounded continuously)
+  d1 = ln(S0/X) + (r + σ2/2)Tσ√T
+
+  d2 = d1 – σ√T
+
+  Note that:
+
+  Xe-rt = X/ert = the present value of the strike price using a continuously compounded interest rate
+
+  ##
+  ## From: https://www.wallstreetmojo.com/black-scholes-model/
+  ##
+
+
+  ## init
+  require 'distribution'
+  N = Distribution::Normal
+  stock = Iro::Stock.find_by ticker: 'NVDA'
+  strike = 910.0
+  r = Iro::Option.rate_daily
+  stdev = 91.0
+  t = 7.0
+  expires_on = '2024-03-22'
+
+=end
+  def d1
+    last   = stock.last
+    r      = self.class.rate_annual
+
+    out = Math.log( last / strike ) + ( r + stdev**2 / 2 ) * t
+    out = out /( stdev * Math.sqrt(t) )
+    return out
+  end
+  def d2
+    last   = stock.last
+    r      = self.class.rate_annual
+
+    out = d1 - stdev * Math.sqrt( t )
+    return out
+  end
+  def t
+    # t      = 1.0 / 365 * Date.today.business_days_until( expires_on )
+    t      = 1.0 / 365 * (expires_on - Date.today).to_i
+  end
+  def stdev
+    recompute = nil
+    stock.stdev( recompute: recompute )
+  end
+  def call_price
+    last   = stock.last
+    r      = self.class.rate_annual
+
+    out = N.cdf( d1 ) * last - N.cdf( d2 ) * strike * Math::E**( -1 * r * t )
+    return out
+  end
+
+  def put_price
+    last   = stock.last
+    r      = self.class.rate_annual
+
+    out = N.cdf(-d2) * strike * exp(-r*t) - N.cdf(-d1) * last
+    return out
+  end
+
+
+  def self.rate_annual
+    0.05
+  end
+
+=begin
+  # test
+
+  inn = 100
+  n.times { inn = inn*(1.0+out) }
+  inn
+
+=end
+  def self.rate_daily
+    n = 250.0 # days
+    # n = 12 # months
+
+    out = (1.0+self.rate_annual)**(1.0/n) - 1.0
+    puts! out, 'rate_daily'
+    return out
+  end
 
 end

data/app/models/iro/position.rb

@@ -2,9 +2,10 @@
 class Iro::Position
   include Mongoid::Document
   include Mongoid::Timestamps
+  include Mongoid::Paranoia
   store_in collection: 'iro_positions'
 
-  attr_accessor :gain_loss_amount
+  attr_accessor :next_gain_loss_amount
 
   STATUS_ACTIVE   = 'active'
   STATUS_PROPOSED = 'proposed'
@@ -53,8 +54,15 @@ class Iro::Position
   field :end_inner_price, type: :float
   field :end_inner_delta, type: :float
 
+  def begin_delta
+    strategy.send("begin_delta_#{strategy.kind}", self)
+  end
+  def end_delta
+    strategy.send("end_delta_#{strategy.kind}", self)
+  end
+
   def breakeven
-    strategy.breakeven(self)
+    strategy.send("breakeven_#{strategy.kind}", self)
   end
 
   def current_underlying_strike
@@ -87,6 +95,9 @@ class Iro::Position
   def max_loss # each
     strategy.send("max_loss_#{strategy.kind}", self)
   end
+  # def gain_loss_amount
+  #   strategy.send("gain_loss_amount_#{strategy.kind}", self)
+  # end
 
 
   field :next_delta, type: :float
@@ -94,52 +105,122 @@ class Iro::Position
   field :next_symbol
   field :next_mark
   field :next_reasons, type: :array, default: []
-  field :should_rollp, type: :float
-
-  ##
-  ## decisions
-  ##
-
-  def should_roll?
-    puts! 'shold_roll?'
-
-    update({
-      next_reasons: [],
-      next_symbol: nil,
-      next_delta: nil,
+  field :rollp, type: :float
+
+
+  ## covered call
+  # def sync
+  #   puts! [ inner_strike, expires_on, stock.ticker ], 'init sync'
+  #   out = Tda::Option.get_quote({
+  #     contractType: 'CALL',
+  #     strike: inner_strike,
+  #     expirationDate: expires_on,
+  #     ticker: stock.ticker,
+  #   })
+  #   puts! out, 'sync'
+  #   self.end_inner_price = ( out.bid + out.ask ) / 2
+  #   self.end_inner_delta = out.delta
+  # end
+
+  ## long call spread
+  # def sync
+  #   # puts! [
+  #   #   [ inner_strike, expires_on, stock.ticker ],
+  #   #   [ outer_strike, expires_on, stock.ticker ],
+  #   #  ], 'init sync inner, outer'
+  #   inner = Tda::Option.get_quote({
+  #     contractType: 'CALL',
+  #     strike: inner_strike,
+  #     expirationDate: expires_on,
+  #     ticker: stock.ticker,
+  #   })
+  #   outer = Tda::Option.get_quote({
+  #     contractType: 'CALL',
+  #     strike: outer_strike,
+  #     expirationDate: expires_on,
+  #     ticker: stock.ticker,
+  #   })
+  #   puts! [inner, outer], 'sync inner, outer'
+  #   self.end_outer_price = ( outer.bid + outer.ask ) / 2
+  #   self.end_outer_delta = outer.delta
+
+  #   self.end_inner_price = ( inner.bid + inner.ask ) / 2
+  #   self.end_inner_delta = inner.delta
+  # end
+
+  def sync
+    put_call = Iro::Strategy::LONG == strategy.long_or_short ? 'CALL' : 'PUT'
+    puts! [
+      [ inner_strike, expires_on, stock.ticker ],
+      [ outer_strike, expires_on, stock.ticker ],
+     ], 'init sync inner, outer'
+    inner = Tda::Option.get_quote({
+      contractType: put_call,
+      strike: inner_strike,
+      expirationDate: expires_on,
+      ticker: stock.ticker,
+    })
+    outer = Tda::Option.get_quote({
+      contractType: put_call,
+      strike: outer_strike,
+      expirationDate: expires_on,
+      ticker: stock.ticker,
     })
+    puts! [inner, outer], 'sync inner, outer'
+    self.end_outer_price = ( outer.bid + outer.ask ) / 2
+    self.end_outer_delta = outer.delta
 
-    if must_roll?
-      out = 1.0
-    elsif can_roll?
-
-      if end_delta < strategy.threshold_delta
-        next_reasons.push "delta is lower than threshold"
-        out = 0.91
-      elsif 1 - end_outer_price/begin_outer_price > strategy.threshold_netp
-        next_reasons.push "made enough percent profit (dubious)"
-        out = 0.61
-      else
-        next_reasons.push "neutral"
-        out = 0.33
-      end
+    self.end_inner_price = ( inner.bid + inner.ask ) / 2
+    self.end_inner_delta = inner.delta
+  end
+  def sync_short_debit_put_spread
+    puts! [
+      [ inner_strike, expires_on, stock.ticker ],
+      [ outer_strike, expires_on, stock.ticker ],
+     ], 'init sync inner, outer'
+    inner = Tda::Option.get_quote({
+      contractType: 'PUT',
+      strike: inner_strike,
+      expirationDate: expires_on,
+      ticker: stock.ticker,
+    })
+    outer = Tda::Option.get_quote({
+      contractType: 'PUT',
+      strike: outer_strike,
+      expirationDate: expires_on,
+      ticker: stock.ticker,
+    })
+    puts! [inner, outer], 'sync inner, outer'
+    self.end_outer_price = ( outer.bid + outer.ask ) / 2
+    self.end_outer_delta = outer.delta
 
-    else
-      out = 0.0
-    end
+    self.end_inner_price = ( inner.bid + inner.ask ) / 2
+    self.end_inner_delta = inner.delta
+  end
 
-    update({
-      next_delta:   next_position[:delta],
-      next_outcome: next_position[:mark] - end_price,
-      next_symbol:  next_position[:symbol],
-      next_mark:    next_position[:mark],
-      should_rollp: out,
-      # status:       Iro::Position::STATE_PROPOSED,
-    })
+  ##
+  ## decisions
+  ##
 
-    puts! next_reasons, 'next_reasons'
-    puts! out, 'out'
-    return out > 0.5
+  def calc_rollp
+    self.next_reasons = []
+    self.next_symbol = nil
+    self.next_delta = nil
+
+    out = strategy.send( "calc_rollp_#{strategy.kind}", self )
+
+    self.rollp = out[0]
+    self.next_reasons.push out[1]
+    save
+
+    # update({
+    #   next_delta:   next_position[:delta],
+    #   next_outcome: next_position[:mark] - end_price,
+    #   next_symbol:  next_position[:symbol],
+    #   next_mark:    next_position[:mark],
+    #   should_rollp: out,
+    #   # status:       Iro::Position::STATE_PROPOSED,
+    # })
   end
 
 
@@ -149,19 +230,6 @@ class Iro::Position
     ( expires_on.to_date - Time.now.to_date ).to_i < 7
   end
 
-  ## If I'm near below water
-  ##
-  ## expires_on = cc.expires_on ; strategy = cc.strategy ; strike = cc.strike ; nil
-  def must_roll?
-    if ( current_underlying_strike + strategy.buffer_above_water ) > strike
-      return true
-    end
-    ## @TODO: This one should not happen, I should log appropriately. _vp_ 2023-03-19
-    if ( expires_on.to_date - Time.now.to_date ).to_i < 1
-      return true
-    end
-  end
-
   ## strike = cc.strike ; strategy = cc.strategy ; nil
   def near_below_water?
     strike < current_underlying_strike + strategy.buffer_above_water

data/app/models/iro/purse.rb

@@ -2,6 +2,7 @@
 class Iro::Purse
   include Mongoid::Document
   include Mongoid::Timestamps
+  include Mongoid::Paranoia
   store_in collection: 'iro_purses'
 
   field :slug
@@ -10,12 +11,25 @@ class Iro::Purse
 
   has_many :positions, class_name: 'Iro::Position', inverse_of: :purse
 
-  field :unit,             type: :integer
-  field :height,           type: :integer
-  field :mark_every_n_usd, type: :float
+  belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+
+  field :unit,             type: :integer, default: 10
+
+  ## for rolling only:
+  field :height,           type: :integer, default: 100
+
+  field :mark_every_n_usd, type: :float, default: 1
+  field :n_next_positions, type: :integer, default: 5
+  ## with unit 10, sum_scale .001
+  ## with unit 100, sum_scale .0001
+  field :summary_scale,    type: :float, default: 0.001
+
+  field :available_amount, type: :float
 
   def to_s
     slug
   end
-
+  def self.list
+    [[nil,nil]] + all.map { |p| [p, p.id] }
+  end
 end

data/app/models/iro/stock.rb

@@ -1,7 +1,10 @@
+include Math
+require 'business_time'
 
 class Iro::Stock
   include Mongoid::Document
   include Mongoid::Timestamps
+  include Mongoid::Paranoia
   store_in collection: 'iro_stocks'
 
   STATUS_ACTIVE   = 'active'
@@ -17,9 +20,18 @@ class Iro::Stock
   index({ ticker: -1 }, { unique: true })
 
   field :last, type: :float
+  field :options_price_increment, type: :float
+
+  field :stdev, type: :float
 
   has_many :positions,  class_name: 'Iro::Position', inverse_of: :stock
   has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
+  has_many :purses,     class_name: 'Iro::Purse',    inverse_of: :stock
+  has_many :options,    class_name: 'Iro::Option',   inverse_of: :stock
+
+  def self.f ticker
+    self.find_by ticker: ticker
+  end
 
   def to_s
     ticker
@@ -30,4 +42,76 @@ class Iro::Stock
   def self.tickers_list
     [[nil,nil]] + all.map { |sss| [ sss.ticker, sss.ticker ] }
   end
+
+=begin
+  stock = Iro::Stock.find_by( ticker: 'NVDA' )
+
+  duration = 1.month
+  stock.volatility_from_mo
+
+  duration = 1.year
+  stock.volatility_from_yr
+
+=end
+  def volatility duration:
+    stock = self
+    begin_on = Time.now - duration - 1.day
+    points = Iro::Datapoint.where( kind: 'STOCK', symbol: stock.ticker,
+      :date.gte => begin_on,
+    ).order_by( date: :asc )
+
+    puts! [points.first.date, points.last.date], "from,to"
+
+    points_p = []
+    points.each_with_index do |p, idx|
+      next if idx == 0
+      prev = points[idx-1]
+
+      out = p.value / prev.value - 1
+      points_p.push out
+    end
+    n = points_p.length
+
+    avg = points_p.reduce(&:+) / n
+    _sum_of_sq = []
+    points_p.map do |p|
+      _sum_of_sq.push( ( p - avg )*( p - avg ) )
+    end
+    sum_of_sq = _sum_of_sq.reduce( &:+ ) / n
+
+    # n_periods = begin_on.to_date.business_days_until( Date.today )
+    out = Math.sqrt( sum_of_sq )*sqrt( n )
+    adjustment = 2.0
+    out = out * adjustment
+    puts! out, 'volatility (adjusted)'
+    return out
+  end
+
+  def volatility_from_mo
+    volatility( duration: 1.month )
+  end
+  def volatility_from_yr
+    volatility( duration: 1.year )
+  end
+  def stdev recompute: nil
+    if !self[:stdev] || recompute
+      out = volatility_from_yr
+      self[:stdev] = out
+      save( validate: false )
+      return out
+    else
+      self[:stdev]
+    end
+  end
+
+  ## stdev
+  ## From: https://stackoverflow.com/questions/19484891/how-do-i-find-the-standard-deviation-in-ruby
+  # contents = [1,2,3,4,5,6,7,8,9]
+  # n = contents.size             # => 9
+  # contents.map!(&:to_f)         # => [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
+  # mean = contents.reduce(&:+)/n # => 5.0
+  # sum_sqr = contents.map {|x| x * x}.reduce(&:+) # => 285.0
+  # std_dev = Math.sqrt((sum_sqr - n * mean * mean)/(n-1)) # => 2.7386127875258306
+
+
 end