iron_warbler 2.0.7.43 → 2.0.7.45

data/app/models/iro/datapoint.rb

@@ -1,187 +0,0 @@
-
-##
-## Datapoints are at most daily!
-## See Priceitem for intra-day data
-##
-class Iro::Datapoint
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  store_in collection: 'iro_datapoints'
-
-  field :kind
-  validates :kind, presence: true
-  index({ kind: -1 })
-  KIND_CRYPTO   = 'CRYPTO'
-  KIND_STOCK    = 'STOCK'
-  KIND_OPTION   = 'OPTION' ## but not PUT or CALL
-  KIND_CURRENCY = 'CURRENCY'
-  KIND_TREASURY = 'TREASURY'
-
-  field :symbol ## ticker, but use 'symbol' here
-  ## crypto
-  SYMBOL_BTC = 'BTC'
-  SYMBOL_ETH = 'ETH'
-  ## currencies
-  SYMBOL_JPY = 'JPY'
-  SYMBOL_COP = 'COP'
-  SUMBOL_EUR = 'EUR'
-  ## treasuries
-  SYMBOL_T1MO  = 'T1MO'
-  SYMBOL_T2MO  = 'T2MO'
-  SYMBOL_T3MO  = 'T3MO'
-  SYMBOL_T4MO  = 'T4MO'
-  SYMBOL_T6MO  = 'T6MO'
-  SYMBOL_T1YR  = 'T1YR'
-  SYMBOL_T2YR  = 'T2YR'
-  SYMBOL_T3YR  = 'T3YR'
-  SYMBOL_T5YR  = 'T5YR'
-  SYMBOL_T7YR  = 'T7YR'
-  SYMBOL_T10YR = 'T10YR'
-  SYMBOL_T20YR = 'T20YR'
-  SYMBOL_T30YR = 'T30YR'
-
-  field :date, type: Date
-  index({ kind: -1, date: -1 })
-  validates :date, uniqueness: { scope: [ :symbol ] }
-
-  field :quote_at, type: DateTime
-  index({ kind: -1, quote_at: -1 })
-  validates :quote_at, uniqueness: { scope: [ :kind, :symbol ] } ## scope-by-kind is unnecessary here? _vp_ 2024-08-08
-
-  field :open, type: Float
-  field :high, type: Float
-  field :low, type: Float
-  def close;    value;    end
-  def close= a; value= a; end
-
-  field :value, type: Float
-  validates :value, presence: true
-
-
-  field :volume, type: Integer
-
-
-  def self.test_0trash
-    add_fields = { '$addFields':  {
-      'date_string': {
-        '$dateToString': { 'format': "%Y-%m-%d", 'date': "$created_at" }
-      }
-    } }
-    # group = { '$group': {
-    #   '_id': "$date_string",
-    #   'my_doc': { '$first': "$$ROOT" }
-    # } }
-    group = { '$group': {
-      '_id': "$date",
-      'my_doc': { '$first': "$$ROOT" }
-    } }
-    lookup = { '$lookup': {
-      'from':         'iro_dates',
-      'localField':   'date_string',
-      'foreignField': 'date',
-      'as':           'dates',
-    } }
-    lookup_merge = { '$replaceRoot': {
-      'newRoot': { '$mergeObjects': [
-        { '$arrayElemAt': [ "$dates", 0 ] }, "$$ROOT"
-      ] }
-    } }
-    match = { '$match': {
-      'kind': 'some-type',
-      'created_at': {
-        '$gte': '2023-12-01'.to_datetime,
-        '$lte': '2023-12-31'.to_datetime,
-      }
-    } }
-
-    outs = Iro::Datapoint.collection.aggregate([
-      add_fields,
-      lookup, lookup_merge,
-      match,
-
-      { '$sort': { 'date_string': 1 } },
-      group,
-      # { '$replaceRoot': { 'newRoot': "$my_doc" } },
-      # { '$project': { '_id': 0, 'date_string': 1, 'value': 1 } },
-    ])
-
-    puts! 'result'
-    pp outs.to_a
-    # puts! outs.to_a, 'result'
-  end
-
-  def self.test
-    lookup = { '$lookup': {
-      'from':         'iro_datapoints',
-      'localField':   'date',
-      'foreignField': 'date',
-      'pipeline': [
-        { '$sort': { 'value': -1 } },
-      ],
-      'as':           'datapoints',
-    } }
-    lookup_merge = { '$replaceRoot': {
-      'newRoot': { '$mergeObjects': [
-        { '$arrayElemAt': [ "$datapoints", 0 ] }, "$$ROOT"
-      ] }
-    } }
-
-
-    match = { '$match': {
-      'date': {
-        '$gte': '2023-12-25',
-        '$lte': '2023-12-31',
-      }
-    } }
-
-    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
-
-  def self.import_stock symbol:, path:
-    csv = CSV.read(path, headers: true)
-    csv.each do |row|
-      flag = create({
-        kind:     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'],
-      })
-      if flag.persisted?
-        print '^'
-      else
-        puts flag.errors.messages
-      end
-    end
-    puts 'ok'
-  end
-
-end

data/app/models/iro/date.rb

@@ -1,10 +0,0 @@
-
-class Iro::Date
-  include Mongoid::Document
-  # include Mongoid::Timestamps
-  store_in collection: 'iro_dates'
-
-  field :date
-
-end
-

data/app/models/iro/option.rb

@@ -1,151 +0,0 @@
-
-class Iro::Option
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  include Mongoid::Paranoia
-  include Iro::OptionBlackScholes
-  store_in collection: 'iro_options'
-
-  attr_accessor :recompute
-
-  belongs_to :stock, class_name: 'Iro::Stock', inverse_of: :strategies
-  def ticker; stock.ticker; end
-  # field :ticker
-  # validates :ticker, presence: true
-
-  field :symbol
-  ## each option can be a leg in a position, no uniqueness
-  # validates :symbol, uniqueness: true, presence: true
-
-  field :put_call, type: :string # 'PUT' or 'CALL'
-  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
-  def self.expirations_list full: false, n: 5
-    out = [[nil,nil]]
-    day = Date.today - 5.days
-    n.times do
-      next_exp = day.next_occurring(:thursday).next_occurring(:friday)
-      if !next_exp.workday?
-        next_exp = Time.previous_business_day( next_exp )
-      end
-
-      out.push([ next_exp.strftime('%b %e'), next_exp.strftime('%Y-%m-%d') ])
-      day = next_exp
-    end
-    return out
-    # [
-    #   [ nil, nil ],
-    #   [ 'Mar 22', '2024-03-22'.to_date ],
-    #   [ 'Mar 28', '2024-03-28'.to_date ],
-    #   [ 'Apr 5',  '2024-04-05'.to_date ],
-    #   [ 'Mar 12', '2024-03-12'.to_date ],
-    #   [ 'Mar 19', '2024-03-19'.to_date ],
-    # ]
-  end
-
-  field :begin_price, type: :float
-  field :begin_delta, type: :float
-  field :end_price, type: :float
-  field :end_delta, type: :float
-
-
-  has_one :outer, class_name: 'Iro::Position', inverse_of: :outer
-  has_one :inner, class_name: 'Iro::Position', inverse_of: :inner
-
-  field :last, type: :float
-
-  ## for TDA
-  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
-
-  before_save :sync, if: ->() { !Rails.env.test? } ## do not sync in test
-  def sync
-    out = Tda::Option.get_quote({
-      contractType: put_call,
-      strike: strike,
-      expirationDate: expires_on,
-      ticker: ticker,
-    })
-    puts! out, 'option sync'
-    self.end_price = ( out.bid + out.ask ) / 2 rescue 0
-    self.end_delta = out.delta if out.delta
-    # self.save
-  end
-
-  def self.max_pain hash
-    outs = {}
-
-    %w| put call |.each do |contractType|
-      dates = hash["#{contractType}ExpDateMap"]
-      dates.each do |_date, strikes| ## _date="2023-02-10:5"
-        date = _date.split(':')[0].to_date.to_s
-        outs[date] ||= {
-          'all'  => {},
-          'call' => {},
-          'put'  => {},
-          'summary' => {},
-        }
-
-        strikes.each do |_strike, _v| ## _strike="18.5"
-          strike = _strike.to_f
-
-          ## calls
-          mem_c = 0
-          strikes.keys.reverse.each do |_key|
-            if _key == _strike
-              break
-            end
-            key = _key.to_f
-            tmp = hash["callExpDateMap"][_date][_key][0]['openInterest'] * ( key - strike )
-            mem_c += tmp
-          end
-          outs[date]['call'][_strike] = mem_c
-
-          ## puts
-          mem_p = 0
-          strikes.keys.each do |_key|
-            if _key == _strike
-              break
-            end
-            key = _key.to_f
-            tmp = hash["putExpDateMap"][_date][_key][0]['openInterest'] * ( strike - key )
-            mem_p += tmp
-          end
-          outs[date]['put'][_strike] = mem_p
-          outs[date]['all'][_strike] = mem_c + mem_p
-
-        end
-      end
-    end
-
-    ## compute summary
-    outs.each do |date, types|
-      all = types['all']
-      outs[date]['summary'] = { 'value' => all.keys[0] }
-      all.each do |strike, amount|
-        if amount < all[ outs[date]['summary']['value'] ]
-          outs[date]['summary']['value'] = strike
-        end
-      end
-    end
-
-    return outs
-  end
-
-
-end

data/app/models/iro/option_black_scholes.rb

@@ -1,149 +0,0 @@
-
-require 'distribution'
-N = Distribution::Normal
-
-module Iro::OptionBlackScholes
-
-  ##
-  ## 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