penfold 1.0.0 → 1.0.1

data/Manifest.txt

@@ -3,10 +3,16 @@ History.txt
 Manifest.txt
 README.rdoc
 Rakefile
+bin/constituents
+bin/optiondate
 bin/penfold
 bin/penfold-position
 bin/penfold-try
+db/init.rb
+db/slurp.rb
+db/sqliterc
 lib/argument_processor.rb
+lib/black_scholes.rb
 lib/commission.rb
 lib/core_ext.rb
 lib/covered_call_early_exit.rb
@@ -16,7 +22,13 @@ lib/covered_call_expiry_otm_exit.rb
 lib/covered_call_position.rb
 lib/market.rb
 lib/option.rb
+lib/option_calendar.rb
 lib/penfold.rb
 lib/stock.rb
-portfolio.yml
+portfolio.example.yml
+symbols/README.txt
+symbols/all-optionable.txt
+symbols/etfs.txt
+symbols/weeklys.txt
+test/test_option_calendar.rb
 test/test_penfold.rb

data/Rakefile

@@ -6,6 +6,11 @@ require 'hoe'
 Hoe.spec 'penfold' do |p|
   p.developer('Andrew A. Smith', 'andy@tinnedfruit.org')
   p.readme_file = "README.rdoc"
+  p.extra_deps.push *[
+    %w(nokogiri >=0),
+    %w(penfold >=0),
+    %w(net-http-persistent >=0)
+  ]
 end
 
 Hoe.add_include_dirs '.'

data/bin/constituents

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+abort "usage: #{File.basename($0)} [index]" unless ARGV[0]
+
+LIB_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH << LIB_DIR
+
+require 'lib/penfold'
+
+puts "# Generated at #{Time.now}"
+puts Market.constituents(ARGV[0]).join("\n")

data/bin/optiondate

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# optiondate [num of days]
+
+LIB_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH << LIB_DIR
+
+require 'lib/option_calendar'
+
+unless ARGV.size == 1 and ARGV.to_s =~ /^\d+$/
+  abort "usage: #{File.basename($0)} [num of days]"
+end
+
+expiry = OptionCalendar.nearest_expiration(Date.today, ARGV[0].to_i.days)
+
+puts expiry.strftime("%y%m%d")
+

data/db/init.rb

@@ -0,0 +1,39 @@
+require "rubygems"
+require "sequel"
+
+DB = Sequel.sqlite("options.sqlite")
+
+DB.create_table :covered_calls do
+  primary_key :id
+
+  Date    :quote_date, :null => false
+  Integer :days, :null => false
+
+  String  :stock, :null => false
+  Float   :stock_price, :null => false # last
+
+  String  :option, :null => false
+  Float   :option_price, :null => false # bid
+
+  Float   :implied_volatility, :null => false
+  Float   :prob_max_profit, :null => false
+  Float   :prob_profit, :null => false
+
+  Float   :downside_protection, :null => false
+
+  Float   :period_return, :null => false
+  Float   :annual_return, :null => false
+
+  Boolean :event, :null => false
+
+  String  :label
+  String  :mktcap
+  String  :name
+
+  index :annual_return
+  index :downside_protection
+  index :prob_max_profit
+
+  unique [:quote_date, :stock, :option]
+end
+

data/db/slurp.rb

@@ -0,0 +1,202 @@
+require 'rubygems'
+require 'sequel'
+require 'penfold'
+
+filename = ARGV[0]
+
+symbols = if filename
+  File.read(filename).
+               split(/\n/).
+               map{|s| s.strip}.
+               reject{|s|s =~ /^#/}
+else
+  %w(VZ C GE DVY PGR COCO BP RIG)
+end
+
+# series is the option symbol timestamp,
+# such as 100821, 100918, etc.
+series = ARGV[1]
+expiry = Date.strptime series, "%y%m%d"
+
+today = Date.today
+
+quote_date = if [6,0].include?(today.wday)
+  # weekend, wind back to friday
+  today - (today.wday.zero? ? 2 : 1)
+else
+  today
+end
+
+puts "Quote date is #{quote_date.inspect}"
+
+INVESTMENT_AMOUNT = 10_000_00 # $10,000.00
+
+# Do not reorder these, only append.
+# DJI  = 1
+# OEX  = 2
+# SPX  = 4
+# ETFS = 8
+# NONE = 16
+INDEX_SYMBOLS = %w(DJI OEX SPX ETFS NONE)
+
+DB = Sequel.sqlite("options.sqlite")
+calls = DB[:covered_calls]
+
+symbols.each do |symbol|
+  puts "== #{symbol} ====================="
+
+  begin
+    # Get a delayed quote, as option quotes are delayed.
+    stock_quote = Market.fetch(symbol, :try_rt => false, :extra => true)
+  rescue
+    puts "Error getting #{symbol}"
+    puts $!
+    next
+  end
+
+  stock = Stock.new(:symbol => symbol, :price => stock_quote.last)
+
+  num_shares = ((INVESTMENT_AMOUNT / stock.price) / 100.0).floor * 100
+
+  if num_shares.zero?
+    puts "Skipping because #{INVESTMENT_AMOUNT.to_money_s} will not buy any shares of #{symbol} @ #{stock.price.to_money_s}."
+    next
+  end
+
+  begin
+    itm_option_quotes = Market.chain(symbol, expiry)
+  rescue
+    puts "No options for #{symbol}"
+    puts $!
+    next
+  end
+
+  event = Market.event?(symbol, expiry)
+
+  begin
+    prices = Market.historical_prices(stock.symbol)
+  rescue
+    puts "No historical pricing available for #{symbol}"
+    puts $!
+    next
+  end
+
+
+
+  itm_options = itm_option_quotes.map do |strike, option_quote|
+    Call.new(
+      :symbol => option_quote.symbol,
+      :stock => stock,
+      :strike => strike,
+      :expires => expiry,
+      :price => option_quote.bid, # TODO: parametize
+      :current_date => quote_date
+    )
+  end
+
+  positions = itm_options.map do |option|
+    CoveredCallPosition.new(
+      :commission => "OptionsHouse",
+      :num_shares => num_shares,
+      :date_established => Date.today,
+      :option => option
+    )
+  end
+
+  # Get the IV for the nearest ot the money ITM option. If this comes back as 
+  # N/A, then the option is probably too far from the money to have an IV.
+  # (example C @ 3.95, ITM option is at 3 strike with few days left)
+  nearest_atm_iv = positions.last.implied_volatility rescue 0.0
+
+  positions.each { |p| p.instance_variable_set "@iv", nearest_atm_iv }
+
+  positions.each do |position|
+    close = CoveredCallExit.new(
+      :opening_position => position,
+      :exit_date => Date.today + 99999,
+      :stock_price => stock.price,
+      :option_price => position.option.price
+    )
+  
+    # calculate percentage above strike for year
+    strike = position.option.strike / 100.0
+    above = prices.select { |price| price >= strike }
+    percent_above = above.size / prices.size.to_f
+
+    summary = <<-SUMMARY
+%s @ %s: %s @ %s  IV %s 
+Prob. (Max) profit  (%s) %s
+Downside Protection %s
+Return (period) ann (%s) %s %s
+SUMMARY
+
+    r = close.annualized_return
+
+    if r > 0.12
+      puts summary % [
+        stock.symbol,
+        stock.price.to_money_s,
+        position.option.to_ticker_s,
+        position.option.price.to_money_s,
+
+        position.implied_volatility.to_percent_s(2),
+        position.probability_max_profit.to_percent_s(2),
+        position.probability_profit.to_percent_s(2),
+
+        position.downside_protection.to_percent_s(2),
+
+        close.period_return.to_percent_s(2),
+        r.to_percent_s(2),
+        event ? "EVENT IN DURATION" : ""
+      ]
+
+
+      flag = 1 << INDEX_SYMBOLS.index("NONE")
+
+      INDEX_SYMBOLS.each_with_index do |index_symbol, i|
+        next if index_symbol == "NONE"
+
+        member_of_index = if File.exists?(fn = "symbols/#{index_symbol.downcase}.txt")
+          File.read(fn).include?("\n#{stock.symbol}\n")
+        else
+          Market.member_of?(stock.symbol, index_symbol)
+        end
+
+        flag |= (1 << i) if member_of_index
+      end
+
+      mktcap = stock_quote.extra[:mktcap]
+
+      if mktcap
+        multiplier = mktcap.scan(/.$/).to_s
+        mktcap = mktcap.to_f
+        mktcap = multiplier == "B" ? mktcap * 1_000_000_000 : multiplier == "M" ? mktcap * 1_000_000 : nil
+      end
+
+      calls.insert(
+        :quote_date          => quote_date,
+        :days                => close.days_in_position,
+        :stock               => stock.symbol,
+        :stock_price         => stock.price / 100.0,
+        :option              => position.option.to_ticker_s,
+        :option_price        => position.option.price / 100.0,
+        :implied_volatility  => position.implied_volatility * 100.0,
+        :prob_max_profit     => position.probability_max_profit * 100.0,
+        :prob_profit         => position.probability_profit * 100.0,
+        :downside_protection => position.downside_protection * 100.0,
+        :period_return       => close.period_return * 100.0,
+        :annual_return       => close.annualized_return * 100.0,
+        :event               => event,
+        :label               => File.split(filename).last,
+        :mktcap              => mktcap,
+        :name                => stock_quote.extra[:name],
+        :divyield            => stock_quote.extra[:divyield],
+        :pe                  => stock_quote.extra[:pe],
+        :sector              => stock_quote.extra[:sector],
+        :industry            => stock_quote.extra[:industry],
+        :percent_above       => percent_above * 100.0,
+        :memberships         => flag
+      )
+    end
+  end
+end

data/db/sqliterc

@@ -0,0 +1,4 @@
+-- Place this in ~/.sqliterc
+.headers on
+.mode column
+.width 5 10 4 5 7 24 6 6 6 6 6 6 6 6 16 10 40 5 7 10 25 covered_calls

data/lib/black_scholes.rb

@@ -0,0 +1,146 @@
+#  JavaScript adopted from Bernt Arne Odegaard's Financial Numerical Recipes
+#  http://finance.bi.no/~bernt/gcc_prog/algoritms/algoritms/algoritms.html
+#  by Steve Derezinski, CXWeb, Inc.  http://www.cxweb.com
+#  Copyright (C) 1998  Steve Derezinski, Bernt Arne Odegaard
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#  http://www.fsf.org/copyleft/gpl.html
+ 
+class BlackScholes
+  class << self
+    def ndist(z)
+      (1.0/(Math.sqrt(2*Math::PI)))*Math.exp(-0.5*z)
+    end
+
+    def n(z)
+      b1 =  0.31938153
+      b2 = -0.356563782
+      b3 =  1.781477937
+      b4 = -1.821255978
+      b5 =  1.330274429
+      p  =  0.2316419
+      c2 =  0.3989423
+
+      a = z.abs
+
+      return 1.0 if a > 6.0
+
+      t = 1.0/(1.0+a*p)
+      b = c2*Math.exp((-z)*(z/2.0))
+      n = ((((b5*t+b4)*t+b3)*t+b2)*t+b1)*t
+      n = 1.0-b*n
+
+      n = 1.0 - n if z < 0.0
+
+      n
+    end
+
+    def black_scholes(call,s,x,r,v,t)
+      # call = Boolean (to calc call, call=True, put: call=false)
+      # s = stock prics, x = strike price, r = no-risk interest rate
+      # v = volitility (1 std dev of s for (1 yr? 1 month?, you pick)
+      # t = time to maturity
+
+      sqt = Math.sqrt(t)
+
+      d1 = (Math.log(s/x) + r*t)/(v*sqt) + 0.5*(v*sqt)
+      d2 = d1 - (v*sqt)
+
+      if call
+        delta = n(d1)
+        nd2 = n(d2)
+      else # put
+        delta = -n(-d1)
+        nd2 = -n(-d2)
+      end
+
+      ert = Math.exp(-r*t)
+      nd1 = ndist(d1)
+
+      gamma = nd1/(s*v*sqt)
+      vega = s*sqt*nd1
+      theta = -(s*v*nd1)/(2*sqt) - r*x*ert*nd2
+      rho = x*t*ert*nd2
+
+      s*delta-x*ert*nd2
+    end 
+
+    def option_implied_volatility(call,s,x,r,t,o)
+      # call = Boolean (to calc call, call=True, put: call=false)
+      # s = stock prics, x = strike price, r = no-risk interest rate
+      # t = time to maturity
+      # o = option price
+
+      sqt = Math.sqrt(t)
+      accuracy = 0.0001
+
+      sigma = (o/s)/(0.398*sqt)
+
+      100.times do
+        price = black_scholes(call,s,x,r,sigma,t)
+        diff = o-price
+
+        return sigma if diff.abs < accuracy
+
+        d1 = (Math.log(s/x) + r*t)/(sigma*sqt) + 0.5*sigma*sqt
+        vega = s*sqt*ndist(d1)
+        sigma = sigma+diff/vega
+      end
+
+      raise "Failed to converge"
+    end
+
+    def call_iv(s,x,r,t,o)
+      option_implied_volatility(true,s,x,r/100.0,t/365.0,o)
+    end
+
+    # Returns probability of occuring below and above target price.
+    def probability(price, target, days, volatility)
+      p = price.to_f
+      q = target.to_f
+      t = days / 365.0
+      v = volatility.to_f
+
+      vt = v*Math.sqrt(t)
+      lnpq = Math.log(q/p)
+
+      d1 = lnpq / vt
+
+      y = (1/(1+0.2316419*d1.abs)*100000).floor / 100000.0
+      z = (0.3989423*Math.exp(-((d1*d1)/2))*100000).floor / 100000.0
+
+      y5 = 1.330274*(y**5)
+      y4 = 1.821256*(y**4)
+      y3 = 1.781478*(y**3)
+      y2 = 0.356538*(y**2)
+      y1 = 0.3193815*y
+
+      x = 1-z*(y5-y4+y3-y2+y1)
+
+      x = (x*100000).floor / 100000.0
+
+      x = 1-x if d1 < 0
+
+      pbelow = (x*1000).floor / 10.0
+      pabove = ((1-x)*1000).floor / 10.0;
+
+      [pbelow/100,pabove/100];
+    end
+
+    def probability_above(price, target, days, volatility)
+      probability(price, target, days, volatility)[1]
+    end
+
+    def probability_below(price, target, days, volatility)
+      probability(price, target, days, volatility)[0]
+    end
+  end
+end
+

data/lib/market.rb

@@ -1,21 +1,27 @@
-require 'rubygems'
-require 'nokogiri'
-require 'open-uri'
 require 'date'
 require 'cgi'
 
+require 'stringio'
+require 'zlib'
+
+require 'rubygems'
+require 'nokogiri'
+require 'net/http/persistent'
+
 class Market
   HEADERS = {
     "Accept" => "application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
     "Accept-Charset" => "ISO-8859-1,utf-8;q=0.7,*;q=0.3",
     "Accept-Language" => "en-US,en;q=0.8",
+    "Accept-Encoding" => "gzip,deflate",
     "Cache-Control" => "max-age=0",
-    "Connection" => "keep-alive",
     "Host" => "finance.yahoo.com",
     "Referer" => "http://finance.yahoo.com/",
     "User-Agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/8.0.552.215 Safari/534.10"
   }
 
+  @http = Net::HTTP::Persistent.new
+
   class Quote
     include ArgumentProcessor
 
@@ -38,12 +44,33 @@ class Market
   end
 
   class << self
+    def get(url)
+      uri = URI.parse(url)
+
+      request = Net::HTTP::Get.new uri.request_uri
+
+      HEADERS.each do |name, value|
+        request.add_field name, value
+      end
+
+      response = @http.request(uri, request)
+      data = response.body
+
+      out = case response["content-encoding"]
+        when /gzip/    then Zlib::GzipReader.new(StringIO.new(data)).read
+        when /deflate/ then Zlib::Inflate.inflate(data)
+        else data
+      end
+
+      out
+    end
+
     def fetch(ticker, opts = {})
       url = "http://finance.yahoo.com/q?s=%s" % ticker
       puts "Fetching #{url}..." if $VERBOSE
 
       doc = with_retry do
-        Nokogiri::HTML.parse(open(url, HEADERS).read)
+        Nokogiri::HTML.parse(get(url))
       end
 
       # Realtime last is at yfs_l90_sym, use if exists
@@ -135,7 +162,7 @@ class Market
       puts "Fetching #{url}..." if $VERBOSE
 
       doc = with_retry do
-        Nokogiri::HTML.parse(open(url, HEADERS).read)
+        Nokogiri::HTML.parse(get(url))
       end
 
       itm_call_data = doc.
@@ -169,7 +196,7 @@ class Market
       puts "Fetching #{url}..." if $VERBOSE
 
       doc = with_retry do
-        Nokogiri::HTML.parse(open(url, HEADERS).read)
+        Nokogiri::HTML.parse(get(url))
       end
 
       return false if doc.text =~ /There is no Company Events data/
@@ -197,7 +224,7 @@ class Market
       puts "Fetching #{url}..." if $VERBOSE
 
       csv = with_retry do
-        open(url, HEADERS).read
+        get(url)
       end
 
       # [newest, ..., oldest]
@@ -211,7 +238,7 @@ class Market
       puts "Fetching #{url}..." if $VERBOSE
 
       doc = with_retry do
-        Nokogiri::HTML.parse(open(url, HEADERS).read)
+        Nokogiri::HTML.parse(get(url))
       end
 
       symbols = doc.at("#yfncsumtab").search("tr td:first-child.yfnc_tabledata1").map{ |td| td.text }

data/lib/option_calendar.rb

@@ -0,0 +1,56 @@
+# Finds upcoming expiry dates for monthly equity options.
+#
+# Test data is the official CBOE expiration calendars for 2010/11.
+
+require 'date'
+
+require 'rubygems'
+require 'active_support'
+
+class OptionCalendar
+  class << self
+    FRIDAY = 5
+
+    def expiration_for(month)
+      start = month.beginning_of_month
+
+      expiry_week = start.advance(:days => 14)
+
+      expiry_week += 1.day while expiry_week.wday != FRIDAY
+
+      expiry_saturday = expiry_week + 1.day
+    end
+
+    def next_expiring_months(from = Date.today)
+      this_month = expiration_for(from)
+      next_month = expiration_for(from.next_month)
+
+      expirations = [
+        this_month,
+        next_month
+      ]
+
+      # If the first month has already expired, remove it, and add another month out
+      if from >= (this_month - 1.day)
+        expirations.shift
+        expirations << expiration_for(next_month.next_month)
+      end
+
+      expirations
+    end
+  
+    def nearest_expiration(date, range = 3.days)
+      expiration_date = expiration_for(date + range)
+
+      if date > expiration_date
+        expiration_date = expiration_for(expiration_date.next_month)
+      end
+
+      if date >= expiration_date - range
+        expiration_for(expiration_date.next_month)
+      else
+        expiration_date
+      end
+    end
+  end
+end

data/lib/penfold.rb

@@ -16,5 +16,5 @@ require 'covered_call_expiry_otm_exit'
 require 'black_scholes'
 
 module Penfold
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/portfolio.example.yml

@@ -0,0 +1,16 @@
+--- 
+example: !ruby/object:CoveredCallPosition 
+  commission: !ruby/object:Commission 
+    option_assignment: 500
+    option_entry: 850
+    option_entry_per_contract: 15
+    stock_entry: 295
+  num_shares: 500
+  option: !ruby/object:Call 
+    expires: 2010-08-24
+    price: 600
+    stock: !ruby/object:Stock 
+      price: 5000
+      symbol: XYZ
+    strike: 5000
+

data/symbols/README.txt

@@ -0,0 +1,7 @@
+When building symbol files, it can be useful to ensure that symbols from a given set of
+files do not occur in more than one file. To print duplicates:
+
+ sort -o tmpA symbolsA.txt
+ sort -o tmpB symbolsB.txt
+ comm -12 tmpA tmpB
+