Swap from representative tickers to asset ID's. /assets route.

Author: brandonparsons

lib/efficient_frontier.py

@@ -10,29 +10,34 @@ def upper_bounds(length):
     return np.ones(length).reshape(length, 1)
 
 def format_mean_returns_dataframe(df, length):
-    return df.sort_index().values.reshape(length, 1)
+    # # No longer need to sort the index - already doing that
+    # return df.sort_index().values.reshape(length, 1)
+    return df.values.reshape(length, 1)
 
 def format_covars_dataframe(df):
-    return df.sort(axis=0).sort(axis=1).values
+    # # No longer need to sort the index - already doing that
+    # return df.sort(axis=0).sort(axis=1).values
+    return df.values
 
-def format_resulting_weights(weights, tickers):
+def format_resulting_weights(weights, asset_ids):
     formatted_weights = [ entry[0] for entry in weights ]
 
     allocations = {}
     for i, weight in enumerate(formatted_weights):
-        allocations[tickers[i]] = weight
+        allocations[asset_ids[i]] = weight
 
     return allocations
 
 #######
 
-def efficient_frontier(tickers, mean_returns, covariance_matrix):
+def efficient_frontier(asset_ids, mean_returns, covariance_matrix):
     # Format data
-    number_of_tickers = mean_returns.size
-    means   = format_mean_returns_dataframe(mean_returns, number_of_tickers)
+
+    number_of_asset_ids = mean_returns.size
+    means   = format_mean_returns_dataframe(mean_returns, number_of_asset_ids)
     covars  = format_covars_dataframe(covariance_matrix)
-    lB      = lower_bounds(number_of_tickers)
-    uB      = upper_bounds(number_of_tickers)
+    lB      = lower_bounds(number_of_asset_ids)
+    uB      = upper_bounds(number_of_asset_ids)
 
     # Solve critical line algorithm
     cla = CLA(means, covars, lB, uB)
@@ -56,15 +61,15 @@ def efficient_frontier(tickers, mean_returns, covariance_matrix):
 
         allocations = {}
         for i, weight in enumerate(allocation):
-          allocations[tickers[i]] = weight
+          allocations[asset_ids[i]] = weight
 
         obj['allocations']  = allocations
 
         portfolios.append(obj)
 
     # Add the minimum variance portfolio
     var, weights = cla.getMinVar()
-    allocations = format_resulting_weights(weights, tickers)
+    allocations = format_resulting_weights(weights, asset_ids)
 
     min_var_port = {
         "mu": np.dot(weights.T, means)[0,0],
@@ -74,16 +79,14 @@ def efficient_frontier(tickers, mean_returns, covariance_matrix):
 
     # Add the maximum sharpe ratio portfolio
     sr, weights = cla.getMaxSR()
-    allocations = format_resulting_weights(weights, tickers)
+    allocations = format_resulting_weights(weights, asset_ids)
 
     max_sr_port = {
         "mu": np.dot(weights.T, means)[0,0],
         "sigma": np.dot(weights.T, np.dot(covars, weights))[0,0]**0.5,
         "allocations": allocations
     }
 
-    # import pdb; pdb.set_trace()
-
     # Return results
     return {
       "portfolios": portfolios,

lib/save_data.py

@@ -0,0 +1,14 @@
+import os
+import redis
+import pandas
+
+def write_csv_files(df, returns, correlation_matrix, covariance_matrix):
+    # Store all data as flat csv files. Whenever you run this function, the output
+    # files will be overwritten.
+    this_dir    = os.path.dirname(__file__)
+    csv_dir     = os.path.join(this_dir, os.pardir, 'csv')
+
+    df.to_csv( os.path.join(csv_dir, 'prices.csv'), header=True, index=True, index_label='Date', sep=',')
+    returns.to_csv( os.path.join(csv_dir, 'returns.csv'), header=True, index=True, index_label='Date', sep=',')
+    correlation_matrix.to_csv( os.path.join(csv_dir, 'correlation_matrix.csv'), header=True, index=True, sep=',')
+    covariance_matrix.to_csv( os.path.join(csv_dir, 'covariance_matrix.csv'), header=True, index=True, sep=',')

old/save_csv_data.py

@@ -3,6 +3,7 @@
 ###########
 
 import os
+import json
 import redis
 import pandas as pd
 
@@ -27,49 +28,65 @@
 if not app.config['DEBUG']:
     sslify = SSLify(app)
 
-redis_url   = os.environ['REDIS_URL']
-redis_conn  = redis.StrictRedis.from_url(redis_url)
+redis_conn = redis.StrictRedis.from_url(os.environ['REDIS_URL'])
 
 
 ###################
 # UTILITY METHODS #
 ###################
 
 def check_for_authorization():
-  auth_token = os.environ['AUTH_TOKEN']
-  provided_token = request.headers.get('Authorization') or request.args.get('auth_token')
-  if (provided_token and provided_token == auth_token):
-    return True
-  else:
-    return abort(403)
-
-def covariance_matrix(tickers):
+    auth_token = os.environ['AUTH_TOKEN']
+    provided_token = request.headers.get('Authorization') or request.args.get('auth_token')
+    if (provided_token and provided_token == auth_token):
+        return True
+    else:
+        return abort(403)
+
+def covariance_matrix(asset_ids):
     # Covariance matrix is a *DataFrame*
     json = redis_conn.get('covariance_matrix')
-    df = pd.io.json.read_json(json)
+    df   = pd.io.json.read_json(json)
 
-    tickers_set = set(tickers)
-    available_tickers_set = set(df.index.values)
-    tickers_to_eliminate = list(available_tickers_set - tickers_set)
+    asset_ids_set             = set(asset_ids)
+    available_asset_ids_set   = set(df.index.values)
+    asset_ids_to_eliminate    = list(available_asset_ids_set - asset_ids_set)
 
-    return df.drop(tickers_to_eliminate, axis=0).drop(tickers_to_eliminate, axis=1)
+    return df.drop(asset_ids_to_eliminate, axis=0).drop(asset_ids_to_eliminate, axis=1)
 
-def mean_returns(tickers):
+def mean_returns(asset_ids):
     # Mean returns is a *Series*
     json = redis_conn.get('mean_returns')
-    df = pd.io.json.read_json(json, typ='series')
+    df   = pd.io.json.read_json(json, typ='series')
 
-    tickers_set = set(tickers)
-    available_tickers_set = set(df.index.values)
-    tickers_to_eliminate = list(available_tickers_set - tickers_set)
+    asset_ids_set             = set(asset_ids)
+    available_asset_ids_set   = set(df.index.values)
+    asset_ids_to_eliminate    = list(available_asset_ids_set - asset_ids_set)
 
-    return df.drop(tickers_to_eliminate)
+    return df.drop(asset_ids_to_eliminate)
+
+def build_efficient_frontier_for(asset_ids):
+    means    = mean_returns(asset_ids)
+    covars   = covariance_matrix(asset_ids)
+    return efficient_frontier(asset_ids, means, covars)
 
 
 ##########
 # ROUTES #
 ##########
 
+@app.route('/assets', methods=['GET'])
+def assets_route():
+    check_for_authorization()
+    return jsonify( json.loads(redis_conn.get('asset_list')) )
+
+@app.route('/calc', methods=["POST"])
+def cla_calc_route():
+    check_for_authorization()
+    asset_ids = (request.json)['asset_ids']
+    app.logger.info("Received CLA calc request for: %s" % asset_ids)
+    return jsonify(build_efficient_frontier_for(asset_ids))
+
 @app.route('/')
 def root():
     return 'Hello World!'
@@ -78,20 +95,6 @@ def root():
 def health():
     return "OK", 200
 
-@app.route('/calc', methods=["POST"])
-def cla_calc_route():
-    check_for_authorization()
-
-    j       = request.json
-    tickers = j['tickers']
-
-    app.logger.info("Received CLA calc request for tickers: %s" % tickers)
-
-    means   = mean_returns(tickers)
-    covars  = covariance_matrix(tickers)
-
-    return jsonify( efficient_frontier(tickers, means, covars) )
-
 
 ##########
 # LOADER #