236 lines
10 KiB
Python
236 lines
10 KiB
Python
# 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() |