bot.py

import tweepy
from datetime import datetime, timedelta
import pytz
import os
import random
import time
from config import *

class HistoricalBot:
    def __init__(self):
        try:
            # Authenticate with Twitter
            print("Initializing Twitter authentication...")
            
            # First, verify that we have all required credentials
            if not all([TWITTER_API_KEY, TWITTER_API_SECRET, 
                       TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET]):
                raise ValueError("Missing Twitter API credentials")
            
            # Create OAuth 1.0a authentication
            auth = tweepy.OAuthHandler(
                TWITTER_API_KEY, 
                TWITTER_API_SECRET
            )
            auth.set_access_token(
                TWITTER_ACCESS_TOKEN, 
                TWITTER_ACCESS_TOKEN_SECRET
            )
            
            # Initialize API v1.1
            self.api = tweepy.API(auth)
            
            # Initialize API v2
            self.client = tweepy.Client(
                consumer_key=TWITTER_API_KEY,
                consumer_secret=TWITTER_API_SECRET,
                access_token=TWITTER_ACCESS_TOKEN,
                access_token_secret=TWITTER_ACCESS_TOKEN_SECRET
            )
            
            # Verify credentials and get user info
            user_info = self.api.verify_credentials()
            self.username = user_info.screen_name
            print(f"Twitter authentication successful! Logged in as @{self.username}")
            
        except ValueError as e:
            print(f"Authentication Error: {str(e)}")
            raise
        except tweepy.errors.TweepyException as e:
            print(f"Tweepy Error: {str(e)}")
            raise
        except Exception as e:
            print(f"Unexpected Error: {str(e)}")
            raise
            
        self.events_dir = "historical_events"
        self.scheduled_tweets = []

    def read_events_file(self, date):
        """Read events from file for a specific date"""
        filename = os.path.join(self.events_dir, f"events_{date.strftime('%Y%m%d')}.txt")
        events = []
        
        if os.path.exists(filename):
            current_event = {}
            with open(filename, 'r', encoding='utf-8') as f:
                for line in f:
                    line = line.strip()
                    if line.startswith("Year: "):
                        if current_event:
                            events.append(current_event)
                        current_event = {"year": line[6:]}
                    elif line.startswith("Description: "):
                        current_event["description"] = line[13:]
                    elif line.startswith("Source: "):
                        current_event["source"] = line[8:]
                
                if current_event:  # Add the last event
                    events.append(current_event)
                    
        return events

    def format_tweet(self, event):
        """Format event into an engaging tweet"""
        year = event['year'].strip()
        description = event['description'].strip()
        
        # Clean up the year format
        year = year.replace('BC', ' BCE').replace('AD', ' CE')
        
        # Clean up common Wikipedia formatting issues
        description = description.split('[')[0]  # Remove citation brackets
        description = description.split('(')[0]  # Remove parentheticals
        
        # Make it more conversational
        intros = [
            "On this day",
            "Today in",
            "Looking back to",
            "History tells us",
            "#OnThisDay"
        ]
        
        # Select random intro
        intro = random.choice(intros)
        
        # Format the tweet
        tweet_text = f"{intro} in {year}, {description}"
        
        # Ensure tweet is within character limit
        if len(tweet_text) > 280:
            tweet_text = tweet_text[:277] + "..."
        
        return tweet_text

    def create_daily_schedule(self):
        """Create schedule for the entire day"""
        today = datetime.now(pytz.timezone(TIME_ZONE))
        events = self.read_events_file(today)
        
        if not events:
            print(f"No events found for {today.strftime('%B %d')}")
            return []
        
        # Select random events (max 8 per day)
        num_tweets = min(len(events), 8)
        selected_events = random.sample(events, num_tweets)
        
        # Get the current time and end of day
        now = datetime.now(pytz.timezone(TIME_ZONE))
        end_of_day = now.replace(hour=23, minute=59, second=59)
        
        # Create schedule
        schedule = []
        for event in selected_events:
            # Random time between now and end of day
            random_time = now + timedelta(
                seconds=random.randint(0, int((end_of_day - now).total_seconds()))
            )
            tweet_text = self.format_tweet(event)
            schedule.append({
                'time': random_time,
                'text': tweet_text
            })
        
        # Sort schedule by time
        schedule.sort(key=lambda x: x['time'])
        
        # Print schedule
        print("\nToday's tweet schedule:")
        for i, tweet in enumerate(schedule, 1):
            print(f"\nTweet {i}/{len(schedule)}:")
            print(f"Scheduled for: {tweet['time'].strftime('%H:%M:%S')}")
            print(f"Content: {tweet['text']}")
            
        return schedule

    def run(self):
        """Run the bot"""
        while True:
            try:
                # Create schedule for the day
                self.scheduled_tweets = self.create_daily_schedule()
                
                # Process all tweets for the day
                for tweet in self.scheduled_tweets:
                    try:
                        # Post tweet and capture the response
                        response = self.client.create_tweet(text=tweet['text'])
                        
                        # Extract tweet ID from response
                        tweet_id = response.data['id']
                        
                        # Construct tweet URL with actual username
                        tweet_url = f"https://twitter.com/{self.username}/status/{tweet_id}"
                        
                        print(f"\nSuccessfully tweeted at {datetime.now().strftime('%H:%M:%S')}:")
                        print(tweet['text'])
                        print(f"\nTweet link: {tweet_url}")
                    except Exception as e:
                        print(f"Error posting tweet: {e}")
                    
                    # Small delay between tweets
                    time.sleep(random.randint(300, 900))  # 5-15 minutes between tweets
                
                # Wait until next day
                tomorrow = datetime.now(pytz.timezone(TIME_ZONE)) + timedelta(days=1)
                tomorrow = tomorrow.replace(hour=0, minute=0, second=0)
                sleep_time = (tomorrow - datetime.now(pytz.timezone(TIME_ZONE))).total_seconds()
                
                print(f"\nWaiting until tomorrow ({sleep_time/3600:.1f} hours)...")
                time.sleep(sleep_time)
                
            except Exception as e:
                print(f"Error in main loop: {e}")
                time.sleep(300)  # Wait 5 minutes before retrying

if __name__ == "__main__":
    bot = HistoricalBot()
    bot.run()