wco_models 3.1.0.187 → 3.1.0.189

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c92eec35ddd3ac3529aaae7038f966e59720968c0752b986e70ff63eb6d68d8
-  data.tar.gz: 2ec53d7a8343064c691ca765ee5dfcf2f45466a2052125c11c302efcedb37e82
+  metadata.gz: 6d7aa099d022824fbef4b0fae04c43b89a70ab7e232e70fce561f268c8733084
+  data.tar.gz: 4b7b8bb274105b8ab5dd52c5705e5cab7e2f16a1d4e43d59434c62ddaa87fa0d
 SHA512:
-  metadata.gz: c67a8e7a82da5ff9dbce62b34c3212ec3ff0a4d2839f194c0a525654bb52881fb3e995f42c4c1814ea5dacc2cb46657ac2e07d9e81737529ee71cce61615aa3b
-  data.tar.gz: 9fdf1636384b545090d1caf80d5f345597f7aef17311c2da04a74ed1d960e866db58e146471765ec6804760e59b731ef5181442c9dbf069467689fcd878cc0a2
+  metadata.gz: 856d7b8285233d1a98b6874c493e6b015da8c8723da597576fb28d0716f190a1a41ea673c18920cca10e12791cb1e08d7f3d4fcb0b3b352dd3562838c406ab5c
+  data.tar.gz: 65badfb5507f336f56d25fe963a5eb8a743186d410cfa4910bdc8fd952c25fa9bcea54df61bfa63511dd63c94715b5846c311dcc4e19b3462be0ae1f8d603596

data/app/models/iro/alert.rb

@@ -0,0 +1,63 @@
+
+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
+
+  DIRECTION_ABOVE = 'ABOVE'
+  DIRECTION_BELOW = 'BELOW'
+  def self.directions_list
+    [ nil, DIRECTION_ABOVE, DIRECTION_BELOW ]
+  end
+
+  STATUS_ACTIVE   = 'active'
+  STATUS_INACTIVE = 'inactive'
+  STATUSES        = [ nil, 'active', 'inactive' ]
+  field :status, default: STATUS_ACTIVE
+  def self.active
+    where( status: STATUS_ACTIVE )
+  end
+
+  field :class_name, default: 'Iro::Stock'
+  validates :class_name, presence: true
+
+  field :symbol, type: String
+  validates :symbol, presence: true
+
+  field :direction, type: String
+  validates :direction, presence: true
+
+  field :strike, type: Float
+  validates :strike, presence: true
+
+  def do_run
+    alert = self
+    begin
+      price = Tda::Stock.get_quote( alert.symbol )&.last
+      return if !price
+
+      if ( alert.direction == alert.class::DIRECTION_ABOVE && price >= alert.strike ) ||
+         ( alert.direction == alert.class::DIRECTION_BELOW && price <= alert.strike )
+
+        if Rails.env.production?
+          Iro::AlertMailer.stock_alert( alert.id.to_s ).deliver_later
+        else
+          Iro::AlertMailer.stock_alert( alert.id.to_s ).deliver_now
+        end
+        alert.update({ status: alert.class::STATUS_INACTIVE })
+        print '^'
+
+      end
+    rescue => err
+      puts! err, 'err'
+      ::ExceptionNotifier.notify_exception(
+        err,
+        data: { alert: alert }
+      )
+    end
+  end
+
+end

data/app/models/iro/datapoint.rb

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

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

data/app/models/iro/option.rb

@@ -0,0 +1,154 @@
+
+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
+
+  CALL = 'CALL'
+  PUT  = 'PUT'
+
+  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

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