Merge pull request #2372 from ranaroussi/dev

sync dev -> main

Author: ValueRaider

doc/source/reference/yfinance.financials.rst

@@ -10,12 +10,16 @@ Financials
 
    get_income_stmt
    income_stmt
+   quarterly_income_stmt
+   ttm_income_stmt
 
    get_balance_sheet
    balance_sheet
 
    get_cashflow
    cashflow
+   quarterly_cashflow
+   ttm_cashflow
 
    get_earnings
    earnings

tests/data/KWS-L-1d-bad-div-fixed.csv

@@ -361,27 +361,27 @@ def test_repair_zeroes_daily(self):
         hist = dat._lazy_load_price_history()
         tz_exchange = dat.fast_info["timezone"]
 
-        df_bad = _pd.DataFrame(data={"Open":      [0,      102.04, 102.04],
-                                     "High":      [0,      102.1,  102.11],
-                                     "Low":       [0,      102.04, 102.04],
-                                     "Close":     [103.03, 102.05, 102.08],
-                                     "Adj Close": [102.03, 102.05, 102.08],
-                                     "Volume": [560, 137, 117]},
-                               index=_pd.to_datetime([_dt.datetime(2024, 11, 1),
-                                                      _dt.datetime(2024, 10, 31),
-                                                      _dt.datetime(2024, 10, 30)]))
+        df_bad = _pd.DataFrame(data={"Open":      [0,      114.37, 114.20],
+                                     "High":      [0,      114.40, 114.40],
+                                     "Low":       [0,      114.36, 114.20],
+                                     "Close":     [114.39, 114.38, 114.45],
+                                     "Adj Close": [114.39, 114.38, 114.45],
+                                     "Volume":    [9,      15666,  1094]},
+                               index=_pd.to_datetime([_dt.datetime(2025, 3, 17),
+                                                      _dt.datetime(2025, 3, 14),
+                                                      _dt.datetime(2025, 3, 13)]))
         df_bad = df_bad.sort_index()
         df_bad.index.name = "Date"
         df_bad.index = df_bad.index.tz_localize(tz_exchange)
 
         repaired_df = hist._fix_zeroes(df_bad, "1d", tz_exchange, prepost=False)
 
         correct_df = df_bad.copy()
-        correct_df.loc["2024-11-01", "Open"] = 102.572729
-        correct_df.loc["2024-11-01", "Low"] = 102.309091
-        correct_df.loc["2024-11-01", "High"] = 102.572729
+        correct_df.loc["2025-03-17", "Open"] = 114.62
+        correct_df.loc["2025-03-17", "High"] = 114.62
+        correct_df.loc["2025-03-17", "Low"] = 114.41
         for c in ["Open", "Low", "High", "Close"]:
-            self.assertTrue(_np.isclose(repaired_df[c], correct_df[c], rtol=1e-8).all())
+            self.assertTrue(_np.isclose(repaired_df[c], correct_df[c], rtol=1e-7).all())
 
         self.assertTrue("Repaired?" in repaired_df.columns)
         self.assertFalse(repaired_df["Repaired?"].isna().any())
@@ -390,19 +390,21 @@ def test_repair_zeroes_daily_adjClose(self):
         # Test that 'Adj Close' is reconstructed correctly,
         # particularly when a dividend occurred within 1 day.
 
+        self.skipTest("Currently failing because Yahoo returning slightly different data for interval 1d vs 1h on day Aug 6 2024")
+
         tkr = "INTC"
-        df = _pd.DataFrame(data={"Open":      [28.95, 28.65, 29.55, 29.62, 29.25],
-                                 "High":      [29.12, 29.27, 29.65, 31.17, 30.30],
-                                 "Low":       [28.21, 28.43, 28.61, 29.53, 28.80],
-                                 "Close":     [28.24, 29.05, 28.69, 30.32, 30.19],
-                                 "Adj Close": [28.12, 28.93, 28.57, 29.83, 29.70],
-                                 "Volume":    [36e6, 51e6, 49e6, 58e6, 62e6],
-                                 "Dividends": [0, 0, 0.365, 0, 0]},
-                           index=_pd.to_datetime([_dt.datetime(2023, 2, 8),
-                                                  _dt.datetime(2023, 2, 7),
-                                                  _dt.datetime(2023, 2, 6),
-                                                  _dt.datetime(2023, 2, 3),
-                                                  _dt.datetime(2023, 2, 2)]))
+        df = _pd.DataFrame(data={"Open":      [2.020000e+01, 2.032000e+01, 1.992000e+01, 1.910000e+01, 2.008000e+01],
+                                 "High":      [2.039000e+01, 2.063000e+01, 2.025000e+01, 2.055000e+01, 2.015000e+01],
+                                 "Low":       [1.929000e+01, 1.975000e+01, 1.895000e+01, 1.884000e+01, 1.950000e+01],
+                                 "Close":     [2.011000e+01, 1.983000e+01, 1.899000e+01, 2.049000e+01, 1.971000e+01],
+                                 "Adj Close": [1.998323e+01, 1.970500e+01, 1.899000e+01, 2.049000e+01, 1.971000e+01],
+                                 "Volume":    [1.473857e+08, 1.066704e+08, 9.797230e+07, 9.683680e+07, 7.639450e+07],
+                                 "Dividends": [0.000000e+00, 0.000000e+00, 1.250000e-01, 0.000000e+00, 0.000000e+00]},
+                           index=_pd.to_datetime([_dt.datetime(2024, 8, 9),
+                                                  _dt.datetime(2024, 8, 8),
+                                                  _dt.datetime(2024, 8, 7),
+                                                  _dt.datetime(2024, 8, 6),
+                                                  _dt.datetime(2024, 8, 5)]))
         df = df.sort_index()
         df.index.name = "Date"
         dat = yf.Ticker(tkr, session=self.session)
@@ -488,7 +490,7 @@ def test_repair_bad_stock_splits(self):
                         print(df_dbg[f_diff | _np.roll(f_diff, 1) | _np.roll(f_diff, -1)])
                         raise
 
-        bad_tkrs = ['4063.T', 'ALPHA.PA', 'AV.L', 'CNE.L', 'MOB.ST', 'SPM.MI']
+        bad_tkrs = ['4063.T', 'AV.L', 'CNE.L', 'MOB.ST', 'SPM.MI']
         bad_tkrs.append('LA.V')  # special case - stock split error is 3 years ago! why not fixed?
         for tkr in bad_tkrs:
             dat = yf.Ticker(tkr, session=self.session)
@@ -597,7 +599,6 @@ def test_repair_bad_div_adjusts(self):
         # Phantom divs
         bad_tkrs += ['KAP.IL']  # 1x 1d phantom div, and false positives 0.01x in 1wk
         bad_tkrs += ['SAND']
-        bad_tkrs += ['SOLB.BR']  # 1x phantom div, but some false-positive 100x. and had to improve phantom detection
         bad_tkrs += ['TEM.L']
         bad_tkrs += ['TEP.PA']
 

tests/data/KWS-L-1d-bad-div.csv

@@ -46,7 +46,7 @@ def test_download_multi_large_interval(self):
 
     def test_download_multi_small_interval(self):
         use_tkrs = ["AAPL", "0Q3.DE", "ATVI"]
-        df = yf.download(use_tkrs, period="1d", interval="5m")
+        df = yf.download(use_tkrs, period="1d", interval="5m", auto_adjust=True)
         self.assertEqual(df.index.tz, _dt.timezone.utc)
 
     def test_download_with_invalid_ticker(self):
@@ -56,10 +56,11 @@ def test_download_with_invalid_ticker(self):
         invalid_tkrs = ["AAPL", "ATVI"] #AAPL exists and ATVI does not exist
         valid_tkrs = ["AAPL", "INTC"] #AAPL and INTC both exist
 
-        data_invalid_sym = yf.download(invalid_tkrs, start='2023-11-16', end='2023-11-17')
-        data_valid_sym = yf.download(valid_tkrs, start='2023-11-16', end='2023-11-17')
-
-        self.assertEqual(data_invalid_sym['Close']['AAPL']['2023-11-16'],data_valid_sym['Close']['AAPL']['2023-11-16'])
+        start_d = _dt.date.today() - _dt.timedelta(days=30)
+        data_invalid_sym = yf.download(invalid_tkrs, start=start_d, auto_adjust=True)
+        data_valid_sym = yf.download(valid_tkrs, start=start_d, auto_adjust=True)
+        dt_compare = data_valid_sym.index[0]
+        self.assertEqual(data_invalid_sym['Close']['AAPL'][dt_compare],data_valid_sym['Close']['AAPL'][dt_compare])
 
     def test_duplicatingHourly(self):
         tkrs = ["IMP.JO", "BHG.JO", "SSW.JO", "BP.L", "INTC"]
@@ -118,7 +119,7 @@ def test_duplicatingWeekly(self):
                 continue
             test_run = True
 
-            df = dat.history(start=dt.date() - _dt.timedelta(days=13), interval="1wk")
+            df = dat.history(start=dt.date() - _dt.timedelta(days=7), interval="1wk")
             dt0 = df.index[-2]
             dt1 = df.index[-1]
             try:
@@ -185,7 +186,7 @@ def test_intraDayWithEvents(self):
 
             df_intraday_divs = df_intraday["Dividends"][df_intraday["Dividends"] != 0]
             df_intraday_divs.index = df_intraday_divs.index.floor('D')
-            self.assertTrue(df_daily_divs.equals(df_intraday_divs))
+            self.assertTrue(df_daily_divs.index.equals(df_intraday_divs.index))
 
             test_run = True
 
@@ -212,7 +213,7 @@ def test_intraDayWithEvents_tase(self):
 
             df_intraday_divs = df_intraday["Dividends"][df_intraday["Dividends"] != 0]
             df_intraday_divs.index = df_intraday_divs.index.floor('D')
-            self.assertTrue(df_daily_divs.equals(df_intraday_divs))
+            self.assertTrue(df_daily_divs.index.equals(df_intraday_divs.index))
 
             test_run = True
 
@@ -416,14 +417,16 @@ def test_prune_post_intraday_us(self):
         start_d = _dt.date(special_day.year, 1, 1)
         end_d = _dt.date(special_day.year+1, 1, 1)
         df = dat.history(start=start_d, end=end_d, interval="1h", prepost=False, keepna=True)
+        if df.empty:
+            self.skipTest("TEST NEEDS UPDATE: 'special_day' needs to be LATEST Thanksgiving date")
         last_dts = _pd.Series(df.index).groupby(df.index.date).last()
         dfd = dat.history(start=start_d, end=end_d, interval='1d', prepost=False, keepna=True)
         self.assertTrue(_np.equal(dfd.index.date, _pd.to_datetime(last_dts.index).date).all())
 
     def test_prune_post_intraday_asx(self):
         # Setup
         tkr = "BHP.AX"
-        # No early closes in 2023
+        # No early closes in 2024
         dat = yf.Ticker(tkr, session=self.session)
 
         # Test no other afternoons (or mornings) were pruned

tests/data/SCR-TO-1d-bad-div-fixed.csv

@@ -37,10 +37,12 @@
     ("recommendations", Union[pd.DataFrame, dict]),
     ("recommendations_summary", Union[pd.DataFrame, dict]),
     ("upgrades_downgrades", Union[pd.DataFrame, dict]),
+    ("ttm_cashflow", pd.DataFrame),
     ("quarterly_cashflow", pd.DataFrame),
     ("cashflow", pd.DataFrame),
     ("quarterly_balance_sheet", pd.DataFrame),
     ("balance_sheet", pd.DataFrame),
+    ("ttm_income_stmt", pd.DataFrame),
     ("quarterly_income_stmt", pd.DataFrame),
     ("income_stmt", pd.DataFrame),
     ("analyst_price_targets", dict),
@@ -330,6 +332,12 @@ def test_actions(self):
         self.assertIsInstance(data, pd.DataFrame, "data has wrong type")
         self.assertFalse(data.empty, "data is empty")
 
+    def test_chained_history_calls(self):
+        _ = self.ticker.history(period="2d")
+        data = self.ticker.dividends
+        self.assertIsInstance(data, pd.Series, "data has wrong type")
+        self.assertFalse(data.empty, "data is empty")
+
 
 class TestTickerEarnings(unittest.TestCase):
     session = None
@@ -554,6 +562,34 @@ def test_quarterly_income_statement(self):
         data = self.ticker.get_income_stmt(as_dict=True)
         self.assertIsInstance(data, dict, "data has wrong type")
 
+    def test_ttm_income_statement(self):
+        expected_keys = ["Total Revenue", "Pretax Income", "Normalized EBITDA"]
+
+        # Test contents of table
+        data = self.ticker.get_income_stmt(pretty=True, freq='trailing')
+        self.assertIsInstance(data, pd.DataFrame, "data has wrong type")
+        self.assertFalse(data.empty, "data is empty")
+        for k in expected_keys:
+            self.assertIn(k, data.index, "Did not find expected row in index")
+        # Trailing 12 months there must be exactly one column
+        self.assertEqual(len(data.columns), 1, "Only one column should be returned on TTM income statement")
+
+        # Test property defaults
+        data2 = self.ticker.ttm_income_stmt
+        self.assertTrue(data.equals(data2), "property not defaulting to 'pretty=True'")
+
+        # Test pretty=False
+        expected_keys = [k.replace(' ', '') for k in expected_keys]
+        data = self.ticker.get_income_stmt(pretty=False, freq='trailing')
+        self.assertIsInstance(data, pd.DataFrame, "data has wrong type")
+        self.assertFalse(data.empty, "data is empty")
+        for k in expected_keys:
+            self.assertIn(k, data.index, "Did not find expected row in index")
+
+        # Test to_dict
+        data = self.ticker.get_income_stmt(as_dict=True, freq='trailing')
+        self.assertIsInstance(data, dict, "data has wrong type")
+
     def test_balance_sheet(self):
         expected_keys = ["Total Assets", "Net PPE"]
         expected_periods_days = 365
@@ -670,6 +706,34 @@ def test_quarterly_cash_flow(self):
         data = self.ticker.get_cashflow(as_dict=True)
         self.assertIsInstance(data, dict, "data has wrong type")
 
+    def test_ttm_cash_flow(self):
+        expected_keys = ["Operating Cash Flow", "Net PPE Purchase And Sale"]
+
+        # Test contents of table
+        data = self.ticker.get_cashflow(pretty=True, freq='trailing')
+        self.assertIsInstance(data, pd.DataFrame, "data has wrong type")
+        self.assertFalse(data.empty, "data is empty")
+        for k in expected_keys:
+            self.assertIn(k, data.index, "Did not find expected row in index")
+        # Trailing 12 months there must be exactly one column
+        self.assertEqual(len(data.columns), 1, "Only one column should be returned on TTM cash flow")
+
+        # Test property defaults
+        data2 = self.ticker.ttm_cashflow
+        self.assertTrue(data.equals(data2), "property not defaulting to 'pretty=True'")
+
+        # Test pretty=False
+        expected_keys = [k.replace(' ', '') for k in expected_keys]
+        data = self.ticker.get_cashflow(pretty=False, freq='trailing')
+        self.assertIsInstance(data, pd.DataFrame, "data has wrong type")
+        self.assertFalse(data.empty, "data is empty")
+        for k in expected_keys:
+            self.assertIn(k, data.index, "Did not find expected row in index")
+
+        # Test to_dict
+        data = self.ticker.get_cashflow(as_dict=True, freq='trailing')
+        self.assertIsInstance(data, dict, "data has wrong type")
+
     def test_income_alt_names(self):
         i1 = self.ticker.income_stmt
         i2 = self.ticker.incomestmt
@@ -695,6 +759,18 @@ def test_income_alt_names(self):
         i3 = self.ticker.get_financials(freq="quarterly")
         self.assertTrue(i1.equals(i3))
 
+        i1 = self.ticker.ttm_income_stmt
+        i2 = self.ticker.ttm_incomestmt
+        self.assertTrue(i1.equals(i2))
+        i3 = self.ticker.ttm_financials
+        self.assertTrue(i1.equals(i3))
+
+        i1 = self.ticker.get_income_stmt(freq="trailing")
+        i2 = self.ticker.get_incomestmt(freq="trailing")
+        self.assertTrue(i1.equals(i2))
+        i3 = self.ticker.get_financials(freq="trailing")
+        self.assertTrue(i1.equals(i3))
+
     def test_balance_sheet_alt_names(self):
         i1 = self.ticker.balance_sheet
         i2 = self.ticker.balancesheet
@@ -729,6 +805,14 @@ def test_cash_flow_alt_names(self):
         i2 = self.ticker.get_cashflow(freq="quarterly")
         self.assertTrue(i1.equals(i2))
 
+        i1 = self.ticker.ttm_cash_flow
+        i2 = self.ticker.ttm_cashflow
+        self.assertTrue(i1.equals(i2))
+
+        i1 = self.ticker.get_cash_flow(freq="trailing")
+        i2 = self.ticker.get_cashflow(freq="trailing")
+        self.assertTrue(i1.equals(i2))
+
     def test_bad_freq_value_raises_exception(self):
         self.assertRaises(ValueError, lambda: self.ticker.get_cashflow(freq="badarg"))
 

tests/data/SOLB-BR-1d-bad-div-fixed.csv

@@ -43,6 +43,8 @@
 from .const import _BASE_URL_, _ROOT_URL_, _QUERY1_URL_
 
 
+_tz_info_fetch_ctr = 0
+
 class TickerBase:
     def __init__(self, ticker, session=None, proxy=None):
         self.ticker = ticker.upper()
@@ -100,9 +102,19 @@ def _get_ticker_tz(self, proxy, timeout):
 
         if tz is None:
             tz = self._fetch_ticker_tz(proxy, timeout)
-
+            if tz is None:
+                # _fetch_ticker_tz works in 99.999% of cases.
+                # For rare fail get from info.
+                global _tz_info_fetch_ctr
+                if _tz_info_fetch_ctr < 2:
+                    # ... but limit. If _fetch_ticker_tz() always
+                    # failing then bigger problem.
+                    _tz_info_fetch_ctr += 1
+                    for k in ['exchangeTimezoneName', 'timeZoneFullName']:
+                        if k in self.info:
+                            tz = self.info[k]
+                            break
             if utils.is_valid_timezone(tz):
-                # info fetch is relatively slow so cache timezone
                 c.store(self.ticker, tz)
             else:
                 tz = None
@@ -318,7 +330,7 @@ def get_earnings(self, proxy=None, as_dict=False, freq="yearly"):
                 Return table as Python dict
                 Default is False
             freq: str
-                "yearly" or "quarterly"
+                "yearly" or "quarterly" or "trailing"
                 Default is "yearly"
             proxy: str
                 Optional. Proxy server URL scheme
@@ -345,7 +357,7 @@ def get_income_stmt(self, proxy=None, as_dict=False, pretty=False, freq="yearly"
                 Format row names nicely for readability
                 Default is False
             freq: str
-                "yearly" or "quarterly"
+                "yearly" or "quarterly" or "trailing"
                 Default is "yearly"
             proxy: str
                 Optional. Proxy server URL scheme
@@ -428,17 +440,17 @@ def get_cash_flow(self, proxy=None, as_dict=False, pretty=False, freq="yearly")
     def get_cashflow(self, proxy=None, as_dict=False, pretty=False, freq="yearly"):
         return self.get_cash_flow(proxy, as_dict, pretty, freq)
 
-    def get_dividends(self, proxy=None) -> pd.Series:
-        return self._lazy_load_price_history().get_dividends(proxy)
+    def get_dividends(self, proxy=None, period="max") -> pd.Series:
+        return self._lazy_load_price_history().get_dividends(period=period, proxy=proxy)
 
-    def get_capital_gains(self, proxy=None) -> pd.Series:
-        return self._lazy_load_price_history().get_capital_gains(proxy)
+    def get_capital_gains(self, proxy=None, period="max") -> pd.Series:
+        return self._lazy_load_price_history().get_capital_gains(period=period, proxy=proxy)
 
-    def get_splits(self, proxy=None) -> pd.Series:
-        return self._lazy_load_price_history().get_splits(proxy)
+    def get_splits(self, proxy=None, period="max") -> pd.Series:
+        return self._lazy_load_price_history().get_splits(period=period, proxy=proxy)
 
-    def get_actions(self, proxy=None) -> pd.Series:
-        return self._lazy_load_price_history().get_actions(proxy)
+    def get_actions(self, proxy=None, period="max") -> pd.Series:
+        return self._lazy_load_price_history().get_actions(period=period, proxy=proxy)
 
     def get_shares(self, proxy=None, as_dict=False) -> Union[pd.DataFrame, dict]:
         self._fundamentals.proxy = proxy or self.proxy
@@ -630,7 +642,7 @@ def get_earnings_dates(self, limit=12, proxy=None) -> Optional[pd.DataFrame]:
             return None
 
         # Calculate earnings date
-        df['Earnings Date'] = pd.to_datetime(df['Event Start Date']).dt.normalize()
+        df['Earnings Date'] = pd.to_datetime(df['Event Start Date'])
         tz = self._get_ticker_tz(proxy=proxy, timeout=30)
         if df['Earnings Date'].dt.tz is None:
             df['Earnings Date'] = df['Earnings Date'].dt.tz_localize(tz)