style: format code with black and isort

Co-authored-by: merendamattia <[email protected]>

Author: Copilot

src/tools/analyze_financial_asset.py

@@ -4,6 +4,7 @@
 This module provides a single tool that combines price retrieval and return calculation
 for a comprehensive financial asset analysis.
 """
+
 import logging
 import time
 from datetime import datetime, timedelta
@@ -47,24 +48,27 @@ def _get_cached_analysis(ticker: str, years: int) -> Optional[str]:
         Optional[str]: Cached JSON response or None if not found
     """
     cache_key = _get_cache_key(ticker, years)
-    
+
     # Try to get from Streamlit session state first (if available)
     try:
         import streamlit as st
-        if hasattr(st, 'session_state') and hasattr(st.session_state, 'financial_asset_cache'):
+
+        if hasattr(st, "session_state") and hasattr(
+            st.session_state, "financial_asset_cache"
+        ):
             cache = st.session_state.financial_asset_cache
             if cache_key in cache:
                 logger.info("Cache HIT for %s (from session_state)", cache_key)
                 return cache[cache_key]
     except (ImportError, RuntimeError):
         # Streamlit not available or not in a session context
         pass
-    
+
     # Fall back to module-level cache
     if cache_key in _CACHE:
         logger.info("Cache HIT for %s (from module cache)", cache_key)
         return _CACHE[cache_key]
-    
+
     logger.info("Cache MISS for %s", cache_key)
     return None
 
@@ -79,26 +83,29 @@ def _set_cached_analysis(ticker: str, years: int, result: str) -> None:
         result: JSON response to cache
     """
     cache_key = _get_cache_key(ticker, years)
-    
+
     # Try to store in Streamlit session state first (if available)
     try:
         import streamlit as st
-        if hasattr(st, 'session_state'):
-            if not hasattr(st.session_state, 'financial_asset_cache'):
+
+        if hasattr(st, "session_state"):
+            if not hasattr(st.session_state, "financial_asset_cache"):
                 st.session_state.financial_asset_cache = {}
             st.session_state.financial_asset_cache[cache_key] = result
             logger.debug("Cached result for %s in session_state", cache_key)
     except (ImportError, RuntimeError):
         # Streamlit not available or not in a session context
         pass
-    
+
     # Also store in module-level cache as fallback
     _CACHE[cache_key] = result
     logger.debug("Cached result for %s in module cache", cache_key)
 
 
 @tool
-def analyze_financial_asset(ticker: str, years: int = 10, use_cache: bool = True) -> str:
+def analyze_financial_asset(
+    ticker: str, years: int = 10, use_cache: bool = True
+) -> str:
     """
     Comprehensive financial asset analysis tool.
 
@@ -132,8 +139,13 @@ def analyze_financial_asset(ticker: str, years: int = 10, use_cache: bool = True
             - error: Error message if unsuccessful
     """
     try:
-        logger.info("Starting analysis for %s with %d years (use_cache=%s)", ticker, years, use_cache)
-        
+        logger.info(
+            "Starting analysis for %s with %d years (use_cache=%s)",
+            ticker,
+            years,
+            use_cache,
+        )
+
         # Check cache if enabled
         if use_cache:
             cached_result = _get_cached_analysis(ticker, years)
@@ -226,11 +238,11 @@ def analyze_financial_asset(ticker: str, years: int = 10, use_cache: bool = True
 
         logger.info("Analysis completed successfully")
         result_json = response.model_dump_json()
-        
+
         # Cache the successful result
         if use_cache:
             _set_cached_analysis(ticker, years, result_json)
-        
+
         return result_json
 
     except Exception as e:
@@ -483,9 +495,11 @@ def get_price_at_date(target_date):
                 logger.debug(
                     "%d-year return: %.2f%%",
                     year,
-                    returns_dict[f"{year}_year"]
-                    if isinstance(returns_dict[f"{year}_year"], (int, float))
-                    else None,
+                    (
+                        returns_dict[f"{year}_year"]
+                        if isinstance(returns_dict[f"{year}_year"], (int, float))
+                        else None
+                    ),
                 )
             else:
                 returns_dict[f"{year}_year"] = "N/A"

tests/unit/test_analyze_financial_asset_cache.py

@@ -60,37 +60,37 @@ def test_cache_set_and_get(self):
         """Test that we can set and retrieve cached values."""
         test_data = '{"success": true, "ticker": "SWDA"}'
         _set_cached_analysis("SWDA", 10, test_data)
-        
+
         result = _get_cached_analysis("SWDA", 10)
         assert result == test_data
 
     def test_cache_different_tickers(self):
         """Test that cache correctly handles different tickers."""
         data1 = '{"success": true, "ticker": "SWDA"}'
         data2 = '{"success": true, "ticker": "AAPL"}'
-        
+
         _set_cached_analysis("SWDA", 10, data1)
         _set_cached_analysis("AAPL", 10, data2)
-        
+
         assert _get_cached_analysis("SWDA", 10) == data1
         assert _get_cached_analysis("AAPL", 10) == data2
 
     def test_cache_different_years(self):
         """Test that cache correctly handles different year periods."""
         data1 = '{"success": true, "years": 5}'
         data2 = '{"success": true, "years": 10}'
-        
+
         _set_cached_analysis("SWDA", 5, data1)
         _set_cached_analysis("SWDA", 10, data2)
-        
+
         assert _get_cached_analysis("SWDA", 5) == data1
         assert _get_cached_analysis("SWDA", 10) == data2
 
     def test_cache_uppercase_normalization(self):
         """Test that cache normalizes ticker case."""
         test_data = '{"success": true, "ticker": "SWDA"}'
         _set_cached_analysis("swda", 10, test_data)
-        
+
         # Should be able to retrieve with different case
         result = _get_cached_analysis("SWDA", 10)
         assert result == test_data
@@ -107,139 +107,133 @@ def teardown_method(self):
         """Clear cache after each test."""
         _CACHE.clear()
 
-    @patch('src.tools.analyze_financial_asset._search_and_resolve_symbol')
-    @patch('src.tools.analyze_financial_asset._get_historical_prices_internal')
-    @patch('src.tools.analyze_financial_asset._calculate_returns_internal')
+    @patch("src.tools.analyze_financial_asset._search_and_resolve_symbol")
+    @patch("src.tools.analyze_financial_asset._get_historical_prices_internal")
+    @patch("src.tools.analyze_financial_asset._calculate_returns_internal")
     def test_cache_miss_calls_functions(
         self, mock_calc_returns, mock_get_prices, mock_search_symbol
     ):
         """Test that on cache miss, all internal functions are called."""
         # Setup mocks
         mock_search_symbol.return_value = MagicMock(
-            success=True,
-            found_symbol="SWDA.DE",
-            company_name="Test ETF"
+            success=True, found_symbol="SWDA.DE", company_name="Test ETF"
         )
         mock_get_prices.return_value = {
             "success": True,
             "prices": [
                 {"date": "2020-01-01", "close_price": 100.0},
-                {"date": "2021-01-01", "close_price": 110.0}
+                {"date": "2021-01-01", "close_price": 110.0},
             ],
             "data_points": 2,
             "years_available": 1.0,
             "start_date": "2020-01-01",
-            "end_date": "2021-01-01"
+            "end_date": "2021-01-01",
         }
         mock_calc_returns.return_value = {
             "success": True,
             "returns": {"1_year": 10.0},
-            "total_return": 10.0
+            "total_return": 10.0,
         }
 
         # First call should miss cache and call functions
         result1 = analyze_financial_asset("SWDA", years=10, use_cache=True)
-        
+
         # Verify functions were called
         assert mock_search_symbol.called
         assert mock_get_prices.called
         assert mock_calc_returns.called
-        
+
         # Verify result is valid JSON
         data = json.loads(result1)
         assert data["success"] is True
         assert data["ticker"] == "SWDA"
 
-    @patch('src.tools.analyze_financial_asset._search_and_resolve_symbol')
-    @patch('src.tools.analyze_financial_asset._get_historical_prices_internal')
-    @patch('src.tools.analyze_financial_asset._calculate_returns_internal')
+    @patch("src.tools.analyze_financial_asset._search_and_resolve_symbol")
+    @patch("src.tools.analyze_financial_asset._get_historical_prices_internal")
+    @patch("src.tools.analyze_financial_asset._calculate_returns_internal")
     def test_cache_hit_skips_functions(
         self, mock_calc_returns, mock_get_prices, mock_search_symbol
     ):
         """Test that on cache hit, internal functions are not called."""
         # Setup mocks for first call
         mock_search_symbol.return_value = MagicMock(
-            success=True,
-            found_symbol="SWDA.DE",
-            company_name="Test ETF"
+            success=True, found_symbol="SWDA.DE", company_name="Test ETF"
         )
         mock_get_prices.return_value = {
             "success": True,
             "prices": [
                 {"date": "2020-01-01", "close_price": 100.0},
-                {"date": "2021-01-01", "close_price": 110.0}
+                {"date": "2021-01-01", "close_price": 110.0},
             ],
             "data_points": 2,
             "years_available": 1.0,
             "start_date": "2020-01-01",
-            "end_date": "2021-01-01"
+            "end_date": "2021-01-01",
         }
         mock_calc_returns.return_value = {
             "success": True,
             "returns": {"1_year": 10.0},
-            "total_return": 10.0
+            "total_return": 10.0,
         }
 
         # First call - cache miss
         result1 = analyze_financial_asset("SWDA", years=10, use_cache=True)
-        
+
         # Reset mock call counts
         mock_search_symbol.reset_mock()
         mock_get_prices.reset_mock()
         mock_calc_returns.reset_mock()
-        
+
         # Second call - should hit cache
         result2 = analyze_financial_asset("SWDA", years=10, use_cache=True)
-        
+
         # Verify functions were NOT called on second attempt
         assert not mock_search_symbol.called
         assert not mock_get_prices.called
         assert not mock_calc_returns.called
-        
+
         # Results should be identical
         assert result1 == result2
 
-    @patch('src.tools.analyze_financial_asset._search_and_resolve_symbol')
-    @patch('src.tools.analyze_financial_asset._get_historical_prices_internal')
-    @patch('src.tools.analyze_financial_asset._calculate_returns_internal')
+    @patch("src.tools.analyze_financial_asset._search_and_resolve_symbol")
+    @patch("src.tools.analyze_financial_asset._get_historical_prices_internal")
+    @patch("src.tools.analyze_financial_asset._calculate_returns_internal")
     def test_use_cache_false_bypasses_cache(
         self, mock_calc_returns, mock_get_prices, mock_search_symbol
     ):
         """Test that use_cache=False bypasses the cache."""
         # Setup mocks
         mock_search_symbol.return_value = MagicMock(
-            success=True,
-            found_symbol="SWDA.DE",
-            company_name="Test ETF"
+            success=True, found_symbol="SWDA.DE", company_name="Test ETF"
         )
         mock_get_prices.return_value = {
             "success": True,
             "prices": [
                 {"date": "2020-01-01", "close_price": 100.0},
-                {"date": "2021-01-01", "close_price": 110.0}
+                {"date": "2021-01-01", "close_price": 110.0},
             ],
             "data_points": 2,
             "years_available": 1.0,
             "start_date": "2020-01-01",
-            "end_date": "2021-01-01"
+            "end_date": "2021-01-01",
         }
         mock_calc_returns.return_value = {
             "success": True,
             "returns": {"1_year": 10.0},
-            "total_return": 10.0
+            "total_return": 10.0,
         }
 
         # First call with caching
         result1 = analyze_financial_asset("SWDA", years=10, use_cache=True)
-        
+
         # Reset mocks
         mock_search_symbol.reset_mock()
         mock_get_prices.reset_mock()
         mock_calc_returns.reset_mock()
-        
+
         # Second call with use_cache=False should call functions again
         result2 = analyze_financial_asset("SWDA", years=10, use_cache=False)
-        
+
         # Verify functions WERE called even though data is cached
         assert mock_search_symbol.called
         assert mock_get_prices.called
@@ -250,7 +244,7 @@ def test_cache_respects_case_insensitive_ticker(self):
         # Pre-populate cache with lowercase ticker
         test_data = '{"success": true, "ticker": "swda"}'
         _set_cached_analysis("swda", 10, test_data)
-        
+
         # Request with uppercase should hit the same cache
         result = _get_cached_analysis("SWDA", 10)
         assert result == test_data
@@ -273,30 +267,32 @@ def test_streamlit_cache_storage(self):
         mock_st_module = MagicMock()
         mock_session_state = MagicMock()
         mock_st_module.session_state = mock_session_state
-        
+
         # Patch the import
-        with patch.dict('sys.modules', {'streamlit': mock_st_module}):
+        with patch.dict("sys.modules", {"streamlit": mock_st_module}):
             test_data = '{"success": true, "ticker": "SWDA"}'
             _set_cached_analysis("SWDA", 10, test_data)
-            
+
             # Verify that financial_asset_cache was created and data was stored
             # The session_state should have been accessed to set the cache
-            assert mock_session_state.financial_asset_cache.__setitem__.called or \
-                   hasattr(mock_session_state, 'financial_asset_cache')
+            assert (
+                mock_session_state.financial_asset_cache.__setitem__.called
+                or hasattr(mock_session_state, "financial_asset_cache")
+            )
 
     def test_streamlit_cache_retrieval(self):
         """Test that cache is retrieved from Streamlit session state when available."""
         # Create a mock streamlit module with pre-cached data
         test_data = '{"success": true, "ticker": "SWDA"}'
-        
+
         mock_st_module = MagicMock()
         mock_session_state = MagicMock()
         # Configure the mock to have the cache
         mock_session_state.financial_asset_cache = {"SWDA_10": test_data}
         mock_st_module.session_state = mock_session_state
-        
+
         # Patch the import
-        with patch.dict('sys.modules', {'streamlit': mock_st_module}):
+        with patch.dict("sys.modules", {"streamlit": mock_st_module}):
             result = _get_cached_analysis("SWDA", 10)
             assert result == test_data
 
@@ -305,11 +301,11 @@ def test_fallback_to_module_cache_when_no_streamlit(self):
         # Store data in module cache
         test_data = '{"success": true, "ticker": "SWDA"}'
         _set_cached_analysis("SWDA", 10, test_data)
-        
+
         # Retrieve should work even without Streamlit
         result = _get_cached_analysis("SWDA", 10)
         assert result == test_data
-        
+
         # Verify it's in module cache
         assert "SWDA_10" in _CACHE
         assert _CACHE["SWDA_10"] == test_data