<jupyter_start><jupyter_text>Unit 5 - Financial Planning<jupyter_code># Initial imports
import os
import requests
import pandas as pd
from dotenv import load_dotenv
import alpaca_trade_api as tradeapi
from MCForecastTools import MCSimulation
import json
%matplotlib inline
# Load .env enviroment variables
load_dotenv()<jupyter_output><empty_output><jupyter_text>Part 1 - Personal Finance Planner  Collect Crypto Prices Using the `requests` Library<jupyter_code># Set current amount of crypto assets
my_btc = 1.2
my_eth = 5.3
# Crypto API URLs
btc_url = "https://api.alternative.me/v2/ticker/Bitcoin/?convert=USD"
eth_url = "https://api.alternative.me/v2/ticker/Ethereum/?convert=USD"
# Fetch current BTC price
response_btc = requests.get(btc_url)
response_content_btc = response_btc.content
data_btc = response_btc.json()

print(json.dumps(data_btc, indent = 5))
# Fetch current ETH price
response_eth = requests.get(eth_url)
response_content_eth = response_eth.content
data_eth = response_eth.json()

print(json.dumps(data_eth, indent = 5))
# Compute current value of my crpto
btc_price = data_btc['data']['1']['quotes']['USD']['price']
btc_value = my_btc * btc_price

eth_price = data_eth['data']['1027']['quotes']['USD']['price']
eth_value = my_eth * eth_price

# Print current crypto wallet balance
print(f"The current value of your {my_btc} BTC is ${btc_value:0.2f}")
print(f"The current value of your {my_eth} ETH is ${eth_value:0.2f}")<jupyter_output>The current value of your 1.2 BTC is $47674.80
The current value of your 5.3 ETH is $14897.40<jupyter_text>Collect Investments Data Using Alpaca: `SPY` (stocks) and `AGG` (bonds)<jupyter_code># Current amount of shares
my_spy = 50
my_agg = 200
# Set Alpaca API key and secret
alpaca_api_key = os.getenv('ALPACA_API_KEY')
alpaca_secret_key = os.getenv('ALPACA_SECRET_KEY')

# Create the Alpaca API object
api = tradeapi.REST(alpaca_api_key, alpaca_secret_key, api_version = 'v2')
# Format current date as ISO format
today = pd.Timestamp('2021-05-27', tz = 'America/New_York').isoformat()

# Set the tickers
tickers = ["AGG", "SPY"]

# Set timeframe to '1D' for Alpaca API
timeframe = "1D"

# Get current closing prices for SPY and AGG
portfolio_df = api.get_barset(tickers, timeframe, start = today, end = today).df

# Preview DataFrame
portfolio_df.head()
# Pick AGG and SPY close prices
spy_close_price = float(portfolio_df['SPY']['close'])
agg_close_price = float(portfolio_df['AGG']['close'])

# Print AGG and SPY close prices
print(f"Current AGG closing price: ${agg_close_price}")
print(f"Current SPY closing price: ${spy_close_price}")
## Compute the current value of shares
spy_value = my_spy * spy_close_price
agg_value = my_agg * agg_close_price

# Print current value of share
print(f"The current value of your {my_spy} SPY shares is ${spy_value:0.2f}")
print(f"The current value of your {my_agg} AGG shares is ${agg_value:0.2f}")<jupyter_output>The current value of your 50 SPY shares is $21014.01
The current value of your 200 AGG shares is $22897.00<jupyter_text>Savings Health Analysis<jupyter_code># Set monthly household income
monthly_income = 12000
total_crypto = btc_value + eth_value
total_shares = agg_value + spy_value

# Create savings DataFrame
savings_data = {'amount':[total_crypto, total_shares]}
df_savings = pd.DataFrame(savings_data, index = ['crypto', 'shares'])

# Display savings DataFrame
display(df_savings)
# Plot savings pie chart
df_savings.plot.pie(y = 'amount', title = 'Composition of Personal Savings')
# Set ideal emergency fund
emergency_fund = monthly_income * 3

# Calculate total amount of savings
total_savings = total_crypto + total_shares

# Validate saving health
if emergency_fund < total_savings:
    print(f"Congratulations! You have enough money in your emergency fund.")
elif emergency_fund == total_savings:
    print(f"Congratulations! You have reached your financial goal")
else:
    print(f"You are ${emergency_fund - total_savings} away from reaching your financial goal." )<jupyter_output>Congratulations! You have enough money in your emergency fund.<jupyter_text>Part 2 - Retirement Planning Monte Carlo Simulation<jupyter_code># Set start and end dates of five years back from today.
# Sample results may vary from the solution based on the time frame chosen
start_date = pd.Timestamp('2016-05-27', tz='America/New_York').isoformat()
end_date = pd.Timestamp('2021-05-27', tz='America/New_York').isoformat()
# Get 5 years' worth of historical data for SPY and AGG
tickers = ['AGG', 'SPY']
timeframe = "1D"
stockdata_df = api.get_barset(
    tickers, 
    timeframe, 
    start = start_date, 
    end = end_date,
    limit = 1000).df

# remove Timestamps
stockdata_df.index = stockdata_df.index.date
# Display sample data
stockdata_df.head()



# Configuring a Monte Carlo simulation to forecast 30 years cumulative returns
MC_4060 = MCSimulation(portfolio_data = stockdata_df, weights = [0.4, 0.6], num_simulation = 500, num_trading_days = 252*30)
# Printing the simulation input data
MC_4060.portfolio_data.head()
# Running a Monte Carlo simulation to forecast 30 years cumulative returns
MC_4060.calc_cumulative_return()
# Plot simulation outcomes
MC_plot = MC_4060.plot_simulation()
# Plot probability distribution and confidence intervals
MC_dist = MC_4060.plot_distribution()<jupyter_output><empty_output><jupyter_text>Retirement Analysis<jupyter_code># Fetch summary statistics from the Monte Carlo simulation results
tbl = MC_4060.summarize_cumulative_return()

# Print summary statistics
print(tbl)<jupyter_output>count           500.000000
mean             20.638872
std              16.479660
min               2.215722
25%              10.586326
50%              16.612789
75%              25.109304
max             144.384071
95% CI Lower      4.394321
95% CI Upper     63.518751
Name: 7560, dtype: float64<jupyter_text>Calculate the expected portfolio return at the 95% lower and upper confidence intervals based on a `$20,000` initial investment.<jupyter_code># Set initial investment
initial_investment = 20000

# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes of our $20,000
ci_lower = round(tbl[8]*20000, 2)
ci_upper = round(tbl[9]*20000, 2)

# Print results
print(f"There is a 95% chance that an initial investment of ${initial_investment} in the portfolio"
      f" over the next 30 years will end within in the range of"
      f" ${ci_lower} and ${ci_upper}")<jupyter_output>There is a 95% chance that an initial investment of $20000 in the portfolio over the next 30 years will end within in the range of $87886.42 and $1270375.02<jupyter_text>Calculate the expected portfolio return at the `95%` lower and upper confidence intervals based on a `50%` increase in the initial investment.<jupyter_code># Set initial investment
initial_investment = 20000 * 1.5

# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes of our $30,000
ci_lower = round(tbl[8]*initial_investment, 2)
ci_upper = round(tbl[9]*initial_investment, 2)

# Print results
print(f"There is a 95% chance that an initial investment of ${initial_investment} in the portfolio"
      f" over the next 30 years will end within in the range of"
      f" ${ci_lower} and ${ci_upper}")<jupyter_output>There is a 95% chance that an initial investment of $30000.0 in the portfolio over the next 30 years will end within in the range of $131829.62 and $1905562.53<jupyter_text>Optional Challenge - Early Retirement Five Years Retirement Option<jupyter_code># Configuring a Monte Carlo simulation to forecast 5 years cumulative returns
MC_2080_fiveyear = MCSimulation(portfolio_data = stockdata_df, weights = [0.2, 0.8], num_simulation = 500, num_trading_days = 252*5)
MC_2080_fiveyear.portfolio_data.head()
# Running a Monte Carlo simulation to forecast 5 years cumulative returns
MC_2080_fiveyear.calc_cumulative_return()
# Plot simulation outcomes
MC_fiveyear_plot = MC_2080_fiveyear.plot_simulation()
# Plot probability distribution and confidence intervals
MC_dist_fiveyear = MC_2080_fiveyear.plot_distribution()
# Fetch summary statistics from the Monte Carlo simulation results
tbl_fiveyear = MC_2080_fiveyear.summarize_cumulative_return()

# Print summary statistics
print(tbl_fiveyear)
# Set initial investment
initial_investment_fiveyear = 50000

# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes of our $60,000
ci_lower_five = round(tbl_fiveyear[8]*60000,2)
ci_upper_five = round(tbl_fiveyear[9]*60000,2)

# Print results
print(f"There is a 95% chance that an initial investment of ${initial_investment_fiveyear} in the portfolio, with a 20%/80% ratio of AGG to SPY"
      f" over the next 5 years will end within in the range of"
      f" ${ci_lower_five} and ${ci_upper_five}")<jupyter_output>There is a 95% chance that an initial investment of $50000 in the portfolio, with a 20%/80% ratio of AGG to SPY over the next 5 years will end within in the range of $51214.53 and $235316.6<jupyter_text>Ten Years Retirement Option<jupyter_code># Configuring a Monte Carlo simulation to forecast 10 years cumulative returns
MC_2080_tenyear = MCSimulation(portfolio_data = stockdata_df, weights = [0.2, 0.8], num_simulation = 500, num_trading_days = 252*10)
MC_2080_tenyear.portfolio_data.head()
# Running a Monte Carlo simulation to forecast 10 years cumulative returns
MC_2080_tenyear.calc_cumulative_return()
# Plot simulation outcomes
MC_tenyear_plot = MC_2080_tenyear.plot_simulation()
# Plot probability distribution and confidence intervals
MC_dist_tenyear = MC_2080_tenyear.plot_distribution()
# Fetch summary statistics from the Monte Carlo simulation results
tbl_tenyear = MC_2080_tenyear.summarize_cumulative_return()

# Print summary statistics
print(tbl_tenyear)
# Set initial investment
initial_investment_tenyear = 50000

# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes of our $50,000
ci_lower_ten = round(tbl_tenyear[8]*50000, 2)
ci_upper_ten = round(tbl_tenyear[9]*50000, 2)

# Print results
print(f"There is a 95% chance that an initial investment of ${initial_investment_tenyear} in the portfolio with a 20%/80% ratio of AGG to SPY"
      f" over the next 10 years will end within in the range of"
      f" ${ci_lower_ten} and ${ci_upper_ten}")<jupyter_output>There is a 95% chance that an initial investment of $50000 in the portfolio with a 20%/80% ratio of AGG to SPY over the next 10 years will end within in the range of $57996.34 and $427045.7
{'fraction_non_alphanumeric': 0.08446840711312902, 'fraction_numerical': 0.05230798335225123, 'mean_word_length': 5.4234507897934385, 'pattern_counts': {'":': 0, '<': 34, '<?xml version=': 0, '>': 33, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '270354', 'license': 'ADSL', 'n_tokens_mistral': 3758, 'n_tokens_neox': 3340, 'n_words': 1140, 'path': 'Starter_Code/financial-planner.ipynb', 'repo_name': 'aseem-mangaokar/apis-homework', 'size': '10572'}