import time import logging import requests import json import random from typing import Dict, Any, List, Tuple from datetime import datetime import os import urllib.parse import re from PIL import Image, ImageDraw, ImageFont import numpy as np import hashlib # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class StockManager: def __init__(self, config: Dict[str, Any], display_manager): self.config = config self.display_manager = display_manager self.stocks_config = config.get('stocks', {}) self.last_update = 0 self.stock_data = {} self.current_stock_index = 0 self.scroll_position = 0 self.cached_text_image = None self.cached_text = None # Get scroll settings from config with faster defaults self.scroll_speed = self.stocks_config.get('scroll_speed', 1) self.scroll_delay = self.stocks_config.get('scroll_delay', 0.001) # Initialize frame rate tracking self.frame_count = 0 self.last_frame_time = time.time() self.last_fps_log_time = time.time() self.frame_times = [] # Try to use the assets/stocks directory from the repository self.logo_dir = os.path.join('assets', 'stocks') # Check if we can use the logo directory, otherwise use temporary try: if not os.path.exists(self.logo_dir): try: os.makedirs(self.logo_dir, mode=0o755, exist_ok=True) logger.info(f"Created logo directory: {self.logo_dir}") except (PermissionError, OSError) as e: logger.warning(f"Cannot create logo directory '{self.logo_dir}': {str(e)}. Using temporary directory.") import tempfile self.logo_dir = tempfile.mkdtemp(prefix='stock_logos_') writable = False # Explicitly set writable to false if creation fails else: writable = True # Assume writable if created successfully else: # Directory exists, check if writable by trying to create a temp file try: temp_file_path = os.path.join(self.logo_dir, "write_test_py.tmp") abs_path = os.path.abspath(temp_file_path) cwd = os.getcwd() euid = os.geteuid() egid = os.getegid() logger.debug(f"Write test: UID={euid}, GID={egid}, CWD='{cwd}', Path='{abs_path}'") with open(temp_file_path, 'w') as f: f.write('test') os.remove(temp_file_path) logger.debug(f"Write test successful in {self.logo_dir}") writable = True except (PermissionError, OSError) as e: logger.warning(f"Cannot write to logo directory '{self.logo_dir}' (write test failed): {e}. Using temporary directory.") writable = False # If not writable, switch to a temporary directory if not writable: import tempfile self.logo_dir = tempfile.mkdtemp(prefix='stock_logos_') logger.info(f"Using logo directory: {self.logo_dir}") except Exception as e: logger.error(f"Error setting up logo directory: {str(e)}") # Fall back to using a temporary directory import tempfile self.logo_dir = tempfile.mkdtemp(prefix='stock_logos_') logger.info(f"Using temporary directory for logos: {self.logo_dir}") self.headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36' } # Initialize with first update self.update_stock_data() def _get_stock_color(self, symbol: str) -> Tuple[int, int, int]: """Get color based on stock performance.""" if symbol not in self.stock_data: return (255, 255, 255) # White for unknown change = self.stock_data[symbol].get('change', 0) if change > 0: return (0, 255, 0) # Green for positive elif change < 0: return (255, 0, 0) # Red for negative return (255, 255, 0) # Yellow for no change def _extract_json_from_html(self, html: str) -> Dict: """Extract the JSON data from Yahoo Finance HTML.""" try: # Look for the finance data in the HTML patterns = [ r'root\.App\.main = (.*?);\s*', r'"QuotePageStore":\s*({.*?}),\s*"', r'{"regularMarketPrice":.*?"regularMarketChangePercent".*?}' ] for pattern in patterns: match = re.search(pattern, html, re.DOTALL) if match: json_str = match.group(1) try: data = json.loads(json_str) if isinstance(data, dict): if 'context' in data: # First pattern matched context = data.get('context', {}) dispatcher = context.get('dispatcher', {}) stores = dispatcher.get('stores', {}) quote_data = stores.get('QuoteSummaryStore', {}) if quote_data: return quote_data else: # Direct quote data return data except json.JSONDecodeError: continue # If we get here, try one last attempt to find the price data directly price_match = re.search(r'"regularMarketPrice":{"raw":([\d.]+)', html) change_match = re.search(r'"regularMarketChangePercent":{"raw":([-\d.]+)', html) prev_close_match = re.search(r'"regularMarketPreviousClose":{"raw":([\d.]+)', html) name_match = re.search(r'"shortName":"([^"]+)"', html) if price_match: return { "price": { "regularMarketPrice": {"raw": float(price_match.group(1))}, "regularMarketChangePercent": {"raw": float(change_match.group(1)) if change_match else 0}, "regularMarketPreviousClose": {"raw": float(prev_close_match.group(1)) if prev_close_match else 0}, "shortName": name_match.group(1) if name_match else None } } return {} except Exception as e: logger.error(f"Error extracting JSON data: {e}") return {} def _fetch_stock_data(self, symbol: str) -> Dict[str, Any]: """Fetch stock data from Yahoo Finance public API.""" try: # Use Yahoo Finance query1 API for chart data encoded_symbol = urllib.parse.quote(symbol) url = f"https://query1.finance.yahoo.com/v8/finance/chart/{encoded_symbol}" params = { 'interval': '5m', # 5-minute intervals 'range': '1d' # 1 day of data } response = requests.get(url, headers=self.headers, params=params, timeout=5) if response.status_code != 200: logger.error(f"Failed to fetch data for {symbol}: HTTP {response.status_code}") return None data = response.json() # Extract the relevant data from the response chart_data = data.get('chart', {}).get('result', [{}])[0] meta = chart_data.get('meta', {}) if not meta: logger.error(f"No meta data found for {symbol}") return None current_price = meta.get('regularMarketPrice', 0) prev_close = meta.get('previousClose', current_price) # Get price history timestamps = chart_data.get('timestamp', []) indicators = chart_data.get('indicators', {}).get('quote', [{}])[0] close_prices = indicators.get('close', []) # Build price history price_history = [] for i, ts in enumerate(timestamps): if i < len(close_prices) and close_prices[i] is not None: price_history.append({ 'timestamp': datetime.fromtimestamp(ts), 'price': close_prices[i] }) # Calculate change percentage change_pct = ((current_price - prev_close) / prev_close) * 100 if prev_close > 0 else 0 # Get company name (symbol will be used if name not available) name = meta.get('symbol', symbol) logger.debug(f"Processed data for {symbol}: price={current_price}, change={change_pct}%") return { "symbol": symbol, "name": name, "price": current_price, "change": change_pct, "open": prev_close, "price_history": price_history } except requests.exceptions.RequestException as e: logger.error(f"Network error fetching data for {symbol}: {e}") return None except (ValueError, IndexError, KeyError) as e: logger.error(f"Error parsing data for {symbol}: {e}") return None except Exception as e: logger.error(f"Unexpected error fetching data for {symbol}: {e}") return None def _fetch_logo_data(self, symbol: str) -> bytes | None: """Fetch logo image data from various sources.""" urls_to_try = [ f"https://logo.clearbit.com/{symbol.lower()}.com", f"https://storage.googleapis.com/iex/api/logos/{symbol}.png" # Add more URLs here if needed ] for url in urls_to_try: try: response = requests.get(url, headers=self.headers, timeout=5) if response.status_code == 200 and 'image' in response.headers.get('Content-Type', ''): try: # Verify it's a valid image before returning bytes from io import BytesIO img = Image.open(BytesIO(response.content)) img.verify() logger.info(f"Successfully fetched logo data for {symbol} from {url}") return response.content except Exception as img_err: logger.warning(f"Invalid image data from {url} for {symbol}: {img_err}") continue # Try next URL except requests.exceptions.RequestException as req_err: logger.warning(f"Error fetching logo from {url} for {symbol}: {req_err}") continue # Try next URL logger.warning(f"Could not fetch logo data for {symbol} from any source.") return None def _draw_chart(self, symbol: str, data: Dict[str, Any]): """Draw a price chart for the stock.""" if not data.get('price_history'): return # Clear the display self.display_manager.clear() # Draw the symbol at the top with small font self.display_manager.draw_text( symbol, y=1, # Moved up slightly color=(255, 255, 255), small_font=True # Use small font ) # Calculate chart dimensions chart_height = 16 # Reduced from 22 to make chart smaller chart_y = 8 # Slightly adjusted starting position width = self.display_manager.matrix.width # Get min and max prices for scaling prices = [p['price'] for p in data['price_history']] if not prices: return min_price = min(prices) max_price = max(prices) price_range = max_price - min_price if price_range == 0: return # Draw chart points points = [] color = self._get_stock_color(symbol) for i, point in enumerate(data['price_history']): x = int((i / len(data['price_history'])) * width) y = chart_y + chart_height - int(((point['price'] - min_price) / price_range) * chart_height) points.append((x, y)) # Draw lines between points for i in range(len(points) - 1): x1, y1 = points[i] x2, y2 = points[i + 1] self.display_manager.draw.line([x1, y1, x2, y2], fill=color, width=1) # Draw current price at the bottom with small font price_text = f"${data['price']:.2f} ({data['change']:+.1f}%)" self.display_manager.draw_text( price_text, y=28, # Moved down slightly from 30 to give more space color=color, small_font=True # Use small font ) # Update the display self.display_manager.update_display() def _reload_config(self): """Reload configuration from file.""" # Reset stock data if symbols have changed new_symbols = set(self.stocks_config.get('symbols', [])) current_symbols = set(self.stock_data.keys()) if new_symbols != current_symbols: self.stock_data = {} self.current_stock_index = 0 self.last_update = 0 # Force immediate update logger.info(f"Stock symbols changed. New symbols: {new_symbols}") def update_stock_data(self): """Update stock data if enough time has passed.""" current_time = time.time() update_interval = self.stocks_config.get('update_interval', 60) # If not enough time has passed, keep using existing data if current_time - self.last_update < update_interval + random.uniform(0, 2): return # Reload config to check for symbol changes self._reload_config() # Get symbols from config symbols = self.stocks_config.get('symbols', []) if not symbols: logger.warning("No stock symbols configured") return # If symbols is a list of strings, convert to list of dicts if isinstance(symbols[0], str): symbols = [{"symbol": symbol} for symbol in symbols] # Create temporary storage for new data new_data = {} success = False for stock in symbols: symbol = stock['symbol'] # Add a small delay between requests to avoid rate limiting time.sleep(random.uniform(0.1, 0.3)) # Reduced delay data = self._fetch_stock_data(symbol) if data: new_data[symbol] = data success = True logger.info(f"Updated {symbol}: ${data['price']:.2f} ({data['change']:+.2f}%)") if success: # Only update the displayed data when we have new data self.stock_data.update(new_data) self.last_update = current_time else: logger.error("Failed to fetch data for any configured stocks") def _download_stock_logo(self, symbol: str) -> str | None: """Attempt to download and save stock logo, returning the path if successful. Checks if logo already exists. If not, fetches data using _fetch_logo_data and attempts to save it to self.logo_dir. Args: symbol: Stock symbol. Returns: Path to the saved logo image if exists or saved successfully, otherwise None. """ filename = f"{symbol.lower()}.png" filepath = os.path.join(self.logo_dir, filename) # Check if we already have the logo if os.path.exists(filepath): logger.debug(f"Found existing logo for {symbol} at {filepath}") return filepath # If not found, try fetching the logo data logger.info(f"Logo for {symbol} not found locally, attempting download.") logo_bytes = self._fetch_logo_data(symbol) if not logo_bytes: return None # Fetching failed # Try to save the fetched data try: with open(filepath, 'wb') as f: f.write(logo_bytes) logger.info(f"Saved new logo for {symbol} to {filepath}") return filepath # Return path on successful save except (PermissionError, OSError) as e: logger.warning(f"Failed to save logo for {symbol} to '{filepath}': {e}. Logo will be loaded in-memory.") return None # Return None indicates save failure except Exception as e: logger.error(f"Unexpected error saving logo for {symbol}: {e}") return None # Return None indicates save failure def _get_stock_logo(self, symbol: str) -> Image.Image: """Get stock logo image, or create a text-based fallback. Args: symbol: Stock symbol (e.g., 'AAPL', 'MSFT') Returns: PIL Image of the logo or text-based fallback """ # Try to get the path to a saved logo (or save it) logo_path = self._download_stock_logo(symbol) # If we have a path, try to load from disk if logo_path: try: logo = Image.open(logo_path) # Verify it's a valid image logo.verify() # Reopen after verify logo = Image.open(logo_path) # Convert to RGBA if not already if logo.mode != 'RGBA': logo = logo.convert('RGBA') # Resize to fit in the display max_size = min(int(self.display_manager.matrix.width / 1.5), int(self.display_manager.matrix.height / 1.5)) logo = logo.resize((max_size, max_size), Image.LANCZOS) return logo except Exception as e: logger.warning(f"Error loading saved logo file '{logo_path}' for {symbol}: {e}. Attempting in-memory load.") # If loading from disk fails, proceed to in-memory load below # If logo_path is None (save failed) or loading from disk failed, try loading into memory logger.info(f"Attempting to load logo for {symbol} directly into memory.") logo_bytes = self._fetch_logo_data(symbol) if logo_bytes: try: from io import BytesIO logo = Image.open(BytesIO(logo_bytes)) # Verify (redundant but safe) logo.verify() logo = Image.open(BytesIO(logo_bytes)) if logo.mode != 'RGBA': logo = logo.convert('RGBA') max_size = min(int(self.display_manager.matrix.width / 1.5), int(self.display_manager.matrix.height / 1.5)) logo = logo.resize((max_size, max_size), Image.LANCZOS) return logo except Exception as e: logger.error(f"Error processing in-memory logo data for {symbol}: {e}") # Fallback if all attempts fail logger.warning(f"Failed to obtain logo for {symbol} from disk or download.") return None def _create_stock_display(self, symbol: str, price: float, change: float, change_percent: float) -> Image.Image: """Create a display image for a stock with logo, symbol, price, and change. Args: symbol: Stock symbol (e.g., 'AAPL', 'MSFT') price: Current stock price change: Price change change_percent: Percentage change Returns: PIL Image of the stock display """ # Create a wider image for scrolling width = self.display_manager.matrix.width * 2 # Reduced from 3x to 2x since we'll handle spacing in display_stocks height = self.display_manager.matrix.height image = Image.new('RGB', (width, height), color=(0, 0, 0)) draw = ImageDraw.Draw(image) # Draw large stock logo on the left logo = self._get_stock_logo(symbol) if logo: # Position logo on the left side with minimal spacing logo_x = 0 # Reduced from 2 to 0 logo_y = (height - logo.height) // 2 image.paste(logo, (logo_x, logo_y), logo) # Draw symbol, price, and change in the center # Use the fonts from display_manager regular_font = self.display_manager.regular_font small_font = self.display_manager.small_font # Create smaller versions of the fonts for symbol and price symbol_font = ImageFont.truetype(self.display_manager.regular_font.path, int(self.display_manager.regular_font.size * 0.8)) # 80% of regular size price_font = ImageFont.truetype(self.display_manager.regular_font.path, int(self.display_manager.regular_font.size * 0.8)) # 80% of regular size # Calculate text dimensions for proper spacing symbol_text = symbol price_text = f"${price:.2f}" change_text = f"{change:+.2f} ({change_percent:+.1f}%)" # Get the height of each text element symbol_bbox = draw.textbbox((0, 0), symbol_text, font=symbol_font) price_bbox = draw.textbbox((0, 0), price_text, font=price_font) change_bbox = draw.textbbox((0, 0), change_text, font=small_font) symbol_height = symbol_bbox[3] - symbol_bbox[1] price_height = price_bbox[3] - price_bbox[1] change_height = change_bbox[3] - change_bbox[1] # Calculate total height needed for all text total_text_height = symbol_height + price_height + change_height + 2 # 2 pixels for spacing # Calculate starting y position to center the text block start_y = (height - total_text_height) // 2 # Draw symbol - moved even closer to the logo symbol_width = symbol_bbox[2] - symbol_bbox[0] symbol_x = width // 4 # Moved from width//3 to width//4 to bring text even closer to logo symbol_y = start_y draw.text((symbol_x, symbol_y), symbol_text, font=symbol_font, fill=(255, 255, 255)) # Draw price - aligned with symbol price_width = price_bbox[2] - price_bbox[0] price_x = symbol_x + (symbol_width - price_width) // 2 # Center price under symbol price_y = symbol_y + symbol_height + 1 # 1 pixel spacing draw.text((price_x, price_y), price_text, font=price_font, fill=(255, 255, 255)) # Draw change with color based on value - aligned with price change_width = change_bbox[2] - change_bbox[0] change_x = price_x + (price_width - change_width) // 2 # Center change under price change_y = price_y + price_height + 1 # 1 pixel spacing change_color = (0, 255, 0) if change >= 0 else (255, 0, 0) draw.text((change_x, change_y), change_text, font=small_font, fill=change_color) # Draw mini chart on the right if symbol in self.stock_data and 'price_history' in self.stock_data[symbol]: price_history = self.stock_data[symbol]['price_history'] if len(price_history) >= 2: # Need at least 2 points to draw a line # Extract prices from price history chart_data = [p['price'] for p in price_history] # Calculate chart dimensions - 50% wider chart_width = int(width // 2.5) # Reduced from width//2 to width//2.5 (20% smaller) chart_height = height // 1.5 chart_x = width - chart_width + 5 # Keep the same right margin chart_y = (height - chart_height) // 2 # Find min and max prices for scaling min_price = min(chart_data) max_price = max(chart_data) # Add padding to avoid flat lines when prices are very close price_range = max_price - min_price if price_range < 0.01: # If prices are very close min_price -= 0.01 max_price += 0.01 price_range = 0.02 # Calculate points for the line points = [] for i, price in enumerate(chart_data): x = chart_x + (i * chart_width) // (len(chart_data) - 1) # Invert y-axis (higher price = lower y value) y = chart_y + chart_height - ((price - min_price) / price_range * chart_height) points.append((x, y)) # Draw the line if len(points) >= 2: draw.line(points, fill=(0, 255, 0) if change >= 0 else (255, 0, 0), width=1) # Draw dots at each point for point in points: draw.ellipse([point[0]-1, point[1]-1, point[0]+1, point[1]+1], fill=(0, 255, 0) if change >= 0 else (255, 0, 0)) # Return the full image without cropping return image def _update_stock_display(self, symbol: str, data: Dict[str, Any], width: int, height: int) -> None: """Update the stock display with smooth scrolling animation.""" try: # Create the full scrolling image full_image = self._create_stock_display(symbol, data['price'], data['change'], data['change'] / data['open'] * 100) scroll_width = width * 2 # Double width for smooth scrolling # Scroll the image smoothly for scroll_pos in range(0, scroll_width - width, 15): # Increased scroll speed to match news ticker # Create visible portion visible_image = full_image.crop((scroll_pos, 0, scroll_pos + width, height)) # Convert to RGB and create numpy array rgb_image = visible_image.convert('RGB') image_array = np.array(rgb_image) # Update display self.display_manager.update_display(image_array) # Small delay for smooth animation time.sleep(0.01) # Reduced delay to 10ms for smoother scrolling # Show final position briefly final_image = full_image.crop((scroll_width - width, 0, scroll_width, height)) rgb_image = final_image.convert('RGB') image_array = np.array(rgb_image) self.display_manager.update_display(image_array) time.sleep(0.5) # Brief pause at the end except Exception as e: logger.error(f"Error updating stock display for {symbol}: {str(e)}") # Show error state self._show_error_state(width, height) def _log_frame_rate(self): """Log frame rate statistics.""" current_time = time.time() # Calculate instantaneous frame time frame_time = current_time - self.last_frame_time self.frame_times.append(frame_time) # Keep only last 100 frames for average if len(self.frame_times) > 100: self.frame_times.pop(0) # Log FPS every second if current_time - self.last_fps_log_time >= 1.0: avg_frame_time = sum(self.frame_times) / len(self.frame_times) avg_fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0 instant_fps = 1.0 / frame_time if frame_time > 0 else 0 logger.info(f"Frame stats - Avg FPS: {avg_fps:.1f}, Current FPS: {instant_fps:.1f}, Frame time: {frame_time*1000:.2f}ms") self.last_fps_log_time = current_time self.frame_count = 0 self.last_frame_time = current_time self.frame_count += 1 def display_stocks(self, force_clear: bool = False): """Display stock information with continuous scrolling animation.""" if not self.stocks_config.get('enabled', False): return # Start update in background if needed if time.time() - self.last_update >= self.stocks_config.get('update_interval', 60): self.update_stock_data() if not self.stock_data: logger.warning("No stock data available to display") return # Get all symbols symbols = list(self.stock_data.keys()) if not symbols: return # Create a continuous scrolling image if needed if self.cached_text_image is None or force_clear: # Create a very wide image that contains all stocks in sequence width = self.display_manager.matrix.width height = self.display_manager.matrix.height # Calculate total width needed for all stocks # Each stock needs width*2 for scrolling, plus consistent gaps between elements stock_gap = width // 3 # Gap between stocks element_gap = width // 6 # Gap between elements within a stock total_width = sum(width * 2 for _ in symbols) + stock_gap * (len(symbols) - 1) + element_gap * (len(symbols) * 2 - 1) # Create the full image full_image = Image.new('RGB', (total_width, height), (0, 0, 0)) draw = ImageDraw.Draw(full_image) # Draw each stock in sequence with consistent spacing current_x = 0 for symbol in symbols: data = self.stock_data[symbol] # Create stock display for this symbol stock_image = self._create_stock_display(symbol, data['price'], data['change'], data['change'] / data['open'] * 100) # Paste this stock image into the full image full_image.paste(stock_image, (current_x, 0)) # Move to next position with consistent spacing current_x += width * 2 + element_gap # Add extra gap between stocks if symbol != symbols[-1]: # Don't add gap after the last stock current_x += stock_gap # Cache the full image self.cached_text_image = full_image self.scroll_position = 0 self.last_update = time.time() # Clear the display if requested if force_clear: self.display_manager.clear() self.scroll_position = 0 # Calculate the visible portion of the image width = self.display_manager.matrix.width total_width = self.cached_text_image.width # Update scroll position with small increments self.scroll_position = (self.scroll_position + self.scroll_speed) % total_width # Calculate the visible portion visible_portion = self.cached_text_image.crop(( self.scroll_position, 0, self.scroll_position + width, self.display_manager.matrix.height )) # Copy the visible portion to the display self.display_manager.image.paste(visible_portion, (0, 0)) self.display_manager.update_display() # Log frame rate self._log_frame_rate() # Add a small delay between frames time.sleep(self.scroll_delay) # If we've scrolled through the entire image, reset if self.scroll_position == 0: return True return False