wco_models 3.1.0.184 → 3.1.0.188

data/app/models/iro/position.rb

@@ -0,0 +1,304 @@
+
+class Iro::Position
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Paranoia
+  store_in collection: 'iro_positions'
+
+  field :prev_gain_loss_amount, type: :float
+  attr_accessor :next_gain_loss_amount
+  def prev_gain_loss_amount
+    out  = autoprev.outer.end_price - autoprev.inner.end_price
+    out += inner.begin_price - outer.begin_price
+  end
+
+
+  STATUS_ACTIVE   = 'active'
+  STATUS_CLOSED   = 'closed'
+  STATUS_PROPOSED = 'proposed'
+  ## one more, 'selected' after proposed?
+  STATUS_PENDING  = 'pending' ## 'working'
+  STATUSES = [ nil, STATUS_CLOSED, STATUS_ACTIVE, STATUS_PROPOSED, STATUS_PENDING ]
+  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
+  delegate :ticker, to: :stock
+
+  belongs_to :strategy, class_name: 'Iro::Strategy', inverse_of: :positions
+  delegate :put_call,        to: :strategy
+  delegate :long_or_short,   to: :strategy
+  delegate :credit_or_debit, to: :strategy
+
+  belongs_to :next_strategy, class_name: 'Iro::Strategy', inverse_of: :next_position, optional: true
+
+
+  belongs_to :prev, class_name: 'Iro::Position', inverse_of: :nxts, optional: true
+  belongs_to :autoprev, class_name: 'Iro::Position', inverse_of: :autonxt, optional: true
+  ## there are many of these, for viewing on the 'roll' view
+  has_many :nxts,     class_name: 'Iro::Position', inverse_of: :prev
+  has_one :autonxt, class_name: 'Iro::Position', inverse_of: :autoprev
+
+  ## Options
+
+  belongs_to :inner, class_name: 'Iro::Option', inverse_of: :inner
+  validates_associated :inner
+
+  belongs_to :outer, class_name: 'Iro::Option', inverse_of: :outer
+  validates_associated :outer
+
+  accepts_nested_attributes_for :inner, :outer
+
+  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
+  def q; quantity; end
+
+  field :begin_on
+
+  field :end_on
+
+  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.send("breakeven_#{strategy.kind}", self)
+  end
+
+  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_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
+
+
+  def sync
+    inner.sync
+    outer.sync
+  end
+
+
+  ##
+  ## decisions
+  ##
+
+  field :next_reasons, type: :array, default: []
+  field :rollp, type: :float
+
+  ## should_roll?
+  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
+  end
+
+  def calc_nxt
+    pos = self
+
+    ## 7 days ahead - not configurable so far
+    outs = Tda::Option.get_quotes({
+      contractType: pos.put_call,
+      expirationDate: next_expires_on,
+      ticker: ticker,
+    })
+    outs_bk = outs.dup
+
+    outs = outs.select do |out|
+      out[:bidSize] + out[:askSize] > 0
+    end
+
+    if 'CALL' == pos.put_call
+      ;
+    elsif 'PUT' == pos.put_call
+      outs = outs.reverse
+    end
+
+    ## next_inner_strike
+    outs = outs.select do |out|
+      if Iro::Strategy::CREDIT == pos.credit_or_debit
+        if Iro::Strategy::SHORT == pos.long_or_short
+          ## short credit call
+          out[:strikePrice] >= strategy.next_inner_strike
+        elsif Iro::Strategy::LONG == pos.long_or_short
+          ## long credit put
+          out[:strikePrice] <= strategy.next_inner_strike
+        end
+      else
+        raise 'zz3 - @TODO: implement, debit spreads'
+      end
+    end
+    puts! outs[0][:strikePrice], 'after calc next_inner_strike'
+    puts! outs, 'outs'
+
+    ## next_buffer_above_water
+    outs = outs.select do |out|
+      if Iro::Strategy::SHORT == pos.long_or_short
+        out[:strikePrice] > strategy.next_buffer_above_water + strategy.stock.last
+      elsif Iro::Strategy::LONG == pos.long_or_short
+        out[:strikePrice] < strategy.stock.last - strategy.next_buffer_above_water
+      else
+        raise 'zz4 - this cannot happen'
+      end
+    end
+    puts! outs[0][:strikePrice], 'after calc next_buffer_above_water'
+    puts! outs, 'outs'
+
+    ## next_inner_delta
+    outs = outs.select do |out|
+      if 'CALL' == pos.put_call
+        out_delta  = out[:delta] rescue 1
+        out_delta <= strategy.next_inner_delta
+      elsif 'PUT' == pos.put_call
+        out_delta  = out[:delta] rescue 0
+        out_delta <= strategy.next_inner_delta
+      else
+        raise 'zz5 - this cannot happen'
+      end
+    end
+    puts! outs[0][:strikePrice], 'after calc next_inner_delta'
+    puts! outs, 'outs'
+
+    inner = outs[0]
+    outs = outs.select do |out|
+      if 'CALL' == pos.put_call
+        out[:strikePrice] >= inner[:strikePrice].to_f + strategy.next_spread_amount
+      elsif 'PUT' == pos.put_call
+        out[:strikePrice] <= inner[:strikePrice].to_f - strategy.next_spread_amount
+      end
+    end
+    outer = outs[0]
+
+    if inner && outer
+      o_attrs = {
+        expires_on: next_expires_on,
+        put_call:   pos.put_call,
+        stock_id:   pos.stock_id,
+      }
+      inner_ = Iro::Option.new(o_attrs.merge({
+        strike:        inner[:strikePrice],
+        begin_price: ( inner[:bid] + inner[:ask] )/2,
+        begin_delta:   inner[:delta],
+        end_price:   ( inner[:bid] + inner[:ask] )/2,
+        end_delta:     inner[:delta],
+      }))
+      outer_ = Iro::Option.new(o_attrs.merge({
+        strike:        outer[:strikePrice],
+        begin_price: ( outer[:bid] + outer[:ask] )/2,
+        begin_delta:   outer[:delta],
+        end_price:   ( outer[:bid] + outer[:ask] )/2,
+        end_delta:     outer[:delta],
+      }))
+      pos.autonxt ||= Iro::Position.new
+      pos.autonxt.update({
+        prev_gain_loss_amount: 'a',
+        status:       'proposed',
+        stock:        strategy.stock,
+        inner:        inner_,
+        outer:        outer_,
+        inner_strike: inner_.strike,
+        outer_strike: outer_.strike,
+        begin_on:     Time.now.to_date,
+        expires_on:   next_expires_on,
+        purse:        purse,
+        strategy:     strategy,
+        quantity:     1,
+        autoprev:     pos,
+      })
+
+      pos.autonxt.sync
+      pos.autonxt.save!
+      pos.save
+      return pos
+
+    else
+      throw 'zmq - should not happen'
+    end
+  end
+
+
+
+  ## ok
+  def next_expires_on
+    out = expires_on.to_datetime.next_occurring(:monday).next_occurring(:friday)
+    if !out.workday?
+      out = Time.previous_business_day(out)
+    end
+    return out
+  end
+
+  ## ok
+  def self.long
+    where( long_or_short: Iro::Strategy::LONG )
+  end
+
+  ## ok
+  def self.short
+    where( long_or_short: Iro::Strategy::SHORT )
+  end
+
+  def to_s
+    out = "#{stock} (#{q}) #{expires_on.to_datetime.strftime('%b %d')} #{strategy.long_or_short} ["
+    if Iro::Strategy::LONG == long_or_short
+      if outer.strike
+        out = out + "$#{outer.strike}->"
+      end
+      out = out + "$#{inner.strike}"
+    else
+      out = out + "$#{inner.strike}"
+      if outer.strike
+        out = out + "<-$#{outer.strike}"
+      end
+    end
+    out += "] "
+    return out
+  end
+end
+
+

data/app/models/iro/priceitem.rb

@@ -0,0 +1,93 @@
+
+##
+## Specifically Option or Stock priceitem?
+## Priceitems are intra-day! See Datapoint for daily data
+##
+class Iro::Priceitem
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  store_in collection: 'iro_price_items'
+
+  ## PUT, CALL, STOCK
+  field :putCall,         type: String ## kind
+  field :symbol,          type: String
+  field :description,     type: String
+  field :ticker,          type: String
+  # belongs_to :stock, inverse_of: :priceitems
+
+  field :bid,             type: Float
+  field :bidSize,         type: Integer
+  field :ask,             type: Float
+  field :askSize,         type: Integer
+  field :last,            type: Float
+
+  field :openPrice,       type: Float
+  field :lowPrice,        type: Float
+  field :highPrice,       type: Float
+  field :closePrice,      type: Float
+
+  field :quote_at, type: DateTime
+  field :quoteTimeInLong, type: Integer
+  field :timestamp,       type: Integer
+  field :totalVolume,     type: Integer
+  field :mark,            type: Float
+  field :exchangeName,    type: String
+  field :volatility,      type: Float
+
+  field :expirationDate, type: :date
+  field :delta,          type: Float
+  field :gamma,          type: Float
+  field :theta,          type: Float
+  field :openInterest,   type: Integer
+  field :strikePrice,    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/purse.rb

@@ -0,0 +1,71 @@
+
+require 'distribution'
+N = Distribution::Normal
+
+class Iro::Purse
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Paranoia
+  store_in collection: 'iro_purses'
+
+  field :slug
+  validates :slug, presence: true, uniqueness: true
+  index({ slug: -1 }, { unique: true })
+
+  has_many :positions,  class_name: 'Iro::Position', inverse_of: :purse
+
+  # has_and_belongs_to_many :strategies, class_name: 'Iro::Strategy', inverse_of: :purses
+  # belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
+
+  field :unit,             type: :integer, default: 10
+  ## with unit 10,  .001
+  ## with unit 100, .0001
+  field :summary_unit,    type: :float, default: 0.001
+
+  ## 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
+
+  field :available_amount, type: :float
+  def available
+    available_amount
+  end
+
+  def balance
+    0.01
+  end
+
+  def delta_wt_avg( begin_end, long_short, inner_outer )
+    max_loss_total = 0
+
+    out = positions.send( long_short ).map do |pos|
+      max_loss_total += pos.max_loss * pos.q
+      pos.max_loss * pos.q * pos.send( inner_outer ).send( "#{begin_end}_delta" )
+    end
+    # puts! out, 'delta_wt_avg 1'
+    out = out.reduce( &:+ ) / max_loss_total rescue 0
+    # puts! out, 'delta_wt_avg 2'
+    return out
+  end
+  ## delta to plot percentage
+  ## convert to normal between 0 and 3 std
+  def delta_to_plot_p( *args )
+    x = delta_wt_avg( *args ).abs
+    if x < 0.5
+      y = 1
+    else
+      y = 2 - 1/( 1.5 - x )
+    end
+    y_ = "#{ (y*100) .to_i}%"
+    return y_
+  end
+
+  def to_s
+    slug
+  end
+  def self.list
+    [[nil,nil]] + all.map { |p| [p, p.id] }
+  end
+end

data/app/models/iro/stock.rb

@@ -0,0 +1,141 @@
+include Math
+require 'business_time'
+
+##
+## https://www.macrotrends.net/stocks/charts/META/meta-platforms/stock-price-history
+##
+class Iro::Stock
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Paranoia
+  store_in collection: 'iro_stocks'
+
+  STATUS_ACTIVE   = 'active'
+  STATUS_INACTIVE = 'inactive'
+  STATUSES        = [ nil, 'active', 'inactive' ]
+  def self.active
+    where( status: STATUS_ACTIVE )
+  end
+  field :status, default: STATUS_ACTIVE
+
+  field :ticker
+  validates :ticker, uniqueness: true, presence: true
+  index({ ticker: -1 }, { unique: true })
+  def symbol;    ticker;     end
+  def symbol= a; ticker = a; end
+
+  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
+  has_many :priceitems, inverse_of: :stock
+
+  belongs_to :user
+  LONG_ONLY     = 'long-only'
+  LONG_OR_SHORT = 'long-or-short'
+  SHORT_ONLY    = 'short-only'
+  field :sentiment, default: LONG_OR_SHORT
+  field :sentiment_num, default: 0 # 1 is very long, -1 is very short
+
+  default_scope { order_by({ ticker: :asc }) }
+
+  ## my_find
+  def self.f ticker
+    self.find_by ticker: ticker
+  end
+
+  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
+
+=begin
+  stock = Iro::Stock.find_by( ticker: 'NVDA' )
+
+  duration = 1.month
+  stock.volatility_from_mo
+
+  duration = 1.year
+  stock.volatility_from_yr
+
+=end
+  field :volatility, type: :float
+  def volatility duration: 1.year, recompute: false
+    if self[:volatility]
+      if !recompute
+        return self[:volatility]
+      end
+    end
+
+    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)'
+    self.update volatility: out
+    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