iron_warbler 2.0.7.18 → 2.0.7.20

data/app/models/iro/datapoint.rb

@@ -5,15 +5,34 @@ class Iro::Datapoint
   include Mongoid::Timestamps
   store_in collection: 'iro_datapoints'
 
-  field :date
+  field :kind ## PUT, CALL, STOCK, CURRENCY, CRYPTO
+  validates :kind, presence: true
+  index({ kind: -1 })
+
+  field :symbol ## ticker, but use 'symbol' ONLY
+
+  field :date, type: Date ## @obsolete, use quote_at
   index({ kind: -1, date: -1 })
 
+  field :quote_at, type: DateTime
+  index({ kind: -1, quote_at: -1 })
+  validates :quote_at, uniqueness: { scope: [ :kind, :symbol ] }
+
+  field :open, type: Float
+  field :high, type: Float
+  field :low, type: Float
+
   field :value, type: Float
   validates :value, presence: true
+  def close
+    value
+  end
+  def close= a
+    value= a
+  end
+
+  field :volume, type: Integer
 
-  field :kind
-  validates :kind, presence: true
-  index({ kind: -1 })
 
   def self.test_0trash
     add_fields = { '$addFields':  {
@@ -21,10 +40,10 @@ class Iro::Datapoint
         '$dateToString': { 'format': "%Y-%m-%d", 'date': "$created_at" }
       }
     } }
-    group = { '$group': {
-      '_id': "$date_string",
-      'my_doc': { '$first': "$$ROOT" }
-    } }
+    # group = { '$group': {
+    #   '_id': "$date_string",
+    #   'my_doc': { '$first': "$$ROOT" }
+    # } }
     group = { '$group': {
       '_id': "$date",
       'my_doc': { '$first': "$$ROOT" }
@@ -113,4 +132,25 @@ class Iro::Datapoint
     # puts! outs.to_a, 'result'
   end
 
+  def self.import_stock symbol:, path:
+    csv = CSV.read(path, headers: true)
+    csv.each do |row|
+      flag = create({
+        kind:    'STOCK',
+        symbol:   symbol,
+        date:     row['date'],
+        quote_at: row['date'],
+
+        volume: row['volume'],
+
+        open:  row['open'],
+        high:  row['high'],
+        low:   row['low'],
+        value: row['close'],
+      })
+      print '.' if flag.persisted?
+    end
+    puts 'ok'
+  end
+
 end

data/app/models/iro/position.rb

@@ -4,6 +4,8 @@ class Iro::Position
   include Mongoid::Timestamps
   store_in collection: 'iro_positions'
 
+  attr_accessor :gain_loss_amount
+
   STATUS_ACTIVE   = 'active'
   STATUS_PROPOSED = 'proposed'
   STATUSES = [ nil, 'active', 'inactive', 'proposed' ]
@@ -12,34 +14,48 @@ class Iro::Position
   scope :active, ->{ where( status: 'active' ) }
 
   belongs_to :purse,    class_name: 'Iro::Purse',    inverse_of: :positions
+  index({ purse_id: 1, ticker: 1 })
+
+  belongs_to :stock,   class_name: 'Iro::Stock',    inverse_of: :positions
+  def ticker
+    stock&.ticker || '-'
+  end
+
   belongs_to :strategy, class_name: 'Iro::Strategy', inverse_of: :positions
 
-  field :ticker
-  validates :ticker, presence: true
-  index({ purse_id: 1, ticker: 1 })
+  # field :ticker
+  # validates :ticker, presence: true
 
-  KINDS = [ nil, 'covered_call', 'credit_put_spread', 'credit_call_spread' ]
-  field :kind
+  field     :outer_strike, type: :float
+  # validates :outer_strike, presence: true
 
-  field :strike, type: :float
-  validates :strike, presence: true
+  field     :inner_strike, type: :float
+  validates :inner_strike, presence: true
 
   field :expires_on
   validates :expires_on, presence: true
 
   field :quantity, type: :integer
   validates :quantity, presence: true
+  def q; quantity; end
 
   field :begin_on
-  field :begin_price, type: :float
-  field :begin_delta, type: :float
+  field :begin_outer_price, type: :float
+  field :begin_outer_delta, type: :float
+
+  field :begin_inner_price, type: :float
+  field :begin_inner_delta, type: :float
 
   field :end_on
-  field :end_price, type: :float
-  field :end_delta, type: :float
+  field :end_outer_price, type: :float
+  field :end_outer_delta, type: :float
 
-  field :net_amount
-  field :net_percent
+  field :end_inner_price, type: :float
+  field :end_inner_delta, type: :float
+
+  def breakeven
+    inner_strike - begin_outer_price + begin_inner_price
+  end
 
   def current_underlying_strike
     Iro::Stock.find_by( ticker: ticker ).last
@@ -59,6 +75,19 @@ class Iro::Position
     print '_'
   end
 
+  def net_percent
+    net_amount / max_gain
+  end
+  def net_amount # each
+    strategy.send("net_amount_#{strategy.kind}", self)
+  end
+  def max_gain # each
+    strategy.send("max_gain_#{strategy.kind}", self)
+  end
+  def max_loss # each
+    strategy.send("max_loss_#{strategy.kind}", self)
+  end
+
 
   field :next_delta, type: :float
   field :next_outcome, type: :float
@@ -67,6 +96,10 @@ class Iro::Position
   field :next_reasons, type: :array, default: []
   field :should_rollp, type: :float
 
+  ##
+  ## decisions
+  ##
+
   def should_roll?
     puts! 'shold_roll?'
 
@@ -83,7 +116,7 @@ class Iro::Position
       if end_delta < strategy.threshold_delta
         next_reasons.push "delta is lower than threshold"
         out = 0.91
-      elsif 1 - end_price/begin_price > strategy.threshold_netp
+      elsif 1 - end_outer_price/begin_outer_price > strategy.threshold_netp
         next_reasons.push "made enough percent profit (dubious)"
         out = 0.61
       else
@@ -219,4 +252,12 @@ class Iro::Position
     return out
   end
 
+  def to_s
+    out = "#{stock} (#{q}) #{expires_on.to_datetime.strftime('%b %d')} #{strategy.kind_short} ["
+    if outer_strike
+      out = out + "$#{outer_strike}->"
+    end
+    out = out + "$#{inner_strike}] "
+    return out
+  end
 end

data/app/models/iro/position_covered_call.rb

@@ -0,0 +1,4 @@
+
+class Iro::PositionCoveredCall < Iro::Position
+
+end

data/app/models/iro/position_debit_spread.rb

@@ -0,0 +1,251 @@
+
+class Iro::PositionDebitSpread < Iro::Positin
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_positions'
+
+  STATUS_ACTIVE   = 'active'
+  STATUS_PROPOSED = 'proposed'
+  STATUSES = [ nil, 'active', 'inactive', 'proposed' ]
+  field :status
+  validates :status, presence: true
+  scope :active, ->{ where( status: 'active' ) }
+
+  belongs_to :purse,    class_name: 'Iro::Purse',    inverse_of: :positions
+  index({ purse_id: 1, ticker: 1 })
+
+  belongs_to :stock,   class_name: 'Iro::Stock',    inverse_of: :positions
+  def ticker
+    stock&.ticker || '-'
+  end
+
+  belongs_to :strategy, class_name: 'Iro::Strategy', inverse_of: :positions
+
+  field     :outer_strike, type: :float
+  validates :outer_strike, presence: true
+
+  field     :inner_strike, type: :float
+  validates :inner_strike, presence: true
+
+  field :expires_on
+  validates :expires_on, presence: true
+
+  field :quantity, type: :integer
+  validates :quantity, presence: true
+
+  field :begin_on
+  field :begin_outer_price, type: :float
+  field :begin_outer_delta, type: :float
+
+  field :begin_inner_price, type: :float
+  field :begin_inner_delta, type: :float
+
+  field :end_on
+  field :end_outer_price, type: :float
+  field :end_outer_delta, type: :float
+
+  field :end_inner_price, type: :float
+  field :end_inner_delta, type: :float
+
+  field :net_amount
+  field :net_percent
+
+  def current_underlying_strike
+    Iro::Stock.find_by( ticker: ticker ).last
+  end
+
+  def refresh
+    out = Tda::Option.get_quote({
+      contractType:   'CALL',
+      strike:         strike,
+      expirationDate: expires_on,
+      ticker:         ticker,
+    })
+    update({
+      end_delta: out[:delta],
+      end_price: out[:last],
+    })
+    print '_'
+  end
+
+  def net_amount # total
+    outer = 0 - begin_outer_price + end_outer_price
+    inner = begin_inner_price - end_inner_price
+    out = ( outer + inner ) * 100 * quantity
+  end
+  def max_gain # total
+    100 * ( begin_outer_price - begin_inner_price ) * quantity
+  end
+  def max_loss
+    out = 100 * ( outer_strike - inner_strike ) * quantity
+    if strategy.long_or_short == Iro::Strategy::SHORT
+      out = out * -1
+    end
+    return out
+  end
+
+
+  field :next_delta, type: :float
+  field :next_outcome, type: :float
+  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,
+    })
+
+    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
+
+    else
+      out = 0.0
+    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,
+    })
+
+    puts! next_reasons, 'next_reasons'
+    puts! out, 'out'
+    return out > 0.5
+  end
+
+
+  ## expires_on = cc.expires_on ; nil
+  def can_roll?
+    ## only if less than 7 days left
+    ( 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
+  end
+
+
+
+  ## 2023-03-18 _vp_ Continue.
+  ## 2023-03-19 _vp_ Continue.
+  ## 2023-08-05 _vp_ an Important method
+  ##
+  ## expires_on = cc.expires_on ; strategy = cc.strategy ; ticker = cc.ticker ; end_price = cc.end_price ; next_expires_on = cc.next_expires_on ; nil
+  ##
+  ## out.map { |p| [ p[:strikePrice], p[:delta] ] }
+  ##
+  def next_position
+    return @next_position if @next_position
+    return {} if ![ STATUS_ACTIVE, STATUS_PROPOSED ].include?( status )
+
+    ## 7 days ahead - not configurable so far
+    out = Tda::Option.get_quotes({
+      ticker: ticker,
+      expirationDate: next_expires_on,
+      contractType: 'CALL',
+    })
+
+    ## above_water
+    if strategy.buffer_above_water.present?
+      out = out.select do |i|
+        i[:strikePrice] > current_underlying_strike + strategy.buffer_above_water
+      end
+      # next_reasons.push "buffer_above_water above #{current_underlying_strike + strategy.buffer_above_water}"
+    end
+
+    if near_below_water?
+      msg = "Panic! climb at a loss. Skip the rest of the calculation."
+      next_reasons.push msg
+      ## @TODO: if not enough money in the purse, cannot roll? 2023-03-19
+
+      # byebug
+
+      ## Take a small loss here.
+      prev = nil
+      out.each_with_index do |i, idx|
+        next if idx == 0
+        if i[:last] < end_price
+          prev ||= i
+        end
+      end
+      out = [ prev ]
+
+    else
+      ## Normal flow, making money.
+      ## @TODO: test! _vp_ 2023-03-19
+
+      ## next_min_strike
+      if strategy.next_min_strike.present?
+        out = out.select do |i|
+          i[:strikePrice] >= strategy.next_min_strike
+        end
+        # next_reasons.push "next_min_strike above #{strategy.next_min_strike}"
+      end
+      # json_puts! out.map { |p| [p[:delta], p[:symbol]] }, 'next_min_strike'
+
+      ## max_delta
+      if strategy.next_max_delta.present?
+        out = out.select do |i|
+          i[:delta] = 0.0 if i[:delta] == "NaN"
+          i[:delta] <= strategy.next_max_delta
+        end
+        # next_reasons.push "next_max_delta below #{strategy.next_max_delta}"
+      end
+      # json_puts! out.map { |p| [p[:delta], p[:symbol]] }, 'next_max_delta'
+    end
+
+    @next_position = out[0] || {}
+  end
+
+  ## @TODO: Test this. _vp_ 2023-04-01
+  def next_expires_on
+    out = expires_on.to_time + 7.days
+    while !out.friday?
+      out = out + 1.day
+    end
+    while !out.workday?
+      out = out - 1.day
+    end
+    return out
+  end
+
+end

data/app/models/iro/price_item.rb

@@ -4,6 +4,7 @@ class Iro::PriceItem
   include Mongoid::Timestamps
   store_in collection: 'iro_price_items'
 
+  ## PUT, CALL, STOCK
   field :putCall,         type: String
   field :symbol,          type: String
   field :ticker,          type: String
@@ -15,9 +16,9 @@ class Iro::PriceItem
   field :last,            type: Float
 
   field :openPrice,       type: Float
-  field :closePrice,      type: Float
   field :lowPrice,        type: Float
   field :highPrice,       type: Float
+  field :closePrice,      type: Float
 
   field :quoteTimeInLong, type: Integer
   field :timestamp,       type: Integer
@@ -26,4 +27,53 @@ class Iro::PriceItem
   field :exchangeName,    type: String
   field :volatility,      type: Float
 
+  def self.my_find props={}
+    lookup = { '$lookup': {
+      'from':         'iro_price_items',
+      'localField':   'date',
+      'foreignField': 'date',
+      'pipeline': [
+        { '$sort': { 'value': -1 } },
+      ],
+      'as':           'dates',
+    } }
+    lookup_merge = { '$replaceRoot': {
+      'newRoot': { '$mergeObjects': [
+        { '$arrayElemAt': [ "$dates", 0 ] }, "$$ROOT"
+      ] }
+    } }
+
+
+    match = { '$match': {
+      'date': {
+        '$gte': props[:begin_on],
+        '$lte': props[:end_on],
+      }
+    } }
+
+    group = { '$group': {
+      '_id': "$date",
+      'my_doc': { '$first': "$$ROOT" }
+    } }
+
+    outs = Iro::Date.collection.aggregate([
+      match,
+
+      lookup,
+      lookup_merge,
+
+      group,
+      { '$replaceRoot': { 'newRoot': "$my_doc" } },
+      # { '$replaceRoot': { 'newRoot': "$my_doc" } },
+
+
+      { '$project': { '_id': 0, 'date': 1, 'value': 1 } },
+      { '$sort': { 'date': 1 } },
+    ])
+
+    puts! 'result'
+    pp outs.to_a
+    # puts! outs.to_a, 'result'
+  end
+
 end

data/app/models/iro/stock.rb

@@ -18,13 +18,16 @@ class Iro::Stock
 
   field :last, type: :float
 
-
-  # has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
+  has_many :positions,  class_name: 'Iro::Position', inverse_of: :stock
+  has_many :strategies, class_name: 'Iro::Strategy', inverse_of: :stock
 
   def to_s
     ticker
   end
   def self.list
+    [[nil,nil]] + all.map { |sss| [ sss.ticker, sss.id ] }
+  end
+  def self.tickers_list
     [[nil,nil]] + all.map { |sss| [ sss.ticker, sss.ticker ] }
   end
 end

data/app/models/iro/strategy.rb

@@ -7,17 +7,43 @@ class Iro::Strategy
   field :slug
   validates :slug, presence: true, uniqueness: true
 
+  LONG = 'is_long'
+  SHORT = 'is_short'
+  field     :long_or_short, type: :string
+  validates :long_or_short, presence: true
+
+  field :description
+
   has_many :positions, class_name: 'Iro::Position', inverse_of: :strategy
 
-  ## multiple strategies per ticker
-  field :ticker
-  validates :ticker, presence: true
-  index({ ticker: 1 })
-  # belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+  belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+
+  KIND_COVERED_CALL = 'covered_call'
+  KIND_LONG_DEBIT_CALL_SPREAD = 'long_debit_call_spread'
+  KIND_SHORT_DEBIT_PUT_SPREAD = 'long_debit_call_spread'
+  KINDS = [ nil,
+    KIND_COVERED_CALL,
+    KIND_LONG_DEBIT_CALL_SPREAD,
+    KIND_SHORT_DEBIT_PUT_SPREAD,
+  ]
+  field :kind
 
+  def kind_short
+    case kind
+    when KIND_COVERED_CALL
+      'cc'
+    when KIND_LONG_DEBIT_CALL_SPREAD
+      'long-spread'
+    when KIND_SHORT_DEBIT_PUT_SPREAD
+      'short-spread'
+    else
+      '@TODO-zez'
+    end
+  end
 
   field :buffer_above_water, type: :float
-  field :next_max_delta, type: :float
+  field :next_max_inner_delta, type: :float
+  field :next_max_outer_delta, type: :float
   field :next_min_strike, type: :float
   field :threshold_delta, type: :float
   field :threshold_netp, type: :float
@@ -26,13 +52,53 @@ class Iro::Strategy
     where( ticker: ticker )
   end
 
+  def max_gain_covered_call p
+    # return p.begin_inner_price
+    p.begin_inner_price * 100 - 0.66
+  end
+  def max_gain_long_debit_call_spread p
+    ## 100 * disalloed for gameui
+    ( p.inner_strike - p.outer_strike - p.begin_outer_price + p.begin_inner_price ) # - 2*0.66
+  end
+  def max_gain_short_debit_put_spread p
+    ## 100 * disalloed for gameui
+    ( p.outer_strike - p.inner_strike - p.begin_outer_price + p.begin_inner_price ) # - 2*0.66
+  end
 
-  def to_s
-    slug
+  def max_loss_covered_call p
+    return 'inf'
+  end
+  def max_loss_long_debit_call_spread p
+    out = 100 * ( p.outer_strike - p.inner_strike )
+  end
+  def max_loss_short_debit_put_spread p
+    out = -100 * ( p.outer_strike - p.inner_strike )
   end
 
-  def self.list
-    [[nil,nil]] + all.map { |ttt| [ ttt.slug, ttt.id ] }
+  def net_amount_covered_call p
+    ( p.begin_inner_price - p.end_inner_price ) * 100
   end
+  def net_amount_long_debit_call_spread p
+    outer = p.end_outer_price - p.begin_outer_price
+    inner = p.begin_inner_price - p.end_inner_price
+    out = ( outer + inner ) * 100
+  end
+  alias_method :net_amount_short_debit_put_spread, :net_amount_long_debit_call_spread
+
+
+  def net_amount_long_debit_call_spread p
+    outer = p.end_outer_price - p.begin_outer_price
+    inner = p.begin_inner_price - p.end_inner_price
+    out = ( outer + inner ) * 100
+  end
+
 
+
+  def to_s
+    slug
+  end
+  def self.list long_or_short = nil
+    these = long_or_short ? where( long_or_short: long_or_short ) : all
+    [[nil,nil]] + these.map { |ttt| [ ttt.slug, ttt.id ] }
+  end
 end

data/app/models/tda/stock.rb

@@ -16,6 +16,9 @@ class Tda::Stock
     path = "/v1/marketdata/quotes"
     inns = self.get path, { query: { apikey: ::TD_AMERITRADE[:apiKey], symbol: tickers } }
     inns = inns.parsed_response
+    if [ NilClass, String ].include?( inns.class )
+      return []
+    end
     inns.each do |k, v|
       inns[k] = v.deep_symbolize_keys
     end