def test_negativ_1_year_performance_calculation(self):
# given:
history = History(95, 100, 100)
# when:
performance = history.performance_1_year()
# then:
self.assertEqual(-0.05, performance, "performance of 5%")
def test_6_month_performance_calculation(self):
#given:
history = History(105, 100, 100)
#when:
performance = history.performance_6_month()
#then:
self.assertEqual(0.05, performance, "performance of 5%")
def fromJson(self, json_str: str) -> Stock:
stock_json = json.loads(json_str)
stock = Stock(stock_json["stock_id"], stock_json["name"], None)
for attr in stock_json.keys():
if attr == "stock_id" or attr == "stock_name":
continue
if attr == "history":
history = stock_json["history"]
stock.history = History(history["today"], history["half_a_year"], history["one_year"])
elif attr == "monthClosings":
stock.monthClosings = MonthClosings()
stock.monthClosings.closings = stock_json["monthClosings"].get("closings")
elif attr == "ratings":
ratings = stock_json["ratings"]
stock.ratings = AnalystRatings(ratings["buy"], ratings["hold"], ratings["sell"])
elif attr == "reaction_to_quarterly_numbers":
reaction = stock_json["reaction_to_quarterly_numbers"]
stock.reaction_to_quarterly_numbers = \
ReactionToQuarterlyNumbers(reaction["price"], reaction["price_before"], reaction["index_price"],
reaction["index_price_before"], reaction["date"])
else:
stock.__setattr__(attr, stock_json[attr])
return stock
def test_index_group_to_json(self):
# given:
index_group = IndexGroup("isin", "index_name", "source_id", "source")
index_group.stocks = [Stock("stock_id", "stock_name", index_group)]
index_group.history = History(1, 2, 3)
index_group.monthClosings = MonthClosings()
index_group.monthClosings.closings = [0, 0, 0, 0]
def scrap_index(indexGroup: IndexGroup, index_storage: IndexStorage):
date = index_storage.date
if sameDay(date, datetime.now()):
date = date - relativedelta(days=1)
index_price_today = get_latest_price(index_storage, date)
index_price_6month = get_historical_price(index_storage,
(date - relativedelta(months=6)))
index_price_1year = get_historical_price(index_storage,
(date - relativedelta(months=12)))
indexGroup.history = History(index_price_today, index_price_6month,
index_price_1year)
indexGroup.monthClosings = get_month_closings(index_storage)
def fromJson(self, json_str: str) -> IndexGroup:
index_json = json.loads(json_str)
# backward compatibilities
isin = index_json["isin"] if "isin" in index_json else index_json["index"]
name = index_json["name"]
sourceID = index_json["sourceId"] if "sourceId" in index_json else name
source = index_json["source"] if "source" in index_json else "onvista"
indexGroup = IndexGroup(isin, name, sourceID, source)
history = index_json["history"]
indexGroup.history = History(history["today"], history["half_a_year"], history["one_year"])
indexGroup.monthClosings = MonthClosings()
indexGroup.monthClosings.closings = index_json["monthClosings"].get("closings")
indexGroup.stocks = list(map(lambda s: Stock(s.id, s.name, indexGroup)), index_json["stocks"])
return indexGroup
def scrap(stock: Stock, stock_storage: StockStorage, util: OnVistaDateUtil = OnVistaDateUtil()):
with open(stock_storage.getStoragePath("profil", "html"), mode="r") as f:
soup = BeautifulSoup(f, 'html.parser')
currencies = scrap_currencies(soup)
price = scrap_price(soup)
fundamentals = scrap_fundamentals(soup)
company_details = scrap_company_details(soup)
with open(stock_storage.getStoragePath("bilanz_guv", "html"), mode="r") as f:
soup = BeautifulSoup(f, 'html.parser')
bilanz_guv = scrap_bilanz_guv(soup)
with open(stock_storage.getStoragePath("schaetzungen", "html"), mode="r") as f:
soup = BeautifulSoup(f, 'html.parser')
schaetzung = scrap_schaetzung(soup)
with open(stock_storage.getStoragePath("analysen", "html"), mode="r") as f:
soup = BeautifulSoup(f, 'html.parser')
stock.ratings = scrap_analysen(soup)
last_year = util.get_last_year()
current_year = util.get_current_year(estimated=False)
next_year = util.get_next_year(estimated=False)
stock.price = asFloat(price)
stock.field = company_details["Branchen"]
GuV = findIn(bilanz_guv, "GuV")
gewinn = asFloat(GuV["Ergebnis nach Steuer"][last_year])
ebit = asFloat(GuV["Ergebnis vor Steuern"][last_year])
erloes = asFloat(GuV["Umsatzerlöse"][last_year])
bilanz = findIn(bilanz_guv, "Bilanz")
eigenkapital = asFloat(bilanz["Eigenkapital"][last_year])
stock.roi = gewinn / eigenkapital * 100
stock.ebit_margin = ebit / erloes * 100
unternehmenskennzahlen = findIn(bilanz_guv, "Unternehmenskennzahlen")
stock.equity_ratio = asFloat(unternehmenskennzahlen["Eigenkapitalquote in %"][last_year])
stock.per = asFloat(schaetzung["KGV"][current_year])
hist_pers = unternehmenskennzahlen["KGV (Jahresendkurs)"]
per_5_years = stock.per
number_of_year = 1
for year in list(hist_pers.keys())[-4:]:
if hist_pers[year] != "-":
per_5_years += asFloat(hist_pers[year])
number_of_year += 1
stock.per_5_years = (per_5_years / number_of_year)
eps_row_name = "Ergebnis/Aktie (reported)" if ("Ergebnis/Aktie (reported)" in schaetzung) else "Ergebnis/Aktie"
stock.eps_current_year = asFloat(schaetzung[eps_row_name][current_year])
stock.eps_next_year = asFloat(schaetzung[eps_row_name][next_year])
stock.per_fallback = stock.price / stock.eps_current_year if stock.eps_current_year != 0 else 0
stock.market_capitalization = asFloat(fundamentals["Marktkapitalisierung in Mrd. EUR"]) * 1000000000
stock_price_today = 0
stock_price_6month = 0
stock_price_1year = 0
stock.history = History(stock_price_today, stock_price_6month, stock_price_1year)
stock.monthClosings = MonthClosings()
stock.historical_eps_current_year = 0
stock.historical_eps_date = 0
stock.historical_eps_next_year = 0
stock.reaction_to_quarterly_numbers = ReactionToQuarterlyNumbers(0, 0, 0, 0, "")
return stock
def scrap(stock: Stock,
stock_storage: StockStorage,
util: OnVistaDateUtil = OnVistaDateUtil()):
path = stock_storage.getStoragePath("fundamental", "html")
content = stock_storage.storage_repository.load(path)
if content:
soup = BeautifulSoup(content, 'html.parser')
stock.symbol = scrap_symbol(soup)
fundamentals = scrap_fundamentals(soup)
last_year_est = util.get_last_year(estimated=True)
last_cross_year_est = util.get_last_cross_year(estimated=True)
fallback_to_last_year_values = last_year_est in fundamentals[
"Rentabilität"][
"Eigenkapitalrendite"] or last_cross_year_est in fundamentals[
"Rentabilität"]["Eigenkapitalrendite"]
if fallback_to_last_year_values:
last_year = util.get_last_year(min_years=2)
last_cross_year = util.get_last_cross_year(min_years=2)
current_year = util.get_last_year(estimated=True)
current_cross_year = util.get_last_cross_year()
current_cross_year_est = util.get_last_cross_year(estimated=True)
next_year = util.get_current_year()
next_cross_year = util.get_current_cross_year()
else:
last_year = util.get_last_year()
last_cross_year = util.get_last_cross_year()
current_year = util.get_current_year()
current_cross_year = util.get_current_cross_year(estimated=False)
current_cross_year_est = util.get_current_cross_year()
next_year = util.get_next_year()
next_cross_year = util.get_next_cross_year()
stock.price = asFloat(
soup.find("ul", {
"class": "KURSDATEN"
}).find("li").find("span").get_text().strip())
stock.roi = asFloat(
get_for_year(fundamentals["Rentabilität"]["Eigenkapitalrendite"],
[last_year, last_cross_year]))
stock.ebit_margin = asFloat(
get_for_year(fundamentals["Rentabilität"]["EBIT-Marge"],
[last_year, last_cross_year]))
stock.equity_ratio = asFloat(
get_for_year(fundamentals["Bilanz"]["Eigenkapitalquote"],
[last_year, last_cross_year]))
stock.per_5_years = calc_per_5_years(
fundamentals,
[current_year, current_cross_year_est, current_cross_year])
stock.per = asFloat(
get_for_year(
fundamentals["Gewinn"]["KGV"],
[current_year, current_cross_year_est, current_cross_year]))
date = stock_storage.indexStorage.date
if sameDay(date, datetime.now()):
date = date - relativedelta(days=1)
stock_price_today = get_latest_price(stock_storage, date)
stock_price_6month = get_historical_price(
stock_storage, (date - relativedelta(months=6)))
stock_price_1year = get_historical_price(
stock_storage, (date - relativedelta(months=12)))
stock.history = History(stock_price_today, stock_price_6month,
stock_price_1year)
stock.monthClosings = get_month_closings(stock_storage)
stock.eps_current_year = asFloat(
get_for_year(
fundamentals["Gewinn"]["Gewinn pro Aktie in EUR"],
[current_year, current_cross_year_est, current_cross_year]))
stock.per_fallback = stock.price / stock.eps_current_year if stock.eps_current_year != 0 else 0
stock.eps_next_year = asFloat(
get_for_year(fundamentals["Gewinn"]["Gewinn pro Aktie in EUR"],
[next_year, next_cross_year]))
stock.market_capitalization = get_market_capitalization(
fundamentals, last_year, last_cross_year)
stock = scrap_ratings(stock, stock_storage)
add_historical_eps(stock, stock_storage)
add_reaction_to_quarterly_numbers(stock, stock_storage)
return stock