def test_investpy_currencies():
retrieve_currency_crosses()
investpy.get_currency_crosses()
investpy.get_currency_crosses_list()
investpy.get_currency_crosses_dict()
params = [{
'currency_cross': 'EUR/USD',
'from_date': '08/07/2019',
'to_date': '08/08/2019',
'as_json': True,
}, {
'currency_cross': 'EUR/USD',
'from_date': '08/07/2019',
'to_date': '08/08/2019',
'as_json': False,
}]
for param in params:
investpy.get_currency_cross_recent_data(
currency_cross=param['currency_cross'], as_json=param['as_json'])
investpy.get_currency_cross_historical_data(
currency_cross=param['currency_cross'],
from_date=param['from_date'],
to_date=param['to_date'],
as_json=param['as_json'])
def importCdnStockData(X):
X = yf.download(X)
X_price = X['Adj Close']
start = X_price.index[0]
end = X_price.index[len(X_price.index) - 1]
# Import currency data.
CADUSD = investpy.get_currency_cross_historical_data(
currency_cross='CAD/USD', from_date='17/10/1989', to_date='22/06/2020')
CADUSD.index = pd.to_datetime(CADUSD.index)
# Determine the earliest overlapping start date.
if (CADUSD.index[0] > start):
start = CADUSD.index[0]
# Ensure all dates are included in both datasets
calendar_dates = pd.date_range(start=start, end=end, freq='D')
X_price = X_price.reindex(calendar_dates, method='ffill')
X_price = X_price.dropna()
CADUSD = CADUSD.reindex(calendar_dates, method='ffill').shift(+1)
X_price = X_price[:] * CADUSD['Close']
X_return = X_price.pct_change()[1:]
return X_return
def importCdnStockDataDates(X, start, end):
safeStart = datetime.strptime(start, '%Y-%m-%d').date() - timedelta(1)
X = yf.download(X, start=str(safeStart), end=end)
X_price = X['Adj Close']
# Import CAD:USD exchange rate.
CADUSD = investpy.get_currency_cross_historical_data(
currency_cross='CAD/USD', from_date='17/10/1989', to_date='22/06/2020')
CADUSD.index = pd.to_datetime(CADUSD.index)
# Determine the earliest overlapping start date.
if (str(CADUSD.index[0])[0:10] > str(safeStart)):
start = CADUSD.index[0]
# Ensure all dates are included in both datasets
calendar_dates = pd.date_range(start=start, end=end, freq='D')
X_price = X_price.reindex(calendar_dates, method='ffill')
X_price = X_price.dropna()
CADUSD = CADUSD.reindex(calendar_dates, method='ffill').shift(+1)
X_price = X_price[:] * CADUSD['Close']
X_return = X_price.pct_change()[1:]
X_return.to_csv('Test_XIC_USD_returns3.csv')
return X_return
#importCdnStockDataDates('XIC.TO', '2003-02-01','2020-06-22')
def get_asset_data(asset_list: list, from_date: str, to_date: str,
asset_type: str,
asset_df: pd.DataFrame) -> Tuple[list, pd.DataFrame]:
# commodity, bond, currency
# etfs and funds need country
if asset_type == "Bonds":
func = lambda a, s, e: investpy.get_bond_historical_data(a, s, e)
elif asset_type == "Currencies":
func = lambda a, s, e: investpy.get_currency_cross_historical_data(
a, s, e)
elif asset_type == "ETFs":
func = lambda a, s, e, c: investpy.get_etf_historical_data(a, c, s, e)
elif asset_type == "Funds":
func = lambda a, s, e, c: investpy.get_fund_historical_data(a, c, s, e)
elif asset_type == "Commodities":
func = lambda a, s, e: investpy.get_commodity_historical_data(a, s, e)
elif asset_type == "Indices":
func = lambda a, s, e, c: investpy.get_index_historical_data(
a, c, s, e)
elif asset_type == "Crypto":
func = lambda a, s, e: investpy.get_crypto_historical_data(a, s, e)
df_list = []
for asset in asset_list:
if asset_type != "ETFs" and asset_type != "Funds" and asset_type != "Indices":
df = func(asset, from_date, to_date)
df_list.append(df)
else:
country = get_attribute_investing(asset_df, asset, 'country')
df = func(asset, from_date, to_date, country)
df_list.append(df)
close_list = [df.Close for df in df_list]
# print(close_list)
close_df = pd.concat(close_list, axis=1)
close_df.columns = asset_list
return df_list, close_df
def get_Currency(assetname):
asset = investpy.get_currency_cross_historical_data(currency_cross=assetname,from_date='01/01/2010',to_date='01/01/2021')
filename = assetname.replace(".", "")
filename = filename.replace("/", "")
filename = filename.replace(" ", "")
filename = filename.replace("&", "")
asset.to_csv(wd+'\\toto_data\\'+'fx-'+filename+'.csv')
def ccy_data(ccy):
df = investpy.get_currency_cross_historical_data(currency_cross=ccy,
from_date=fromdate,
to_date=tdy)['Close']
df = pd.DataFrame(df)
df.columns = [ccy]
return df
def hkd2usd(date1, date2):
df = ivpy.get_currency_cross_historical_data(
currency_cross='USD/HKD',
from_date=date1.strftime('%d/%m/%Y'),
to_date=date2.strftime('%d/%m/%Y'))
df = df.iloc[:, :4]
df = df.rename(lambda x: 'HKD->USD: ' + x, axis='columns')
return df
def eur2gbp(date1, date2):
df = ivpy.get_currency_cross_historical_data(
currency_cross='GBP/EUR',
from_date=date1.strftime('%d/%m/%Y'),
to_date=date2.strftime('%d/%m/%Y'))
df = df.iloc[:, :4]
df = df.rename(lambda x: 'EUR->GBP: ' + x, axis='columns')
return df
def to_euro_modifier(currency: str, dates: Tuple[datetime.date]) -> np.ndarray:
"""Retrieves currency-to-EUR conversion for the given dates. Cached to make sure this is only queried once for
a given currency & date-range."""
from_date = dates[0].strftime("%d/%m/%Y")
to_date = (dates[-1] + datetime.timedelta(days=7)).strftime("%d/%m/%Y")
history = investpy.get_currency_cross_historical_data(
currency_cross=f"EUR/{currency}", from_date=from_date, to_date=to_date)
history = history.reset_index()
values = densify_history(history, dates)
return 1 / values
def get_forex_rates(filename):
pairs = list(pd.read_csv(filename, header=None)[0])
final_df = pd.DataFrame()
for pair in pairs:
df = investpy.get_currency_cross_historical_data(
currency_cross=pair,
from_date=config['earliest_date'],
to_date=config['latest_date'])
final_df = final_df.append(df)
final_df.to_csv("historical_forex.csv")
def dataHistoricalCurrencyCross(currency_cross, from_date, to_date):
df = investpy.get_currency_cross_historical_data(currency_cross=currency_cross, as_json=True, from_date=from_date,
to_date=to_date)
# print(df)
result_json = df
result_decoded_json = json.loads(result_json)['historical']
resultado = json.dumps(result_decoded_json)
out_file = open("consulta_historica_archivo.json", "w")
out_file.writelines(str(resultado))
out_file.close()
df = pd.read_json(r'consulta_historica_archivo.json')
# export_csv = df.to_csv(r'historico_moneda.csv', index=None, header=True)
salida = df
return salida
def _download_data(self, asset_type, symbol, name, country, from_date,
max_date):
if asset_type == "BOND":
# name == symbol
df = ip.get_bond_historical_data(symbol,
from_date=from_date,
to_date=max_date)
elif asset_type == "CERT":
df = ip.get_certificate_historical_data(name,
country=country,
from_date=from_date,
to_date=max_date)
elif asset_type == "CRYPTO":
df = ip.get_crypto_historical_data(name,
from_date=from_date,
to_date=max_date)
elif asset_type == "COMM":
df = ip.get_commodity_historical_data(symbol,
from_date=from_date,
to_date=max_date)
elif asset_type == "ETF":
df = ip.get_etf_historical_data(name,
country=country,
from_date=from_date,
to_date=max_date)
elif asset_type == "FUND":
df = ip.get_fund_historical_data(name,
country=country,
from_date=from_date,
to_date=max_date)
elif asset_type == "FX":
df = ip.get_currency_cross_historical_data(symbol,
from_date=from_date,
to_date=max_date)
elif asset_type == "INDEX":
df = ip.get_index_historical_data(name,
country=country,
from_date=from_date,
to_date=max_date)
elif asset_type == "STOCK":
df = ip.get_stock_historical_data(symbol,
country=country,
from_date=from_date,
to_date=max_date)
return df
def get_currency_info(ticker):
price_now = get_currency_price(ticker)
now = datetime.datetime.now()
if ticker in ["EUR", "USD"]:
price_year_ago = investpy.get_currency_cross_historical_data(
currency_cross="{}/ISK".format(ticker),
from_date=(now -
datetime.timedelta(days=365)).strftime('%d/%m/%Y'),
to_date=(now - datetime.timedelta(days=350)
).strftime('%d/%m/%Y'))['Close'][-1]
else:
price_year_ago = investpy.get_crypto_historical_data(
crypto="bitcoin",
from_date=(now -
datetime.timedelta(days=365)).strftime('%d/%m/%Y'),
to_date=(now - datetime.timedelta(days=350)).strftime(
'%d/%m/%Y'))['Close'][-1] * get_currency_price("USD")
return price_now, price_year_ago
def DataHandler(mode):
if mode == 'investingCom':
dataAll = []
for fx in [
'USD/SEK', 'USD/NOK', 'USD/ZAR', 'USD/RUB', 'USD/CNH',
'USD/INR', 'USD/COP', 'USD/CAD', 'USD/EUR', 'USD/ILS',
'USD/CRC', 'USD/PLN', 'USD/CHF', 'USD/CZK', 'USD/IDR',
'USD/HUF', 'USD/KRW', 'USD/GBP', 'USD/MXN', 'USD/CLP',
'USD/DKK', 'USD/NZD', 'USD/JPY', 'USD/AUD'
]:
print(fx)
name = fx.replace('/', '')
df = investpy.get_currency_cross_historical_data(
currency_cross=fx,
from_date='01/01/1990',
to_date='14/03/2020').reset_index().rename(columns={
"Date": "Dates",
"Close": name
}).set_index('Dates')[name]
dataAll.append(df)
pd.concat(dataAll, axis=1).to_sql('FxDataInvestingCom',
conn,
if_exists='replace')
def DataHandler(mode):
if mode == 'investingCom':
dataAll = []
fxPairsList = ['USD/EUR', 'USD/GBP', 'USD/AUD', 'USD/NZD', 'USD/JPY', 'USD/CAD','USD/CHF','USD/SEK','USD/NOK', 'USD/DKK',
'USD/ZAR', 'USD/RUB', 'USD/PLN', 'USD/MXN', 'USD/CNH', 'USD/KRW', 'USD/INR', 'USD/IDR', 'USD/HUF', 'USD/COP']
namesDF = pd.DataFrame(fxPairsList, columns=["Names"])
namesDF['Names'] = namesDF['Names'].str.replace('/', '')
namesDF.to_sql('BasketGekko', conn, if_exists='replace')
for fx in fxPairsList:
print(fx)
name = fx.replace('/', '')
df = investpy.get_currency_cross_historical_data(currency_cross=fx, from_date='01/01/2000',
to_date='29/10/2020').reset_index().rename(
columns={"Date": "Dates", "Close": name}).set_index('Dates')[name]
dataAll.append(df)
pd.concat(dataAll, axis=1).to_sql('UsdBasedPairs', conn, if_exists='replace')
elif mode == 'investingCom_Invert':
df = pd.read_sql('SELECT * FROM UsdBasedPairs', conn).set_index('Dates', drop=True)
df.columns = [x.replace('USD', '') + 'USD' for x in df.columns]
df = df.apply(lambda x : 1/x)
df.to_sql('FxDataRaw', conn, if_exists='replace')
df.plot()
plt.show()
def test_investpy_currency_crosses():
"""
This function checks that currency cross data retrieval functions listed in investpy work properly.
"""
params = [
{
'base': None,
'second': None,
},
{
'base': 'EUR',
'second': None,
},
{
'base': None,
'second': 'EUR',
},
{
'base': 'EUR',
'second': 'USD',
},
]
for param in params:
investpy.get_currency_crosses(base=param['base'],
second=param['second'])
investpy.get_currency_crosses_list(base=param['base'],
second=param['second'])
params = [
{
'base': None,
'second': None,
'columns': None,
'as_json': True
},
{
'base': None,
'second': None,
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': None,
'columns': None,
'as_json': True
},
{
'base': 'EUR',
'second': None,
'columns': None,
'as_json': False
},
{
'base': None,
'second': 'USD',
'columns': None,
'as_json': True
},
{
'base': None,
'second': 'USD',
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'USD',
'columns': None,
'as_json': True
},
{
'base': 'EUR',
'second': 'USD',
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'USD',
'columns': ['name', 'full_name'],
'as_json': False
},
]
for param in params:
investpy.get_currency_crosses_dict(base=param['base'],
second=param['second'],
columns=param['columns'],
as_json=param['as_json'])
investpy.get_available_currencies()
params = [
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': True,
'order': 'ascending',
'debug': True
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'descending',
'debug': False
},
]
for param in params:
investpy.get_currency_cross_recent_data(
currency_cross=param['currency_cross'],
as_json=param['as_json'],
order=param['order'],
debug=param['debug'])
investpy.get_currency_cross_historical_data(
currency_cross=param['currency_cross'],
from_date=param['from_date'],
to_date=param['to_date'],
as_json=param['as_json'],
order=param['order'],
debug=param['debug'])
investpy.search_currency_crosses(by='base', value='EUR')
# print(vix_df.tail())
# S&P 500
sp_df = pdr.get_data_yahoo("SPY", start='2012-01-01', end='2030-12-01')
sp_df = sp_df.drop(['Open', 'High', 'Low', 'Adj Close'], axis=1)
# print(sp_df.head())
# print(sp_df.tail())
# DXY
dxy_df = pdr.get_data_yahoo("DX-Y.NYB", start="2012-01-01", end="2030-12-01")
df = dxy_df.drop(['High', 'Low', 'Volume', 'Adj Close'], axis=1)
# print(dxy_df.tail())
# EUR/USD
eur_df = investpy.get_currency_cross_historical_data(currency_cross='EUR/USD',
from_date='01/01/2012',
to_date='12/01/2030')
eur_df = eur_df.drop(['High', 'Low', 'Currency'], axis=1)
# print(eur_df.tail())
# Gold/Usd
gold_df = pdr.DataReader('GOLDAMGBD228NLBM', data_source, starttime, endtime)
# print(gold_df.tail())
# Silver/Usd
silver_df = pdr.DataReader('SLVPRUSD', data_source, starttime, endtime)
# print(silver_df.tail())
# Bitcoin/Usd and BTC_Volume
bitcoin_df = investpy.get_crypto_historical_data(crypto='bitcoin',
from_date='01/01/2012',
def DataHandler(mode):
if mode == 'run':
dataVec = [1, 1, 1, 1]
if dataVec[0] == 1:
BondsList = []
for bond in BondsTickers:
print(bond)
df = investpy.get_bond_historical_data(
bond=bond, from_date=fromDate,
to_date=toDate).reset_index().rename(columns={
"Date": "Dates",
"Close": bond
}).set_index('Dates')[bond]
BondsList.append(df)
BondsDF = pd.concat(BondsList, axis=1)
BondsDF[BondsDF == 0] = np.nan
BondsDF[BondsDF.abs() > 100] = np.nan
BondsDF = BondsDF.ffill().sort_index()
BondsDF.to_sql('Bonds_Prices', conn, if_exists='replace')
if dataVec[1] == 1:
EqsList = []
for EqIndex in EqsTickers:
print(EqIndex)
df = investpy.get_index_historical_data(
index=EqIndex[0],
country=EqIndex[1],
from_date=fromDate,
to_date=toDate).reset_index().rename(columns={
"Date": "Dates",
"Close": EqIndex[0]
}).set_index('Dates')[EqIndex[0]]
EqsList.append(df)
EqsDF = pd.concat(EqsList, axis=1)
EqsDF[EqsDF == 0] = np.nan
EqsDF = EqsDF.ffill().sort_index()
EqsDF.to_sql('Eqs_Prices', conn, if_exists='replace')
if dataVec[2] == 1:
FxList = []
for fx in FxTickers:
print(fx)
name = fx.replace('/', '')
df = investpy.get_currency_cross_historical_data(
currency_cross=fx, from_date=fromDate,
to_date=toDate).reset_index().rename(columns={
"Date": "Dates",
"Close": name
}).set_index('Dates')[name]
FxList.append(df)
FxDF = pd.concat(FxList, axis=1)
FxDF[FxDF == 0] = np.nan
FxDF = FxDF.ffill().sort_index()
FxDF["JPYUSD"] = FxDF["USDJPY"].apply(lambda x: 1 / x)
FxDF["CNYUSD"] = FxDF["USDCNY"].apply(lambda x: 1 / x)
FxDF[['EURUSD', 'GBPUSD', 'USDJPY',
'USDCNY']].to_sql('Fx_Prices_raw', conn, if_exists='replace')
FxDF[['EURUSD', 'GBPUSD', 'CNYUSD',
'JPYUSD']].to_sql('Fx_Prices', conn, if_exists='replace')
if dataVec[3] == 1:
CustomList = []
for customProduct in CustomTickers:
print(customProduct[1])
search_results = investpy.search(text=customProduct[1],
n_results=5)
for search_result in search_results:
jResult = json.loads(str(search_result))
if ((jResult["id_"] == customProduct[0]) &
(jResult["name"] == customProduct[1])):
df = search_result.retrieve_historical_data(
from_date=fromDate,
to_date=toDate).reset_index().rename(
columns={
"Date": "Dates",
"Close": customProduct[1]
}).set_index('Dates')[customProduct[1]]
CustomList.append(df)
CustomDF = pd.concat(CustomList, axis=1)
CustomDF[CustomDF == 0] = np.nan
CustomDF = CustomDF.ffill().sort_index()
CustomDF.to_sql('Custom_Prices', conn, if_exists='replace')
elif mode == 'plot':
dataAll = []
for x in ['Bonds_Prices', 'Eqs_Prices', 'Fx_Prices', 'Custom_Prices']:
df = pd.read_sql('SELECT * FROM ' + x, conn)
if x == 'Bonds_Prices':
df = df.rename(columns={"index": "Dates"})
df['Dates'] = pd.to_datetime(df['Dates'])
df = df.set_index('Dates', drop=True)
dataAll.append(df)
Prices = pd.concat(dataAll, axis=1)
Prices.to_sql('Prices', conn, if_exists='replace')
Rates = sl.d(Prices[BondsTickers]).fillna(0)
Rates.to_sql('Rates', conn, if_exists='replace')
rets = sl.dlog(Prices.drop(BondsTickers, axis=1)).fillna(0)
rets.to_sql('AssetsRets', conn, if_exists='replace')
# TO PLOT
Prices = pd.read_sql('SELECT * FROM Prices', conn).set_index('Dates',
drop=True)
Prices.index = [
x.replace("00:00:00", "").strip() for x in Prices.index
]
for subset in ['A', 'B']:
if subset == 'A':
df = Prices[BondsTickers]
ylabel = '$B_t$'
returnTs = pd.read_sql('SELECT * FROM Rates',
conn).set_index('Dates', drop=True)
returnTs.index = [
x.replace("00:00:00", "").strip() for x in returnTs.index
]
returnTs_ylabel = '$r_t$'
else:
df = Prices[[
x for x in Prices.columns if x not in BondsTickers
]].ffill()
ylabel = '$S_t$'
returnTs = pd.read_sql('SELECT * FROM AssetsRets',
conn).set_index('Dates', drop=True)
returnTs.index = [
x.replace("00:00:00", "").strip() for x in returnTs.index
]
returnTs_ylabel = '$x_t$'
# Plot 1
fig, ax = plt.subplots()
mpl.pyplot.locator_params(axis='x', nbins=35)
df.plot(ax=ax)
for label in ax.get_xticklabels():
label.set_fontsize(25)
label.set_ha("right")
label.set_rotation(45)
ax.set_xlim(xmin=0.0, xmax=len(Prices) + 1)
mpl.pyplot.ylabel(ylabel, fontsize=32)
plt.legend(loc=2,
bbox_to_anchor=(1, 1.02),
frameon=False,
prop={'size': 17})
plt.subplots_adjust(top=0.95,
bottom=0.2,
right=0.8,
left=0.08,
hspace=0,
wspace=0)
plt.margins(0, 0)
plt.grid()
plt.show()
# Plot 2
fig, ax = plt.subplots()
mpl.pyplot.locator_params(axis='x', nbins=35)
returnTs.plot(ax=ax)
for label in ax.get_xticklabels():
label.set_fontsize(25)
label.set_ha("right")
label.set_rotation(45)
ax.set_xlim(xmin=0.0, xmax=len(Prices) + 1)
mpl.pyplot.ylabel(returnTs_ylabel, fontsize=32)
plt.legend(loc=2,
bbox_to_anchor=(1, 1.02),
frameon=False,
prop={'size': 17})
plt.subplots_adjust(top=0.95,
bottom=0.2,
right=0.8,
left=0.08,
hspace=0,
wspace=0)
plt.margins(0, 0)
plt.grid()
plt.show()
def test_investpy_currency_crosses():
"""
This function checks that currency cross data retrieval functions listed in investpy work properly.
"""
params = [
{
'base': None,
'second': None,
},
{
'base': 'EUR',
'second': None,
},
{
'base': None,
'second': 'EUR',
},
{
'base': 'EUR',
'second': 'USD',
},
]
for param in params:
investpy.get_currency_crosses(base=param['base'], second=param['second'])
investpy.get_currency_crosses_list(base=param['base'], second=param['second'])
params = [
{
'base': None,
'second': None,
'columns': None,
'as_json': True
},
{
'base': None,
'second': None,
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': None,
'columns': None,
'as_json': True
},
{
'base': 'EUR',
'second': None,
'columns': None,
'as_json': False
},
{
'base': None,
'second': 'USD',
'columns': None,
'as_json': True
},
{
'base': None,
'second': 'USD',
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'USD',
'columns': None,
'as_json': True
},
{
'base': 'EUR',
'second': 'USD',
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'USD',
'columns': ['name', 'full_name'],
'as_json': False
},
]
for param in params:
investpy.get_currency_crosses_dict(base=param['base'],
second=param['second'],
columns=param['columns'],
as_json=param['as_json'])
investpy.get_available_currencies()
params = [
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': True,
'order': 'ascending',
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/1990',
'to_date': '01/01/2019',
'as_json': False,
'order': 'descending',
},
{
'currency_cross': 'XAG/USD',
'from_date': '01/01/2010',
'to_date': '01/01/2015',
'as_json': False,
'order': 'descending',
},
{
'currency_cross': 'XAU/USD',
'from_date': '01/01/2010',
'to_date': '01/01/2015',
'as_json': False,
'order': 'descending',
}
]
for param in params:
investpy.get_currency_cross_recent_data(currency_cross=param['currency_cross'],
as_json=param['as_json'],
order=param['order'],
interval='Daily')
investpy.get_currency_cross_historical_data(currency_cross=param['currency_cross'],
from_date=param['from_date'],
to_date=param['to_date'],
as_json=param['as_json'],
order=param['order'],
interval='Daily')
params = [
{
'currency_cross': 'EUR/USD',
'as_json': False
},
{
'currency_cross': 'EUR/USD',
'as_json': True
},
{
'currency_cross': 'XAU/USD',
'as_json': True
},
{
'currency_cross': 'XAG/USD',
'as_json': True
}
]
for param in params:
investpy.get_currency_cross_information(currency_cross=param['currency_cross'], as_json=param['as_json'])
params = [
{
'currency': 'try',
'as_json': False,
'n_results': 100
},
{
'currency': 'amd',
'as_json': True,
'n_results': 100
}
]
for param in params:
investpy.get_currency_crosses_overview(currency=param['currency'], as_json=param['as_json'], n_results=param['n_results'])
investpy.search_currency_crosses(by='base', value='EUR')
def get_feature_info_get(samsung_etc):
# 크롤링 start_date, end_date
start_date = '2015-01-01'
#input('YYYY-MM-DD 형식을 지켜 입력해주세요 ex) 2018-01-01 : ')
end_date = '2021-02-20'
#input('YYYY-MM-DD 형식을 지켜 입력해주세요 ex) 2020-10-13 : ')
# investing.com 양식, ex) dd/mm/yyyy
start_date_ = start_date[8:] + '/' + start_date[5:7] + '/' + start_date[:4]
end_date_ = end_date[8:] + '/' + end_date[5:7] + '/' + end_date[:4]
# krx 양식 ex) yyyymmdd
start_date__ = start_date[0:4] + start_date[5:7] + start_date[8:10]
end_date__ = end_date[0:4] + end_date[5:7] + end_date[8:10]
# 코로나 이전날짜
# 주요 3개국 대비 원 환율
# 달러/원
exchange_rate_usd_ = investpy.get_currency_cross_historical_data(
currency_cross='USD/KRW', from_date=start_date_, to_date=end_date_)
exchange_rate_usd_.columns = [
'exchange_rate_usd_Open', 'exchange_rate_usd_High',
'exchange_rate_usd_Low', 'exchange_rate_usd_Close',
'exchange_rate_usd_Currency'
]
exchange_rate_usd_ = exchange_rate_usd_.drop([
'exchange_rate_usd_Open', 'exchange_rate_usd_High',
'exchange_rate_usd_Low', 'exchange_rate_usd_Currency'
],
axis=1)
# 삼성 차트 데이터
sam_ = stock.get_market_ohlcv_by_date(start_date__, end_date__, "005930")
sam_.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
model_samsung = sam_.copy()
# 미국 국채 수익률 (5년)
treasury_5y_ = yf.download("^FVX", start=start_date, end=end_date)
treasury_5y_.columns = [
'treasury_5y_Open', 'treasury_5y_High', 'treasury_5y_Low',
'treasury_5y_Close', 'treasury_5y_Adj Close', 'treasury_5y_Volume'
]
treasury_5y_ = treasury_5y_.drop([
'treasury_5y_Open', 'treasury_5y_High', 'treasury_5y_Low',
'treasury_5y_Adj Close', 'treasury_5y_Volume'
],
axis=1)
# HANG SENG
hang_seng_ = yf.download("^HSI", start=start_date, end=end_date)
hang_seng_.columns = [
'hang_seng_Open', 'hang_seng_High', 'hang_seng_Low', 'hang_seng_Close',
'hang_seng_Adj Close', 'hang_seng_Volume'
]
hang_seng_ = hang_seng_.drop([
'hang_seng_Open', 'hang_seng_High', 'hang_seng_Low', 'hang_seng_Close',
'hang_seng_Volume'
],
axis=1)
#QQQ
qqq = yf.download("QQQ", start=start_date, end=end_date)
qqq.columns = [
'qqq_Open', 'qqq_High', 'qqq_Low', 'qqq_Close', 'qqq_Adj Close',
'qqq_Volume'
]
qqq = qqq.drop(
['qqq_Open', 'qqq_High', 'qqq_Low', 'qqq_Close', 'qqq_Volume'], axis=1)
# Russell 2000
russell_2000_ = yf.download("^RUT", start=start_date, end=end_date)
russell_2000_.columns = [
'russell_2000_Open', 'russell_2000_High', 'russell_2000_Low',
'russell_2000_Close', 'russell_2000_Adj Close', 'russell_2000_Volume'
]
russell_2000_ = russell_2000_.drop([
'russell_2000_Open', 'russell_2000_High', 'russell_2000_Low',
'russell_2000_Adj Close', 'russell_2000_Volume'
],
axis=1)
# SOX 지수 엔비디아(8.9%), 텍사스인스트루먼트(8.6%), 퀄컴(7.7%), 인텔(7.4%) 반도체장비기업 18.52%
SOXX = yf.download("SOXX", start=start_date, end=end_date)
SOXX.columns = [
'SOXX_Open', 'SOXX_High', 'SOXX_Low', 'SOXX_Close', 'SOXX_Adj Close',
'SOXX_Volume'
]
SOXX = SOXX.drop(
['SOXX_Open', 'SOXX_High', 'SOXX_Low', 'SOXX_Close', 'SOXX_Volume'],
axis=1)
# S&P 500
snp_500_ = yf.download("^GSPC", start=start_date, end=end_date)
snp_500_.columns = [
'snp_500_Open', 'snp_500_High', 'snp_500_Low', 'snp_500_Close',
'snp_500_Adj Close', 'snp_500_Volume'
]
snp_500_ = snp_500_.drop([
'snp_500_Open', 'snp_500_High', 'snp_500_Low', 'snp_500_Adj Close',
'snp_500_Volume'
],
axis=1)
model_samsung = model_samsung.drop(['Open', 'High', 'Low'], axis=1)
model_samsung[:'2018-05-03'][
'Volume'] = model_samsung[:'2018-05-03']['Volume'] * 50
model_samsung = pd.concat([model_samsung, samsung_etc], axis=1)
model_samsung['US'] = exchange_rate_usd_
model_samsung['SNP500'] = snp_500_
model_samsung['SOXX'] = SOXX
model_samsung['hang_seng'] = hang_seng_
model_samsung['qqq'] = qqq
vix = fdr.DataReader('VIX', '1990-01-01', '2021-02-23') # S&P 500 VIX
vix.iloc[-5:]
vix.columns = [
'vix', 'vix_open', 'vix_high', 'vix_low', 'vix_volume', 'vix_change'
]
model_vix = vix['vix']
model_samsung = pd.concat([model_samsung, model_vix], axis=1)
model_samsung = model_samsung.dropna()
return model_samsung
import pandas as pd
import matplotlib.pyplot as plt
# Definitions and initializations
currency = []
save_path = '/home/ubuntu/Desktop/ALLPAIRS/'
# Today's date
today_date = datetime.today().strftime('%d/%m/%Y')
# Get list of currencies and the ruble pairing ones
currency_list = investpy.get_currency_crosses_list()
[currency.append(x) for x in currency_list if '/BGN' in x]
# Remove duplicate ones:
currency_pairs = list(dict.fromkeys(currency))
# Loop through the cleaned pairs
for currency_pair in currency_pairs:
# call the API and get the information
investing_api = investpy.get_currency_cross_historical_data(currency_cross=currency_pair, from_date='01/01/1900',
to_date=today_date, order='ascending', interval='Daily')
invest_plot = pd.DataFrame(investing_api)
new = invest_plot.reset_index()
new.plot(x ='Date', y='Close', kind = 'line')
saveto = save_path + currency_pair.replace("/","") + '.png'
plt.savefig(saveto)
print(currency_pair + " Saved to " + saveto)
import numpy as np
import tensorflow as tf
import re
import time
import investpy
import pandas as pd
import matplotlib.pyplot as plt
import math
from sklearn.preprocessing import MinMaxScaler
#Get Stock
df = investpy.get_currency_cross_historical_data(currency_cross='USD/JPY',
from_date='01/01/2018',
to_date='19/02/2021')
#Drop not need
df.drop('Currency', axis=1, inplace=True)
#Plot the mean
#Featch the trend
df['Close'].plot(figsize=(16, 8), linewidth=5, fontsize=10)
plt.title('Close', fontsize=20)
plt.savefig('USDJPY Close.png')
close = df[['Close']]
close.rolling(12).mean().plot(figsize=(16, 8), linewidth=5, fontsize=10)
plt.title('Close Rolling Mean', fontsize=20)
plt.savefig('Stock Plot/USDJPY Close Rolling 12.png')
open_price = df[['Open']]
open_price.rolling(12).mean().plot(figsize=(16, 8), linewidth=5, fontsize=10)
def get_currency(currencies_name, start, end):
currency = investpy.get_currency_cross_historical_data(currencies_name,
from_date=start,
to_date=end)
return currency
def test_currency_crosses_errors():
"""
This function raises errors on currency cross retrieval functions
"""
try:
retrieve_currency_crosses(test_mode=None)
except:
pass
params = [{
'base': ['error'],
'second': None
}, {
'base': None,
'second': ['error']
}, {
'base': 'error',
'second': None
}, {
'base': 'EUR',
'second': 'error'
}, {
'base': None,
'second': 'error'
}, {
'base': 'EUR',
'second': 'EUR',
}]
for param in params:
try:
investpy.get_currency_crosses(base=param['base'],
second=param['second'])
except:
pass
try:
investpy.get_currency_crosses_list(base=param['base'],
second=param['second'])
except:
pass
params = [
{
'base': ['error'],
'second': None,
'columns': None,
'as_json': False
},
{
'base': None,
'second': ['error'],
'columns': None,
'as_json': False
},
{
'base': None,
'second': None,
'columns': None,
'as_json': 'error'
},
{
'base': None,
'second': None,
'columns': 'error',
'as_json': False
},
{
'base': None,
'second': None,
'columns': ['error'],
'as_json': False
},
{
'base': 'error',
'second': None,
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'error',
'columns': None,
'as_json': False
},
{
'base': None,
'second': 'error',
'columns': None,
'as_json': False
},
{
'base': 'EUR',
'second': 'Eur',
'columns': None,
'as_json': False
},
]
for param in params:
try:
investpy.get_currency_crosses_dict(base=param['base'],
second=param['second'],
columns=param['columns'],
as_json=param['as_json'])
except:
pass
params = [
{
'currency_cross': None,
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': ['error'],
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'as_json': 'error',
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'as_json': False,
'order': 'error',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'as_json': False,
'order': 'ascending',
'debug': 'error'
},
{
'currency_cross': 'error/error',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'as_json': False,
'order': 'ascending',
'debug': False
},
]
for param in params:
try:
investpy.get_currency_cross_recent_data(
currency_cross=param['currency_cross'],
as_json=param['as_json'],
order=param['order'],
debug=param['debug'])
except:
pass
params = [
{
'currency_cross': None,
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': ['error'],
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': 'error',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': 'error',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2017',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': 'error',
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'error',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': 'error'
},
{
'currency_cross': 'error/error',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': False
},
{
'currency_cross': 'EUR/USD',
'from_date': '01/01/2018',
'to_date': '01/01/2019',
'as_json': False,
'order': 'ascending',
'debug': False
},
]
for param in params:
try:
investpy.get_currency_cross_historical_data(
currency_cross=param['currency_cross'],
from_date=param['from_date'],
to_date=param['to_date'],
as_json=param['as_json'],
order=param['order'],
debug=param['debug'])
except:
pass
params = [
{
'by': None,
'value': 'EUR',
},
{
'by': ['error'],
'value': 'EUR',
},
{
'by': 'error',
'value': 'EUR',
},
{
'by': 'base',
'value': None,
},
{
'by': 'base',
'value': ['error'],
},
{
'by': 'base',
'value': 'error',
},
]
for param in params:
try:
investpy.search_currency_crosses(by=param['by'],
value=param['value'])
except:
pass
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
#!sudo apt-get install msttcorefonts -qq
from pylab import rcParams
import matplotlib as mpl
import warnings; warnings.simplefilter('ignore')
import matplotlib
import matplotlib.font_manager as fm
link ='http://www.bcra.gov.ar/Pdfs/PublicacionesEstadisticas/Serieanual.xls'
CNY = investpy.get_currency_cross_historical_data(currency_cross='CNY/USD',
from_date='01/01/2014', to_date=date.today().strftime('%d/%m/%Y'))
RRII_N=list()
años=np.arange(2014,2021)
for a in años:
balance_bcra1 = pd.read_excel(link,'serie semanal {}'.format(a),skiprows=3,index_col=0)
balance_bcra=balance_bcra1.T
total = balance_bcra.isnull().sum().sort_values(ascending=False)
porcentaje = (balance_bcra.isnull().sum()/balance_bcra.isnull().count()).sort_values(ascending=False)
data_faltante = pd.concat([total, porcentaje], axis=1, keys=['Total', 'Porcentaje'])
balance_bcra =balance_bcra.drop((data_faltante[data_faltante['Porcentaje'] >0.95]).index,1)
bcra_bal=balance_bcra.div(balance_bcra["Tipo de Cambio"].iloc[:,1], axis=0).round(0)
col_rrii=bcra_bal.columns[bcra_bal.columns.str.contains('Divisas \.\.\..*|Oro .*|Colocaciones realizables en divisas.*|Instrumentos Derivados sobre Reservas.*|Convenios Multilaterales de Crédito.*', regex=True)]
