foodie_dev/foodie-automator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

number of entries and each entry’s timestamp

Browse Source
This commit is contained in:
Shane
2025-05-07 20:10:49 +10:00
parent 2041084962
commit 77743121b5
1 changed files with 89 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
foodie_weekly_thread.py
+71 -109
View File
@@ -179,21 +179,21 @@ def load_recent_posts():
return posts return posts
def filter_posts_for_week(posts, start_date, end_date): def filter_posts_for_week(posts, start_date, end_date):
"""Filter posts within the specified week.""" """Filter posts within the given week range."""
filtered_posts = [] filtered_posts = []
logging.debug(f"Filtering {len(posts)} posts for range {start_date} to {end_date}")
for post in posts: for post in posts:
try: try:
timestamp = datetime.fromisoformat(post["timestamp"]) post_date = datetime.fromisoformat(post["timestamp"])
logging.debug(f"Checking post '{post['title']}' with timestamp {timestamp}") logging.debug(f"Checking post: title={post['title']}, timestamp={post_date}, in range {start_date} to {end_date}")
if start_date <= timestamp <= end_date: if start_date <= post_date <= end_date:
filtered_posts.append(post) filtered_posts.append(post)
logging.debug(f"Included post: {post['title']}")
else: else:
logging.debug(f"Post '{post['title']}' timestamp {timestamp} outside range") logging.debug(f"Excluded post: {post['title']} (timestamp {post_date} outside range)")
except ValueError as e: except (KeyError, ValueError) as e:
logging.warning(f"Skipping post with invalid timestamp: {post.get('title', 'Unknown')} - {e}") logging.warning(f"Skipping post due to invalid format: {e}")
logging.info(f"Filtered to {len(filtered_posts)} posts within week range") continue
logging.info(f"Filtered to {len(filtered_posts)} posts for the week")
return filtered_posts return filtered_posts
def generate_intro_tweet(author): def generate_intro_tweet(author):
@@ -291,126 +291,88 @@ def generate_final_cta(author):
return fallback return fallback
def post_weekly_thread(): def post_weekly_thread():
"""Post weekly threads for each author.""" """Generate and post a weekly thread of top posts for each author."""
try:
logging.info("Starting foodie_weekly_thread.py") logging.info("Starting foodie_weekly_thread.py")
print("Starting foodie_weekly_thread.py")
valid_credentials = validate_twitter_credentials()
if not valid_credentials:
logging.error("No valid Twitter credentials found, exiting")
return
# Calculate date range: 7 days prior to run date
today = datetime.now(timezone.utc) today = datetime.now(timezone.utc)
days_to_monday = today.weekday() start_date = (today - timedelta(days=7)).replace(hour=0, minute=0, second=0, microsecond=0)
start_date = (today - timedelta(days=days_to_monday + 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)
end_date = start_date + timedelta(days=6, hours=23, minutes=59, seconds=59)
logging.info(f"Fetching posts from {start_date} to {end_date}") logging.info(f"Fetching posts from {start_date} to {end_date}")
print(f"Fetching posts from {start_date} to {end_date}")
all_posts = load_recent_posts() # Load and filter posts
logging.info(f"Loaded {len(all_posts)} posts from recent_posts.json") recent_posts = load_json_file(RECENT_POSTS_FILE)
print(f"Loaded {len(all_posts)} posts from recent_posts.json") logging.info(f"Loaded {len(recent_posts)} posts from {RECENT_POSTS_FILE}")
if not all_posts: # Deduplicate posts
logging.warning("No posts loaded, exiting post_weekly_thread") seen = set()
print("No posts loaded, exiting post_weekly_thread") deduped_posts = []
return for post in recent_posts:
key = (post["title"], post["url"], post["author_username"])
weekly_posts = filter_posts_for_week(all_posts, start_date, end_date) if key not in seen:
logging.info(f"Filtered to {len(weekly_posts)} posts for the week") seen.add(key)
print(f"Filtered to {len(weekly_posts)} posts for the week") 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: if not weekly_posts:
logging.warning("No posts found within the week range, exiting post_weekly_thread") logging.warning(f"No posts found within the week range {start_date} to {end_date}, exiting post_weekly_thread")
print("No posts found within the week range, exiting post_weekly_thread")
return return
posts_by_author = {} # Group posts by author
posts_by_author = {author["username"]: [] for author in AUTHORS}
for post in weekly_posts: for post in weekly_posts:
author = post["author_username"] username = post["author_username"]
if author not in posts_by_author: if username in posts_by_author:
posts_by_author[author] = [] posts_by_author[username].append(post)
posts_by_author[author].append(post)
logging.debug(f"Grouped posts by author: {list(posts_by_author.keys())}")
# Post threads for each author
for author in AUTHORS: for author in AUTHORS:
try: username = author["username"]
author_posts = posts_by_author.get(author["username"], []) author_posts = posts_by_author.get(username, [])
logging.info(f"Processing author {author['username']} with {len(author_posts)} posts")
print(f"Processing author {author['username']} with {len(author_posts)} posts")
if not author_posts: if not author_posts:
logging.info(f"No posts found for {author['username']} this week") logging.info(f"No posts found for {username}, skipping")
print(f"No posts found for {author['username']} this week")
continue continue
author_posts.sort(key=lambda x: x.get("timestamp", ""), reverse=True) # Select top 10 posts (or fewer if less than 10)
top_posts = author_posts[:10] author_posts = sorted(author_posts, key=lambda x: datetime.fromisoformat(x["timestamp"]), reverse=True)[:10]
logging.info(f"Selected {len(top_posts)} top posts for {author['username']}") logging.info(f"Selected {len(author_posts)} posts for {username}")
print(f"Selected {len(top_posts)} top posts for {author['username']}")
intro_tweet = generate_intro_tweet(author) # Generate and post thread
if not intro_tweet:
logging.error(f"Failed to generate intro tweet for {author['username']}, skipping")
continue
logging.info(f"Posting intro tweet for {author['username']}: {intro_tweet}")
print(f"Posting intro tweet for {author['username']}: {intro_tweet}")
intro_response = post_tweet(author, intro_tweet)
if not intro_response:
logging.error(f"Failed to post intro tweet for {author['username']}, skipping thread")
print(f"Failed to post intro tweet for {author['username']}")
continue
intro_tweet_id = intro_response.get("id")
last_tweet_id = intro_tweet_id
logging.debug(f"Intro tweet posted with ID {intro_tweet_id}")
for i, post in enumerate(top_posts, 1):
try: try:
post_tweet_content = f"{i}. {post['title']} Link: {post['url']}" # Post lead tweet
logging.info(f"Posting thread reply {i} for {author['username']}: {post_tweet_content}") lead_tweet = (
print(f"Posting thread reply {i} for {author['username']}: {post_tweet_content}") f"Top foodie finds this week from {author['name']} (@{author['x_username']})! "
reply_response = post_tweet(author, post_tweet_content, reply_to_id=last_tweet_id) f"Check out these {len(author_posts)} posts on InsiderFoodie.com 🍽️"
if not reply_response: )
logging.error(f"Failed to post thread reply {i} for {author['username']}") lead_response = post_tweet(author, lead_tweet)
if not lead_response:
logging.error(f"Failed to post lead tweet for {username}, skipping")
continue
lead_tweet_id = lead_response["id"]
logging.info(f"Posted lead tweet for {username}: {lead_tweet}")
# Post thread tweets
for i, post in enumerate(author_posts, 1):
thread_tweet = (
f"{i}. {post['title']} "
f"Read more: {post['url']} #FoodieThread"
)
thread_response = post_tweet(author, thread_tweet, reply_to_id=lead_tweet_id)
if thread_response:
lead_tweet_id = thread_response["id"]
logging.info(f"Posted thread tweet {i} for {username}: {thread_tweet}")
else: else:
last_tweet_id = reply_response.get("id") logging.warning(f"Failed to post thread tweet {i} for {username}")
logging.debug(f"Thread reply {i} posted with ID {last_tweet_id}")
except Exception as e:
logging.error(f"Error posting thread reply {i} for {author['username']}: {e}", exc_info=True)
continue
# Post final CTA tweet # Post engagement tweet
if last_tweet_id and top_posts: # Ensure there's a valid thread to reply to engagement_tweet = generate_engagement_tweet(author)
try: if engagement_tweet:
final_cta = generate_final_cta(author) post_tweet(author, engagement_tweet, reply_to_id=lead_tweet_id)
if not final_cta: logging.info(f"Posted engagement tweet for {username}: {engagement_tweet}")
logging.error(f"Failed to generate final CTA tweet for {author['username']}, skipping") except Exception as e:
logging.error(f"Error posting thread for {username}: {e}", exc_info=True)
continue continue
logging.info(f"Posting final CTA tweet for {author['username']}: {final_cta}")
print(f"Posting final CTA tweet for {author['username']}: {final_cta}")
cta_response = post_tweet(author, final_cta, reply_to_id=last_tweet_id)
if not cta_response:
logging.error(f"Failed to post final CTA tweet for {author['username']}")
else:
logging.debug(f"Final CTA tweet posted with ID {cta_response.get('id')}")
except Exception as e:
logging.error(f"Error posting final CTA tweet for {author['username']}: {e}", exc_info=True)
logging.info(f"Successfully posted weekly thread for {author['username']}")
print(f"Successfully posted weekly thread for {author['username']}")
except Exception as e:
logging.error(f"Error processing author {author['username']}: {e}", exc_info=True)
continue
logging.info("Completed foodie_weekly_thread.py")
print("Completed foodie_weekly_thread.py")
except Exception as e:
logging.error(f"Unexpected error in post_weekly_thread: {e}", exc_info=True)
print(f"Error in post_weekly_thread: {e}")
def main(): def main():
"""Main function to run the script.""" """Main function to run the script."""