add engagement manual posting to X

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()