diff --git a/foodie_engagement_generator.py b/foodie_engagement_generator.py new file mode 100644 index 0000000..c8964ea --- /dev/null +++ b/foodie_engagement_generator.py @@ -0,0 +1,236 @@ +# foodie_engagement_generator.py +import json +import logging +import random +import signal +import sys +import fcntl +import os +import time +from datetime import datetime, timedelta, timezone +from openai import OpenAI +from foodie_utils import AUTHORS, SUMMARY_MODEL, load_json_file, save_json_file, update_system_activity +from foodie_config import X_API_CREDENTIALS, AUTHOR_BACKGROUNDS_FILE +from dotenv import load_dotenv + +load_dotenv() + +SCRIPT_NAME = "foodie_engagement_generator" +LOCK_FILE = "/home/shane/foodie_automator/locks/foodie_engagement_generator.lock" +LOG_FILE = "/home/shane/foodie_automator/logs/foodie_engagement_generator.log" +ENGAGEMENT_TWEETS_FILE = "/home/shane/foodie_automator/engagement_tweets.json" +LOG_PRUNE_DAYS = 30 +MAX_RETRIES = 3 +RETRY_BACKOFF = 2 + +def setup_logging(): + """Initialize logging with pruning of old logs.""" + try: + os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True) + if os.path.exists(LOG_FILE): + with open(LOG_FILE, 'r') as f: + lines = f.readlines() + cutoff = datetime.now(timezone.utc) - timedelta(days=LOG_PRUNE_DAYS) + pruned_lines = [] + malformed_count = 0 + for line in lines: + if len(line) < 19 or not line[:19].replace('-', '').replace(':', '').replace(' ', '').isdigit(): + malformed_count += 1 + continue + try: + timestamp = datetime.strptime(line[:19], '%Y-%m-%d %H:%M:%S').replace(tzinfo=timezone.utc) + if timestamp > cutoff: + pruned_lines.append(line) + except ValueError: + malformed_count += 1 + continue + if malformed_count > 0: + logging.info(f"Skipped {malformed_count} malformed log lines during pruning") + with open(LOG_FILE, 'w') as f: + f.writelines(pruned_lines) + + logging.basicConfig( + filename=LOG_FILE, + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' + ) + console_handler = logging.StreamHandler() + console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')) + logging.getLogger().addHandler(console_handler) + logging.getLogger("openai").setLevel(logging.WARNING) + logging.info("Logging initialized for foodie_engagement_generator.py") + except Exception as e: + print(f"Failed to setup logging: {e}") + sys.exit(1) + +def acquire_lock(): + """Acquire a lock to prevent concurrent runs.""" + os.makedirs(os.path.dirname(LOCK_FILE), exist_ok=True) + lock_fd = open(LOCK_FILE, 'w') + try: + fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + lock_fd.write(str(os.getpid())) + lock_fd.flush() + return lock_fd + except IOError: + logging.info("Another instance of foodie_engagement_generator.py is running") + sys.exit(0) + +def signal_handler(sig, frame): + """Handle termination signals gracefully.""" + logging.info("Received termination signal, marking script as stopped...") + update_system_activity(SCRIPT_NAME, "stopped") + sys.exit(0) + +signal.signal(signal.SIGTERM, signal_handler) +signal.signal(signal.SIGINT, signal_handler) + +# Initialize OpenAI client +try: + client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) + if not os.getenv("OPENAI_API_KEY"): + logging.error("OPENAI_API_KEY is not set in environment variables") + raise ValueError("OPENAI_API_KEY is required") +except Exception as e: + logging.error(f"Failed to initialize OpenAI client: {e}", exc_info=True) + sys.exit(1) + +# Load author backgrounds +try: + with open(AUTHOR_BACKGROUNDS_FILE, 'r') as f: + AUTHOR_BACKGROUNDS = json.load(f) +except Exception as e: + logging.error(f"Failed to load author_backgrounds.json: {e}", exc_info=True) + sys.exit(1) + +def generate_engagement_tweet(author): + """Generate an engagement tweet using author background themes.""" + credentials = X_API_CREDENTIALS.get(author["username"]) + if not credentials: + logging.error(f"No X credentials found for {author['username']}") + return None + author_handle = credentials["x_username"] + + background = next((bg for bg in AUTHOR_BACKGROUNDS if bg["username"] == author["username"]), {}) + if not background or "engagement_themes" not in background: + logging.warning(f"No background or engagement themes found for {author['username']}") + theme = "food trends" + else: + theme = random.choice(background["engagement_themes"]) + + prompt = ( + f"Generate a concise tweet (under 230 characters) for {author_handle}. " + f"Create an engaging question or statement about {theme} to spark interaction. " + f"Include a call to action to follow {author_handle} or like the tweet, and mention InsiderFoodie.com with a link to https://insiderfoodie.com. " + f"Avoid using the word 'elevate'—use more humanized language like 'level up' or 'bring to life'. " + f"Do not include emojis, hashtags, or reward-driven incentives (e.g., giveaways)." + ) + + for attempt in range(MAX_RETRIES): + try: + response = client.chat.completions.create( + model=SUMMARY_MODEL, + messages=[ + {"role": "system", "content": "You are a social media expert crafting engaging tweets."}, + {"role": "user", "content": prompt} + ], + max_tokens=100, + temperature=0.7 + ) + tweet = response.choices[0].message.content.strip() + if len(tweet) > 280: + tweet = tweet[:277] + "..." + logging.debug(f"Generated engagement tweet: {tweet}") + return tweet + except Exception as e: + logging.warning(f"Failed to generate engagement tweet for {author['username']} (attempt {attempt + 1}): {e}") + if attempt < MAX_RETRIES - 1: + time.sleep(RETRY_BACKOFF * (2 ** attempt)) + else: + logging.error(f"Failed to generate engagement tweet after {MAX_RETRIES} attempts") + engagement_templates = [ + f"What's the most mouthwatering {theme} you've seen this week? Share below and follow {author_handle} for more on InsiderFoodie.com! Link: https://insiderfoodie.com", + f"{theme.capitalize()} lovers unite! What's your go-to pick? Tell us and like this tweet for more from {author_handle} on InsiderFoodie.com! Link: https://insiderfoodie.com", + f"Ever tried a {theme} that blew your mind? Share your favorites and follow {author_handle} for more on InsiderFoodie.com! Link: https://insiderfoodie.com", + f"What {theme} trend are you loving right now? Let us know and like this tweet to keep up with {author_handle} on InsiderFoodie.com! Link: https://insiderfoodie.com" + ] + template = random.choice(engagement_templates) + logging.info(f"Using fallback engagement tweet: {template}") + return template + +def generate_engagement_tweets(): + """Generate engagement tweets for authors and save to file.""" + try: + logging.info("Starting foodie_engagement_generator.py") + tweets = [] + timestamp = datetime.now(timezone.utc).isoformat() + + for author in AUTHORS: + try: + tweet = generate_engagement_tweet(author) + if not tweet: + logging.error(f"Failed to generate engagement tweet for {author['username']}, skipping") + continue + + # Collect tweet data + tweet_data = { + "username": author["username"], + "x_handle": X_API_CREDENTIALS[author["username"]]["x_username"], + "tweet": tweet, + "timestamp": timestamp + } + tweets.append(tweet_data) + logging.info(f"Generated engagement tweet for {author['username']}: {tweet}") + except Exception as e: + logging.error(f"Error generating engagement tweet for {author['username']}: {e}", exc_info=True) + continue + + # Save tweets to file, overwriting any existing content + if tweets: + try: + tweet_data = { + "timestamp": timestamp, + "tweets": tweets + } + save_json_file(ENGAGEMENT_TWEETS_FILE, tweet_data) + logging.info(f"Saved {len(tweets)} engagement tweets to {ENGAGEMENT_TWEETS_FILE}") + except Exception as e: + logging.error(f"Failed to save engagement tweets to {ENGAGEMENT_TWEETS_FILE}: {e}") + else: + logging.warning("No engagement tweets generated, nothing to save") + + logging.info("Completed foodie_engagement_generator.py") + sleep_time = random.randint(82800, 86400) # ~23–24 hours + return True, sleep_time + except Exception as e: + logging.error(f"Unexpected error in generate_engagement_tweets: {e}", exc_info=True) + sleep_time = random.randint(82800, 86400) # ~23–24 hours + return False, sleep_time + +def main(): + """Main function to run the script.""" + lock_fd = None + try: + lock_fd = acquire_lock() + setup_logging() + update_system_activity(SCRIPT_NAME, "running", os.getpid()) # Record start + success, sleep_time = generate_engagement_tweets() + update_system_activity(SCRIPT_NAME, "stopped") # Record stop + logging.info(f"Run completed, sleep_time: {sleep_time} seconds") + return success, sleep_time + except Exception as e: + logging.error(f"Fatal error in main: {e}", exc_info=True) + print(f"Fatal error: {e}") + update_system_activity(SCRIPT_NAME, "stopped") # Record stop on error + sleep_time = random.randint(82800, 86400) # ~23–24 hours + logging.info(f"Run completed, sleep_time: {sleep_time} seconds") + return False, sleep_time + finally: + if lock_fd: + fcntl.flock(lock_fd, fcntl.LOCK_UN) + lock_fd.close() + os.remove(LOCK_FILE) if os.path.exists(LOCK_FILE) else None + +if __name__ == "__main__": + success, sleep_time = main() \ No newline at end of file