iron_warbler 2.0.7.43 → 2.0.7.45

data/app/models/iro/position.rb

@@ -1,299 +0,0 @@
-
-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
-
-  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::SHORT == pos.long_or_short
-        out[:strikePrice] >= strategy.next_inner_strike
-      elsif Iro::Strategy::LONG == pos.long_or_short
-        out[:strikePrice] <= strategy.next_inner_strike
-      else
-        raise 'zz3 - this cannot happen'
-      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

@@ -1,93 +0,0 @@
-
-##
-## 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

@@ -1,72 +0,0 @@
-
-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

@@ -1,134 +0,0 @@
-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
-
-  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