A bunch of fixes

Author: philfoster

bin/analyze_ccw.py

@@ -0,0 +1,83 @@
+#! /usr/bin/python3
+
+import pandas as pd
+import argparse
+from screener_tools import read_json_file
+
+DEFAULT_ANALYZER_CONFIG="./etc/analyzer.json"
+
+COL_RANK="Score"
+COL_ROO="ROO Annualized(%)"
+COL_TOTAL_GAIN="Total Annualized(%)"
+COL_BETA="Beta"
+COL_DOWNSIDE="Downside Protection(%)"
+COL_DELTA="Delta"
+
+WEIGHT_RANK="score_weight"
+WEIGHT_ROO="roo_weight"
+WEIGHT_TOTAL_GAIN="total_gain_weight"
+WEIGHT_BETA="beta_weight"
+WEIGHT_DOWNSIDE="downside_weight"
+WEIGHT_DELTA="delta_weight"
+
+DEFAULT_WEIGHT_RANK=1.0
+DEFAULT_WEIGHT_ROO=2.0
+DEFAULT_WEIGHT_TOTAL_GAIN=2.0
+DEFAULT_WEIGHT_BETA=25
+DEFAULT_WEIGHT_DOWNSIDE=20.0
+DEFAULT_WEIGHT_DELTA=100.0
+
+COL_RANK_SCORE="Rank Score"
+COL_RANK_ROO="ROO Score"
+COL_RANK_TOTAL_GAIN="Total Gain Score"
+COL_RANK_BETA="Beta Score"
+COL_RANK_DOWNSIDE="Downside Score"
+COL_RANK_DELTA="Delta Score"
+COL_RANK_OPTION="Total Option Score"
+
+global GLOBAL_VERBOSE
+global GLOBAL_CONFIG
+
+def main(results_csv,output_file):
+    df = pd.read_csv(results_csv)
+
+    df[COL_RANK_SCORE] = calculate_simple_score(df[COL_RANK],GLOBAL_CONFIG.get(WEIGHT_RANK,DEFAULT_WEIGHT_RANK))
+    df[COL_RANK_ROO] = calculate_simple_score(df[COL_ROO],GLOBAL_CONFIG.get(WEIGHT_ROO,DEFAULT_WEIGHT_ROO))
+    df[COL_RANK_TOTAL_GAIN] = calculate_simple_score(df[COL_TOTAL_GAIN],GLOBAL_CONFIG.get(WEIGHT_TOTAL_GAIN,DEFAULT_WEIGHT_TOTAL_GAIN))
+    df[COL_RANK_BETA] = calculate_beta_score(df[COL_BETA],GLOBAL_CONFIG.get(WEIGHT_BETA,DEFAULT_WEIGHT_BETA))
+    df[COL_RANK_DOWNSIDE] = calculate_simple_score(df[COL_DOWNSIDE],GLOBAL_CONFIG.get(WEIGHT_DOWNSIDE,DEFAULT_WEIGHT_DOWNSIDE))
+    df[COL_RANK_DELTA] = calculate_simple_score(df[COL_DELTA],GLOBAL_CONFIG.get(WEIGHT_DELTA,DEFAULT_WEIGHT_DELTA))
+
+    df[COL_RANK_OPTION] = (df[COL_RANK_SCORE] + df[COL_RANK_ROO] + df[COL_RANK_TOTAL_GAIN] + df[COL_RANK_BETA] + df[COL_RANK_DOWNSIDE] + df[COL_RANK_DELTA] ) / 6
+
+    print(df[COL_RANK_OPTION])
+
+    df.to_csv(output_file)
+
+def calculate_simple_score(series,weight):
+    return series * weight
+
+def calculate_beta_score(series,weight):
+    return (3 - series) * weight
+
+def debug(msg):
+    if GLOBAL_DEBUG:
+        print(msg)
+
+if __name__ == "__main__":
+    # Setup the argument parsing
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c','--config-file', dest='config_file', help="analyzer configuration file", default=DEFAULT_ANALYZER_CONFIG)
+    parser.add_argument('-r','--results', dest='results', required=True, help="CSV file with covered calls")
+    parser.add_argument('-v','--verbose', dest='verbose', required=False,default=False,action='store_true',help="Increase verbosity")
+    parser.add_argument('-d','--debug', dest='debug', required=False,default=False,action='store_true',help="Enable debugging")
+    parser.add_argument('-o','--output-csv', dest='output', required=True, help="CSV file to write the output to")
+    args = parser.parse_args()
+
+    GLOBAL_VERBOSE = args.verbose
+    GLOBAL_DEBUG = args.debug
+
+    GLOBAL_CONFIG = read_json_file(args.config_file)
+
+    main(args.results,args.output)
+

bin/ata.py

@@ -8,6 +8,7 @@
 
 from pandas_datareader import data as pdr
 from etrade_tools import *
+from screener_tools import *
 from stock_chart_tools.utils import get_historical_data, EMA, OBV, SSO, MACD
 from stock_chart_tools.utils import COLUMN_CLOSE, COLUMN_VOLUME, COLUMN_HIGH, COLUMN_LOW, MACD_DIVERGENCE, MACD_LABEL, OBV_LABEL, SS_K, SS_D
 
@@ -32,17 +33,6 @@
 FRESHNESS_DAYS=1
 ONE_DAY = 24 * 60 * 60
 
-CACHE_FRESHNESS_SECONDS=60*60 * 2
-
-# Columns
-THREE_DAY_EMA="3dayEMA"
-FIVE_DAY_EMA="5dayEMA"
-NINE_DAY_EMA="9dayEMA"
-TWENTY_DAY_EMA="20dayEMA"
-HUNDRED_DAY_EMA="100dayEMA"
-VOL_THREE_DAY="Vol3DayEMA"
-VOL_TWENTY_DAY="Vol20DayEMA"
-
 # Globals
 global GLOBAL_VERBOSE
 
@@ -64,7 +54,7 @@ def analyze_symbol(screener_config,questions,symbol):
     answer_file = get_answer_file(screener_config.get(CACHE_DIR),symbol)
     answers = get_all_answers_from_cache(answer_file)
 
-    price_data = get_one_year_data(symbol,screener_config.get(CACHE_DIR))
+    price_data = get_two_year_data(symbol,screener_config.get(CACHE_DIR))
 
     (value,timestamp) = is_price_uptrending(symbol,price_data,answers)
     (value,timestamp) = is_price_above_20dayEMA(symbol,price_data,answers)
@@ -83,53 +73,6 @@ def analyze_symbol(screener_config,questions,symbol):
 
     cache_answers(answer_file,answers)
 
-def get_cache_filename(symbol,cache_dir):
-    return os.path.join(expanduser(cache_dir),f"{symbol}.year.cache")
-
-def get_cached_historical_data(symbol,cache_dir):
-    filename = get_cache_filename(symbol,cache_dir)
-    try:
-        print(f"trying to get the cached data")
-        file_mtime = os.path.getmtime(filename)
-        if (time.time() - file_mtime) < CACHE_FRESHNESS_SECONDS:
-            data = pd.read_csv(filename,index_col=0)
-            return data
-        else:
-            print(f"{filename} cache is not fresh enough")
-    except Exception as e:
-        debug(f"could not read cache {filename}: {e}")
-
-    return None
-
-def cache_historical_data(symbol,cache_dir,price_data):
-    filename = get_cache_filename(symbol,cache_dir)
-    price_data.to_csv(filename)
-
-def get_one_year_data(symbol,cache_dir):
-
-    # Try to get the price data from cache
-    price_data = get_cached_historical_data(symbol,cache_dir)
-    if price_data is not None:
-        debug(f"{symbol} returning historical data from cache")
-        return price_data
-
-    # Nothing fresh in the cache
-    debug(f"{symbol} getting historical data from API")
-    price_data = get_historical_data(symbol)
-
-    price_data[THREE_DAY_EMA] = EMA(price_data[COLUMN_CLOSE],3)
-    price_data[FIVE_DAY_EMA] = EMA(price_data[COLUMN_CLOSE],5)
-    price_data[NINE_DAY_EMA] = EMA(price_data[COLUMN_CLOSE],9)
-    price_data[TWENTY_DAY_EMA] = EMA(price_data[COLUMN_CLOSE],20)
-    price_data[HUNDRED_DAY_EMA] = EMA(price_data[COLUMN_CLOSE],100)
-
-    price_data[VOL_THREE_DAY] = EMA(price_data[COLUMN_VOLUME],3)
-    price_data[VOL_TWENTY_DAY] = EMA(price_data[COLUMN_VOLUME],20)
-
-    cache_historical_data(symbol,cache_dir,price_data)
-
-    return price_data
-
 def is_fresh(cached_answer):
 
     # Check to see if "-f" was passed, if so, ignore freshness

bin/buy_stock.py

@@ -0,0 +1,25 @@
+#! /usr/bin/python3
+
+import argparse
+import json
+from etrade_tools import *
+
+DEFAULT_CONFIG_FILE="./etc/etrade.json"
+DEFAULT_ACCOUNT_NAME="Rollover IRA"
+
+def main(config_file, account_name):
+    acct = get_account_by_name(config_file, account_name)
+    print(f"acct name={acct.get_display_name()} balance=${acct.get_balance():.2f}")
+
+def get_account_by_name(config_file, account_name):
+    accounts = get_account_list(config_file)
+    return accounts.get_account_by_name(account_name)
+
+if __name__ == "__main__":
+    # Setup the argument parsing
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c','--config-file', dest='config_file', help="etrade configuration file", default=DEFAULT_CONFIG_FILE)
+    parser.add_argument('-a','--account', dest='account_name', required=False,default=DEFAULT_ACCOUNT_NAME,action='store_true',help="Account Name")
+    args = parser.parse_args()
+    main(args.config_file,args.account_name)
+

bin/find_roll_outs.py

@@ -28,17 +28,22 @@
 
 # How many days out to look for rollouts
 MAX_ROLLOUT_DAYS = 65
+MIN_ROLLOUT_DAYS = 1
 
 # This is the highest strike price to consider
 MAX_STRIKE_FACTOR = 1.05
 
-def main(config_file, symbol, existing_expiration, strike, verbose):
+def main(config_file, symbol, existing_expiration, strike, min_days, max_days, verbose):
 
     quote = get_quote(config_file, symbol)
     price = quote.get_price()
     exdate = quote.get_exdate()
     dividend = quote.get_dividend()
 
+    intrinsic_value = price - strike
+    if intrinsic_value < 0:
+        intrinsic_value = 0
+
     if price <= float(strike * (100 - PRICE_PROXIMITY)/100):
         print(f"{symbol}: price ${price:.2f} is more than {PRICE_PROXIMITY}% below strike {strike}")
         return
@@ -50,16 +55,25 @@ def main(config_file, symbol, existing_expiration, strike, verbose):
 
     print(f"{symbol}: ${price:.2f}")
     print(f"{call_option.get_display_symbol()}")
+
+    ask = call_option.get_ask()
+    time_value = ask - intrinsic_value
+    tv_prct = 100 * (time_value / strike)
+
+    itm_prct = 100 * (intrinsic_value / strike)
+
+    print(f"Ask: {ask} (time value remaining=${time_value:.2f} / {tv_prct:.1f}%)")
+    print(f"Current intrinsic value: ${intrinsic_value:.2f} ({itm_prct:.1f}%)")
     print(f"-----")
-    ask = call_option.get_bid()
 
     if ask == 0:
         print("ERROR: ask is 0.00, maybe the market will open soon?")
         return
 
-    option_chain_list = get_matching_option_chains(config_file, symbol, existing_expiration, MAX_ROLLOUT_DAYS)
+    option_chain_list = get_matching_option_chains(config_file, symbol, existing_expiration, min_days, max_days)
     for option_chain in option_chain_list:
-        roll_out_days = option_chain.get_expiration() - existing_expiration
+        #roll_out_days = option_chain.get_expiration() - existing_expiration
+        roll_out_days = option_chain.get_expiration() - datetime.datetime.now()
         risky_exdate = False
         div_ex_date_from_expiration = option_chain.get_expiration() - exdate
         if 0 < div_ex_date_from_expiration.days < EXDATE_THRESHOLD:
@@ -74,34 +88,76 @@ def main(config_file, symbol, existing_expiration, strike, verbose):
             if bid < ask:
                 # Skip this, it would end with a debit
                 continue
+
             credit = bid - ask
             buy_up = strike_price - strike
 
             total_gain = credit + buy_up
-            prct = 100 * (total_gain / strike)
-            bpd = 100 * (prct / roll_out_days.days)
+            total_prct = 100 * (total_gain / strike)
+            bpd = 100 * (total_prct / roll_out_days.days)
 
             buy_up_prct = 100 * (buy_up/strike)
-            buy_up_score = (100 * BUY_UP_SCORE_FACTOR * buy_up_prct) / (roll_out_days.days ** 2)
+            credit_prct = 100 * (credit/strike)
+
+            #buy_up_score = (100 * BUY_UP_SCORE_FACTOR * buy_up_prct) / (roll_out_days.days ** 2)
+            #credit_score = (100 * CREDIT_FACTOR * credit ) / (roll_out_days.days ** 2)
 
-            credit_score = (100 * CREDIT_FACTOR * credit ) / (roll_out_days.days ** 2)
+            (total_score) = get_scores(buy_up_prct, credit_prct, roll_out_days.days, risky_exdate)
 
-            total_score = credit_score + buy_up_score + bpd
-            if risky_exdate:
-                total_score = total_score * RISKY_EXDATE_FACTOR
+            print(f"{call.get_display_symbol():28}:  credit=${credit:5.2f}({credit_prct:4.2f}%) buy_up=${buy_up:5.2f}({buy_up_prct:4.2f}%) total={total_prct:5.2f}% days={roll_out_days.days:2d} bpd={bpd:5.2f} exdate_risk={risky_exdate} score={total_score:5.2f}")
 
-            print(f"{call.get_display_symbol()}:  credit=${credit:5.2f} buy_up=${buy_up:5.2f} gain={prct:5.2f}% days={roll_out_days.days:2d} bpd={bpd:5.2f} c_score={credit_score:5.2f} b_score={buy_up_score:5.2f} exdate_risk={risky_exdate} score={total_score:5.2f}")
+def get_scores(buy_up_prct, credit_prct, num_days, risky_exdate):
+    # What makes a good score?
+    #   The best score has a good credit, and a roll up, is soon not later than the next monthly expiration
+    # Points:
+        # buy up score: multiply by 100 (on the order of 0.5 to 4.0)
+        # credit score: multiply by 100 (on the order of 0.5 to 4.0)
+        # credit score > buy up score: if buy up == 0, add 1 else divide credit by buy up (0.5 to 2.0)
+        # Risky ex-date: subtract 2
+        # Date: (10 - (days / 7) )/ 5 (0.00 to 1.8)
 
+    # What makes a bad score?
+    #   Too much buy up, not enough credit
+    #   Has a risky exdate
+
+    # Add credit and buy up
+    #print(f"credit prct = {credit_prct:.2f}")
+    #print(f"buy_up = {buy_up_prct:.2f}")
+
+    score = (credit_prct + buy_up_prct)
+
+    # Add the credit preference
+    credit_preference = 0
+    if buy_up_prct > 0:
+
+        if buy_up_prct > credit_prct:
+            credit_preference = credit_prct
+        else:
+            credit_preference = (credit_prct) + (buy_up_prct)
+
+#    print(f"credit prefernece = {credit_preference:.2f}")
+    score += credit_preference
+        
+    duration_factor = (10 - ((num_days / 7)*3))
+    score += duration_factor
+
+    exdate_factor = 0
+    if risky_exdate:
+        exdate_factor = -2
+
+    score += exdate_factor
+
+    return score
 
-def get_matching_option_chains(config_file, symbol, existing_expiration, MAX_ROLLOUT_DAYS):
+def get_matching_option_chains(config_file, symbol, existing_expiration, min_days, max_days):
     option_chain_list = list()
     dates = get_expiration_dates(config_file, symbol)
 
     for (expiration_date, expiration_type) in dates:
         if expiration_date > existing_expiration:
             elapsed = expiration_date - existing_expiration
             days = elapsed.days
-            if days < MAX_ROLLOUT_DAYS:
+            if min_days < days < max_days:
                 option_chain = get_option_chain(config_file, symbol, expiration_date)
                 if option_chain:
                     option_chain_list.append(option_chain)
@@ -131,11 +187,13 @@ def get_expiration_dates(config_file, symbol):
     parser.add_argument('-s','--symbol', dest='symbol', required=True,help="Symbol of the call" )
     parser.add_argument('-e','--expiration', dest='expiration', required=True,help="Symbol to search" )
     parser.add_argument('-p','--strike-price', dest='strike', required=True,help="Strike price" )
+    parser.add_argument('--min-days', dest='min_days', required=False, default=MIN_ROLLOUT_DAYS,help="Minimum number of days until expiration" )
+    parser.add_argument('--max-days', dest='max_days', required=False, default=MAX_ROLLOUT_DAYS,help="Maximum number of days until expiration" )
     parser.add_argument('-v','--verbose', dest='verbose', required=False,default=False,action='store_true',help="Increase verbosity")
     args = parser.parse_args()
 
     if args.expiration is not None:
         (y,m,d) = args.expiration.split("-")
         expiration = datetime.datetime(year=int(y),month=int(m), day=int(d))
 
-    main(args.config_file, args.symbol, expiration, float(args.strike), args.verbose)
+    main(args.config_file, args.symbol, expiration, float(args.strike), int(args.min_days), int(args.max_days), args.verbose)

bin/get_account.py

@@ -0,0 +1,31 @@
+#! /usr/bin/python3
+
+import argparse
+import json
+from etrade_tools import *
+
+DEFAULT_CONFIG_FILE="./etc/etrade.json"
+
+def main(config_file, verbose):
+    accounts = get_account_list(config_file)
+    rollover = accounts.get_account_by_name("Rollover IRA")
+    if rollover:
+        print(f"Account {rollover.get_name()}")
+
+        for p in rollover.get_positions():
+            quantity = p.get_quantity()
+            print(f"{p.get_display_name()} quantity={quantity}")
+
+        print(f"Cash: ${rollover.get_balance():.2f}")
+
+    
+
+
+if __name__ == "__main__":
+    # Setup the argument parsing
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c','--config-file', dest='config_file', help="etrade configuration file", default=DEFAULT_CONFIG_FILE)
+    parser.add_argument('-v','--verbose', dest='verbose', required=False,default=False,action='store_true',help="Increase verbosity")
+    args = parser.parse_args()
+    main(args.config_file,args.verbose)
+