def get_yahoo_Adj_Close_tickerList(ticker=['IBM', 'MSFT'], start_date='2019-01-01', end_date='2020-06-06'):
df = yf.download(ticker,
start=start_date,
end=end_date,
progress=False)['Adj Close']
return df
#%%
import matplotlib.pyplot as plt
import matplotlib
import yfinance as yf
import numpy as np
import pandas as pd
import datetime as dt
import seaborn as sns
matplotlib.rcParams['axes.unicode_minus'] = False
# data 불러오기
samsung_elec = yf.download('005930.KS', start="2018-01-01", end="2018-12-31")
celtrion = yf.download('068270.KS', start="2018-01-02", end="2018-12-31")
hyundai_M = yf.download('005380.KS', start="2018-01-02", end="2018-12-31")
stock_data = pd.DataFrame({
'Samsung': samsung_elec['Adj Close'],
'Celtrion': celtrion['Adj Close'],
'Hyundai': hyundai_M['Adj Close']
})
#로그수익률 계산
logret = np.log(stock_data / stock_data.shift(1))
logret_np = logret.iloc[:, 0:3].to_numpy() #NOTE 계산이 쉽도록 numpy로 만들어줌
portfolio_expected_returns = [] # NOTE 변하는 기대수익률을 저장하는 list
portfolio_variance = [] # NOTE 변하는 변동성을 저장하는 list
weight_list = np.zeros(shape=(1000, 3)) # NOTE 바뀌는 list에 대한 array
for sim in range(1000):
# weight 시뮬레이션
def sector_comp_data(request, pk, sector):
start = request.GET['start']
sect = sector.replace('-', ' ').title()
hlds = (Holding.objects.select_related('stock', 'portfolio').filter(
portfolio__id=pk, stock__sector=sect))
tickers = ' '.join(hlds.values_list('stock__ticker', flat=True))
prices_full = yf.download(
tickers, start,
datetime.datetime.strftime(
datetime.datetime.today() + datetime.timedelta(days=1),
'%Y-%m-%d'))['Close']
prices = prices_full.dropna()
try:
if prices_full.isna().iloc[0, 0]:
prices_full = prices_full.iloc[1:, :]
except IndexError:
pass
quants = hlds.order_by('stock__ticker').values_list('quantity', flat=True)
if quants.count() > 1:
values = (prices * quants).sum(axis=1)
else:
values = (prices * quants)
values = (values / values[0]).to_json(orient='split')
port_data = json.loads(values)
port_data['port'] = port_data.pop('data')
new_start = datetime.datetime.strftime(prices.index[0], '%Y-%m-%d')
orig_start = datetime.datetime.strftime(prices_full.index[0], '%Y-%m-%d')
if new_start != orig_start:
fault = prices_full.iloc[prices_full.index.get_loc(prices.index[0]) -
1, ]
fault = fault[fault.isna()].index[0]
port_data['msg'] = 'Earliest available: {}. No data for {}.'.format(
new_start, fault)
# get benchmark values
bench = {
'energy': 'XLE',
'financials': 'XLF',
'utilities': 'XLU',
'industrials': 'XLI',
'information-technology': 'XLK',
'health-care': 'XLV',
'consumer-discretionary': 'XLY',
'consumer-staples': 'XLP',
'materials': 'XLB',
'communication-services': 'XTL',
'real-estate': 'VNQ'
}
sp500 = yf.download(
bench[sector], new_start,
datetime.datetime.strftime(
datetime.datetime.today() + datetime.timedelta(days=1),
'%Y-%m-%d'))['Close'].dropna()
sp500 = sp500 / sp500[0]
port_data['sp500'] = sp500.tolist()
return JsonResponse(port_data)
def get_yahoo_data_1_ticker(ticker='IBM', start_date='2019-01-01', end_date='2020-06-06'):
df = yf.download(ticker,
start=start_date,
end=end_date,
progress=False)
return df
def consulta_bc(codigo_bcb):
url = 'http://api.bcb.gov.br/dados/serie/bcdata.sgs.{}/dados?formato=json'.format(
codigo_bcb)
df = pd.read_json(url)
df['data'] = pd.to_datetime(df['data'], dayfirst=True)
df.set_index('data', inplace=True)
return df
data_inicio = '1994-07-01'
ipca = consulta_bc(433)
ipca_acumulado = (1 + ipca[ipca.index >= data_inicio]).cumprod()
ipca_acumulado.iloc[0] = 1
ibov = yf.download(tickers='^BVSP')[['Adj Close']]
ibov_retorno = ibov.pct_change()
ibov_retono_acumulado = (
1 + ibov_retorno[ibov_retorno.index >= data_inicio]).cumprod()
ibov_retono_acumulado.iloc[0] = 1
cdi = consulta_bc(12)
cdi_acumulado = (1 + cdi[cdi.index >= data_inicio] / 100).cumprod()
cdi_acumulado.iloc[0] = 1
fig, ax = plt.subplots()
ax.plot(ibov_retono_acumulado)
ax.plot(cdi_acumulado)
#plt.show()
def get_portfolio_value(request, pk):
port = Portfolio.objects.prefetch_related('holding_set',
'holding_set__stock').get(pk=pk)
start = request.GET['start']
if port.holding_set.all().count() == 0:
return JsonResponse(json.loads(json.dumps({'msg': 'No stocks'})))
if port.holding_set.all().count() >= 1:
tickers = ' '.join(port.holding_set.all().values_list('stock__ticker',
flat=True))
prices_full = yf.download(
tickers, start,
datetime.datetime.strftime(
datetime.datetime.today() + datetime.timedelta(days=1),
'%Y-%m-%d'))['Close']
prices = prices_full.dropna()
#prices_full = pd.DataFrame(Stock.objects.filter(holding__portfolio=port).order_by('ticker').values('ticker', 'history__Close'))
#df = pd.DataFrame()
#for ind, row in prices_full.iterrows():
# new = pd.DataFrame({row['ticker']: row['history__Close']})
# df = df.merge(new, "outer", left_index=True, right_index=True)
#prices_full = df
#prices_full.index = prices_full.index.astype('datetime64[ns]')
#prices_full = prices_full[prices_full.index >= start]
#prices = prices_full.dropna()
try:
if prices_full.isna().iloc[0, 0]:
prices_full = prices_full.iloc[1:, :]
except IndexError:
pass
quants = port.holding_set.all().order_by('stock__ticker').values_list(
'quantity', flat=True)
if quants.count() > 1:
values = (prices * quants).sum(axis=1)
else:
values = (prices * quants)
values = (values / values[0]).to_json(orient='split')
port_data = json.loads(values)
port_data['port'] = port_data.pop('data')
new_start = datetime.datetime.strftime(prices.index[0], '%Y-%m-%d')
orig_start = datetime.datetime.strftime(prices_full.index[0],
'%Y-%m-%d')
if new_start != orig_start:
fault = prices_full.iloc[
prices_full.index.get_loc(prices.index[0]) - 1, ]
fault = fault[fault.isna()].index[0]
port_data[
'msg'] = 'Earliest available: {}. No data for {}.'.format(
new_start, fault)
# get benchmark values
sp500 = yf.download(
'^GSPC', new_start,
datetime.datetime.strftime(
datetime.datetime.today() + datetime.timedelta(days=1),
'%Y-%m-%d'))['Close'].dropna()
sp500 = sp500 / sp500[0]
port_data['sp500'] = sp500.tolist()
return JsonResponse(port_data)
def main():
tickers = 'SPY AAPL MRNA TSLA'
data = yf.download(tickers, period='max', group_by='ticker')
dirty = pd.DataFrame(data['TSLA'])
frame = clean_data(dirty)
def historical_command(signal: str = "", start=""):
"""Displays historical price comparison between similar companies [Yahoo Finance]"""
# Debug user input
if cfg.DEBUG:
logger.debug("scr-historical %s %s", signal, start)
# Check for argument
if signal not in so.d_signals_desc:
raise Exception("Invalid preset selected!")
register_matplotlib_converters()
screen = ticker.Ticker()
if signal in finviz_model.d_signals:
screen.set_filter(signal=finviz_model.d_signals[signal])
else:
preset_filter = configparser.RawConfigParser()
preset_filter.optionxform = str # type: ignore
preset_filter.read(so.presets_path + signal + ".ini")
d_general = preset_filter["General"]
d_filters = {
**preset_filter["Descriptive"],
**preset_filter["Fundamental"],
**preset_filter["Technical"],
}
d_filters = {k: v for k, v in d_filters.items() if v}
if d_general["Signal"]:
screen.set_filter(filters_dict=d_filters,
signal=d_general["Signal"])
else:
screen.set_filter(filters_dict=d_filters)
if start == "":
start = datetime.now() - timedelta(days=365)
else:
start = datetime.strptime(start, cfg.DATE_FORMAT)
# Output Data
l_min = []
l_leg = []
l_stocks = screen.ScreenerView(verbose=0)
if len(l_stocks) > 10:
description = (
"\nThe limit of stocks to compare with are 10. Hence, 10 random similar stocks will be displayed."
"\nThe selected list will be: ")
random.shuffle(l_stocks)
l_stocks = sorted(l_stocks[:10])
description = description + (", ".join(l_stocks))
logger.debug(description)
plt.figure(figsize=plot_autoscale(), dpi=PLOT_DPI)
while l_stocks:
l_parsed_stocks = []
for symbol in l_stocks:
try:
df_similar_stock = yf.download(
symbol,
start=datetime.strftime(start, "%Y-%m-%d"),
progress=False,
threads=False,
)
if not df_similar_stock.empty:
plt.plot(
df_similar_stock.index,
df_similar_stock["Adj Close"].values,
)
l_min.append(df_similar_stock.index[0])
l_leg.append(symbol)
l_parsed_stocks.append(symbol)
except Exception as e:
error = (
f"{e}\nDisregard previous error, which is due to API Rate limits from Yahoo Finance. "
f"Because we like '{symbol}', and we won't leave without getting data from it."
)
return {
"title":
"ERROR Stocks: [Yahoo Finance] Historical Screener",
"description": error,
}
for parsed_stock in l_parsed_stocks:
l_stocks.remove(parsed_stock)
if signal:
plt.title(
f"Screener Historical Price using {finviz_model.d_signals[signal]} signal"
)
else:
plt.title(f"Screener Historical Price using {signal} preset")
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend(l_leg)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
# ensures that the historical data starts from same datapoint
plt.xlim([max(l_min), df_similar_stock.index[-1]])
imagefile = "scr_historical.png"
plt.savefig(imagefile)
imagefile = image_border(imagefile)
return {
"title": "Stocks: [Yahoo Finance] Historical Screener",
"description": description,
"imagefile": imagefile,
}
def get_sp500_comps_tsne(
ticker: str,
lr: int = 200,
no_plot: bool = False,
num_tickers: int = 10,
external_axes: Optional[List[plt.Axes]] = None,
) -> List[str]:
"""
Runs TSNE on SP500 tickers (along with ticker if not in SP500).
TSNE is a method of visualing higher dimensional data
https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html
Note that the TSNE numbers are meaningless and will be arbitrary if run again.
Parameters
----------
ticker : str
Ticker to get comparisons to
lr : int
Learning rate for TSNE
no_plot : bool
Flag to hold off on plotting
num_tickers : int
Number of tickers to return
Returns
-------
List[str]
List of the 10 closest stocks due to TSNE
"""
# Adding the type makes pylint stop yelling
close_vals: pd.DataFrame = get_1y_sp500()
if ticker not in close_vals.columns:
df_ticker = yf.download(ticker,
start=close_vals.index[0],
progress=False)["Adj Close"].to_frame()
df_ticker.columns = [ticker]
close_vals = close_vals.join(df_ticker, how="inner")
close_vals = close_vals.dropna(how="all").fillna(method="bfill")
rets = close_vals.pct_change()[1:].T
model = TSNE(learning_rate=lr)
tsne_features = model.fit_transform(normalize(rets))
xs = tsne_features[:, 0]
ys = tsne_features[:, 1]
if not no_plot:
# This plot has 1 axis
if not external_axes:
_, ax = plt.subplots(figsize=plot_autoscale(), dpi=PLOT_DPI)
else:
if len(external_axes) != 1:
logger.error("Expected list of one axis item.")
console.print("[red]Expected list of one axis item./n[/red]")
return []
(ax, ) = external_axes
data = pd.DataFrame({"X": xs, "Y": ys}, index=rets.index)
x0, y0 = data.loc[ticker]
data["dist"] = (data.X - x0)**2 + (data.Y - y0)**2
data = data.sort_values(by="dist")
ticker_df = data[data.index == ticker]
top_n = data.iloc[1:(num_tickers + 1)]
top_n_name = top_n.index.to_list()
top_100 = data[(num_tickers + 1):101]
ax.scatter(
top_n.X,
top_n.Y,
alpha=0.8,
c=theme.up_color,
label=f"Top {num_tickers} closest tickers",
)
ax.scatter(top_100.X,
top_100.Y,
alpha=0.5,
c="grey",
label="Top 100 closest tickers")
for x, y, company in zip(top_n.X, top_n.Y, top_n.index):
ax.annotate(company, (x, y), fontsize=9, alpha=0.9)
for x, y, company in zip(top_100.X, top_100.Y, top_100.index):
ax.annotate(company, (x, y), fontsize=9, alpha=0.75)
ax.scatter(
ticker_df.X,
ticker_df.Y,
s=50,
c=theme.down_color,
)
ax.annotate(ticker, (ticker_df.X, ticker_df.Y), fontsize=9, alpha=1)
ax.legend()
ax.set_title(
f"Top 100 closest stocks on S&P500 to {ticker} using TSNE algorithm",
fontsize=11,
)
ax.set_xlabel("Dimension 1")
ax.set_ylabel("Dimension 2")
theme.style_primary_axis(ax)
if not external_axes:
theme.visualize_output()
return top_n_name
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 1 16:53:18 2020
@author: Austin
"""
import pandas as pd
import numpy as np
import yfinance as yf
import datetime as dt
ticker = "^GSPC"
SnP = yf.download(ticker,
dt.date.today() - dt.timedelta(1825), dt.datetime.today())
DF = SnP.copy()
#CAGR is annual cumulative growth return
def CAGR(DF):
df = DF.copy()
df["daily_ret"] = DF["Adj Close"].pct_change()
df["cum_return"] = (1 + df["daily_ret"]).cumprod()
#cumprod is cumulative product
#shows you the pct change of your initial investment
#n is the power that we will raise the ratio to
n = len(df) / 252 #252 is the number of trading days in a year
CAGR = (df["cum_return"][-1])**(1 / n) - 1
#[-1] latest value
def download_data(*op_args):
symbol = op_args[0]
df = yf.download(symbol, start=start, end=end, interval='1m')
df.to_csv(f"~/airflow/raw_data/{start}/{symbol}_data.csv")
return
def download_historical_data(self, start_date: pd.Timestamp,
end_date: pd.Timestamp):
return yf.download(self.__ticker, start=start_date, end=end_date)
import json
import pandas as pd
import yfinance as yf
from datetime import datetime
from datetime import timedelta
client = MongoClient()
db = client["stocks_database"]
company = db["Company"]
start = datetime.now().date() + timedelta(-30)
end = datetime.now().date()
portfolio_new = pd.DataFrame()
tickr = ["MSFT", "AAPL", "GOOG"]
for tick in tickr:
portfolio_new[tick] = yf.download(tick, start, end)['Adj Close']
portfolio_new.reset_index(inplace=True)
ast = portfolio_new.to_json("records")
x = json.loads(ast)
print(x)
company.insert_one({tick: x})
# for tick in tickr:
#
# ##########################################################
# ticker = ["GOOG"]
# for tic in ticker:
# data_from_db = company.find_one({"index":tic})
# print(data_from_db["data"])
# df = pd.DataFrame(data_from_db["data"])
import yfinance as yf
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# %matplotlib inline
plt.style.use('seaborn-darkgrid')
# yahoo finance is used to fetch data
# Đọc dữ liệu
Df = yf.download('GLD', '2020-01-01', '2020-4-17', auto_adjust=True)
# Giữ các
Df = Df[['Close']]
# Drop rows with missing values
Df = Df.dropna()
# Vẽ biểu đồ giá đóng của GLD
Df.Close.plot(figsize=(10, 7), color='r')
plt.ylabel("Gold ETF Prices")
plt.title("Gold ETF Price Series")
plt.show()
st.pyplot()
# Xác định các biến giải thích
import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
import warnings
plt.style.use('seaborn')
plt.rcParams['figure.figsize'] = [16, 9]
plt.rcParams['figure.dpi'] = 300
warnings.simplefilter(action='ignore', category=FutureWarning)
RISKY_ASSET = 'MSFT'
START_DATE = '2019-01-01'
END_DATE = '2019-07-31'
df = yf.download(RISKY_ASSET, start=START_DATE, end=END_DATE, adjusted=True)
adj_close = df['Adj Close']
returns = adj_close.pct_change().dropna()
print(f'Average return: {100 * returns.mean():.2f}%')
returns.plot(title=f'{RISKY_ASSET} returns: {START_DATE} -{END_DATE}')
train = returns['2019-01-01':'2019-06-30']
test = returns['2019-07-01':'2019-07-31']
T = len(test)
N = len(test)
S_0 = adj_close[train.index[-1].date()]
N_SIM = 100
mu = train.mean()
sigma = train.std()
