Compare commits
No commits in common. 'main' and 'my-fix-branch' have entirely different histories.
main
...
my-fix-bra
13 changed files with 1479 additions and 3904 deletions
@ -1,129 +0,0 @@ |
||||
import logging |
||||
|
||||
logging.basicConfig( |
||||
filename='/home/shane/foodie_automator/logs/check_x_capacity.log', |
||||
level=logging.DEBUG, |
||||
format='%(asctime)s - %(levelname)s - %(message)s' |
||||
) |
||||
|
||||
import requests |
||||
from requests_oauthlib import OAuth1 |
||||
from datetime import datetime, timezone |
||||
from dotenv import load_dotenv |
||||
import os |
||||
import time |
||||
from foodie_config import X_API_CREDENTIALS |
||||
|
||||
# Load environment variables from .env file |
||||
load_dotenv() |
||||
|
||||
# Function to delete a tweet |
||||
def delete_tweet(tweet_id, auth): |
||||
try: |
||||
response = requests.delete(f"https://api.x.com/2/tweets/{tweet_id}", auth=auth) |
||||
response.raise_for_status() |
||||
logging.info(f"Successfully deleted tweet {tweet_id}") |
||||
return True |
||||
except Exception as e: |
||||
logging.error(f"Failed to delete tweet {tweet_id}: {e}") |
||||
return False |
||||
|
||||
# Function to check rate limits for a given author |
||||
def check_rate_limits_for_author(username, credentials, retry=False): |
||||
logging.info(f"{'Retrying' if retry else 'Checking'} rate limits for {username} (handle: {credentials['x_username']})") |
||||
|
||||
# Retrieve OAuth 1.0a credentials for the author |
||||
consumer_key = credentials["api_key"] |
||||
consumer_secret = credentials["api_secret"] |
||||
access_token = credentials["access_token"] |
||||
access_token_secret = credentials["access_token_secret"] |
||||
|
||||
# Validate credentials |
||||
if not all([consumer_key, consumer_secret, access_token, access_token_secret]): |
||||
logging.error(f"Missing OAuth credentials for {username} in X_API_CREDENTIALS.") |
||||
return None |
||||
|
||||
# Set up OAuth 1.0a authentication |
||||
auth = OAuth1(consumer_key, consumer_secret, access_token, access_token_secret) |
||||
|
||||
# Add delay to avoid IP-based rate limiting |
||||
logging.info(f"Waiting 5 seconds before attempting to post for {username}") |
||||
time.sleep(5) |
||||
|
||||
# Try posting a test tweet to get v2 rate limit headers |
||||
tweet_id = None |
||||
try: |
||||
tweet_data = {"text": f"Test tweet to check rate limits for {username} - please ignore"} |
||||
response = requests.post("https://api.x.com/2/tweets", json=tweet_data, auth=auth) |
||||
response.raise_for_status() |
||||
tweet_id = response.json()['data']['id'] |
||||
logging.info("Successfully posted test tweet for %s: %s", username, response.json()) |
||||
logging.info("Response Headers for %s: %s", username, response.headers) |
||||
# Extract rate limit headers if present |
||||
app_limit = response.headers.get('x-app-limit-24hour-limit', 'N/A') |
||||
app_remaining = response.headers.get('x-app-limit-24hour-remaining', 'N/A') |
||||
app_reset = response.headers.get('x-app-limit-24hour-reset', 'N/A') |
||||
logging.info("App 24-Hour Tweet Limit for %s: %s", username, app_limit) |
||||
logging.info("App 24-Hour Tweets Remaining for %s: %s", username, app_remaining) |
||||
if app_reset != 'N/A': |
||||
reset_time = datetime.fromtimestamp(int(app_reset), timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC') |
||||
logging.info("App 24-Hour Reset (Readable) for %s: %s", username, reset_time) |
||||
return tweet_id |
||||
except requests.exceptions.HTTPError as e: |
||||
logging.info("Test Tweet Response Status Code for %s: %s", username, e.response.status_code) |
||||
logging.info("Test Tweet Response Headers for %s: %s", username, e.response.headers) |
||||
if e.response.status_code == 429: |
||||
logging.info("Rate Limit Exceeded for /2/tweets for %s", username) |
||||
|
||||
# Extract user-specific 24-hour limits |
||||
user_limit = e.response.headers.get('x-user-limit-24hour-limit', 'N/A') |
||||
user_remaining = e.response.headers.get('x-user-limit-24hour-remaining', 'N/A') |
||||
user_reset = e.response.headers.get('x-user-limit-24hour-reset', 'N/A') |
||||
logging.info("User 24-Hour Tweet Limit for %s: %s", username, user_limit) |
||||
logging.info("User 24-Hour Tweets Remaining for %s: %s", username, user_remaining) |
||||
logging.info("User 24-Hour Reset (Timestamp) for %s: %s", username, user_reset) |
||||
if user_reset != 'N/A': |
||||
reset_time = datetime.fromtimestamp(int(user_reset), timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC') |
||||
logging.info("User 24-Hour Reset (Readable) for %s: %s", username, reset_time) |
||||
|
||||
# Extract app-specific 24-hour limits |
||||
app_limit = e.response.headers.get('x-app-limit-24hour-limit', 'N/A') |
||||
app_remaining = e.response.headers.get('x-app-limit-24hour-remaining', 'N/A') |
||||
app_reset = e.response.headers.get('x-app-limit-24hour-reset', 'N/A') |
||||
logging.info("App 24-Hour Tweet Limit for %s: %s", username, app_limit) |
||||
logging.info("App 24-Hour Tweets Remaining for %s: %s", username, app_remaining) |
||||
logging.info("App 24-Hour Reset (Timestamp) for %s: %s", username, app_reset) |
||||
if app_reset != 'N/A': |
||||
reset_time = datetime.fromtimestamp(int(app_reset), timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC') |
||||
logging.info("App 24-Hour Reset (Readable) for %s: %s", username, reset_time) |
||||
return None |
||||
except Exception as e: |
||||
logging.error("Failed to post test tweet for %s: %s", username, e) |
||||
return None |
||||
|
||||
# Main loop to check rate limits for all authors |
||||
if __name__ == "__main__": |
||||
# First pass: Attempt to post for all authors |
||||
successful_tweets = {} |
||||
for username, credentials in X_API_CREDENTIALS.items(): |
||||
tweet_id = check_rate_limits_for_author(username, credentials) |
||||
if tweet_id: |
||||
successful_tweets[username] = (tweet_id, credentials) |
||||
logging.info("-" * 50) |
||||
|
||||
# Delete successful tweets to free up quota |
||||
for username, (tweet_id, credentials) in successful_tweets.items(): |
||||
auth = OAuth1( |
||||
credentials["api_key"], |
||||
credentials["api_secret"], |
||||
credentials["access_token"], |
||||
credentials["access_token_secret"] |
||||
) |
||||
delete_tweet(tweet_id, auth) |
||||
|
||||
# Second pass: Retry for authors that failed |
||||
logging.info("Retrying for authors that initially failed...") |
||||
for username, credentials in X_API_CREDENTIALS.items(): |
||||
if username not in successful_tweets: |
||||
check_rate_limits_for_author(username, credentials, retry=True) |
||||
logging.info("-" * 50) |
||||
@ -1,236 +0,0 @@ |
||||
# 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() |
||||
@ -1,324 +1,76 @@ |
||||
# foodie_engagement_tweet.py |
||||
import json |
||||
import logging |
||||
import random |
||||
import signal |
||||
import sys |
||||
import fcntl |
||||
import os |
||||
import time |
||||
import logging |
||||
from datetime import datetime, timedelta, timezone |
||||
from openai import OpenAI |
||||
from foodie_utils import ( |
||||
post_tweet, |
||||
AUTHORS, |
||||
SUMMARY_MODEL, |
||||
check_author_rate_limit, |
||||
load_json_file, |
||||
save_json_file, # Add this |
||||
update_system_activity, |
||||
get_next_author_round_robin |
||||
) |
||||
from foodie_config import X_API_CREDENTIALS, AUTHOR_BACKGROUNDS_FILE |
||||
from dotenv import load_dotenv |
||||
from openai import OpenAI # Add this import |
||||
from foodie_utils import post_tweet, AUTHORS, SUMMARY_MODEL |
||||
from dotenv import load_dotenv # Add this import |
||||
|
||||
print("Loading environment variables") |
||||
load_dotenv() |
||||
print(f"Environment variables loaded: OPENAI_API_KEY={bool(os.getenv('OPENAI_API_KEY'))}") |
||||
# Setup logging |
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') |
||||
|
||||
SCRIPT_NAME = "foodie_engagement_tweet" |
||||
LOCK_FILE = "/home/shane/foodie_automator/locks/foodie_engagement_tweet.lock" |
||||
LOG_FILE = "/home/shane/foodie_automator/logs/foodie_engagement_tweet.log" |
||||
LOG_PRUNE_DAYS = 30 |
||||
MAX_RETRIES = 3 |
||||
RETRY_BACKOFF = 2 |
||||
|
||||
def setup_logging(): |
||||
"""Initialize logging with pruning of old logs.""" |
||||
print("Entering setup_logging") |
||||
try: |
||||
log_dir = os.path.dirname(LOG_FILE) |
||||
print(f"Ensuring log directory exists: {log_dir}") |
||||
os.makedirs(log_dir, exist_ok=True) |
||||
print(f"Log directory permissions: {os.stat(log_dir).st_mode & 0o777}, owner: {os.stat(log_dir).st_uid}") |
||||
|
||||
if os.path.exists(LOG_FILE): |
||||
print(f"Pruning old logs in {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 |
||||
print(f"Skipped {malformed_count} malformed log lines during pruning") |
||||
with open(LOG_FILE, 'w') as f: |
||||
f.writelines(pruned_lines) |
||||
print(f"Log file pruned, new size: {os.path.getsize(LOG_FILE)} bytes") |
||||
|
||||
print(f"Configuring logging to {LOG_FILE}") |
||||
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_tweet.py") |
||||
print("Logging setup complete") |
||||
except Exception as e: |
||||
print(f"Failed to setup logging: {e}") |
||||
sys.exit(1) |
||||
|
||||
def acquire_lock(): |
||||
"""Acquire a lock to prevent concurrent runs.""" |
||||
print("Entering acquire_lock") |
||||
try: |
||||
lock_dir = os.path.dirname(LOCK_FILE) |
||||
print(f"Ensuring lock directory exists: {lock_dir}") |
||||
os.makedirs(lock_dir, exist_ok=True) |
||||
print(f"Opening lock file: {LOCK_FILE}") |
||||
lock_fd = open(LOCK_FILE, 'w') |
||||
print(f"Attempting to acquire lock on {LOCK_FILE}") |
||||
fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) |
||||
lock_fd.write(str(os.getpid())) |
||||
lock_fd.flush() |
||||
print(f"Lock acquired, PID: {os.getpid()}") |
||||
return lock_fd |
||||
except IOError as e: |
||||
print(f"Failed to acquire lock, another instance is running: {e}") |
||||
logging.info("Another instance of foodie_engagement_tweet.py is running") |
||||
sys.exit(0) |
||||
except Exception as e: |
||||
print(f"Unexpected error in acquire_lock: {e}") |
||||
sys.exit(1) |
||||
|
||||
def signal_handler(sig, frame): |
||||
"""Handle termination signals gracefully.""" |
||||
print(f"Received signal: {sig}") |
||||
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) |
||||
# Load environment variables |
||||
load_dotenv() |
||||
|
||||
# Initialize OpenAI client |
||||
print("Initializing OpenAI client") |
||||
try: |
||||
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) |
||||
if not os.getenv("OPENAI_API_KEY"): |
||||
print("OPENAI_API_KEY is not set") |
||||
logging.error("OPENAI_API_KEY is not set in environment variables") |
||||
raise ValueError("OPENAI_API_KEY is required") |
||||
print("OpenAI client initialized") |
||||
except Exception as e: |
||||
print(f"Failed to initialize OpenAI client: {e}") |
||||
logging.error(f"Failed to initialize OpenAI client: {e}", exc_info=True) |
||||
sys.exit(1) |
||||
|
||||
# Load author backgrounds |
||||
print(f"Loading author backgrounds from {AUTHOR_BACKGROUNDS_FILE}") |
||||
try: |
||||
with open(AUTHOR_BACKGROUNDS_FILE, 'r') as f: |
||||
AUTHOR_BACKGROUNDS = json.load(f) |
||||
print(f"Author backgrounds loaded: {len(AUTHOR_BACKGROUNDS)} entries") |
||||
except Exception as e: |
||||
print(f"Failed to load author_backgrounds.json: {e}") |
||||
logging.error(f"Failed to load author_backgrounds.json: {e}", exc_info=True) |
||||
sys.exit(1) |
||||
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) |
||||
|
||||
def generate_engagement_tweet(author): |
||||
"""Generate an engagement tweet using author background themes and persona.""" |
||||
print(f"Generating tweet for author: {author['username']}") |
||||
try: |
||||
credentials = X_API_CREDENTIALS.get(author["username"]) |
||||
if not credentials: |
||||
print(f"No X credentials found for {author['username']}") |
||||
logging.error(f"No X credentials found for {author['username']}") |
||||
return None |
||||
author_handle = credentials["x_username"] |
||||
print(f"Author handle: {author_handle}") |
||||
author_handle = author["x_username"] # Updated to use x_username from X_API_CREDENTIALS |
||||
prompt = ( |
||||
f"Generate a concise tweet (under 280 characters) for {author_handle}. " |
||||
f"Create an engaging food-related question or statement 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)." |
||||
) |
||||
|
||||
background = next((bg for bg in AUTHOR_BACKGROUNDS if bg["username"] == author["username"]), {}) |
||||
if not background or "engagement_themes" not in background: |
||||
print(f"No background or themes for {author['username']}, using default theme") |
||||
logging.warning(f"No background or engagement themes found for {author['username']}") |
||||
theme = "food trends" |
||||
else: |
||||
theme = random.choice(background["engagement_themes"]) |
||||
print(f"Selected theme: {theme}") |
||||
|
||||
# Get the author's persona from AUTHORS |
||||
persona = next((a["persona"] for a in AUTHORS if a["username"] == author["username"]), "Unknown") |
||||
|
||||
prompt = ( |
||||
f"Generate a concise tweet (under 230 characters) for {author_handle} as a {persona}. " |
||||
f"Create an engaging, specific question about {theme} to spark interaction (e.g., 'What's your go-to sushi spot in Tokyo?'). " |
||||
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)." |
||||
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 |
||||
) |
||||
print(f"OpenAI prompt: {prompt}") |
||||
|
||||
for attempt in range(MAX_RETRIES): |
||||
print(f"Attempt {attempt + 1} to generate tweet") |
||||
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] + "..." |
||||
print(f"Generated tweet: {tweet}") |
||||
logging.debug(f"Generated engagement tweet: {tweet}") |
||||
return tweet |
||||
except Exception as e: |
||||
print(f"Failed to generate tweet (attempt {attempt + 1}): {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: |
||||
print(f"Exhausted retries for {author['username']}") |
||||
logging.error(f"Failed to generate engagement tweet after {MAX_RETRIES} attempts") |
||||
engagement_templates = [ |
||||
f"What's your favorite {theme} dish? Share below and follow {author_handle} for more on InsiderFoodie.com! Link: https://insiderfoodie.com", |
||||
f"Which {theme} spot is a must-visit? Tell us and like this tweet for more from {author_handle} on InsiderFoodie.com! Link: https://insiderfoodie.com", |
||||
f"Got a {theme} hidden gem? Share it and follow {author_handle} for more on InsiderFoodie.com! Link: https://insiderfoodie.com", |
||||
f"What's the best {theme} you've tried? 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) |
||||
print(f"Using fallback tweet: {template}") |
||||
logging.info(f"Using fallback engagement tweet: {template}") |
||||
return template |
||||
tweet = response.choices[0].message.content.strip() |
||||
if len(tweet) > 280: |
||||
tweet = tweet[:277] + "..." |
||||
return tweet |
||||
except Exception as e: |
||||
print(f"Error in generate_engagement_tweet for {author['username']}: {e}") |
||||
logging.error(f"Error in generate_engagement_tweet for {author['username']}: {e}", exc_info=True) |
||||
return None |
||||
logging.warning(f"Failed to generate engagement tweet for {author['username']}: {e}") |
||||
# Fallback templates |
||||
engagement_templates = [ |
||||
f"Whats the most mouthwatering dish youve seen this week Share below and follow {author_handle} for more foodie ideas on InsiderFoodie.com Link: https://insiderfoodie.com", |
||||
f"Food lovers unite Whats your go to comfort food Tell us and like this tweet for more tasty ideas from {author_handle} on InsiderFoodie.com Link: https://insiderfoodie.com", |
||||
f"Ever tried a dish that looked too good to eat Share your favorites and follow {author_handle} for more culinary trends on InsiderFoodie.com Link: https://insiderfoodie.com", |
||||
f"What food 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) |
||||
return template |
||||
|
||||
def post_engagement_tweet(): |
||||
"""Post engagement tweets for all authors with a delay between posts.""" |
||||
print("Entering post_engagement_tweet") |
||||
try: |
||||
logging.info("Starting foodie_engagement_tweet.py") |
||||
posted = False |
||||
state_file = '/home/shane/foodie_automator/author_state.json' |
||||
state = load_json_file(state_file, default={'last_author_index': -1}) |
||||
delay_seconds = 30 # Delay between posts to avoid rate limits and spread engagement |
||||
|
||||
# Iterate through all authors |
||||
for index, author in enumerate(AUTHORS): |
||||
username = author['username'] |
||||
print(f"Processing author: {username}") |
||||
logging.info(f"Processing author: {username}") |
||||
|
||||
try: |
||||
print("Checking rate limit") |
||||
if not check_author_rate_limit(author): |
||||
print(f"Rate limit exceeded for {username}, skipping") |
||||
logging.info(f"Rate limit exceeded for {username}, skipping") |
||||
continue |
||||
|
||||
print("Generating tweet") |
||||
tweet = generate_engagement_tweet(author) |
||||
if not tweet: |
||||
print(f"Failed to generate tweet for {username}, skipping") |
||||
logging.error(f"Failed to generate engagement tweet for {username}, skipping") |
||||
continue |
||||
|
||||
print(f"Posting tweet: {tweet}") |
||||
logging.info(f"Posting engagement tweet for {username}: {tweet}") |
||||
if post_tweet(author, tweet): |
||||
print(f"Successfully posted tweet for {username}") |
||||
logging.info(f"Successfully posted engagement tweet for {username}") |
||||
posted = True |
||||
# Update last_author_index to maintain round-robin consistency |
||||
state['last_author_index'] = index |
||||
save_json_file(state_file, state) |
||||
else: |
||||
print(f"Failed to post tweet for {username}") |
||||
logging.warning(f"Failed to post tweet for {username}") |
||||
|
||||
# Add delay between posts (except for the last author) |
||||
if index < len(AUTHORS) - 1: |
||||
print(f"Waiting {delay_seconds} seconds before next post") |
||||
logging.info(f"Waiting {delay_seconds} seconds before next post") |
||||
time.sleep(delay_seconds) |
||||
|
||||
except Exception as e: |
||||
print(f"Error posting tweet for {username}: {e}") |
||||
logging.error(f"Error posting tweet for {username}: {e}", exc_info=True) |
||||
continue |
||||
|
||||
print("Completed post_engagement_tweet") |
||||
logging.info("Completed foodie_engagement_tweet.py") |
||||
sleep_time = 86400 # 1 day for cron |
||||
return posted, sleep_time |
||||
except Exception as e: |
||||
print(f"Unexpected error in post_engagement_tweet: {e}") |
||||
logging.error(f"Unexpected error in post_engagement_tweet: {e}", exc_info=True) |
||||
sleep_time = 86400 # 1 day |
||||
return False, sleep_time |
||||
|
||||
def main(): |
||||
"""Main function to run the script.""" |
||||
print("Starting main") |
||||
lock_fd = None |
||||
try: |
||||
print("Acquiring lock") |
||||
lock_fd = acquire_lock() |
||||
print("Setting up logging") |
||||
setup_logging() |
||||
print("Updating system activity to running") |
||||
update_system_activity(SCRIPT_NAME, "running", os.getpid()) |
||||
print("Checking author state file") |
||||
author_state_file = "/home/shane/foodie_automator/author_state.json" |
||||
if not os.path.exists(author_state_file): |
||||
print(f"Author state file not found: {author_state_file}") |
||||
logging.error(f"Author state file not found: {author_state_file}") |
||||
raise FileNotFoundError(f"Author state file not found: {author_state_file}") |
||||
print(f"Author state file exists: {author_state_file}") |
||||
print("Posting engagement tweet") |
||||
posted, sleep_time = post_engagement_tweet() |
||||
print("Updating system activity to stopped") |
||||
update_system_activity(SCRIPT_NAME, "stopped") |
||||
print(f"Run completed, posted: {posted}, sleep_time: {sleep_time}") |
||||
logging.info(f"Run completed, posted: {posted}, sleep_time: {sleep_time} seconds") |
||||
return posted, sleep_time |
||||
except Exception as e: |
||||
print(f"Exception in main: {e}") |
||||
logging.error(f"Fatal error in main: {e}", exc_info=True) |
||||
print(f"Fatal error: {e}") |
||||
update_system_activity(SCRIPT_NAME, "stopped") |
||||
sleep_time = 86400 # 1 day for cron |
||||
print(f"Run completed, sleep_time: {sleep_time}") |
||||
logging.info(f"Run completed, sleep_time: {sleep_time} seconds") |
||||
return False, sleep_time |
||||
finally: |
||||
if lock_fd: |
||||
print("Releasing lock") |
||||
fcntl.flock(lock_fd, fcntl.LOCK_UN) |
||||
lock_fd.close() |
||||
os.remove(LOCK_FILE) if os.path.exists(LOCK_FILE) else None |
||||
print(f"Lock file removed: {LOCK_FILE}") |
||||
# Reference date for calculating the 2-day interval |
||||
reference_date = datetime(2025, 4, 29, tzinfo=timezone.utc) # Starting from April 29, 2025 |
||||
current_date = datetime.now(timezone.utc) |
||||
|
||||
# Calculate the number of days since the reference date |
||||
days_since_reference = (current_date - reference_date).days |
||||
|
||||
# Post only if the number of days since the reference date is divisible by 2 |
||||
if days_since_reference % 2 == 0: |
||||
logging.info("Today is an engagement tweet day (every 2 days). Posting...") |
||||
for author in AUTHORS: |
||||
tweet = generate_engagement_tweet(author) |
||||
|
||||
logging.info(f"Posting engagement tweet for {author['username']}: {tweet}") |
||||
if post_tweet(author, tweet): |
||||
logging.info(f"Successfully posted engagement tweet for {author['username']}") |
||||
else: |
||||
logging.warning(f"Failed to post engagement tweet for {author['username']}") |
||||
else: |
||||
logging.info("Today is not an engagement tweet day (every 2 days). Skipping...") |
||||
|
||||
if __name__ == "__main__": |
||||
posted, sleep_time = main() |
||||
post_engagement_tweet() |
||||
File diff suppressed because it is too large
Load Diff
@ -1,395 +1,133 @@ |
||||
# foodie_weekly_thread.py |
||||
import json |
||||
import os |
||||
from datetime import datetime, timedelta |
||||
import logging |
||||
import random |
||||
import signal |
||||
import sys |
||||
import fcntl |
||||
import time |
||||
import re |
||||
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, RECENT_POSTS_FILE |
||||
from dotenv import load_dotenv |
||||
import shutil |
||||
from openai import OpenAI # Add this import |
||||
from foodie_utils import post_tweet, AUTHORS, SUMMARY_MODEL |
||||
|
||||
load_dotenv() |
||||
|
||||
SCRIPT_NAME = "foodie_weekly_thread" |
||||
LOCK_FILE = "/home/shane/foodie_automator/locks/foodie_weekly_thread.lock" |
||||
LOG_FILE = "/home/shane/foodie_automator/logs/foodie_weekly_thread.log" |
||||
WEEKLY_THREADS_FILE = "/home/shane/foodie_automator/weekly_threads.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_weekly_thread.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_weekly_thread.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) |
||||
# Setup logging |
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') |
||||
|
||||
# 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) |
||||
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) |
||||
|
||||
def generate_intro_tweet(author): |
||||
"""Generate an intro tweet for the weekly thread.""" |
||||
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"] |
||||
logging.debug(f"Generating intro tweet for {author_handle}") |
||||
|
||||
prompt = ( |
||||
f"Generate a concise tweet (under 200 characters) for {author_handle}. " |
||||
f"Introduce a thread of their top 10 foodie posts of the week on InsiderFoodie.com. " |
||||
f"Make it engaging, create curiosity, and include a call to action to visit InsiderFoodie.com or follow {author_handle}. " |
||||
f"Avoid using the word 'elevate'—use humanized language like 'level up' or 'bring to life'. " |
||||
f"Strictly exclude 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=150, |
||||
temperature=0.7 |
||||
) |
||||
tweet = response.choices[0].message.content.strip() |
||||
tweet = re.sub(r'[\U0001F000-\U0001FFFF]', '', tweet) # Remove emojis |
||||
if len(tweet) > 280: |
||||
tweet = tweet[:277] + "..." |
||||
logging.debug(f"Generated intro tweet: {tweet}") |
||||
return tweet |
||||
except Exception as e: |
||||
logging.warning(f"Failed to generate intro 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 intro tweet after {MAX_RETRIES} attempts") |
||||
fallback = ( |
||||
f"Top 10 foodie posts this week by {author_handle}! Visit InsiderFoodie.com and follow {author_handle} for more." |
||||
) |
||||
logging.info(f"Using fallback intro tweet: {fallback}") |
||||
return fallback |
||||
|
||||
def generate_final_cta(author): |
||||
"""Generate a final CTA tweet for the weekly thread using GPT.""" |
||||
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"] |
||||
logging.debug(f"Generating final CTA tweet for {author_handle}") |
||||
|
||||
prompt = ( |
||||
f"Generate a concise tweet (under 200 characters) for {author_handle}. " |
||||
f"Conclude a thread of their top 10 foodie posts of the week on InsiderFoodie.com. " |
||||
f"Make it engaging, value-driven, in the style of Neil Patel. " |
||||
f"Include a call to action to visit InsiderFoodie.com and follow {author_handle}. " |
||||
f"Mention that top 10 foodie trends are shared every Monday. " |
||||
f"Avoid using the word 'elevate'—use humanized language like 'level up' or 'bring to life'. " |
||||
f"Strictly exclude 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=150, |
||||
temperature=0.7 |
||||
) |
||||
tweet = response.choices[0].message.content.strip() |
||||
tweet = re.sub(r'[\U0001F000-\U0001FFFF]', '', tweet) # Remove emojis |
||||
if len(tweet) > 280: |
||||
tweet = tweet[:277] + "..." |
||||
logging.debug(f"Generated final CTA tweet: {tweet}") |
||||
return tweet |
||||
except Exception as e: |
||||
logging.warning(f"Failed to generate final CTA 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 final CTA tweet after {MAX_RETRIES} attempts") |
||||
fallback = ( |
||||
f"Want more foodie insights? Visit insiderfoodie.com and follow {author_handle} " |
||||
f"for top 10 foodie trends every Monday." |
||||
) |
||||
logging.info(f"Using fallback final CTA tweet: {fallback}") |
||||
return fallback |
||||
RECENT_POSTS_FILE = "/home/shane/foodie_automator/recent_posts.json" |
||||
|
||||
def load_recent_posts(): |
||||
"""Load and deduplicate posts from recent_posts.json.""" |
||||
logging.debug(f"Attempting to load posts from {RECENT_POSTS_FILE}") |
||||
posts = load_json_file(RECENT_POSTS_FILE) |
||||
|
||||
if not posts: |
||||
logging.warning(f"No valid posts loaded from {RECENT_POSTS_FILE}") |
||||
return [] |
||||
posts = [] |
||||
if not os.path.exists(RECENT_POSTS_FILE): |
||||
return posts |
||||
|
||||
# Deduplicate posts |
||||
unique_posts = {} |
||||
for post in posts: |
||||
try: |
||||
required_fields = ["title", "url", "author_username", "timestamp"] |
||||
if not all(key in post for key in required_fields): |
||||
logging.warning(f"Skipping invalid post: missing fields {post}") |
||||
continue |
||||
datetime.fromisoformat(post["timestamp"].replace('Z', '+00:00')) |
||||
key = (post["title"], post["url"], post["author_username"]) |
||||
if key not in unique_posts: |
||||
unique_posts[key] = post |
||||
else: |
||||
logging.debug(f"Skipping duplicate post: {post['title']}") |
||||
except (KeyError, ValueError) as e: |
||||
logging.warning(f"Skipping post due to invalid format: {e}") |
||||
continue |
||||
with open(RECENT_POSTS_FILE, 'r') as f: |
||||
for line in f: |
||||
if line.strip(): |
||||
try: |
||||
entry = json.loads(line.strip()) |
||||
posts.append(entry) |
||||
except json.JSONDecodeError as e: |
||||
logging.warning(f"Skipping invalid JSON line in {RECENT_POSTS_FILE}: {e}") |
||||
|
||||
deduped_posts = list(unique_posts.values()) |
||||
logging.info(f"Loaded {len(deduped_posts)} unique posts from {RECENT_POSTS_FILE}") |
||||
return deduped_posts |
||||
return posts |
||||
|
||||
def filter_posts_for_week(posts, start_date, end_date): |
||||
"""Filter posts within the given week range.""" |
||||
filtered_posts = [] |
||||
for post in posts: |
||||
try: |
||||
post_date = datetime.fromisoformat(post["timestamp"]) |
||||
logging.debug(f"Checking post: title={post['title']}, timestamp={post_date}, in range {start_date} to {end_date}") |
||||
if start_date <= post_date <= end_date: |
||||
filtered_posts.append(post) |
||||
logging.debug(f"Included post: {post['title']}") |
||||
else: |
||||
logging.debug(f"Excluded post: {post['title']} (timestamp {post_date} outside range)") |
||||
except (KeyError, ValueError) as e: |
||||
logging.warning(f"Skipping post due to invalid format: {e}") |
||||
continue |
||||
logging.info(f"Filtered to {len(filtered_posts)} posts for the week") |
||||
timestamp = datetime.fromisoformat(post["timestamp"]) |
||||
if start_date <= timestamp <= end_date: |
||||
filtered_posts.append(post) |
||||
return filtered_posts |
||||
|
||||
def generate_weekly_thread(): |
||||
"""Generate weekly thread content for each author and save to file on Mondays.""" |
||||
logging.info("Starting foodie_weekly_thread.py") |
||||
def generate_intro_tweet(author): |
||||
author_handle = author["handle"] |
||||
prompt = ( |
||||
f"Generate a concise tweet (under 280 characters) for {author_handle}. " |
||||
f"Introduce a thread of their top 10 foodie posts of the week on InsiderFoodie.com. " |
||||
f"Make it engaging, create curiosity, and include a call to action to visit InsiderFoodie.com, follow {author_handle}, or like the thread. " |
||||
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)." |
||||
) |
||||
|
||||
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] + "..." |
||||
return tweet |
||||
except Exception as e: |
||||
logging.warning(f"Failed to generate intro tweet for {author['username']}: {e}") |
||||
# Fallback template |
||||
return ( |
||||
f"This weeks top 10 foodie finds by {author_handle} Check out the best on InsiderFoodie.com " |
||||
f"Follow {author_handle} for more and like this thread to stay in the loop Visit us at https://insiderfoodie.com" |
||||
) |
||||
|
||||
# Check if today is Monday |
||||
def post_weekly_thread(): |
||||
# Determine the date range (Monday to Sunday of the past week) |
||||
today = datetime.now(timezone.utc) |
||||
if today.weekday() != 0: # 0 = Monday |
||||
logging.info(f"Today is not Monday (weekday: {today.weekday()}), skipping weekly thread") |
||||
return |
||||
days_since_monday = (today.weekday() + 1) % 7 + 7 # Go back to previous Monday |
||||
start_date = (today - timedelta(days=days_since_monday)).replace(hour=0, minute=0, second=0, microsecond=0) |
||||
end_date = start_date + timedelta(days=6, hours=23, minutes=59, seconds=59) |
||||
|
||||
# Calculate date range: 7 days prior to run date |
||||
start_date = (today - timedelta(days=7)).replace(hour=0, minute=0, second=0, microsecond=0) |
||||
end_date = (today - timedelta(days=1)).replace(hour=23, minute=59, second=59, microsecond=999999) |
||||
logging.info(f"Fetching posts from {start_date} to {end_date}") |
||||
|
||||
# Load and filter posts |
||||
recent_posts = load_json_file(RECENT_POSTS_FILE) |
||||
logging.info(f"Loaded {len(recent_posts)} posts from {RECENT_POSTS_FILE}") |
||||
|
||||
# Deduplicate posts |
||||
seen = set() |
||||
deduped_posts = [] |
||||
for post in recent_posts: |
||||
key = (post["title"], post["url"], post["author_username"]) |
||||
if key not in seen: |
||||
seen.add(key) |
||||
deduped_posts.append(post) |
||||
logging.info(f"Filtered to {len(deduped_posts)} unique posts after deduplication") |
||||
|
||||
weekly_posts = filter_posts_for_week(deduped_posts, start_date, end_date) |
||||
if not weekly_posts: |
||||
logging.warning(f"No posts found within the week range {start_date} to {end_date}, exiting generate_weekly_thread") |
||||
return |
||||
all_posts = load_recent_posts() |
||||
weekly_posts = filter_posts_for_week(all_posts, start_date, end_date) |
||||
|
||||
# Group posts by author |
||||
posts_by_author = {author["username"]: [] for author in AUTHORS} |
||||
posts_by_author = {} |
||||
for post in weekly_posts: |
||||
username = post["author_username"] |
||||
if username in posts_by_author: |
||||
posts_by_author[username].append(post) |
||||
|
||||
# Generate thread content for each author |
||||
thread_content = [] |
||||
timestamp = datetime.now(timezone.utc).isoformat() |
||||
author = post["author_username"] # Updated to match the key in recent_posts.json |
||||
if author not in posts_by_author: |
||||
posts_by_author[author] = [] |
||||
posts_by_author[author].append(post) |
||||
|
||||
# For each author, post a thread |
||||
for author in AUTHORS: |
||||
username = author["username"] |
||||
author_posts = posts_by_author.get(username, []) |
||||
author_posts = posts_by_author.get(author["username"], []) |
||||
if not author_posts: |
||||
logging.info(f"No posts found for {username}, skipping") |
||||
logging.info(f"No posts found for {author['username']} this week") |
||||
continue |
||||
|
||||
# Select top 2 posts (to fit within 3-tweet limit: lead + 2 posts) |
||||
author_posts = sorted(author_posts, key=lambda x: datetime.fromisoformat(x["timestamp"]), reverse=True) |
||||
selected_posts = author_posts[:2] |
||||
logging.info(f"Found {len(author_posts)} posts for {username}, selected {len(selected_posts)}") |
||||
# Sort by timestamp (as a proxy for interest_score) and take top 10 |
||||
author_posts.sort(key=lambda x: x.get("timestamp", ""), reverse=True) |
||||
top_posts = author_posts[:10] |
||||
|
||||
# Generate thread content |
||||
try: |
||||
# Generate intro tweet |
||||
intro_tweet = generate_intro_tweet(author) |
||||
if not intro_tweet: |
||||
logging.error(f"Failed to generate intro tweet for {username}, skipping") |
||||
continue |
||||
|
||||
# Generate thread tweets (up to 2) |
||||
thread_tweets = [] |
||||
for i, post in enumerate(selected_posts, 1): |
||||
thread_tweet = ( |
||||
f"{i}. {post['title']} " |
||||
f"Read more: {post['url']}" |
||||
) |
||||
if len(thread_tweet) > 280: |
||||
thread_tweet = f"{i}. {post['title'][:200]}... Read more: {post['url']}" |
||||
thread_tweets.append(thread_tweet) |
||||
logging.info(f"Generated thread tweet {i} for {username}: {thread_tweet}") |
||||
|
||||
# Generate final CTA tweet |
||||
final_cta = generate_final_cta(author) |
||||
if not final_cta: |
||||
logging.error(f"Failed to generate final CTA tweet for {username}, using fallback") |
||||
final_cta = ( |
||||
f"Want more foodie insights? Visit insiderfoodie.com and follow {X_API_CREDENTIALS[username]['x_username']} " |
||||
f"for top 10 foodie trends every Monday." |
||||
) |
||||
if not top_posts: |
||||
continue |
||||
|
||||
# Collect thread content for this author |
||||
author_thread = { |
||||
"username": username, |
||||
"x_handle": X_API_CREDENTIALS[username]["x_username"], |
||||
"intro_tweet": intro_tweet, |
||||
"thread_tweets": thread_tweets, |
||||
"final_cta": final_cta, |
||||
"timestamp": timestamp |
||||
} |
||||
thread_content.append(author_thread) |
||||
logging.info(f"Generated thread content for {username}") |
||||
# First tweet: Intro with CTA (generated by GPT) |
||||
intro_tweet = generate_intro_tweet(author) |
||||
|
||||
except Exception as e: |
||||
logging.error(f"Error generating thread content for {username}: {e}", exc_info=True) |
||||
logging.info(f"Posting intro tweet for {author['username']}: {intro_tweet}") |
||||
intro_response = post_tweet(author, intro_tweet) |
||||
if not intro_response: |
||||
logging.warning(f"Failed to post intro tweet for {author['username']}") |
||||
continue |
||||
|
||||
# Save thread content to file, overwriting any existing content |
||||
if thread_content: |
||||
try: |
||||
# Backup existing file before overwriting |
||||
if os.path.exists(WEEKLY_THREADS_FILE): |
||||
backup_dir = "/home/shane/foodie_automator/backups" |
||||
os.makedirs(backup_dir, exist_ok=True) |
||||
backup_file = f"{backup_dir}/weekly_threads_{timestamp.replace(':', '-')}.json" |
||||
shutil.copy(WEEKLY_THREADS_FILE, backup_file) |
||||
logging.info(f"Backed up existing {WEEKLY_THREADS_FILE} to {backup_file}") |
||||
intro_tweet_id = intro_response.get("id") |
||||
|
||||
# Save new thread content, overwriting the file |
||||
thread_data = { |
||||
"week_start": start_date.isoformat(), |
||||
"week_end": end_date.isoformat(), |
||||
"timestamp": timestamp, |
||||
"threads": thread_content |
||||
} |
||||
save_json_file(WEEKLY_THREADS_FILE, thread_data) |
||||
logging.info(f"Saved thread content for {len(thread_content)} authors to {WEEKLY_THREADS_FILE}") |
||||
except Exception as e: |
||||
logging.error(f"Failed to save thread content to {WEEKLY_THREADS_FILE}: {e}") |
||||
else: |
||||
logging.warning("No thread content generated, nothing to save") |
||||
|
||||
logging.info("Completed foodie_weekly_thread.py") |
||||
# Post each top post as a reply in the thread |
||||
for i, post in enumerate(top_posts, 1): |
||||
post_tweet_content = ( |
||||
f"{i}. {post['title']} Link: {post['url']}" |
||||
) |
||||
logging.info(f"Posting thread reply {i} for {author['username']}: {post_tweet_content}") |
||||
post_tweet(author, post_tweet_content, reply_to_id=intro_tweet_id) |
||||
|
||||
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 |
||||
generate_weekly_thread() |
||||
update_system_activity(SCRIPT_NAME, "stopped") # Record stop |
||||
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 |
||||
sys.exit(1) |
||||
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 |
||||
logging.info(f"Successfully posted weekly thread for {author['username']}") |
||||
|
||||
if __name__ == "__main__": |
||||
main() |
||||
# Run only on Sundays |
||||
if datetime.now(timezone.utc).weekday() == 6: # Sunday (0 = Monday, 6 = Sunday) |
||||
post_weekly_thread() |
||||
else: |
||||
logging.info("Not Sunday - skipping weekly thread posting") |
||||
@ -1,195 +1,95 @@ |
||||
#!/bin/bash |
||||
|
||||
# Directory to monitor |
||||
BASE_DIR="/home/shane/foodie_automator" |
||||
LOG_DIR="$BASE_DIR/logs" |
||||
LOCK_DIR="$BASE_DIR/locks" |
||||
LOG_FILE="$LOG_DIR/manage_scripts.log" |
||||
VENV_PYTHON="$BASE_DIR/venv/bin/python" |
||||
CHECKSUM_FILE="$BASE_DIR/.file_checksum" |
||||
LOG_FILE="$BASE_DIR/manage_scripts.log" |
||||
|
||||
mkdir -p "$LOG_DIR" "$LOCK_DIR" || { echo "Error: Failed to create directories"; exit 1; } |
||||
|
||||
# Log function |
||||
log() { |
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE" |
||||
echo "$1" |
||||
} |
||||
|
||||
# Calculate checksum of files (excluding logs, JSON files, and venv) |
||||
calculate_checksum() { |
||||
find "$BASE_DIR" -type f \ |
||||
-not -path "$BASE_DIR/logs/*" \ |
||||
-not -path "$BASE_DIR/*.log" \ |
||||
-not -path "$BASE_DIR/*.json" \ |
||||
-not -path "$BASE_DIR/.file_checksum" \ |
||||
-not -path "$BASE_DIR/venv/*" \ |
||||
-not -path "$BASE_DIR/locks/*" \ |
||||
-exec sha256sum {} \; | sort | sha256sum | awk '{print $1}' |
||||
} |
||||
|
||||
# Check if scripts are running |
||||
check_running() { |
||||
local script_name="$1" |
||||
local lock_file="$LOCK_DIR/${script_name}.lock" |
||||
if [ -f "$lock_file" ]; then |
||||
local pid=$(cat "$lock_file") |
||||
if ps -p "$pid" > /dev/null; then |
||||
log "$script_name is already running (PID: $pid)" |
||||
return 0 |
||||
else |
||||
log "Stale lock file for $script_name, removing" |
||||
rm -f "$lock_file" |
||||
fi |
||||
fi |
||||
return 1 |
||||
} |
||||
|
||||
run_script() { |
||||
local script="$1" |
||||
local script_name="${script%.py}" |
||||
local script_log="$LOG_DIR/${script_name}.log" |
||||
if check_running "$script_name"; then |
||||
echo "0" # Skip sleep |
||||
return 1 |
||||
fi |
||||
log "Running $script..." |
||||
"$VENV_PYTHON" "$BASE_DIR/$script" >> "$script_log" 2>&1 & |
||||
local pid=$! |
||||
echo "$pid" > "$LOCK_DIR/${script_name}.lock" |
||||
wait "$pid" |
||||
local exit_code=$? |
||||
if [ $exit_code -eq 0 ]; then |
||||
log "$script completed successfully" |
||||
else |
||||
log "$script failed with exit code $exit_code" |
||||
fi |
||||
sleep_time=$(grep "sleep_time:" "$script_log" | tail -n 1 | grep -oP 'sleep_time: \K[0-9]+' || echo $((RANDOM % 601 + 1200))) |
||||
log "$script completed, sleep_time: $sleep_time seconds" |
||||
rm -f "$LOCK_DIR/${script_name}.lock" |
||||
echo "$sleep_time" |
||||
pgrep -f "python3.*foodie_automator" > /dev/null |
||||
} |
||||
|
||||
# Stop scripts |
||||
stop_scripts() { |
||||
log "Stopping scripts..." |
||||
for script in foodie_automator_rss.py foodie_automator_reddit.py foodie_automator_google.py; do |
||||
pkill -TERM -f "python3.*foodie_automator" || true |
||||
sleep 10 |
||||
pkill -9 -f "python3.*foodie_automator" || true |
||||
log "Scripts stopped." |
||||
} |
||||
|
||||
# Start scripts |
||||
start_scripts() { |
||||
log "Starting scripts..." |
||||
cd "$BASE_DIR" |
||||
source venv/bin/activate |
||||
# Find all foodie_automator_*.py scripts and start them |
||||
for script in foodie_automator_*.py; do |
||||
if [ -f "$script" ]; then |
||||
local script_name="${script%.py}" |
||||
if pkill -TERM -f "$VENV_PYTHON.*$script_name"; then |
||||
log "Sent TERM to $script_name" |
||||
sleep 2 |
||||
pkill -9 -f "$VENV_PYTHON.*$script_name" || true |
||||
else |
||||
log "No running $script_name found" |
||||
fi |
||||
rm -f "$LOCK_DIR/${script_name}.lock" |
||||
log "Removed lock file for $script_name" |
||||
log "Starting $script..." |
||||
nohup python3 "$script" >> "${script%.py}.log" 2>&1 & |
||||
fi |
||||
done |
||||
log "Scripts stopped." |
||||
log "All scripts started." |
||||
} |
||||
|
||||
# Update dependencies |
||||
update_dependencies() { |
||||
log "Updating dependencies..." |
||||
cd "$BASE_DIR" || { log "Failed to change to $BASE_DIR"; exit 1; } |
||||
cd "$BASE_DIR" |
||||
# Create venv if it doesn't exist |
||||
if [ ! -d "venv" ]; then |
||||
python3 -m venv venv |
||||
log "Created new virtual environment" |
||||
fi |
||||
source "$BASE_DIR/venv/bin/activate" |
||||
source venv/bin/activate |
||||
pip install --upgrade pip |
||||
pip install -r requirements.txt || (pip install requests openai beautifulsoup4 feedparser praw duckduckgo_search selenium Pillow pytesseract webdriver-manager && log "Fallback: Installed core dependencies") |
||||
log "Dependencies updated." |
||||
} |
||||
|
||||
if [ "$1" == "stop" ]; then |
||||
log "Received stop command, stopping all scripts..." |
||||
stop_scripts |
||||
for script in foodie_engagement_generator.py foodie_weekly_thread.py; do |
||||
local script_name="${script%.py}" |
||||
if pkill -TERM -f "$VENV_PYTHON.*$script_name"; then |
||||
log "Sent TERM to $script_name" |
||||
sleep 2 |
||||
pkill -9 -f "$VENV_PYTHON.*$script_name" || true |
||||
else |
||||
log "No running $script_name found" |
||||
fi |
||||
rm -f "$LOCK_DIR/$script_name.lock" |
||||
log "Stopped $script_name" |
||||
done |
||||
log "All scripts stopped. Reminder: Disable cron jobs (crontab -e)." |
||||
exit 0 |
||||
fi |
||||
|
||||
if [ "$1" == "start" ]; then |
||||
log "Received start command, starting all scripts..." |
||||
cd "$BASE_DIR" || { log "Failed to change to $BASE_DIR"; exit 1; } |
||||
source "$BASE_DIR/venv/bin/activate" |
||||
if [ -f "$BASE_DIR/.env" ]; then |
||||
while IFS='=' read -r key value; do |
||||
if [[ ! -z "$key" && ! "$key" =~ ^# ]]; then |
||||
export "$key=$value" |
||||
fi |
||||
done < <(grep -v '^#' "$BASE_DIR/.env") |
||||
log ".env variables loaded" |
||||
else |
||||
log "Error: .env file not found" |
||||
exit 1 |
||||
fi |
||||
for script in foodie_automator_rss.py foodie_automator_reddit.py foodie_automator_google.py; do |
||||
if [ -f "$script" ]; then |
||||
sleep_time=$(run_script "$script" | tail -n 1) |
||||
if [ "$sleep_time" != "0" ]; then |
||||
log "Sleeping for $sleep_time seconds after $script" |
||||
sleep "$sleep_time" |
||||
fi |
||||
else |
||||
log "Script $script not found" |
||||
fi |
||||
done |
||||
if [ -f "foodie_engagement_generator.py" ]; then |
||||
if ! check_running "foodie_engagement_generator"; then |
||||
log "Running foodie_engagement_generator.py..." |
||||
"$VENV_PYTHON" "foodie_engagement_generator.py" >> "$LOG_DIR/foodie_engagement_generator.log" 2>&1 |
||||
log "foodie_engagement_generator.py completed" |
||||
fi |
||||
fi |
||||
log "All scripts started. Ensure cron jobs are enabled (crontab -l)." |
||||
exit 0 |
||||
fi |
||||
|
||||
# Main logic |
||||
log "Checking for file changes..." |
||||
CURRENT_CHECKSUM=$(calculate_checksum) |
||||
|
||||
if [ -f "$CHECKSUM_FILE" ]; then |
||||
PREVIOUS_CHECKSUM=$(cat "$CHECKSUM_FILE") |
||||
else |
||||
PREVIOUS_CHECKSUM="" |
||||
fi |
||||
|
||||
if [ "$CURRENT_CHECKSUM" != "$PREVIOUS_CHECKSUM" ]; then |
||||
log "File changes detected. Previous checksum: $PREVIOUS_CHECKSUM, Current checksum: $CURRENT_CHECKSUM" |
||||
if pgrep -f "$VENV_PYTHON.*foodie_automator" > /dev/null; then |
||||
|
||||
# Stop scripts if running |
||||
if check_running; then |
||||
stop_scripts |
||||
fi |
||||
|
||||
# Update dependencies |
||||
update_dependencies |
||||
|
||||
# Start scripts |
||||
start_scripts |
||||
|
||||
# Update checksum |
||||
echo "$CURRENT_CHECKSUM" > "$CHECKSUM_FILE" |
||||
log "Checksum updated." |
||||
fi |
||||
cd "$BASE_DIR" |
||||
source "$BASE_DIR/venv/bin/activate" |
||||
if [ -f "$BASE_DIR/.env" ]; then |
||||
while IFS='=' read -r key value; do |
||||
if [[ ! -z "$key" && ! "$key" =~ ^# ]]; then |
||||
export "$key=$value" |
||||
fi |
||||
done < <(grep -v '^#' "$BASE_DIR/.env") |
||||
log ".env variables loaded" |
||||
else |
||||
log "Error: .env file not found" |
||||
exit 1 |
||||
log "No file changes detected." |
||||
fi |
||||
for script in foodie_automator_rss.py foodie_automator_reddit.py foodie_automator_google.py; do |
||||
if [ -f "$script" ]; then |
||||
sleep_time=$(run_script "$script" | tail -n 1) |
||||
if [ "$sleep_time" != "0" ]; then |
||||
log "Sleeping for $sleep_time seconds after $script" |
||||
sleep "$sleep_time" |
||||
fi |
||||
else |
||||
log "Script $script not found" |
||||
fi |
||||
done |
||||
log "All scripts processed." |
||||
exit 0 |
||||
Loading…
Reference in new issue