Repository navigation
Expand file tree
/
Copy pathmodels.py
More file actions
140 lines (108 loc) · 5.58 KB
/
Copy pathmodels.py
File metadata and controls
140 lines (108 loc) · 5.58 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import yfinance as yf
import pandas as pd
from scrapers import DeepHistoryScraper
class StockValuator:
def __init__(self, ticker):
self.ticker_symbol = ticker.upper()
self.stock = yf.Ticker(self.ticker_symbol)
# Cache standard data
self.info = self.stock.info
self.cash_flow = self.stock.cashflow
self.quarterly_income = self.stock.quarterly_income_stmt
# Initialize our custom Scraper
self.scraper = DeepHistoryScraper(self.ticker_symbol)
def get_current_price(self):
return self.info.get('currentPrice', 0)
def get_quarterly_growth(self):
try:
q_data = self.quarterly_income.T.sort_index()
target_cols = ['Total Revenue', 'Net Income']
available_cols = [c for c in target_cols if c in q_data.columns]
if not available_cols: return None, 0.05, 0
df = q_data[available_cols].copy()
df['Revenue Growth (YoY)'] = df['Total Revenue'].pct_change(periods=4)
df['Net Income Growth (YoY)'] = df['Net Income'].pct_change(periods=4)
valid_yoy_points = df['Revenue Growth (YoY)'].dropna()
if not valid_yoy_points.empty:
average_growth = valid_yoy_points.mean()
count = len(valid_yoy_points)
else:
qoq = df['Total Revenue'].pct_change(periods=1).iloc[-1]
average_growth = qoq * 4
count = 0
return df.sort_index(ascending=False).head(5), average_growth, count
except Exception:
return None, 0.05, 0
def get_deep_history_cagr(self):
print("... Scraping deep history from StockAnalysis.com ...")
revenue_series = self.scraper.get_revenue_history()
if revenue_series is None or len(revenue_series) < 5:
print(" (Scraping failed or insufficient data, falling back to 5% default)")
return 0.05, 0
start_val = revenue_series.iloc[0]
end_val = revenue_series.iloc[-1]
years = len(revenue_series) - 1
cagr = (end_val / start_val) ** (1 / years) - 1
return cagr, years
def calculate_capm_discount_rate(self):
try:
treasury = yf.Ticker("^TNX")
hist = treasury.history(period="1d")
if hist.empty: return 0.10, 0.04, 1.0 # Fallback
risk_free_rate = hist['Close'].iloc[-1] / 100
beta = self.info.get('beta', 1.0)
if beta is None: beta = 1.0
market_risk_premium = 0.055
required_return = risk_free_rate + (beta * market_risk_premium)
return round(required_return, 4), risk_free_rate, beta
except Exception:
return 0.10, 0.04, 1.0
def calculate_dcf_value(self, growth_rate=0.05, discount_rate=0.10, years=5):
try:
free_cash_flow = self.cash_flow.loc['Free Cash Flow'].iloc[0]
except (KeyError, IndexError):
return None
future_cash_flows = []
for i in range(1, years + 1):
fcf_forecast = free_cash_flow * ((1 + growth_rate) ** i)
discounted_fcf = fcf_forecast / ((1 + discount_rate) ** i)
future_cash_flows.append(discounted_fcf)
perpetual_rate = 0.025
if discount_rate <= perpetual_rate: discount_rate = perpetual_rate + 0.01
terminal_value = (future_cash_flows[-1] * (1 + perpetual_rate)) / (discount_rate - perpetual_rate)
discounted_tv = terminal_value / ((1 + discount_rate) ** years)
shares = self.info.get('sharesOutstanding')
if not shares: return None
return round((sum(future_cash_flows) + discounted_tv) / shares, 2)
def calculate_graham_number(self):
try:
eps = self.info.get('trailingEps')
book_value = self.info.get('bookValue')
if eps is None or book_value is None or eps <= 0 or book_value <= 0: return 0
return round((22.5 * eps * book_value) ** 0.5, 2)
except TypeError: return None
def calculate_gordon_growth_value(self, required_return=0.10, growth_rate=0.03):
dividend_rate = self.info.get('dividendRate')
if dividend_rate is None or required_return <= growth_rate: return None
return round((dividend_rate * (1 + growth_rate)) / (required_return - growth_rate), 2)
class BondValuator:
def __init__(self, face_value, coupon_rate, years_to_maturity, market_rate, frequency=1):
self.F, self.r, self.n, self.i, self.freq = face_value, coupon_rate, years_to_maturity, market_rate, frequency
def calculate_price(self):
periods = self.n * self.freq
p_rate = self.i / self.freq
p_coupon = (self.F * self.r) / self.freq
if p_rate == 0: annuity = periods
else: annuity = (1 - (1 + p_rate) ** -periods) / p_rate
return round((p_coupon * annuity) + (self.F / ((1 + p_rate) ** periods)), 2)
def calculate_macaulay_duration(self):
periods = self.n * self.freq
p_rate = self.i / self.freq
p_coupon = (self.F * self.r) / self.freq
total_pv, weighted_sum = 0, 0
for t in range(1, periods + 1):
cf = p_coupon + (self.F if t == periods else 0)
pv_cf = cf / ((1 + p_rate) ** t)
total_pv += pv_cf
weighted_sum += (t * pv_cf)
return round((weighted_sum / total_pv) / self.freq, 2) if total_pv else 0