def levermann_03():
stock_list = db.get_list(table=cst.TABLE_STOCKS, columns=cst.COLUMN_URI)
for stock in stock_list:
# equity_capital = db.get_equity_capital(stock)
equity_capital = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EQUITY_CAPITAL,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
# balance = db.get_balance(stock)
balance = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_BALANCE,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
if equity_capital is None or balance is None or balance == 0:
logger.info(
"Calculate Lev03: Equity Capital or Balance is None or 0 for stock: %s"
% stock)
continue
equity_ratio = round(equity_capital / balance, 2)
if db.check_is_financial_company(stock):
if equity_ratio > 0.10:
lev_03_score = 1
elif equity_ratio < 0.05:
lev_03_score = -1
else:
lev_03_score = 0
else:
if equity_ratio > 0.25:
lev_03_score = 1
elif equity_ratio < 0.15:
lev_03_score = -1
else:
lev_03_score = 0
# db.save_equity_ratio_to_db(stock, equity_ratio, lev_03_score)
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
current_date=date.get_current_date(),
stock_uri=stock,
lev_03_val=equity_ratio,
lev_03_sco=lev_03_score,
)
def levermann_02():
stock_list = db.get_list(table=cst.TABLE_STOCKS, columns=cst.COLUMN_URI)
for stock in stock_list:
# operative_result = db.get_operative_result(stock)
operative_result = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_OPERATIVE_RESULT,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
# sales_revenue = db.get_sales_revenue(stock)
sales_revenue = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_SALES_REVENUE,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
if operative_result is None or sales_revenue is None or sales_revenue == 0:
logger.info(
"Calculate Lev02: Operative Result or Sales Revenue is None for stock: %s"
% stock)
continue
ebit = round(operative_result / sales_revenue, 2)
if db.check_is_financial_company(stock):
logger.info("Calculate Lev02: %s is financial Stock" % stock)
ebit = 0
lev_02_score = 0
else:
if ebit > 0.12:
lev_02_score = 1
elif ebit < 0.06:
lev_02_score = -1
else:
lev_02_score = 0
# db.save_ebit_to_db(stock, ebit, lev_02_score)
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
current_date=date.get_current_date(),
stock_uri=stock,
lev_02_val=ebit,
lev_02_sco=lev_02_score,
)
def test_upsert_new_kgv5(self):
current_date = "2019-03-30"
stock_uri = "ab_inbev-Aktie"
kgv5 = "24.91"
lev_04_score = "-1"
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
database=cst.TEST_DATABASE,
current_date=current_date,
stock_uri=stock_uri,
lev_04_val=kgv5,
lev_04_sco=lev_04_score,
)
self.assertEqual(
kgv5,
str(
db.get_item(
table=cst.TABLE_LEVERMANN,
column=cst.COLUMN_LEV04_VALUE,
condition=[cst.COLUMN_DATE, "2019-03-30"],
database=cst.TEST_DATABASE,
)),
)
def test_upsert_new_ebit(self):
current_date = "2019-03-30"
stock_uri = "ab_inbev-Aktie"
ebit = "0.32"
lev_02_score = "1"
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
database=cst.TEST_DATABASE,
current_date=current_date,
stock_uri=stock_uri,
lev_02_val=ebit,
lev_02_sco=lev_02_score,
)
self.assertEqual(
ebit,
str(
db.get_item(
table=cst.TABLE_LEVERMANN,
column=cst.COLUMN_LEV02_VALUE,
condition=[cst.COLUMN_DATE, "2019-03-30"],
database=cst.TEST_DATABASE,
)),
)
def test_upsert_existing_roe(self):
current_date = "2019-03-23"
stock_uri = "ab_inbev-Aktie"
return_on_equity = "0.08"
lev_01_score = "-1"
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
database=cst.TEST_DATABASE,
current_date=current_date,
stock_uri=stock_uri,
lev_01_val=return_on_equity,
lev_01_sco=lev_01_score,
)
self.assertEqual(
return_on_equity,
str(
db.get_item(
table=cst.TABLE_LEVERMANN,
column=cst.COLUMN_LEV01_VALUE,
condition=[cst.COLUMN_DATE, "2019-03-23"],
database=cst.TEST_DATABASE,
)),
)
def test_upsert_existing_single_balance_data_to_db(self):
current_date = "2019-03-09"
stock_uri = "ab_inbev-Aktie"
equity_capital = 121541.00
earnings_at = 3702.48
operative_result = 14520.88
db.upsert_item(
table=cst.TABLE_COMPANY_DATA,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
database=cst.TEST_DATABASE,
current_date=current_date,
stock_uri=stock_uri,
equity_capital=equity_capital,
earnings_after_tax=earnings_at,
operative_result=operative_result,
)
self.assertEqual(
"3702.48",
str(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EARNINGS_AT,
condition=[cst.COLUMN_EQUITY_CAPITAL, 121541.00],
database=cst.TEST_DATABASE,
)),
)
def test_get_latest_date_from_index_history_which_does_not_exist(self):
actual_latest_date = db.get_item(
table=cst.TABLE_INDEX_HISTORIES,
column="max(Datum)",
condition=[cst.COLUMN_INDEX_URI, "bux"],
database=cst.TEST_DATABASE,
)
self.assertIsNone(actual_latest_date)
def test_upsert_new_targets(self):
current_date = "2019-03-09"
stock_uri = "ab_inbev-Aktie"
buy, hold, sell = 7, 1, 0
db.upsert_item(
table=cst.TABLE_COMPANY_DATA,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
stock_uri=stock_uri,
current_date=current_date,
analyst_buy=buy,
analyst_hold=hold,
analyst_sell=sell,
database=cst.TEST_DATABASE,
)
self.assertEqual(
buy,
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_ANALYST_BUY,
condition=[cst.COLUMN_DATE, "2019-03-09"],
database=cst.TEST_DATABASE,
),
)
self.assertEqual(
hold,
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_ANALYST_HOLD,
condition=[cst.COLUMN_DATE, "2019-03-09"],
database=cst.TEST_DATABASE,
),
)
self.assertEqual(
sell,
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_ANALYST_SELL,
condition=[cst.COLUMN_DATE, "2019-03-09"],
database=cst.TEST_DATABASE,
),
)
def test_get_latest_date_from_stock_history_with_condition(self):
asserted_latest_date = date.string_to_date("01.02.2019")
actual_latest_date = db.get_item(
table=cst.TABLE_STOCKS_HISTORIES,
column="max(Datum)",
condition=[cst.COLUMN_STOCK_URI, "Adidas-Aktie"],
database=cst.TEST_DATABASE,
)
self.assertEqual(asserted_latest_date, actual_latest_date)
def test_get_latest_date_from_index_history_with_condition(self):
asserted_latest_date = date.string_to_date("08.03.2019")
actual_latest_date = db.get_item(
table=cst.TABLE_INDEX_HISTORIES,
column="max(Datum)",
condition=[cst.COLUMN_INDEX_URI, "dax"],
database=cst.TEST_DATABASE,
)
self.assertEqual(asserted_latest_date, actual_latest_date)
def levermann_01():
stock_list = db.get_list(table=cst.TABLE_STOCKS, columns=cst.COLUMN_URI)
for stock in stock_list:
# earnings_before_tax = db.get_earnings_after_tax(stock)
earnings_before_tax = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EARNINGS_AT,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
# equity_capital = db.get_equity_capital(stock)
equity_capital = db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EQUITY_CAPITAL,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
if earnings_before_tax is None or equity_capital is None or equity_capital == 0:
logger.info(
"Calculate Lev01: Earnings before Tax or Equity Capital is None for stock: %s"
% stock)
continue
return_on_equity = round(earnings_before_tax / equity_capital, 2)
if return_on_equity > 0.2:
lev_01_score = 1
elif return_on_equity < 0.1:
lev_01_score = -1
else:
lev_01_score = 0
# db.save_roe_to_db(stock, return_on_equity, lev_01_score)
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
current_date=date.get_current_date(),
stock_uri=stock,
lev_01_val=return_on_equity,
lev_01_sco=lev_01_score,
)
def test_get_earnings_after_tax(self):
self.assertEqual(
3702.48,
float(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EARNINGS_AT,
condition=[cst.COLUMN_STOCK_URI, "ab_inbev-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
)),
)
def test_get_equity_capital(self):
self.assertEqual(
62899.88,
float(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EQUITY_CAPITAL,
condition=[cst.COLUMN_STOCK_URI, "ab_inbev-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
)),
)
def test_get_quarterly_date(self):
asserted_date = date.string_to_date("21.03.2019")
self.assertEqual(
asserted_date,
db.get_item(
table=cst.TABLE_STOCK_DATES,
column=cst.COLUMN_DATE,
condition=[cst.COLUMN_STOCK_URI, "ab_inbev-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
),
)
def test_get_latest_stock_price(self):
self.assertEqual(
199.40,
float(
db.get_item(
table=cst.TABLE_STOCKS_HISTORIES,
column=cst.COLUMN_CLOSING_VALUE,
condition=[cst.COLUMN_STOCK_URI, "adidas-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
)),
)
def test_get_sales_revenue(self):
self.assertEqual(
46297.11,
float(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_SALES_REVENUE,
condition=[cst.COLUMN_STOCK_URI, "ab_inbev-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
)),
)
def test_get_operative_result(self):
self.assertEqual(
14520.88,
float(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_OPERATIVE_RESULT,
condition=[cst.COLUMN_STOCK_URI, "ab_inbev-Aktie"],
order=[cst.COLUMN_DATE, cst.DESC],
database=cst.TEST_DATABASE,
)),
)
def test_upsert_new_single_balance_data_to_db(self):
current_date = "2019-03-23"
stock_uri = "coca-cola-Aktie"
earnings_at = 6434.00
operative_result = 9652.00
sales_revenue = 31697.00
balance = 83216.00
equity_capital = 19058.00
eps_m3 = 1.51
eps_m2 = 0.29
eps_m1 = 1.51
db.upsert_item(
table=cst.TABLE_COMPANY_DATA,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
database=cst.TEST_DATABASE,
current_date=current_date,
stock_uri=stock_uri,
earnings_after_tax=earnings_at,
operative_result=operative_result,
sales_revenue=sales_revenue,
balance=balance,
equity_capital=equity_capital,
eps_m3=eps_m3,
eps_m2=eps_m2,
eps_m1=eps_m1,
)
self.assertEqual(
"1.51",
str(
db.get_item(
table=cst.TABLE_COMPANY_DATA,
column=cst.COLUMN_EPS_M3,
condition=[cst.COLUMN_STOCK_URI, "coca-cola-Aktie"],
database=cst.TEST_DATABASE,
)),
)
def levermann_07():
stock_list = db.get_list(table=cst.TABLE_STOCKS, columns=cst.COLUMN_URI)
for stock in stock_list:
logger.info("Calculating Lev07 for %s" % stock)
# quarterly_date = db.get_quarterly_date(stock)
quarterly_date = db.get_item(
table=cst.TABLE_STOCK_DATES,
column=cst.COLUMN_DATE,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
if quarterly_date is None:
logger.info(
"Calculate Lev07: Quaterly Date is None for stock: %s" % stock)
db.save_quarterly_reaction_to_db(stock, 0, 0)
continue
index = db.get_main_index_of_stock(stock)
if index is None:
logger.info("Calculate Lev07: No Index found")
continue
quarterly_stock_pack = db.get_closing_stock_price(
quarterly_date, stock)
quarterly_index_pack = db.get_closing_index_price(
quarterly_date, index)
if quarterly_stock_pack is None or quarterly_index_pack is None:
logger.info(
"Calculate Lev07: Quaterly Date Pack or Quaterly Index Pack is None for stock: %s"
% stock)
continue
quarterly_stock_closing_price, quarterly_stock_actual_date = (
quarterly_stock_pack)
quarterly_index_closing_price, quarterly_index_actual_date = (
quarterly_index_pack)
day_before_actual_date_stock = date.edit_date(
quarterly_stock_actual_date, cst.DT_MINUS, 1, cst.DT_DAY)
day_before_actual_date_index = date.edit_date(
quarterly_index_actual_date, cst.DT_MINUS, 1, cst.DT_DAY)
compare_price_stock = db.get_closing_stock_price(
day_before_actual_date_stock, stock)
compare_price_index = db.get_closing_index_price(
day_before_actual_date_index, index)
if compare_price_stock is None:
logger.info(
"Calc Lev07: Compare Price Stock is None for stock: %s" %
stock)
continue
if compare_price_index is None:
logger.info(
"Calc Lev07: Compare Price Index is None for stock: %s" %
stock)
continue
if compare_price_stock[0] is None or compare_price_stock[0] == 0:
logger.info(
"Calculate Lev07: First Item in Compare Price Stock is None or 0: %s"
% stock)
continue
if compare_price_index[0] is None or compare_price_index[0] == 0:
logger.info(
"Calculate Lev07: First Item in Compare Price Index is None or 0: %s"
% stock)
continue
stock_diff = (quarterly_stock_closing_price /
compare_price_stock[0]) - 1
index_diff = (quarterly_index_closing_price /
compare_price_index[0]) - 1
if index_diff == 0:
continue
combined_diff = round(stock_diff - index_diff, 2)
if combined_diff >= 0.01:
lev_score = 1
elif -0.01 < combined_diff < 0.01:
lev_score = 0
elif combined_diff <= -0.01:
lev_score = -1
db.save_quarterly_reaction_to_db(stock, combined_diff, lev_score)
def levermann_04_05():
stock_list = db.get_list(table=cst.TABLE_STOCKS, columns=cst.COLUMN_URI)
for stock in stock_list:
# current_stock_price = db.get_latest_stock_price(stock)
current_stock_price = db.get_item(
table=cst.TABLE_STOCKS_HISTORIES,
column=cst.COLUMN_CLOSING_VALUE,
condition=[cst.COLUMN_STOCK_URI, stock],
order=[cst.COLUMN_DATE, cst.DESC],
)
eps = db.get_latest_eps(stock)
if current_stock_price is None or eps is None:
logger.info("Calculate Lev04/05: Current Stockprice is None: %s" %
stock)
continue
if eps is None:
logger.info("Calculate Lev04/05: EPS is None for stock: %s" %
stock)
continue
if None in eps:
logger.info("Calculate Lev04/05: Any Nones in EPS for stock: %s" %
stock)
continue
eps_0 = eps[3]
kgv5 = float(current_stock_price) / (sum(eps) /
5) if sum(eps) != 0 else 9999.99
kgv5 = 9999.99 if kgv5 > 9999.99 else kgv5
kgv0 = float(current_stock_price) / eps_0 if eps_0 != 0 else 14
kgv0 = 9999.99 if kgv0 > 9999.99 else kgv0
if 0 < kgv5 < 12:
lev_04_score = 1
elif 12 < kgv5 < 16:
lev_04_score = 0
elif kgv5 <= 0 or kgv5 >= 16:
lev_04_score = -1
else:
lev_04_score = 0
# db.save_kgv5_to_db(stock, round(kgv5, 2), lev_04_score)
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
current_date=date.get_current_date(),
stock_uri=stock,
lev_04_val=round(kgv5, 2),
lev_04_sco=lev_04_score,
)
if 0 < kgv0 < 12:
lev_05_score = 1
elif 12 < kgv0 < 16:
lev_05_score = 0
elif kgv0 <= 0 or kgv0 >= 16:
lev_05_score = -1
else:
lev_05_score = 0
# db.save_kgv0_to_db(stock, round(kgv0, 2), lev_05_score)
db.upsert_item(
table=cst.TABLE_LEVERMANN,
primary_keys=[cst.COLUMN_STOCK_URI, cst.COLUMN_DATE],
current_date=date.get_current_date(),
stock_uri=stock,
lev_05_val=round(kgv0, 2),
lev_05_sco=lev_05_score,
)
