# rstat_tool/main.py import argparse import json import os import time import praw import yfinance as yf from dotenv import load_dotenv from . import database from .ticker_extractor import extract_tickers from .sentiment_analyzer import get_sentiment_score from .logger_setup import get_logger load_dotenv() MARKET_CAP_REFRESH_INTERVAL = 86400 POST_AGE_LIMIT = 86400 log = get_logger() def load_subreddits(filepath): try: with open(filepath, 'r') as f: return json.load(f).get("subreddits", []) except (FileNotFoundError, json.JSONDecodeError) as e: log.error(f"Error loading config file '{filepath}': {e}") return None def get_financial_data(ticker_symbol): try: ticker = yf.Ticker(ticker_symbol) data = { "market_cap": ticker.fast_info.get('marketCap'), "closing_price": ticker.fast_info.get('previousClose') } return data except Exception: return {"market_cap": None, "closing_price": None} def get_reddit_instance(): client_id = os.getenv("REDDIT_CLIENT_ID") client_secret = os.getenv("REDDIT_CLIENT_SECRET") user_agent = os.getenv("REDDIT_USER_AGENT") if not all([client_id, client_secret, user_agent]): print("Error: Reddit API credentials not found in .env file.") return None return praw.Reddit(client_id=client_id, client_secret=client_secret, user_agent=user_agent) def scan_subreddits(reddit, subreddits_list, post_limit=100, comment_limit=100, days_to_scan=1): """ Scans subreddits with a hybrid mention counting logic. - If a ticker is in the title, it gets credit for all comments. - If not, tickers only get credit for direct mentions in comments. """ conn = database.get_db_connection() post_age_limit = days_to_scan * 86400 current_time = time.time() log.info(f"\nScanning {len(subreddits_list)} subreddit(s) for NEW posts in the last {days_to_scan} day(s)...") for subreddit_name in subreddits_list: try: # Always use the lowercase version of the name for consistency. normalized_sub_name = subreddit_name.lower() subreddit_id = database.get_or_create_entity(conn, 'subreddits', 'name', normalized_sub_name) subreddit = reddit.subreddit(normalized_sub_name) log.info(f"Scanning r/{normalized_sub_name}...") for submission in subreddit.new(limit=post_limit): if (current_time - submission.created_utc) > post_age_limit: log.info(f" -> Reached posts older than the {days_to_scan}-day limit.") break tickers_in_title = set(extract_tickers(submission.title)) all_tickers_found_in_post = set(tickers_in_title) # Start a set to track all tickers for financials submission.comments.replace_more(limit=0) all_comments = submission.comments.list()[:comment_limit] # --- CASE A: Tickers were found in the title --- if tickers_in_title: log.info(f" -> Title Mention(s): {', '.join(tickers_in_title)}. Attributing all comments.") post_sentiment = get_sentiment_score(submission.title) # Add one 'post' mention for each title ticker for ticker_symbol in tickers_in_title: ticker_id = database.get_or_create_entity(conn, 'tickers', 'symbol', ticker_symbol) database.add_mention(conn, ticker_id, subreddit_id, submission.id, 'post', int(submission.created_utc), post_sentiment) # Add one 'comment' mention for EACH comment FOR EACH title ticker for comment in all_comments: comment_sentiment = get_sentiment_score(comment.body) for ticker_symbol in tickers_in_title: ticker_id = database.get_or_create_entity(conn, 'tickers', 'symbol', ticker_symbol) database.add_mention(conn, ticker_id, subreddit_id, submission.id, 'comment', int(comment.created_utc), comment_sentiment) # --- CASE B: No tickers in the title, scan comments individually --- else: for comment in all_comments: tickers_in_comment = set(extract_tickers(comment.body)) if tickers_in_comment: all_tickers_found_in_post.update(tickers_in_comment) # Add to our set for financials comment_sentiment = get_sentiment_score(comment.body) for ticker_symbol in tickers_in_comment: ticker_id = database.get_or_create_entity(conn, 'tickers', 'symbol', ticker_symbol) database.add_mention(conn, ticker_id, subreddit_id, submission.id, 'comment', int(comment.created_utc), comment_sentiment) # --- EFFICIENT FINANCIALS UPDATE --- # Now, update market cap once for every unique ticker found in the whole post for ticker_symbol in all_tickers_found_in_post: ticker_id = database.get_or_create_entity(conn, 'tickers', 'symbol', ticker_symbol) ticker_info = database.get_ticker_info(conn, ticker_id) if not ticker_info['last_updated'] or (current_time - ticker_info['last_updated'] > MARKET_CAP_REFRESH_INTERVAL): log.info(f" -> Fetching financial data for {ticker_symbol}...") financials = get_financial_data(ticker_symbol) database.update_ticker_financials( conn, ticker_id, financials['market_cap'] or ticker_info['market_cap'], financials['closing_price'] or ticker_info['closing_price'] ) # --- DEEP DIVE SAVE (Still valuable) --- all_comment_sentiments = [get_sentiment_score(c.body) for c in all_comments] avg_sentiment = sum(all_comment_sentiments) / len(all_comment_sentiments) if all_comment_sentiments else 0 post_analysis_data = { "post_id": submission.id, "title": submission.title, "post_url": f"https://reddit.com{submission.permalink}", "subreddit_id": subreddit_id, "post_timestamp": int(submission.created_utc), "comment_count": len(all_comments), "avg_comment_sentiment": avg_sentiment } database.add_or_update_post_analysis(conn, post_analysis_data) except Exception as e: log.error(f"Could not scan r/{subreddit_name}. Error: {e}") conn.close() log.info("\n--- Scan Complete ---") def main(): """Main function to run the Reddit stock analysis tool.""" parser = argparse.ArgumentParser(description="Analyze stock ticker mentions on Reddit.", formatter_class=argparse.RawTextHelpFormatter) parser.add_argument("-f", "--config", default="subreddits.json", help="Path to the JSON file containing subreddits.\n(Default: subreddits.json)") parser.add_argument("-s", "--subreddit", help="Scan a single subreddit, ignoring the config file.") parser.add_argument("-d", "--days", type=int, default=1, help="Number of past days to scan for new posts.\n(Default: 1 for last 24 hours)") parser.add_argument("-p", "--posts", type=int, default=200, help="Max posts to check per subreddit.\n(Default: 200)") parser.add_argument("-c", "--comments", type=int, default=100, help="Number of comments to scan per post.\n(Default: 100)") parser.add_argument("-l", "--limit", type=int, default=20, help="Number of tickers to show in the CLI report.\n(Default: 20)") args = parser.parse_args() if args.subreddit: # If --subreddit is used, create a list with just that one. subreddits_to_scan = [args.subreddit] log.info(f"Targeted Scan Mode: Focusing on r/{args.subreddit}") else: # Otherwise, load from the config file. log.info(f"Config Scan Mode: Loading subreddits from {args.config}") # Use the correct argument name: args.config subreddits_to_scan = load_subreddits(args.config) if not subreddits_to_scan: log.error("Error: No subreddits to scan. Please check your config file or --subreddit argument.") return # --- Initialize and Run --- database.initialize_db() reddit = get_reddit_instance() if not reddit: return scan_subreddits( reddit, subreddits_to_scan, post_limit=args.posts, comment_limit=args.comments, days_to_scan=args.days ) database.generate_summary_report(limit=args.limit) if __name__ == "__main__": main()