Upload 5 files

agents.py

@@ -0,0 +1,170 @@
+from langchain_google_genai import GoogleGenerativeAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.chains import LLMChain
+
+class SocialMediaAgents:
+    PLATFORM_LIMITS = {
+        "twitter": {"chars": 280, "words": None},
+        "instagram": {"chars": None, "words": 400},
+        "linkedin": {"chars": None, "words": 600},
+        "facebook": {"chars": None, "words": 1000}
+    }
+
+    def __init__(self, api_key: str):
+        """Initialize the agent with a Google API key."""
+        self.llm = GoogleGenerativeAI(model="gemini-1.5-flash", google_api_key=api_key)
+
+    def _create_chain(self, template: str) -> LLMChain:
+        """Create an LLM chain with the given prompt template."""
+        prompt = ChatPromptTemplate.from_template(template)
+        return LLMChain(llm=self.llm, prompt=prompt)
+
+    def _enforce_limits(self, text: str, platform: str) -> str:
+        """Enforce platform-specific character or word limits."""
+        limits = self.PLATFORM_LIMITS[platform.lower()]
+        if limits["chars"] and len(text) > limits["chars"]:
+            return text[:limits["chars"]-3] + "..."
+        if limits["words"]:
+            words = text.split()
+            if len(words) > limits["words"]:
+                return " ".join(words[:limits["words"]]) + "..."
+        return text
+
+    # def twitter_transform(self, title: str, description: str) -> dict:
+    #     """Transform content for Twitter."""
+    #     link = "https://www.eye-on.ai/podcast-archive"
+    #     template = """Transform this into a Twitter post (280 characters max):
+    #     - Attention-grabbing message
+    #     - 1-2 relevant hashtags
+    #     - Essential information only
+        
+    #     Format output EXACTLY like this:
+    #     New Title: [transformed title]
+    #     ---
+    #     New Description: [transformed description]
+        
+    #     add this line after descripttion and make link clickable listen to full podcast on {link}
+
+    #     Original Content:
+    #     Title: {title}
+    #     Description: {description}"""
+    #     chain = self._create_chain(template)
+    #     response = chain.invoke({"title": title, "description": description, "link": link})
+
+    def twitter_transform(self, title: str, description: str,link:str) -> dict:
+        """Transform content for Twitter with a clickable link and within 280 characters."""
+        template = """
+        Transform this into a Twitter post (max 280 characters total):
+        - Create an attention-grabbing single-line tweet using key info from the title and description
+        - Include 1-2 relevant hashtags
+        - End with this line exactly: Listen to full podcast: {link}
+        - Ensure the ENTIRE result is no more than 280 characters TOTAL (including the link line)
+        - if character more than 280 characters manage limit and exclude description character
+        - Don't short {link} i want full link
+        Return in this format:
+        New Title: [transformed title]
+        ---
+        New Description: [tweet content]
+
+        Original Content:
+        Title: {title}
+        Description: {description}
+            """
+        chain = self._create_chain(template)
+        response = chain.invoke({"title": title, "description": description, "link": link})
+        
+
+
+        parts = response['text'].split('---')
+        result = {
+            "new_title": parts[0].replace('New Title:', '').strip(),
+            "new_description": parts[1].replace('New Description:', '').strip()
+        }
+        combined_text = f"{result['new_title']} {result['new_description']}"
+        limited_text = self._enforce_limits(combined_text, "twitter")
+        if len(limited_text) < len(combined_text):
+            result['new_title'] = ""
+            result['new_description'] = limited_text
+        return result
+
+    def instagram_transform(self, title: str, description: str) -> dict:
+        """Transform content for Instagram."""
+        template = """Transform this into an Instagram post (400 words max):
+        - Catchy title with relevant emojis
+        - Engaging description
+        - 3-5 relevant hashtags
+        
+        Format output EXACTLY like this:
+        New Title: [transformed title]
+        ---
+        New Description: [transformed description]
+        
+        Original Content:
+        Title: {title}
+        Description: {description}"""
+        chain = self._create_chain(template)
+        response = chain.invoke({"title": title, "description": description})
+        parts = response['text'].split('---')
+        result = {
+            "new_title": parts[0].replace('New Title:', '').strip(),
+            "new_description": parts[1].replace('New Description:', '').strip()
+        }
+        result['new_description'] = self._enforce_limits(result['new_description'], "instagram")
+        return result
+
+    def linkedin_transform(self, title: str, description: str,link) -> dict:
+        """Transform content for LinkedIn."""
+        
+        template = """Transform this into a LinkedIn post (600 words max):
+        - Professional title
+        - Detailed description with business insights
+        - 2-3 relevant hashtags
+        - Professional tone
+        - End with this line exactly: Listen to full podcast: {link}
+        - Don't change link format and words.
+        - Ensure the ENTIRE result is no more than 600 words TOTAL (including the link line)
+        - if character more than 600 words manage limit and exclude description character
+        
+        Format output EXACTLY like this:
+        New Title: [transformed title]
+        ---
+        New Description: [transformed description]
+        
+        Original Content:
+        Title: {title}
+        Description: {description}"""
+        chain = self._create_chain(template)
+        response = chain.invoke({"title": title, "description": description, "link": link})
+        parts = response['text'].split('---')
+        result = {
+            "new_title": parts[0].replace('New Title:', '').strip(),
+            "new_description": parts[1].replace('New Description:', '').strip()
+        }
+        result['new_description'] = self._enforce_limits(result['new_description'], "linkedin")
+        return result
+
+    def facebook_transform(self, title: str, description: str) -> dict:
+        """Transform content for Facebook."""
+        template = """Transform this into a Facebook post (1000 words max):
+        - Engaging title
+        - Conversational description
+        - Call to action for engagement
+        - 1-2 relevant hashtags
+        
+        Format output EXACTLY like this:
+        New Title: [transformed title]
+        ---
+        New Description: [transformed description]
+        
+        Original Content:
+        Title: {title}
+        Description: {description}"""
+        chain = self._create_chain(template)
+        response = chain.invoke({"title": title, "description": description})
+        parts = response['text'].split('---')
+        result = {
+            "new_title": parts[0].replace('New Title:', '').strip(),
+            "new_description": parts[1].replace('New Description:', '').strip()
+        }
+        result['new_description'] = self._enforce_limits(result['new_description'], "facebook")
+        return result

app.py

@@ -0,0 +1,472 @@
+from flask import Flask, redirect, url_for, request, render_template, session
+from apscheduler.schedulers.background import BackgroundScheduler
+import requests
+from datetime import datetime, timedelta
+import tweepy
+from agents import SocialMediaAgents  # Assuming this is your agents.py file
+import feedparser
+from helpers import post_to_linkedin, post_to_twitter, extract_image_url
+import random
+import uuid
+from dotenv import load_dotenv
+import os
+import atexit
+import json
+
+load_dotenv()
+
+ngrok_link = os.getenv("Ngrok_Link")
+
+app = Flask(__name__)
+app.secret_key = '12345678765'  # Replace with a secure key
+
+scheduler = BackgroundScheduler()
+scheduler.start()
+
+api_key = os.getenv("Gemini_key")
+
+agents = SocialMediaAgents(api_key)
+
+LINKEDIN_CLIENT_ID = os.getenv("LINKEDIN_CLIENT_ID")
+LINKEDIN_CLIENT_SECRET = os.getenv("LINKEDIN_CLIENT_SECRET")
+TWITTER_CLIENT_ID = os.getenv("TWITTER_CLIENT_ID")
+TWITTER_CLIENT_SECRET = os.getenv("TWITTER_CLIENT_SECRET")
+
+posts = []
+temp_posts = {}
+
+@app.route('/')
+def home():
+    connected_platforms = {
+        'linkedin': 'linkedin_access_token' in session and 'linkedin_id' in session,
+        'twitter': 'twitter_access_token' in session and 'twitter_access_token_secret' in session,
+        
+    }
+    name ={
+        'name':session.get('linkedin_name'),
+        'tw_name':session.get('twitter_name')
+    }
+    print(name['tw_name'])
+    return render_template('home.html', connected_platforms=connected_platforms , name = name) 
+
+@app.route('/connect_all')
+def connect_all():
+    session['connect_all'] = True
+    return redirect(url_for('linkedin_auth'))
+
+@app.route('/linkedin/auth')
+def linkedin_auth():
+    if "linkedin_access_token" not in session:
+        redirect_uri = f'{ngrok_link}/linkedin/callback'
+        scope = 'openid profile w_member_social'
+        auth_url = (
+            f'https://www.linkedin.com/oauth/v2/authorization?'
+            f'response_type=code&client_id={LINKEDIN_CLIENT_ID}&redirect_uri={redirect_uri}&'
+            f'scope={scope}&state=randomstring'
+        )
+        return redirect(auth_url)
+
+@app.route('/linkedin/callback')
+def linkedin_callback():
+    code = request.args.get('code')
+    if not code:
+        return "Error: No authorization code provided"
+    token_url = 'https://www.linkedin.com/oauth/v2/accessToken'
+
+    
+
+    data = {
+        'grant_type': 'authorization_code',
+        'code': code,
+        'redirect_uri': f'{ngrok_link}/linkedin/callback',
+        'client_id': LINKEDIN_CLIENT_ID,
+        'client_secret': LINKEDIN_CLIENT_SECRET
+    }
+    response = requests.post(token_url, data=data)
+    if response.status_code != 200:
+        return "Error: Could not get LinkedIn access token"
+    token_data = response.json()
+    session['linkedin_access_token'] = token_data.get('access_token')
+    profile_url = 'https://api.linkedin.com/v2/userinfo'
+    headers = {'Authorization': f'Bearer {session["linkedin_access_token"]}'}
+    profile_response = requests.get(profile_url, headers=headers)
+    
+
+    if profile_response.status_code != 200:
+        return "Error: Could not fetch LinkedIn profile"
+    user_info = profile_response.json()
+    session['linkedin_id'] = user_info.get('sub')
+    
+    print("here333333333",user_info)
+    session['linkedin_name'] = user_info['name']
+    if session.get('connect_all') and 'twitter_access_token' not in session:
+        return redirect(url_for('twitter_auth'))
+    return redirect(url_for('home'))
+
+@app.route('/twitter/auth')
+def twitter_auth():
+    auth = tweepy.OAuth1UserHandler(TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET, f'{ngrok_link}/twitter/callback')
+    try:
+        redirect_url = auth.get_authorization_url()
+        session['request_token'] = auth.request_token
+        return redirect(redirect_url)
+    except tweepy.TweepyException as e:
+        return f"Error starting Twitter auth: {e}"
+
+# @app.route('/twitter/callback')
+# def twitter_callback():
+#     request_token = session.pop('request_token', None)
+#     if not request_token:
+#         return "Error: Request token not found in session. <a href='/twitter/auth'>Please try logging in again</a>."
+#     verifier = request.args.get('oauth_verifier')
+#     if not verifier:
+#         return "Error: No OAuth verifier provided"
+#     auth = tweepy.OAuth1UserHandler(TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET)
+#     auth.request_token = request_token
+#     try:
+#         auth.get_access_token(verifier)
+#         session['twitter_access_token'] = auth.access_token
+#         session['twitter_access_token_secret'] = auth.access_token_secret
+#         session.pop('connect_all', None)
+#         return redirect(url_for('home'))
+#     except tweepy.TweepyException as e:
+#         return f"Twitter authorization failed: {e}"
+
+
+
+
+#==============   Additional ============#######
+
+
+@app.route('/twitter/callback')
+def twitter_callback():
+    request_token = session.pop('request_token', None)
+    if not request_token:
+        return "Error: Request token not found in session. <a href='/twitter/auth'>Please try logging in again</a>."
+    
+    verifier = request.args.get('oauth_verifier')
+    if not verifier:
+        return "Error: No OAuth verifier provided"
+    
+    auth = tweepy.OAuth1UserHandler(TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET)
+    auth.request_token = request_token
+    
+    try:
+        auth.get_access_token(verifier)
+        session['twitter_access_token'] = auth.access_token
+        print("@@@@@@@@@@@@@@",auth.access_token)
+
+        access_token = auth.access_token
+
+        # Path to your existing JSON file
+        json_file_path = "access.json"
+
+        # Load the existing data
+        try:
+            with open(json_file_path, "r") as f:
+                data = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            data = {}
+        # Store or update the access_token
+        data["access_token"] = access_token
+
+        # Write it back to the file
+        with open(json_file_path, "w") as f:
+            json.dump(data, f, indent=4)
+
+
+        session['twitter_access_token_secret'] = auth.access_token_secret
+
+        #Set the access tokens to the auth handler
+        auth.set_access_token(auth.access_token, auth.access_token_secret)
+        api = tweepy.API(auth)
+
+        #Get user info
+        user = api.verify_credentials()
+        if user:
+            session['twitter_name'] = user.name  # Full display name (e.g., "John Doe")
+            session['twitter_username'] = user.screen_name  # Handle (e.g., "johndoe")
+        
+        session.pop('connect_all', None)
+        return redirect(url_for('home'))
+
+    except tweepy.TweepyException as e:
+        return f"Twitter authorization failed: {e}"
+
+
+
+@app.route('/disconnect/<platform>')
+def disconnect(platform):
+    if platform == 'linkedin':
+
+        print("access",session["linkedin_access_token"])
+        session.pop('linkedin_access_token', None)
+        # print("sssss",session["linkedin_access_token"])
+
+        # session.pop('linkedin_access_token', None)
+        session.pop('linkedin_id', None)
+    elif platform == 'twitter':
+        session.pop('twitter_access_token', None)
+        session.pop('twitter_access_token_secret', None)
+    return redirect(url_for('home'))
+
+@app.route('/post', methods=['GET', 'POST'])
+def create_post():
+    if not (session.get('linkedin_access_token') or session.get('twitter_access_token')):
+        return redirect(url_for('home'))
+    
+    if request.method == 'POST':
+        rss_urls = request.form.getlist('rss_urls')
+        posts_per_day = int(request.form['posts_per_day'])
+        frequency = request.form['frequency']
+        schedule_type = request.form['schedule_type']
+        first_post_time = datetime.strptime(request.form['first_post_time'], '%Y-%m-%dT%H:%M')
+
+        if schedule_type == 'daily':
+            total_posts = posts_per_day
+        elif schedule_type == 'weekly':
+            total_posts = posts_per_day * 7
+        else:  # monthly
+            total_posts = posts_per_day * 30
+
+        all_entries = []
+        for rss_url in rss_urls:
+            feed = feedparser.parse(rss_url)
+            all_entries.extend(feed.entries)
+        
+        selected_entries = random.sample(all_entries, min(total_posts, len(all_entries)))
+
+        # selected_entries = sorted(
+        #         all_entries,
+        #         key=lambda entry: entry.published_parsed,
+        #         reverse=False
+        #     )[:total_posts]
+
+        
+        # selected_entries = sorted(
+        #         all_entries,
+        #         key=lambda entry: entry.published_parsed,
+        #         reverse=False
+        #     )[-3:]
+
+
+        generated_posts = {'linkedin': [], 'twitter': []}
+        if session.get('linkedin_access_token'):
+            for entry in selected_entries:
+                title = entry.title
+                description = entry.get('description', entry.get('summary', ''))
+                print("desc",description)
+                print(type(description))
+                image_url = extract_image_url(entry)
+                print("img_url",image_url)
+                if image_url == None:
+                    print("here44444")
+                    image_url = "https://static.libsyn.com/p/assets/0/2/1/3/0213c7d9616b570b16c3140a3186d450/LOGO_1400x1400.jpg"
+                transformed = agents.linkedin_transform(title, description)
+                
+                text = f"{transformed['new_title']} {transformed['new_description']}"
+                generated_posts['linkedin'].append({
+                    'text': text,
+                    'image_url': image_url,
+                    'platform': 'linkedin',
+                    'access_token': session['linkedin_access_token'],
+                    'linkedin_id': session['linkedin_id'],
+                    'status': 'pending'
+                })
+        if session.get('twitter_access_token'):
+            for entry in selected_entries:
+                title = entry.title
+                description = entry.get('description', entry.get('summary', ''))
+                image_url = extract_image_url(entry)
+                print("desc",description)
+                print(type(description))
+                print("img_url",image_url)
+                if image_url == None:
+                    print("here44444")
+                    image_url = "https://static.libsyn.com/p/assets/0/2/1/3/0213c7d9616b570b16c3140a3186d450/LOGO_1400x1400.jpg"
+                
+                
+                transformed = agents.twitter_transform(title, description)
+                text = f"{transformed['new_title']} {transformed['new_description']}"
+                
+                
+                generated_posts['twitter'].append({
+                    'text': text,
+                    'image_url': image_url,
+                    'platform': 'twitter',
+                    'access_token': session['twitter_access_token'],
+                    'access_token_secret': session['twitter_access_token_secret'],
+                    'status': 'pending'
+                })
+        
+        post_id = str(uuid.uuid4())
+        temp_posts[post_id] = {
+            'posts': generated_posts,
+            'first_post_time': first_post_time,
+            'frequency': int(frequency)
+        }
+        return redirect(url_for('review_posts', post_id=post_id))
+    
+    return render_template('post.html')
+
+@app.route('/review/<post_id>', methods=['GET', 'POST'])
+def review_posts(post_id):
+    if post_id not in temp_posts:
+        return redirect(url_for('create_post'))
+    
+    post_data = temp_posts[post_id]
+    all_posts = []
+    for platform_posts in post_data['posts'].values():
+        all_posts.extend(platform_posts)
+    
+    if request.method == 'POST':
+        first_post_time = post_data['first_post_time']
+        frequency = post_data['frequency']
+        
+        # Schedule posts separately for each platform
+        for platform, platform_posts in post_data['posts'].items():
+            for i, post in enumerate(platform_posts):
+                scheduled_time = first_post_time + timedelta(minutes=frequency * i)
+                post['scheduled_time'] = scheduled_time
+                posts.append(post)
+                if platform == 'linkedin':
+                    scheduler.add_job(post_to_linkedin, 'date', run_date=scheduled_time, args=[post])
+                elif platform == 'twitter':
+                    scheduler.add_job(post_to_twitter, 'date', run_date=scheduled_time, args=[post])
+        
+        del temp_posts[post_id]
+        return redirect(url_for('scheduled_posts'))
+    
+    return render_template('review.html', 
+                         posts=all_posts,
+                         first_post_time=post_data['first_post_time'].isoformat(),
+                         frequency=post_data['frequency'])
+
+@app.route('/scheduled')
+def scheduled_posts():
+    linkedin_posts = [p for p in posts if p['platform'] == 'linkedin' and p['status'] == 'pending']
+    twitter_posts = [p for p in posts if p['platform'] == 'twitter' and p['status'] == 'pending']
+    return render_template('scheduled.html', linkedin_posts=linkedin_posts, twitter_posts=twitter_posts)
+
+
+
+
+
+def scheduled_task():
+    print(f"Scheduled task ran at: {datetime.now()}")
+    print("eeeeeewwwww",session.get('twitter_access_token'))
+    try:
+
+        json_file_path = 'access.json'
+        if os.path.exists(json_file_path) and os.path.getsize(json_file_path) > 0:
+    # Load existing JSON data
+            with open(json_file_path, "r") as f:
+                data = json.load(f)
+
+            # Save or update the access token
+            access_token = data["access_token"]
+
+            print("Access token saved.")
+
+
+
+            rss_url = "https://feeds.libsyn.com/123267/rss"
+            feed = feedparser.parse(rss_url)
+            print("Podcast Title:", feed.feed.title)
+            print("Podcast Link:", feed.feed.link)
+            print("Description:", feed.feed.get("description", "No description available."))
+
+            # Print latest episode info
+            print("\nLatest Episode:")
+            latest = feed.entries[0]
+            print("Title:", latest.title)
+            print("Published:", latest.published)
+            print("Link:", latest.link)
+            print("Description:", latest.description)
+
+       
+            
+        else:
+            print("login to linkedin")
+
+
+    except:
+        print("not")
+
+@app.route('/ping-api')
+def ping_api():
+    print("📡 Ping API endpoint hit!")
+    json_file_path = 'access.json'
+    if os.path.exists(json_file_path) and os.path.getsize(json_file_path) > 0:
+# Load existing JSON data
+        with open(json_file_path, "r") as f:
+            data = json.load(f)
+
+        # Save or update the access token
+        access_token = data["access_token"]
+
+        print("Access token saved.")
+
+
+
+        rss_url = "https://feeds.libsyn.com/123267/rss"
+        feed = feedparser.parse(rss_url)
+        print("Podcast Title:", feed.feed.title)
+        print("Podcast Link:", feed.feed.link)
+        print("Description:", feed.feed.get("description", "No description available."))
+
+        # Print latest episode info
+        print("\nLatest Episode:")
+        latest = feed.entries[0]
+        print("Title:", latest.title)
+        print("Published:", latest.published)
+
+        if latest.published:
+            json_file_path = "latest.json"
+
+        # Load the existing data
+            try:
+                with open(json_file_path, "r") as f:
+                    data = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                data = {}
+        # Store or update the access_token
+        data["access_token"] = access_token
+
+        # Write it back to the file
+        with open(json_file_path, "w") as f:
+            json.dump(data, f, indent=4)
+        print("Link:", latest.link)
+        print("Description:", latest.description)
+
+    
+        
+    else:
+        print("login to linkedin")
+    s = {
+        'na':'yes'
+    }
+    return s
+
+def scheduled_task():
+    try:
+        response = requests.get("http://127.0.0.1:5000/ping-api")
+        print(f"[{datetime.now()}] Status: {response.status_code}, Response: {response.text}")
+    except requests.exceptions.RequestException as e:
+        print(f"[{datetime.now()}] Failed to call API: {e}")
+
+
+# ✅ Setup scheduler
+scheduler = BackgroundScheduler()
+scheduler.add_job(func=scheduled_task, trigger="interval", seconds=10)
+scheduler.start()
+
+# ✅ Clean up scheduler on shutdown
+atexit.register(lambda: scheduler.shutdown())
+
+
+
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 5000))  # Get the port from Render
+    app.run(debug=True, host='0.0.0.0', port=port)

helpers.py

@@ -0,0 +1,193 @@
+import re
+from io import BytesIO
+import requests
+import tweepy
+
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+LINKEDIN_CLIENT_ID = os.getenv("LINKEDIN_CLIENT_ID")
+LINKEDIN_CLIENT_SECRET = os.getenv("LINKEDIN_CLIENT_SECRET")
+TWITTER_CLIENT_ID = os.getenv("TWITTER_CLIENT_ID")
+TWITTER_CLIENT_SECRET = os.getenv("TWITTER_CLIENT_SECRET")
+
+def extract_image_url(entry):
+    """Extract an image URL from an RSS feed entry."""
+    for enclosure in entry.get('enclosures', []):
+        if enclosure.get('type', '').startswith('image/'):
+            return enclosure.get('url')
+    for media in entry.get('media_content', []):
+        if media.get('type', '').startswith('image/'):
+            return media.get('url')
+    for thumbnail in entry.get('media_thumbnail', []):
+        if thumbnail.get('url'):
+            return thumbnail.get('url')
+    if 'image' in entry:
+        image = entry['image']
+        if isinstance(image, dict) and 'url' in image:
+            return image['url']
+        elif isinstance(image, list):
+            for img in image:
+                if 'url' in img:
+                    return img['url']
+    if 'itunes_image' in entry:
+        return entry['itunes_image'].get('href')
+    for field in ['description', 'summary', 'content']:
+        if field in entry:
+            content = entry[field]
+            if isinstance(content, list):
+                content = content[0].get('value', '')
+            elif isinstance(content, dict):
+                content = content.get('value', '')
+            else:
+                content = str(content)
+            match = re.search(r'<img[^>]+src=["\'](.*?)["\']', content, re.I)
+            if match:
+                return match.group(1)
+    return None
+
+def post_to_linkedin(post):
+    """Post content to LinkedIn with optional image."""
+    if post['status'] not in ['pending', 'posting']:
+        return
+    access_token = post['access_token']
+
+
+    print("linkedin_access_token",access_token)
+    linkedin_id = post['linkedin_id']
+    image_url = post.get('image_url')
+    headers = {
+        'Authorization': f'Bearer {access_token}',
+        'Content-Type': 'application/json',
+    }
+    if image_url:
+        response = requests.get(image_url, timeout=10)
+        if response.status_code == 200:
+            image_content = response.content
+            register_url = 'https://api.linkedin.com/v2/assets?action=registerUpload'
+            register_body = {
+                'registerUploadRequest': {
+                    'recipes': ['urn:li:digitalmediaRecipe:feedshare-image'],
+                    'owner': f'urn:li:person:{linkedin_id}',
+                    'serviceRelationships': [
+                        {'relationshipType': 'OWNER', 'identifier': 'urn:li:userGeneratedContent'}
+                    ]
+                }
+            }
+            register_response = requests.post(register_url, headers=headers, json=register_body)
+            if register_response.status_code == 200:
+                upload_data = register_response.json()['value']
+                upload_url = upload_data['uploadMechanism']['com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest']['uploadUrl']
+                asset = upload_data['asset']
+                upload_headers = {'Authorization': f'Bearer {access_token}'}
+                upload_response = requests.put(upload_url, headers=upload_headers, data=image_content)
+                if upload_response.status_code == 201:
+                    api_url = 'https://api.linkedin.com/v2/ugcPosts'
+                    post_body = {
+                        'author': f'urn:li:person:{linkedin_id}',
+                        'lifecycleState': 'PUBLISHED',
+                        'specificContent': {
+                            'com.linkedin.ugc.ShareContent': {
+                                'shareCommentary': {'text': post['text']},
+                                'shareMediaCategory': 'IMAGE',
+                                'media': [{'status': 'READY', 'media': asset}]
+                            }
+                        },
+                        'visibility': {'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'}
+                    }
+                    response = requests.post(api_url, headers=headers, json=post_body)
+                    post['status'] = 'posted' if response.status_code == 201 else 'failed'
+                    print(f"LinkedIn post attempt: {response.status_code} - {response.text}")
+                else:
+                    print(f"Image upload failed: {upload_response.status_code}")
+            else:
+                print(f"Upload registration failed: {register_response.status_code}")
+        else:
+            print(f"Image download failed: {response.status_code}")
+        if post['status'] != 'posted':
+            api_url = 'https://api.linkedin.com/v2/ugcPosts'
+            post_body = {
+                'author': f'urn:li:person:{linkedin_id}',
+                'lifecycleState': 'PUBLISHED',
+                'specificContent': {
+                    'com.linkedin.ugc.ShareContent': {
+                        'shareCommentary': {'text': post['text']},
+                        'shareMediaCategory': 'NONE'
+                    }
+                },
+                'visibility': {'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'}
+            }
+            response = requests.post(api_url, headers=headers, json=post_body)
+            post['status'] = 'posted' if response.status_code == 201 else 'failed'
+            print(f"LinkedIn text-only post: {response.status_code} - {response.text}")
+    else:
+        api_url = 'https://api.linkedin.com/v2/ugcPosts'
+        post_body = {
+            'author': f'urn:li:person:{linkedin_id}',
+            'lifecycleState': 'PUBLISHED',
+            'specificContent': {
+                'com.linkedin.ugc.ShareContent': {
+                    'shareCommentary': {'text': post['text']},
+                    'shareMediaCategory': 'NONE'
+                }
+            },
+            'visibility': {'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'}
+        }
+        response = requests.post(api_url, headers=headers, json=post_body)
+        post['status'] = 'posted' if response.status_code == 201 else 'failed'
+        print(f"LinkedIn post attempt: {response.status_code} - {response.text}")
+
+def post_to_twitter(post):
+    """Post content to Twitter with optional image."""
+    if post['status'] not in ['pending', 'posting']:
+        return
+    client = tweepy.Client(
+        consumer_key=TWITTER_CLIENT_ID,
+        consumer_secret=TWITTER_CLIENT_SECRET,
+        access_token=post['access_token'],
+        access_token_secret=post['access_token_secret']
+    )
+    print("access_token_secret",client.access_token_secret)
+    image_url = post.get('image_url')
+    if image_url:
+        response = requests.get(image_url, timeout=10)
+        if response.status_code == 200:
+            image_content = BytesIO(response.content)
+            try:
+                api = tweepy.API(tweepy.OAuth1UserHandler(
+                    TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET,
+                    post['access_token'], post['access_token_secret']
+                ))
+                media = api.media_upload(filename='image', file=image_content)
+                client.create_tweet(text=post['text'], media_ids=[media.media_id])
+                post['status'] = 'posted'
+                print("Twitter post with image successful")
+            except tweepy.TweepyException as e:
+                print(f"Twitter image post error: {e}")
+                try:
+                    client.create_tweet(text=post['text'])
+                    post['status'] = 'posted'
+                    print("Twitter text-only post successful")
+                except tweepy.TweepyException as e:
+                    post['status'] = 'failed'
+                    print(f"Twitter text-only error: {e}")
+            except Exception as e:
+                print(f"Media upload error: {e}")
+        else:
+            print(f"Image download failed: {response.status_code}")
+            try:
+                client.create_tweet(text=post['text'])
+                post['status'] = 'posted'
+                print("Twitter text-only post successful")
+            except tweepy.TweepyException as e:
+                post['status'] = 'failed'
+                print(f"Twitter text-only error: {e}")
+    else:
+        try:
+            client.create_tweet(text=post['text'])
+            post['status'] = 'posted'
+            print("Twitter post successful")
+        except tweepy.TweepyException as e:
+            post['status'] = 'failed'
+            print(f"Twitter error: {e}")

requirements.txt

@@ -0,0 +1,10 @@
+flask
+apscheduler
+requests
+tweepy
+feedparser
+langchain_google_genai
+langchain_core
+flask-session
+langchain
+python-dotenv

test2.py

@@ -0,0 +1,306 @@
+from flask import Flask, redirect, url_for, request, render_template, session
+from apscheduler.schedulers.background import BackgroundScheduler
+import requests
+from datetime import datetime, timedelta
+import tweepy
+from agents import SocialMediaAgents  # Assuming this is your agents.py file
+import feedparser
+from helpers import post_to_linkedin, post_to_twitter, extract_image_url
+import random
+import uuid
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+ngrok_link = os.getenv("Ngrok_Link")
+
+app = Flask(__name__)
+app.secret_key = '12345678765'  # Replace with a secure key
+
+scheduler = BackgroundScheduler()
+scheduler.start()
+
+api_key = os.getenv("Gemini_key")
+
+agents = SocialMediaAgents(api_key)
+
+LINKEDIN_CLIENT_ID = os.getenv("LINKEDIN_CLIENT_ID")
+LINKEDIN_CLIENT_SECRET = os.getenv("LINKEDIN_CLIENT_SECRET")
+TWITTER_CLIENT_ID = os.getenv("TWITTER_CLIENT_ID")
+TWITTER_CLIENT_SECRET = os.getenv("TWITTER_CLIENT_SECRET")
+
+posts = []
+temp_posts = {}
+
+@app.route('/')
+def home():
+    connected_platforms = {
+        'linkedin': 'linkedin_access_token' in session and 'linkedin_id' in session,
+        'twitter': 'twitter_access_token' in session and 'twitter_access_token_secret' in session
+    }
+
+    name ={
+        'name':session.get('linkedin_name'),
+        'tw_name':session.get('twitter_name')
+    }
+
+
+    return render_template('home.html', connected_platforms=connected_platforms,name=name)
+
+@app.route('/connect_all')
+def connect_all():
+    session['connect_all'] = True
+    return redirect(url_for('linkedin_auth'))
+
+@app.route('/linkedin/auth')
+def linkedin_auth():
+    redirect_uri = f'{ngrok_link}/linkedin/callback'
+    scope = 'openid profile w_member_social'
+    auth_url = (
+        f'https://www.linkedin.com/oauth/v2/authorization?'
+        f'response_type=code&client_id={LINKEDIN_CLIENT_ID}&redirect_uri={redirect_uri}&'
+        f'scope={scope}&state=randomstring'
+    )
+
+    print("auth------------",auth_url)
+    return redirect(auth_url)
+
+@app.route('/linkedin/callback')
+def linkedin_callback():
+    code = request.args.get('code')
+    if not code:
+        return "Error: No authorization code provided"
+    
+    print("code11111111",code)
+    token_url = 'https://www.linkedin.com/oauth/v2/accessToken'
+    data = {
+        'grant_type': 'authorization_code',
+        'code': code,
+        'redirect_uri': f'{ngrok_link}/linkedin/callback',
+        'client_id': LINKEDIN_CLIENT_ID,
+        'client_secret': LINKEDIN_CLIENT_SECRET
+    }
+    response = requests.post(token_url, data=data)
+    if response.status_code != 200:
+        return "Error: Could not get LinkedIn access token"
+    token_data = response.json()
+    session['linkedin_access_token'] = token_data.get('access_token')
+    profile_url = 'https://api.linkedin.com/v2/userinfo'
+    headers = {'Authorization': f'Bearer {session["linkedin_access_token"]}'}
+    profile_response = requests.get(profile_url, headers=headers)
+    if profile_response.status_code != 200:
+        return "Error: Could not fetch LinkedIn profile"
+    user_info = profile_response.json()
+
+    session['linkedin_name'] = user_info['name']
+    session['linkedin_id'] = user_info.get('sub')
+    
+    if session.get('connect_all') and 'twitter_access_token' not in session:
+        return redirect(url_for('twitter_auth'))
+    return redirect(url_for('home'))
+
+@app.route('/twitter/auth')
+def twitter_auth():
+    auth = tweepy.OAuth1UserHandler(TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET, f'{ngrok_link}/twitter/callback')
+    try:
+        redirect_url = auth.get_authorization_url()
+        session['request_token'] = auth.request_token
+        return redirect(redirect_url)
+    except tweepy.TweepyException as e:
+        return f"Error starting Twitter auth: {e}"
+
+@app.route('/twitter/callback')
+def twitter_callback():
+    request_token = session.pop('request_token', None)
+    if not request_token:
+        return "Error: Request token not found in session. <a href='/twitter/auth'>Please try logging in again</a>."
+    verifier = request.args.get('oauth_verifier')
+    if not verifier:
+        return "Error: No OAuth verifier provided"
+    auth = tweepy.OAuth1UserHandler(TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET)
+    auth.request_token = request_token
+    try:
+        auth.get_access_token(verifier)
+        session['twitter_access_token'] = auth.access_token
+        session['twitter_access_token_secret'] = auth.access_token_secret
+
+        print("twitter_session = 1",session.get('twitter_access_token'))
+        auth.set_access_token(auth.access_token, auth.access_token_secret)
+        api = tweepy.API(auth)
+
+        
+        user = api.verify_credentials()
+        if user:
+            session['twitter_name'] = user.name  
+            # session['twitter_username'] = user.screen_name
+
+
+        session.pop('connect_all', None)
+        return redirect(url_for('home'))
+    except tweepy.TweepyException as e:
+        return f"Twitter authorization failed: {e}"
+
+@app.route('/disconnect/<platform>')
+def disconnect(platform):
+    if platform == 'linkedin':
+        session.pop('linkedin_access_token', None)
+        session.pop('linkedin_id', None)
+    elif platform == 'twitter':
+        session.pop('twitter_access_token', None)
+        session.pop('twitter_access_token_secret', None)
+    return redirect(url_for('home'))
+
+@app.route('/post', methods=['GET', 'POST'])
+def create_post():
+    if not (session.get('linkedin_access_token') or session.get('twitter_access_token')):
+        return redirect(url_for('home'))
+    
+    if request.method == 'POST':
+        rss_urls = request.form.getlist('rss_urls')
+        posts_per_day = int(request.form['posts_per_day'])
+        frequency = request.form['frequency']
+        schedule_type = request.form['schedule_type']
+        first_post_time = datetime.strptime(request.form['first_post_time'], '%Y-%m-%dT%H:%M')
+
+        if schedule_type == 'daily':
+            total_posts = posts_per_day
+        elif schedule_type == 'weekly':
+            total_posts = posts_per_day * 7
+        else:  # monthly
+            total_posts = posts_per_day * 30
+
+        all_entries = []
+        for rss_url in rss_urls:
+            feed = feedparser.parse(rss_url)
+            all_entries.extend(feed.entries)
+        
+        selected_entries = random.sample(all_entries, min(total_posts, len(all_entries)))
+
+        # selected_entries = sorted(
+        #         all_entries,
+        #         key=lambda entry: entry.published_parsed,
+        #         reverse=False
+        #     )[:total_posts]
+
+        
+        # selected_entries = sorted(
+        #         all_entries,
+        #         key=lambda entry: entry.published_parsed,
+        #         reverse=False
+        #     )[-3:]
+
+
+        generated_posts = {'linkedin': [], 'twitter': []}
+        if session.get('linkedin_access_token'):
+            for entry in selected_entries:
+                title = entry.title
+                description = entry.get('description', entry.get('summary', ''))
+                print("desc",description)
+                print(type(description))
+                image_url = extract_image_url(entry)
+                print("img_url",image_url)
+                link = entry.get('link', '')
+                if image_url == None:
+                    print("here44444")
+                    image_url = "https://static.libsyn.com/p/assets/0/2/1/3/0213c7d9616b570b16c3140a3186d450/LOGO_1400x1400.jpg"
+                transformed = agents.linkedin_transform(title, description,link)
+                
+                text = f"{transformed['new_title']} {transformed['new_description']}"
+                generated_posts['linkedin'].append({
+                    'text': text,
+                    'image_url': image_url,
+                    'platform': 'linkedin',
+                    'access_token': session['linkedin_access_token'],
+                    'linkedin_id': session['linkedin_id'],
+                    'status': 'pending'
+                })
+        if session.get('twitter_access_token'):
+            print("twitter_session = 2",session.get('twitter_access_token'))
+            for entry in selected_entries:
+                title = entry.title
+                description = entry.get('description', entry.get('summary', ''))
+                image_url = extract_image_url(entry)
+                print("desc",description)
+                print(type(description))
+                print("img_url",image_url)
+                link = entry.get('link', '')
+                if image_url == None:
+                    print("here44444")
+                    image_url = "https://static.libsyn.com/p/assets/0/2/1/3/0213c7d9616b570b16c3140a3186d450/LOGO_1400x1400.jpg"
+                
+                
+                transformed = agents.twitter_transform(title, description,link)
+                text = f"{transformed['new_title']} {transformed['new_description']}"
+                
+                
+                generated_posts['twitter'].append({
+                    'text': text,
+                    'image_url': image_url,
+                    'platform': 'twitter',
+                    'access_token': session['twitter_access_token'],
+                    'access_token_secret': session['twitter_access_token_secret'],
+                    'status': 'pending'
+                })
+        
+        post_id = str(uuid.uuid4())
+        temp_posts[post_id] = {
+            'posts': generated_posts,
+            'first_post_time': first_post_time,
+            'frequency': int(frequency)
+        }
+        return redirect(url_for('review_posts', post_id=post_id))
+    
+    return render_template('post.html')
+
+@app.route('/review/<post_id>', methods=['GET', 'POST'])
+def review_posts(post_id):
+    if post_id not in temp_posts:
+        return redirect(url_for('create_post'))
+    
+    now = datetime.now()
+
+    current_time = now.strftime("%H:%M:%S")
+    print("Current Time =", current_time)
+   
+    post_data = temp_posts[post_id]
+    all_posts = []
+    for platform_posts in post_data['posts'].values():
+        all_posts.extend(platform_posts)
+    
+    if request.method == 'POST':
+        first_post_time = post_data['first_post_time']
+        frequency = post_data['frequency']
+        
+        # Schedule posts separately for each platform
+        for platform, platform_posts in post_data['posts'].items():
+            for i, post in enumerate(platform_posts):
+                scheduled_time = first_post_time + timedelta(minutes=frequency * i)
+                post['scheduled_time'] = scheduled_time
+                posts.append(post)
+                if platform == 'linkedin':
+                    scheduler.add_job(post_to_linkedin, 'date', run_date=scheduled_time, args=[post])
+                elif platform == 'twitter':
+                    
+                    print("pooooooooossssssssssssttttttt",post)
+                    scheduler.add_job(post_to_twitter, 'date', run_date=scheduled_time, args=[post])
+                    now = datetime.now()
+                    current_time = now.strftime("%H:%M:%S")
+                    print("end Time =", current_time)
+        del temp_posts[post_id]
+        return redirect(url_for('scheduled_posts'))
+    
+    return render_template('review.html', 
+                         posts=all_posts,
+                         first_post_time=post_data['first_post_time'].isoformat(),
+                         frequency=post_data['frequency'])
+
+@app.route('/scheduled')
+def scheduled_posts():
+    linkedin_posts = [p for p in posts if p['platform'] == 'linkedin' and p['status'] == 'pending']
+    twitter_posts = [p for p in posts if p['platform'] == 'twitter' and p['status'] == 'pending']
+    return render_template('scheduled.html', linkedin_posts=linkedin_posts, twitter_posts=twitter_posts)
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 5000))  # Get the port from Render
+    app.run(debug=True, host='0.0.0.0', port=port)