├── src
    ├── __init__.py
    ├── instantly-tweet-from-openai.py
    ├── tweeter-from-code.py
    ├── tweeter-random-from-file.py
    ├── schedule-daily-post-from-openai.py
    ├── schedule-daily-post-from-file.py
    └── functions.py
├── requirements.txt
├── data
    └── tweets.txt
├── config
    └── keys.py
├── LICENSE
├── templates
    ├── index.html
    ├── base.html
    ├── manage_tweets.html
    ├── post.html
    └── schedule.html
├── README.md
├── cli.py
└── web.py


/src/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | tweepy
2 | schedule
3 | openai
4 | click
5 | flask


--------------------------------------------------------------------------------
/data/tweets.txt:
--------------------------------------------------------------------------------
1 | Here is a tweet 1
2 | here is a different tweet
3 | tweeet tweeet blah blah
4 | 


--------------------------------------------------------------------------------
/config/keys.py:
--------------------------------------------------------------------------------
1 | bearer_token = "GET_KEY_FROM_developer.twitter.com/apps"
2 | api_key = "GET_KEY_FROM_developer.twitter.com/apps"
3 | api_secret = "GET_KEY_FROM_developer.twitter.com/apps"
4 | access_token = "GET_KEY_FROM_developer.twitter.com/apps"
5 | access_token_secret = "GET_KEY_FROM_developer.twitter.com/apps"
6 | openai_key = "GET_YOUR_OPENAI_API_KEY_FROM_https://platform.openai.com/api-keys"
7 | 


--------------------------------------------------------------------------------
/src/instantly-tweet-from-openai.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'config'))
 4 | import keys
 5 | from functions import generate_response, initialize_tweepy, get_formatted_date
 6 | 
 7 | prompt = "Create a short tweet about Motorbikes."
 8 | response = generate_response(prompt)
 9 | 
10 | def send_post():
11 |     client, _ = initialize_tweepy()
12 |     tweet_text = f"{response}"
13 |     client.create_tweet(text=tweet_text)
14 |     print("Tweet posted successfully")
15 | 
16 | send_post()
17 | 


--------------------------------------------------------------------------------
/src/tweeter-from-code.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | 
 4 | sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'config'))
 5 | import keys
 6 | sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 7 | from functions import initialize_tweepy, get_formatted_date
 8 | 
 9 | def send_post():
10 |     client, _ = initialize_tweepy()
11 |     formatted_date = get_formatted_date()
12 | 
13 |     client.create_tweet(text=f"Hello Python 🐍. It is {formatted_date} today!🚀🚀.")
14 |     print("Tweet posted successfully")
15 | 
16 | send_post()
17 | 


--------------------------------------------------------------------------------
/src/tweeter-random-from-file.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | import random
 4 | 
 5 | sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'config'))
 6 | import keys
 7 | sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 8 | from functions import initialize_tweepy
 9 | 
10 | def send_post():
11 |     client, _ = initialize_tweepy()
12 |     
13 |     with open(os.path.join(os.path.dirname(__file__), '..', 'data', 'tweets.txt'), 'r') as file:
14 |         lines = file.readlines()
15 |     tweet_text = random.choice(lines).strip()
16 |     client.create_tweet(text=f"{tweet_text}")
17 | 
18 |     print("Tweet posted successfully")
19 | 
20 | send_post()
21 | 


--------------------------------------------------------------------------------
/src/schedule-daily-post-from-openai.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | import schedule
 4 | import time
 5 | import random
 6 | 
 7 | sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'config'))
 8 | import keys
 9 | from functions import generate_response, initialize_tweepy, get_formatted_date
10 | 
11 | def send_post():
12 |     prompt = "Create a short tweet about Motorbikes."
13 |     response = generate_response(prompt)
14 | 
15 |     client, _ = initialize_tweepy()
16 |     tweet_text = f"{response}"
17 |     client.create_tweet(text=tweet_text)
18 |     print("Tweet posted successfully")
19 |     
20 | schedule.every().day.at("09:00").do(send_post)
21 | 
22 | while True:
23 |     schedule.run_pending()
24 |     time.sleep(60)
25 | 


--------------------------------------------------------------------------------
/src/schedule-daily-post-from-file.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | import random
 4 | import schedule
 5 | import time
 6 | 
 7 | sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'config'))
 8 | import keys
 9 | sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
10 | from functions import initialize_tweepy, get_formatted_date
11 | 
12 | def send_post():
13 |     client, _ = initialize_tweepy()
14 |     
15 |     with open(os.path.join(os.path.dirname(__file__), '..', 'data', 'tweets.txt'), 'r') as file:
16 |         lines = file.readlines()
17 |     tweet_text = random.choice(lines).strip()
18 |     client.create_tweet(text=f"{tweet_text}")
19 | 
20 |     print("Tweet posted successfully")
21 | 
22 | schedule.every().day.at("09:00").do(send_post)
23 | 
24 | while True:
25 |     schedule.run_pending()
26 |     time.sleep(60)
27 | 


--------------------------------------------------------------------------------
/src/functions.py:
--------------------------------------------------------------------------------
 1 | import tweepy
 2 | import datetime
 3 | import sys
 4 | from openai import OpenAI
 5 | sys.path.append('../config')
 6 | import keys  
 7 | 
 8 | 
 9 | def initialize_tweepy():
10 |     client = tweepy.Client(keys.bearer_token, keys.api_key, keys.api_secret, keys.access_token, keys.access_token_secret)
11 |     auth = tweepy.OAuthHandler(keys.api_key, keys.api_secret, keys.access_token, keys.access_token_secret)
12 |     api = tweepy.API(auth)
13 |     return client, api
14 | 
15 | def get_formatted_date():
16 |     current_date = datetime.date.today()
17 |     return current_date.strftime("%B %d, %Y")
18 | 
19 | def generate_response(prompt):
20 |     client = OpenAI(api_key=keys.openai_key)
21 |     model = "gpt-5-nano"
22 |     messages = [
23 |         {"role": "system", "content": "You are a helpful assistant."},
24 |         {"role": "user", "content": prompt}
25 |     ]
26 | 
27 |     response = client.chat.completions.create(
28 |         model=model,
29 |         messages=messages,
30 |         temperature=0
31 |     )
32 | 
33 |     response_message = response.choices[0].message.content
34 |     return response_message.strip()


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Lewis Pour
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/templates/index.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block title %}Dashboard - Twitter Bot{% endblock %}
  4 | 
  5 | {% block content %}
  6 | <div class="row">
  7 |     <div class="col-12">
  8 |         <h1 class="mb-4">
  9 |             <i class="bi bi-speedometer2"></i> Dashboard
 10 |         </h1>
 11 |     </div>
 12 | </div>
 13 | 
 14 | <div class="row g-4">
 15 |     <!-- Status Card -->
 16 |     <div class="col-md-6 col-lg-4">
 17 |         <div class="card">
 18 |             <div class="card-header">
 19 |                 <i class="bi bi-info-circle"></i> Bot Status
 20 |             </div>
 21 |             <div class="card-body">
 22 |                 <div class="mb-3">
 23 |                     <strong>Scheduler:</strong>
 24 |                     {% if scheduler_running %}
 25 |                         <span class="status-badge status-running">
 26 |                             <i class="bi bi-check-circle"></i> Running
 27 |                         </span>
 28 |                     {% else %}
 29 |                         <span class="status-badge status-stopped">
 30 |                             <i class="bi bi-x-circle"></i> Stopped
 31 |                         </span>
 32 |                     {% endif %}
 33 |                 </div>
 34 | 
 35 |                 {% if scheduled_jobs %}
 36 |                 <div class="mt-3">
 37 |                     <strong>Active Jobs:</strong>
 38 |                     <ul class="list-unstyled mt-2">
 39 |                         {% for job in scheduled_jobs %}
 40 |                         <li class="mb-2">
 41 |                             <i class="bi bi-clock"></i> {{ job.time }} - {{ job.type }}
 42 |                         </li>
 43 |                         {% endfor %}
 44 |                     </ul>
 45 |                 </div>
 46 |                 {% endif %}
 47 |             </div>
 48 |         </div>
 49 |     </div>
 50 | 
 51 |     <!-- Credentials Test Card -->
 52 |     <div class="col-md-6 col-lg-4">
 53 |         <div class="card">
 54 |             <div class="card-header">
 55 |                 <i class="bi bi-shield-check"></i> Test Credentials
 56 |             </div>
 57 |             <div class="card-body">
 58 |                 <p>Verify your Twitter API credentials are working correctly.</p>
 59 |                 <button class="btn btn-primary w-100" onclick="testCredentials()">
 60 |                     <i class="bi bi-check-circle"></i> Test Now
 61 |                 </button>
 62 |                 <div id="credentialsResult" class="mt-3"></div>
 63 |             </div>
 64 |         </div>
 65 |     </div>
 66 | 
 67 |     <!-- Quick Actions Card -->
 68 |     <div class="col-md-12 col-lg-4">
 69 |         <div class="card">
 70 |             <div class="card-header">
 71 |                 <i class="bi bi-lightning"></i> Quick Actions
 72 |             </div>
 73 |             <div class="card-body">
 74 |                 <div class="d-grid gap-2">
 75 |                     <a href="/post" class="btn btn-primary">
 76 |                         <i class="bi bi-send"></i> Post a Tweet
 77 |                     </a>
 78 |                     <a href="/manage-tweets" class="btn btn-outline-primary">
 79 |                         <i class="bi bi-list-ul"></i> Manage Tweets
 80 |                     </a>
 81 |                     <a href="/schedule" class="btn btn-outline-primary">
 82 |                         <i class="bi bi-calendar-check"></i> Schedule Posts
 83 |                     </a>
 84 |                 </div>
 85 |             </div>
 86 |         </div>
 87 |     </div>
 88 | </div>
 89 | 
 90 | <!-- Features Overview -->
 91 | <div class="row mt-4">
 92 |     <div class="col-12">
 93 |         <div class="card">
 94 |             <div class="card-header">
 95 |                 <i class="bi bi-star"></i> Features
 96 |             </div>
 97 |             <div class="card-body">
 98 |                 <div class="row">
 99 |                     <div class="col-md-4 mb-3">
100 |                         <h5><i class="bi bi-robot"></i> AI-Powered Tweets</h5>
101 |                         <p class="text-muted">Generate tweets using OpenAI's GPT-5-nano with custom prompts.</p>
102 |                     </div>
103 |                     <div class="col-md-4 mb-3">
104 |                         <h5><i class="bi bi-file-text"></i> Tweet Library</h5>
105 |                         <p class="text-muted">Manage a library of pre-written tweets and post them randomly.</p>
106 |                     </div>
107 |                     <div class="col-md-4 mb-3">
108 |                         <h5><i class="bi bi-calendar-event"></i> Scheduling</h5>
109 |                         <p class="text-muted">Schedule daily tweets to run automatically at specific times.</p>
110 |                     </div>
111 |                 </div>
112 |             </div>
113 |         </div>
114 |     </div>
115 | </div>
116 | 
117 | {% endblock %}
118 | 
119 | {% block extra_js %}
120 | <script>
121 |     async function testCredentials() {
122 |         const resultDiv = document.getElementById('credentialsResult');
123 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Testing...';
124 | 
125 |         try {
126 |             const response = await fetch('/test-credentials', {
127 |                 method: 'POST'
128 |             });
129 | 
130 |             const data = await response.json();
131 | 
132 |             if (data.success) {
133 |                 resultDiv.innerHTML = `
134 |                     <div class="alert alert-success mb-0">
135 |                         <strong>Success!</strong><br>
136 |                         <small>
137 |                             <i class="bi bi-person"></i> @${data.data.username}<br>
138 |                             <i class="bi bi-people"></i> ${data.data.followers} followers<br>
139 |                             <i class="bi bi-person-check"></i> ${data.data.following} following
140 |                         </small>
141 |                     </div>
142 |                 `;
143 |             } else {
144 |                 resultDiv.innerHTML = `
145 |                     <div class="alert alert-danger mb-0">
146 |                         <strong>Error!</strong><br>
147 |                         <small>${data.error}</small>
148 |                     </div>
149 |                 `;
150 |             }
151 |         } catch (error) {
152 |             resultDiv.innerHTML = `
153 |                 <div class="alert alert-danger mb-0">
154 |                     <strong>Error!</strong><br>
155 |                     <small>${error.message}</small>
156 |                 </div>
157 |             `;
158 |         }
159 |     }
160 | 
161 |     // Auto-refresh scheduler status every 10 seconds
162 |     setInterval(async () => {
163 |         try {
164 |             const response = await fetch('/scheduler-status');
165 |             const data = await response.json();
166 |             // Update UI if needed
167 |             // This could be enhanced to update the status badge dynamically
168 |         } catch (error) {
169 |             console.error('Error fetching scheduler status:', error);
170 |         }
171 |     }, 10000);
172 | </script>
173 | {% endblock %}
174 | 


--------------------------------------------------------------------------------
/templates/base.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>{% block title %}Twitter Auto-Post Bot{% endblock %}</title>
  7 |     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
  8 |     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.0/font/bootstrap-icons.css">
  9 |     <style>
 10 |         :root {
 11 |             --twitter-blue: #1DA1F2;
 12 |             --twitter-dark: #14171A;
 13 |             --twitter-gray: #657786;
 14 |         }
 15 | 
 16 |         body {
 17 |             background-color: #f8f9fa;
 18 |         }
 19 | 
 20 |         .navbar {
 21 |             background: linear-gradient(135deg, var(--twitter-blue) 0%, #0d8bd9 100%);
 22 |             box-shadow: 0 2px 4px rgba(0,0,0,0.1);
 23 |         }
 24 | 
 25 |         .navbar-brand {
 26 |             font-weight: bold;
 27 |             color: white !important;
 28 |         }
 29 | 
 30 |         .nav-link {
 31 |             color: rgba(255,255,255,0.9) !important;
 32 |             transition: color 0.3s;
 33 |         }
 34 | 
 35 |         .nav-link:hover {
 36 |             color: white !important;
 37 |         }
 38 | 
 39 |         .nav-link.active {
 40 |             color: white !important;
 41 |             font-weight: 600;
 42 |         }
 43 | 
 44 |         .card {
 45 |             border: none;
 46 |             border-radius: 10px;
 47 |             box-shadow: 0 2px 8px rgba(0,0,0,0.08);
 48 |             transition: transform 0.2s, box-shadow 0.2s;
 49 |         }
 50 | 
 51 |         .card:hover {
 52 |             transform: translateY(-2px);
 53 |             box-shadow: 0 4px 12px rgba(0,0,0,0.12);
 54 |         }
 55 | 
 56 |         .card-header {
 57 |             background: linear-gradient(135deg, var(--twitter-blue) 0%, #0d8bd9 100%);
 58 |             color: white;
 59 |             font-weight: 600;
 60 |             border: none;
 61 |             border-radius: 10px 10px 0 0 !important;
 62 |         }
 63 | 
 64 |         .btn-primary {
 65 |             background: var(--twitter-blue);
 66 |             border: none;
 67 |             transition: background 0.3s, transform 0.1s;
 68 |         }
 69 | 
 70 |         .btn-primary:hover {
 71 |             background: #0d8bd9;
 72 |             transform: translateY(-1px);
 73 |         }
 74 | 
 75 |         .btn-primary:active {
 76 |             transform: translateY(0);
 77 |         }
 78 | 
 79 |         .tweet-box {
 80 |             border: 2px solid #e1e8ed;
 81 |             border-radius: 10px;
 82 |             padding: 15px;
 83 |             margin-bottom: 15px;
 84 |             background: white;
 85 |         }
 86 | 
 87 |         .alert {
 88 |             border-radius: 10px;
 89 |             border: none;
 90 |         }
 91 | 
 92 |         .form-control:focus {
 93 |             border-color: var(--twitter-blue);
 94 |             box-shadow: 0 0 0 0.2rem rgba(29, 161, 242, 0.25);
 95 |         }
 96 | 
 97 |         .footer {
 98 |             margin-top: 50px;
 99 |             padding: 20px 0;
100 |             background-color: white;
101 |             border-top: 1px solid #e1e8ed;
102 |         }
103 | 
104 |         .status-badge {
105 |             display: inline-block;
106 |             padding: 5px 12px;
107 |             border-radius: 20px;
108 |             font-size: 0.85rem;
109 |             font-weight: 600;
110 |         }
111 | 
112 |         .status-running {
113 |             background-color: #d4edda;
114 |             color: #155724;
115 |         }
116 | 
117 |         .status-stopped {
118 |             background-color: #f8d7da;
119 |             color: #721c24;
120 |         }
121 |     </style>
122 |     {% block extra_css %}{% endblock %}
123 | </head>
124 | <body>
125 |     <nav class="navbar navbar-expand-lg navbar-dark">
126 |         <div class="container">
127 |             <a class="navbar-brand" href="/">
128 |                 <i class="bi bi-twitter"></i> Twitter Bot Manager
129 |             </a>
130 |             <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
131 |                 <span class="navbar-toggler-icon"></span>
132 |             </button>
133 |             <div class="collapse navbar-collapse" id="navbarNav">
134 |                 <ul class="navbar-nav ms-auto">
135 |                     <li class="nav-item">
136 |                         <a class="nav-link {% if request.path == '/' %}active{% endif %}" href="/">
137 |                             <i class="bi bi-house-door"></i> Dashboard
138 |                         </a>
139 |                     </li>
140 |                     <li class="nav-item">
141 |                         <a class="nav-link {% if request.path == '/post' %}active{% endif %}" href="/post">
142 |                             <i class="bi bi-send"></i> Post Tweet
143 |                         </a>
144 |                     </li>
145 |                     <li class="nav-item">
146 |                         <a class="nav-link {% if request.path == '/manage-tweets' %}active{% endif %}" href="/manage-tweets">
147 |                             <i class="bi bi-list-ul"></i> Manage Tweets
148 |                         </a>
149 |                     </li>
150 |                     <li class="nav-item">
151 |                         <a class="nav-link {% if request.path == '/schedule' %}active{% endif %}" href="/schedule">
152 |                             <i class="bi bi-calendar-check"></i> Schedule
153 |                         </a>
154 |                     </li>
155 |                 </ul>
156 |             </div>
157 |         </div>
158 |     </nav>
159 | 
160 |     <main class="container my-4">
161 |         {% with messages = get_flashed_messages(with_categories=true) %}
162 |             {% if messages %}
163 |                 {% for category, message in messages %}
164 |                     <div class="alert alert-{{ category }} alert-dismissible fade show" role="alert">
165 |                         {{ message }}
166 |                         <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
167 |                     </div>
168 |                 {% endfor %}
169 |             {% endif %}
170 |         {% endwith %}
171 | 
172 |         {% block content %}{% endblock %}
173 |     </main>
174 | 
175 |     <footer class="footer">
176 |         <div class="container text-center text-muted">
177 |             <p class="mb-0">
178 |                 <i class="bi bi-twitter"></i> Twitter Auto-Post Bot |
179 |                 <a href="https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot" target="_blank" class="text-decoration-none">
180 |                     <i class="bi bi-github"></i> GitHub
181 |                 </a>
182 |             </p>
183 |         </div>
184 |     </footer>
185 | 
186 |     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
187 |     <script>
188 |         // Helper function to show toast notifications
189 |         function showToast(message, type = 'info') {
190 |             const alertDiv = document.createElement('div');
191 |             alertDiv.className = `alert alert-${type} alert-dismissible fade show`;
192 |             alertDiv.innerHTML = `
193 |                 ${message}
194 |                 <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
195 |             `;
196 |             document.querySelector('main').insertBefore(alertDiv, document.querySelector('main').firstChild);
197 | 
198 |             setTimeout(() => {
199 |                 alertDiv.remove();
200 |             }, 5000);
201 |         }
202 |     </script>
203 |     {% block extra_js %}{% endblock %}
204 | </body>
205 | </html>
206 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 | 
  3 | # 🐦 Twitter Auto-Post Bot 🤖
  4 | 
  5 | [![Python](https://img.shields.io/badge/python-v3.7+-blue.svg)](https://www.python.org/downloads/release/python-370/)
  6 | [![Tweepy](https://img.shields.io/badge/tweepy-v4.14-blue)](http://docs.tweepy.org/en/latest/)
  7 | [![OpenAI](https://img.shields.io/badge/openai-v1.11.1-blue.svg)](https://platform.openai.com/docs/libraries)
  8 | 
  9 | [![Schedule](https://img.shields.io/badge/schedule-v1.2.1-blue)](https://schedule.readthedocs.io/en/stable/)
 10 | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 11 | 
 12 | Automate your Twitter presence. Auto Post tweets from from openAI GPT-5-nano, from a file, from a string, schedule a new tweet to be posted daily or post the tweet instantly.
 13 | </div>
 14 | 
 15 | ---
 16 | 
 17 | ## 🌟 About The Project
 18 | 
 19 | This Python-based Twitter Auto-Post Bot automates tweeting, Credit to the Tweepy library for making this easy, this project enables scheduled and random tweets, offering a dynamic and engaging Twitter experience.
 20 | 
 21 | ### 📁 Files Overview
 22 | #### Using OpenAI
 23 | ##### Instantly:
 24 | - `src/instantly-tweet-from-openai.py`: Immediately tweets a tweet from openAI api response, currently using GPT-5-nano, but you can change the model in [functions.py](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/functions.py#L21)
 25 | 
 26 | - ###### Prompt defined [here](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/instantly-tweet-from-openai.py#L7) 
 27 | 
 28 | ##### Schedule to auto post, tweet daily at a time:
 29 | - `src/schedule-daily-post-from-openai.py`: Automates daily tweets, Runs daily at a scheduled time and queries open ai api to create a tweet, the tweet returned is then automatically tweeted each day to fully automate twitter on auto pilot. By default the model is OPENAI GPT-5-nano but you can change the model in [functions.py](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/functions.py#L21).
 30 | - ###### Prompt defined [here](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/schedule-daily-post-from-openai.py#L12) 
 31 | - ###### Schedule time defined [here](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/schedule-daily-post-from-openai.py#L20)
 32 | 
 33 | #### From File
 34 | - `src/schedule-daily-post-from-file.py`: Automates daily tweets, randomly selecting from `tweets.txt`. To change the schedule time [edit this](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot/blob/main/src/schedule-daily-post-from-file.py#L22).
 35 | - `src/tweeter-random-from-file.py`: Instantly posts a random tweet from `tweets.txt`.
 36 | 
 37 | ###### Add your tweets to `data/tweets.txt`: one per line. They will be randomly selected and tweeted. 
 38 | 
 39 | #### Manually tweeting using script
 40 | `src/tweeter-from-code.py`: Immediately tweets a pre-defined message with the current date, but you can change this to whatever you like.
 41 | 
 42 | #### common files
 43 | - `config/keys.py`: Holds both the creds for openai and twitter api.
 44 | - `src/functions.py`: Shared functions for generating tweets from openai and tweet posting
 45 | - `requirements.txt`: Lists all necessary Python packages.
 46 | 
 47 | ### ⭐ New: Command Line Interface (CLI)
 48 | 
 49 | The bot now includes a powerful CLI for easy management! See the [CLI Usage](#-cli-usage) section below.
 50 | 
 51 | ## 🚀 Getting Started
 52 | 
 53 | ### Prerequisites
 54 | 
 55 | - Python 3.x
 56 | - Tweepy (Twitter API)
 57 | 
 58 | ### Installation
 59 | 
 60 | 1. Clone the repo:
 61 |    ```sh
 62 |    git clone git@github.com:lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot.git
 63 |    ```
 64 | 2. Install Python packages:
 65 |    ```sh
 66 |    pip install -r requirements.txt
 67 |    ```
 68 | 
 69 | ### Setup
 70 | 
 71 | 1. Obtain Twitter API credentials [here](https://developer.twitter.com/apps).
 72 | 2. update `config/keys.py` file with your credentials:
 73 |     ```python
 74 |    bearer_token = "GET_KEY_FROM_developer.twitter.com/apps"
 75 |    api_key = "GET_KEY_FROM_developer.twitter.com/apps"
 76 |    api_secret = "GET_KEY_FROM_developer.twitter.com/apps"
 77 |    access_token = "GET_KEY_FROM_developer.twitter.com/apps"
 78 |    access_token_secret = "GET_KEY_FROM_developer.twitter.com/apps"
 79 |    openai_key = "GET_YOUR_OPENAI_API_KEY_FROM_https://platform.openai.com/api-keys"
 80 |     ```
 81 | 3. Customize `data/tweets.txt` with your tweets. (SKIP: If not using tweet from file)
 82 | 
 83 | ## 🔧 Usage
 84 | 
 85 | ### Option 1: Using the Web UI (Recommended)
 86 | 
 87 | The easiest way to use the bot is through the browser-based web interface. See the [Web UI Usage](#-web-ui-usage) section below.
 88 | 
 89 | ### Option 2: Using the CLI
 90 | 
 91 | For command-line enthusiasts, see the [CLI Usage](#-cli-usage) section below for terminal-based commands.
 92 | 
 93 | ### Option 3: Running Scripts Directly
 94 | 
 95 | Run any script using Python:
 96 | 
 97 | ```bash
 98 | cd src/
 99 | python instantly-tweet-from-openai.py
100 | ```
101 | 
102 | ## 🌐 Web UI Usage
103 | 
104 | The Web UI provides the easiest way to manage your Twitter bot through your browser.
105 | 
106 | ### Starting the Web Interface
107 | 
108 | After installing dependencies with `pip install -r requirements.txt`, start the web server:
109 | 
110 | ```bash
111 | python web.py
112 | ```
113 | 
114 | The web interface will be available at: **http://localhost:8080**
115 | 
116 | Your browser should automatically open, or you can manually navigate to the URL.
117 | 
118 | ### Web UI Features
119 | 
120 | #### Dashboard
121 | - View bot status and scheduler state
122 | - Test Twitter API credentials
123 | - Quick access to all features
124 | - Monitor scheduled jobs
125 | 
126 | #### Post Tweet
127 | - **AI-Generated Tweets**: Generate tweets using OpenAI's GPT-5-nano with custom prompts
128 | - **Random from File**: Post a random tweet from your tweets.txt library
129 | - **Custom Tweet**: Write and post your own tweet with character counter
130 | 
131 | #### Manage Tweets
132 | - View all tweets in your library
133 | - Add new tweets to the library
134 | - Edit existing tweets inline
135 | - Delete unwanted tweets
136 | - See library statistics
137 | 
138 | #### Schedule
139 | - Schedule daily AI-generated tweets at specific times
140 | - Schedule daily posts from your tweet library
141 | - Monitor scheduler status in real-time
142 | - Start/stop the scheduler
143 | - View active scheduled jobs
144 | 
145 | ### Web UI Tips
146 | 
147 | - The web server must remain running for scheduled tweets to work
148 | - All times are in 24-hour format (HH:MM)
149 | - Only one scheduler can run at a time
150 | - The interface auto-refreshes scheduler status every 10 seconds
151 | 
152 | ## 🎯 CLI Usage
153 | 
154 | The CLI provides a simple and intuitive interface for all bot operations.
155 | 
156 | ### Installation
157 | 
158 | After installing dependencies with `pip install -r requirements.txt`, you can run the CLI:
159 | 
160 | ```bash
161 | python cli.py --help
162 | ```
163 | 
164 | ### Available Commands
165 | 
166 | #### 1. Test Credentials
167 | 
168 | Test your Twitter API credentials:
169 | 
170 | ```bash
171 | python cli.py test
172 | ```
173 | 
174 | #### 2. Post a Tweet Instantly
175 | 
176 | **Post with AI (OpenAI):**
177 | ```bash
178 | python cli.py post --ai
179 | ```
180 | 
181 | **Post with custom AI prompt:**
182 | ```bash
183 | python cli.py post --ai --prompt "Create a tweet about Python programming"
184 | ```
185 | 
186 | **Post random tweet from file:**
187 | ```bash
188 | python cli.py post --file
189 | ```
190 | 
191 | **Post custom text:**
192 | ```bash
193 | python cli.py post --text "Hello Twitter! This is my custom tweet"
194 | ```
195 | 
196 | #### 3. Schedule Daily Tweets
197 | 
198 | **Schedule AI-generated tweets:**
199 | ```bash
200 | python cli.py schedule-posts --ai --time "09:00"
201 | ```
202 | 
203 | **Schedule with custom prompt:**
204 | ```bash
205 | python cli.py schedule-posts --ai --time "14:30" --prompt "Create a tweet about technology"
206 | ```
207 | 
208 | **Schedule tweets from file:**
209 | ```bash
210 | python cli.py schedule-posts --file --time "12:00"
211 | ```
212 | 
213 | #### 4. Manage Tweets File
214 | 
215 | **List all tweets in file:**
216 | ```bash
217 | python cli.py list-tweets
218 | ```
219 | 
220 | **Add a new tweet to file:**
221 | ```bash
222 | python cli.py add-tweet
223 | ```
224 | 
225 | ### CLI Tips
226 | 
227 | - All times are in 24-hour format (HH:MM)
228 | - Press `Ctrl+C` to stop the scheduler
229 | - The `--help` flag works with any command for more details
230 | - Example: `python cli.py post --help`
231 | 
232 | ## 🤝 Contributing
233 | 
234 | Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
235 | 
236 | ## 📝 License
237 | 
238 | Distributed under the MIT License. See `LICENSE` for more information.
239 | 
240 | ## ✉️ Contact
241 | Project Link: [https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot](https://github.com/lewispour/Twitter-auto-Post-Bot---X.com---Tweepy-python-bot)
242 | 
243 | ## ✉️ Status
244 | - Last tested and still working on 04/12/2025 ✅
245 | 


--------------------------------------------------------------------------------
/cli.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | """
  3 | Twitter Auto-Post Bot CLI
  4 | A command-line interface for managing automated Twitter posts.
  5 | """
  6 | 
  7 | import click
  8 | import sys
  9 | import os
 10 | import schedule
 11 | import time
 12 | import random
 13 | 
 14 | sys.path.append(os.path.join(os.path.dirname(__file__), 'config'))
 15 | sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
 16 | 
 17 | import keys
 18 | from src.functions import generate_response, initialize_tweepy, get_formatted_date
 19 | 
 20 | 
 21 | @click.group()
 22 | @click.version_option(version='1.0.0')
 23 | def cli():
 24 |     """Twitter Auto-Post Bot - Automate your Twitter presence."""
 25 |     pass
 26 | 
 27 | 
 28 | @cli.command()
 29 | @click.option('--ai', is_flag=True, help='Generate tweet using AI')
 30 | @click.option('--file', 'from_file', is_flag=True, help='Post random tweet from file')
 31 | @click.option('--text', help='Post custom text')
 32 | @click.option('--prompt', default='Create a short tweet about Motorbikes.', help='Custom prompt for AI (only with --ai)')
 33 | def post(ai, from_file, text, prompt):
 34 |     """Post a tweet instantly."""
 35 | 
 36 |     if sum([ai, from_file, bool(text)]) != 1:
 37 |         click.echo(click.style('Error: Please specify exactly one option: --ai, --file, or --text', fg='red'))
 38 |         sys.exit(1)
 39 | 
 40 |     try:
 41 |         client, _ = initialize_tweepy()
 42 | 
 43 |         if ai:
 44 |             click.echo(click.style(f'Generating tweet with AI...', fg='yellow'))
 45 |             click.echo(click.style(f'Prompt: {prompt}', fg='cyan'))
 46 |             response = generate_response(prompt)
 47 |             tweet_text = response
 48 |             click.echo(click.style(f'\nGenerated tweet: {tweet_text}', fg='green'))
 49 | 
 50 |         elif from_file:
 51 |             tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
 52 |             if not os.path.exists(tweets_file):
 53 |                 click.echo(click.style(f'Error: tweets.txt not found at {tweets_file}', fg='red'))
 54 |                 sys.exit(1)
 55 | 
 56 |             with open(tweets_file, 'r') as file:
 57 |                 lines = [line.strip() for line in file.readlines() if line.strip()]
 58 | 
 59 |             if not lines:
 60 |                 click.echo(click.style('Error: tweets.txt is empty', fg='red'))
 61 |                 sys.exit(1)
 62 | 
 63 |             tweet_text = random.choice(lines)
 64 |             click.echo(click.style(f'Selected tweet: {tweet_text}', fg='green'))
 65 | 
 66 |         else:
 67 |             tweet_text = text
 68 |             click.echo(click.style(f'Posting: {tweet_text}', fg='green'))
 69 | 
 70 |         client.create_tweet(text=tweet_text)
 71 |         click.echo(click.style('Tweet posted successfully!', fg='green', bold=True))
 72 | 
 73 |     except Exception as e:
 74 |         click.echo(click.style(f'Error posting tweet: {str(e)}', fg='red'))
 75 |         sys.exit(1)
 76 | 
 77 | 
 78 | @cli.command()
 79 | @click.option('--ai', is_flag=True, help='Schedule AI-generated tweets')
 80 | @click.option('--file', 'from_file', is_flag=True, help='Schedule tweets from file')
 81 | @click.option('--time', 'schedule_time', default='09:00', help='Time to post daily (HH:MM format, default: 09:00)')
 82 | @click.option('--prompt', default='Create a short tweet about Motorbikes.', help='Custom prompt for AI (only with --ai)')
 83 | def schedule_posts(ai, from_file, schedule_time, prompt):
 84 |     """Schedule daily tweets at a specific time."""
 85 | 
 86 |     if not ai and not from_file:
 87 |         click.echo(click.style('Error: Please specify either --ai or --file', fg='red'))
 88 |         sys.exit(1)
 89 | 
 90 |     if ai and from_file:
 91 |         click.echo(click.style('Error: Please specify only one option: --ai or --file', fg='red'))
 92 |         sys.exit(1)
 93 | 
 94 |     try:
 95 |         client, _ = initialize_tweepy()
 96 | 
 97 |         if ai:
 98 |             def send_ai_post():
 99 |                 try:
100 |                     click.echo(click.style(f'\nGenerating and posting tweet...', fg='yellow'))
101 |                     response = generate_response(prompt)
102 |                     client.create_tweet(text=response)
103 |                     click.echo(click.style(f'Tweet posted: {response}', fg='green'))
104 |                     click.echo(click.style(f'Next post scheduled for tomorrow at {schedule_time}', fg='cyan'))
105 |                 except Exception as e:
106 |                     click.echo(click.style(f'Error posting tweet: {str(e)}', fg='red'))
107 | 
108 |             schedule.every().day.at(schedule_time).do(send_ai_post)
109 |             click.echo(click.style(f'Scheduled AI-generated tweets daily at {schedule_time}', fg='green', bold=True))
110 |             click.echo(click.style(f'Prompt: {prompt}', fg='cyan'))
111 | 
112 |         else:
113 |             tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
114 |             if not os.path.exists(tweets_file):
115 |                 click.echo(click.style(f'Error: tweets.txt not found at {tweets_file}', fg='red'))
116 |                 sys.exit(1)
117 | 
118 |             def send_file_post():
119 |                 try:
120 |                     with open(tweets_file, 'r') as file:
121 |                         lines = [line.strip() for line in file.readlines() if line.strip()]
122 | 
123 |                     if not lines:
124 |                         click.echo(click.style('Error: tweets.txt is empty', fg='red'))
125 |                         return
126 | 
127 |                     tweet_text = random.choice(lines)
128 |                     client.create_tweet(text=tweet_text)
129 |                     click.echo(click.style(f'\nTweet posted: {tweet_text}', fg='green'))
130 |                     click.echo(click.style(f'Next post scheduled for tomorrow at {schedule_time}', fg='cyan'))
131 |                 except Exception as e:
132 |                     click.echo(click.style(f'Error posting tweet: {str(e)}', fg='red'))
133 | 
134 |             schedule.every().day.at(schedule_time).do(send_file_post)
135 |             click.echo(click.style(f'Scheduled tweets from file daily at {schedule_time}', fg='green', bold=True))
136 | 
137 |         click.echo(click.style('\nPress Ctrl+C to stop the scheduler', fg='yellow'))
138 | 
139 |         while True:
140 |             schedule.run_pending()
141 |             time.sleep(60)
142 | 
143 |     except KeyboardInterrupt:
144 |         click.echo(click.style('\n\nScheduler stopped.', fg='yellow'))
145 |     except Exception as e:
146 |         click.echo(click.style(f'Error: {str(e)}', fg='red'))
147 |         sys.exit(1)
148 | 
149 | 
150 | @cli.command()
151 | def test():
152 |     """Test Twitter API credentials."""
153 |     try:
154 |         click.echo(click.style('Testing Twitter API credentials...', fg='yellow'))
155 |         client, api = initialize_tweepy()
156 | 
157 |         user = api.verify_credentials()
158 |         click.echo(click.style('\nCredentials verified successfully!', fg='green', bold=True))
159 |         click.echo(click.style(f'Authenticated as: @{user.screen_name}', fg='cyan'))
160 |         click.echo(click.style(f'Name: {user.name}', fg='cyan'))
161 |         click.echo(click.style(f'Followers: {user.followers_count}', fg='cyan'))
162 |         click.echo(click.style(f'Following: {user.friends_count}', fg='cyan'))
163 | 
164 |     except Exception as e:
165 |         click.echo(click.style(f'\nCredentials test failed: {str(e)}', fg='red'))
166 |         click.echo(click.style('\nPlease check your credentials in config/keys.py', fg='yellow'))
167 |         sys.exit(1)
168 | 
169 | 
170 | @cli.command()
171 | def list_tweets():
172 |     """List all tweets from the tweets.txt file."""
173 |     tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
174 | 
175 |     if not os.path.exists(tweets_file):
176 |         click.echo(click.style(f'Error: tweets.txt not found at {tweets_file}', fg='red'))
177 |         sys.exit(1)
178 | 
179 |     try:
180 |         with open(tweets_file, 'r') as file:
181 |             lines = [line.strip() for line in file.readlines() if line.strip()]
182 | 
183 |         if not lines:
184 |             click.echo(click.style('tweets.txt is empty. Add some tweets first!', fg='yellow'))
185 |             return
186 | 
187 |         click.echo(click.style(f'\nFound {len(lines)} tweet(s) in file:', fg='green', bold=True))
188 |         click.echo()
189 | 
190 |         for i, tweet in enumerate(lines, 1):
191 |             click.echo(click.style(f'{i}. ', fg='cyan') + tweet)
192 | 
193 |     except Exception as e:
194 |         click.echo(click.style(f'Error reading tweets file: {str(e)}', fg='red'))
195 |         sys.exit(1)
196 | 
197 | 
198 | @cli.command()
199 | def add_tweet():
200 |     """Add a new tweet to the tweets.txt file interactively."""
201 |     tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
202 | 
203 |     os.makedirs(os.path.dirname(tweets_file), exist_ok=True)
204 | 
205 |     tweet = click.prompt(click.style('Enter your tweet', fg='cyan'))
206 | 
207 |     if len(tweet) > 280:
208 |         click.echo(click.style(f'Warning: Tweet is {len(tweet)} characters (Twitter limit is 280)', fg='yellow'))
209 |         if not click.confirm(click.style('Do you want to add it anyway?', fg='yellow')):
210 |             click.echo(click.style('Tweet not added.', fg='red'))
211 |             return
212 | 
213 |     try:
214 |         with open(tweets_file, 'a') as file:
215 |             file.write(tweet + '\n')
216 | 
217 |         click.echo(click.style('\nTweet added successfully!', fg='green', bold=True))
218 | 
219 |     except Exception as e:
220 |         click.echo(click.style(f'Error adding tweet: {str(e)}', fg='red'))
221 |         sys.exit(1)
222 | 
223 | 
224 | if __name__ == '__main__':
225 |     cli()
226 | 


--------------------------------------------------------------------------------
/web.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | """
  3 | Twitter Auto-Post Bot Web Interface
  4 | A browser-based interface for managing automated Twitter posts.
  5 | """
  6 | 
  7 | from flask import Flask, render_template, request, jsonify, redirect, url_for, flash
  8 | import sys
  9 | import os
 10 | import random
 11 | import json
 12 | import threading
 13 | import schedule
 14 | import time
 15 | from datetime import datetime
 16 | 
 17 | sys.path.append(os.path.join(os.path.dirname(__file__), 'config'))
 18 | sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
 19 | 
 20 | import keys
 21 | from src.functions import generate_response, initialize_tweepy, get_formatted_date
 22 | 
 23 | app = Flask(__name__)
 24 | app.secret_key = 'twitter-bot-secret-key-change-in-production'
 25 | 
 26 | # Global variable to track scheduler
 27 | scheduler_running = False
 28 | scheduler_thread = None
 29 | scheduled_jobs = []
 30 | 
 31 | 
 32 | def get_tweets_from_file():
 33 |     """Read all tweets from the tweets.txt file."""
 34 |     tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
 35 |     if not os.path.exists(tweets_file):
 36 |         return []
 37 | 
 38 |     with open(tweets_file, 'r') as file:
 39 |         return [line.strip() for line in file.readlines() if line.strip()]
 40 | 
 41 | 
 42 | def save_tweets_to_file(tweets):
 43 |     """Save tweets to the tweets.txt file."""
 44 |     tweets_file = os.path.join(os.path.dirname(__file__), 'data', 'tweets.txt')
 45 |     os.makedirs(os.path.dirname(tweets_file), exist_ok=True)
 46 | 
 47 |     with open(tweets_file, 'w') as file:
 48 |         for tweet in tweets:
 49 |             file.write(tweet + '\n')
 50 | 
 51 | 
 52 | @app.route('/')
 53 | def index():
 54 |     """Dashboard page."""
 55 |     return render_template('index.html', scheduler_running=scheduler_running, scheduled_jobs=scheduled_jobs)
 56 | 
 57 | 
 58 | @app.route('/test-credentials', methods=['POST'])
 59 | def test_credentials():
 60 |     """Test Twitter API credentials."""
 61 |     try:
 62 |         client, api = initialize_tweepy()
 63 |         user = api.verify_credentials()
 64 | 
 65 |         return jsonify({
 66 |             'success': True,
 67 |             'data': {
 68 |                 'username': user.screen_name,
 69 |                 'name': user.name,
 70 |                 'followers': user.followers_count,
 71 |                 'following': user.friends_count
 72 |             }
 73 |         })
 74 |     except Exception as e:
 75 |         return jsonify({
 76 |             'success': False,
 77 |             'error': str(e)
 78 |         }), 400
 79 | 
 80 | 
 81 | @app.route('/post')
 82 | def post_page():
 83 |     """Post tweet page."""
 84 |     return render_template('post.html')
 85 | 
 86 | 
 87 | @app.route('/post-tweet', methods=['POST'])
 88 | def post_tweet():
 89 |     """Post a tweet instantly."""
 90 |     try:
 91 |         data = request.get_json()
 92 |         tweet_type = data.get('type')
 93 | 
 94 |         client, _ = initialize_tweepy()
 95 | 
 96 |         if tweet_type == 'ai':
 97 |             prompt = data.get('prompt', 'Create a short tweet about Motorbikes.')
 98 |             tweet_text = generate_response(prompt)
 99 |         elif tweet_type == 'file':
100 |             tweets = get_tweets_from_file()
101 |             if not tweets:
102 |                 return jsonify({'success': False, 'error': 'No tweets found in file'}), 400
103 |             tweet_text = random.choice(tweets)
104 |         elif tweet_type == 'text':
105 |             tweet_text = data.get('text')
106 |             if not tweet_text:
107 |                 return jsonify({'success': False, 'error': 'No text provided'}), 400
108 |         else:
109 |             return jsonify({'success': False, 'error': 'Invalid tweet type'}), 400
110 | 
111 |         client.create_tweet(text=tweet_text)
112 | 
113 |         return jsonify({
114 |             'success': True,
115 |             'tweet': tweet_text
116 |         })
117 |     except Exception as e:
118 |         return jsonify({
119 |             'success': False,
120 |             'error': str(e)
121 |         }), 400
122 | 
123 | 
124 | @app.route('/manage-tweets')
125 | def manage_tweets():
126 |     """Manage tweets page."""
127 |     tweets = get_tweets_from_file()
128 |     return render_template('manage_tweets.html', tweets=tweets)
129 | 
130 | 
131 | @app.route('/add-tweet', methods=['POST'])
132 | def add_tweet():
133 |     """Add a new tweet to the file."""
134 |     try:
135 |         data = request.get_json()
136 |         tweet = data.get('tweet', '').strip()
137 | 
138 |         if not tweet:
139 |             return jsonify({'success': False, 'error': 'Tweet cannot be empty'}), 400
140 | 
141 |         tweets = get_tweets_from_file()
142 |         tweets.append(tweet)
143 |         save_tweets_to_file(tweets)
144 | 
145 |         return jsonify({'success': True})
146 |     except Exception as e:
147 |         return jsonify({'success': False, 'error': str(e)}), 400
148 | 
149 | 
150 | @app.route('/delete-tweet', methods=['POST'])
151 | def delete_tweet():
152 |     """Delete a tweet from the file."""
153 |     try:
154 |         data = request.get_json()
155 |         index = data.get('index')
156 | 
157 |         tweets = get_tweets_from_file()
158 |         if 0 <= index < len(tweets):
159 |             tweets.pop(index)
160 |             save_tweets_to_file(tweets)
161 |             return jsonify({'success': True})
162 |         else:
163 |             return jsonify({'success': False, 'error': 'Invalid index'}), 400
164 |     except Exception as e:
165 |         return jsonify({'success': False, 'error': str(e)}), 400
166 | 
167 | 
168 | @app.route('/update-tweet', methods=['POST'])
169 | def update_tweet():
170 |     """Update a tweet in the file."""
171 |     try:
172 |         data = request.get_json()
173 |         index = data.get('index')
174 |         new_text = data.get('text', '').strip()
175 | 
176 |         if not new_text:
177 |             return jsonify({'success': False, 'error': 'Tweet cannot be empty'}), 400
178 | 
179 |         tweets = get_tweets_from_file()
180 |         if 0 <= index < len(tweets):
181 |             tweets[index] = new_text
182 |             save_tweets_to_file(tweets)
183 |             return jsonify({'success': True})
184 |         else:
185 |             return jsonify({'success': False, 'error': 'Invalid index'}), 400
186 |     except Exception as e:
187 |         return jsonify({'success': False, 'error': str(e)}), 400
188 | 
189 | 
190 | @app.route('/schedule')
191 | def schedule_page():
192 |     """Schedule tweets page."""
193 |     return render_template('schedule.html', scheduled_jobs=scheduled_jobs, scheduler_running=scheduler_running)
194 | 
195 | 
196 | def run_scheduler():
197 |     """Run the scheduler in a separate thread."""
198 |     global scheduler_running
199 |     while scheduler_running:
200 |         schedule.run_pending()
201 |         time.sleep(60)
202 | 
203 | 
204 | @app.route('/start-schedule', methods=['POST'])
205 | def start_schedule():
206 |     """Start scheduled tweets."""
207 |     global scheduler_running, scheduler_thread, scheduled_jobs
208 | 
209 |     try:
210 |         data = request.get_json()
211 |         schedule_type = data.get('type')
212 |         schedule_time = data.get('time', '09:00')
213 |         prompt = data.get('prompt', 'Create a short tweet about Motorbikes.')
214 | 
215 |         if scheduler_running:
216 |             return jsonify({'success': False, 'error': 'Scheduler is already running'}), 400
217 | 
218 |         # Clear existing jobs
219 |         schedule.clear()
220 |         scheduled_jobs = []
221 | 
222 |         client, _ = initialize_tweepy()
223 | 
224 |         if schedule_type == 'ai':
225 |             def send_ai_post():
226 |                 try:
227 |                     response = generate_response(prompt)
228 |                     client.create_tweet(text=response)
229 |                     print(f'Posted tweet: {response}')
230 |                 except Exception as e:
231 |                     print(f'Error posting tweet: {str(e)}')
232 | 
233 |             schedule.every().day.at(schedule_time).do(send_ai_post)
234 |             scheduled_jobs.append({
235 |                 'type': 'AI Generated',
236 |                 'time': schedule_time,
237 |                 'prompt': prompt
238 |             })
239 | 
240 |         elif schedule_type == 'file':
241 |             def send_file_post():
242 |                 try:
243 |                     tweets = get_tweets_from_file()
244 |                     if tweets:
245 |                         tweet_text = random.choice(tweets)
246 |                         client.create_tweet(text=tweet_text)
247 |                         print(f'Posted tweet: {tweet_text}')
248 |                 except Exception as e:
249 |                     print(f'Error posting tweet: {str(e)}')
250 | 
251 |             schedule.every().day.at(schedule_time).do(send_file_post)
252 |             scheduled_jobs.append({
253 |                 'type': 'Random from File',
254 |                 'time': schedule_time,
255 |                 'prompt': 'N/A'
256 |             })
257 | 
258 |         scheduler_running = True
259 |         scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
260 |         scheduler_thread.start()
261 | 
262 |         return jsonify({'success': True, 'message': f'Scheduler started for {schedule_time}'})
263 |     except Exception as e:
264 |         return jsonify({'success': False, 'error': str(e)}), 400
265 | 
266 | 
267 | @app.route('/stop-schedule', methods=['POST'])
268 | def stop_schedule():
269 |     """Stop scheduled tweets."""
270 |     global scheduler_running, scheduled_jobs
271 | 
272 |     scheduler_running = False
273 |     schedule.clear()
274 |     scheduled_jobs = []
275 | 
276 |     return jsonify({'success': True, 'message': 'Scheduler stopped'})
277 | 
278 | 
279 | @app.route('/scheduler-status')
280 | def scheduler_status():
281 |     """Get scheduler status."""
282 |     return jsonify({
283 |         'running': scheduler_running,
284 |         'jobs': scheduled_jobs
285 |     })
286 | 
287 | 
288 | if __name__ == '__main__':
289 |     print("Starting Twitter Bot Web Interface...")
290 |     print("Open your browser and navigate to: http://localhost:8080")
291 |     app.run(debug=True, host='0.0.0.0', port=8080)
292 | 


--------------------------------------------------------------------------------
/templates/manage_tweets.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block title %}Manage Tweets - Twitter Bot{% endblock %}
  4 | 
  5 | {% block content %}
  6 | <div class="row">
  7 |     <div class="col-12">
  8 |         <h1 class="mb-4">
  9 |             <i class="bi bi-list-ul"></i> Manage Tweet Library
 10 |         </h1>
 11 |     </div>
 12 | </div>
 13 | 
 14 | <div class="row">
 15 |     <div class="col-lg-8">
 16 |         <!-- Add New Tweet -->
 17 |         <div class="card mb-4">
 18 |             <div class="card-header">
 19 |                 <i class="bi bi-plus-circle"></i> Add New Tweet
 20 |             </div>
 21 |             <div class="card-body">
 22 |                 <div class="mb-3">
 23 |                     <label for="newTweet" class="form-label">Tweet Text</label>
 24 |                     <textarea class="form-control" id="newTweet" rows="3" maxlength="280" placeholder="Enter your tweet here..."></textarea>
 25 |                     <div class="form-text">
 26 |                         <span id="newTweetCharCount">0</span> / 280 characters
 27 |                     </div>
 28 |                 </div>
 29 | 
 30 |                 <button class="btn btn-primary" onclick="addTweet()">
 31 |                     <i class="bi bi-plus-lg"></i> Add Tweet
 32 |                 </button>
 33 |             </div>
 34 |         </div>
 35 | 
 36 |         <!-- Tweet List -->
 37 |         <div class="card">
 38 |             <div class="card-header d-flex justify-content-between align-items-center">
 39 |                 <span><i class="bi bi-collection"></i> Your Tweets ({{ tweets|length }})</span>
 40 |                 <button class="btn btn-sm btn-outline-light" onclick="location.reload()">
 41 |                     <i class="bi bi-arrow-clockwise"></i> Refresh
 42 |                 </button>
 43 |             </div>
 44 |             <div class="card-body">
 45 |                 <div id="tweetsList">
 46 |                     {% if tweets %}
 47 |                         {% for tweet in tweets %}
 48 |                         <div class="tweet-box" id="tweet-{{ loop.index0 }}">
 49 |                             <div class="d-flex justify-content-between align-items-start">
 50 |                                 <div class="flex-grow-1 me-3">
 51 |                                     <div class="tweet-text" id="text-{{ loop.index0 }}">{{ tweet }}</div>
 52 |                                     <textarea class="form-control d-none" id="edit-{{ loop.index0 }}" rows="3">{{ tweet }}</textarea>
 53 |                                 </div>
 54 |                                 <div class="btn-group-vertical btn-group-sm">
 55 |                                     <button class="btn btn-outline-primary" id="edit-btn-{{ loop.index0 }}" onclick="editTweet({{ loop.index0 }})">
 56 |                                         <i class="bi bi-pencil"></i>
 57 |                                     </button>
 58 |                                     <button class="btn btn-outline-success d-none" id="save-btn-{{ loop.index0 }}" onclick="saveTweet({{ loop.index0 }})">
 59 |                                         <i class="bi bi-check"></i>
 60 |                                     </button>
 61 |                                     <button class="btn btn-outline-secondary d-none" id="cancel-btn-{{ loop.index0 }}" onclick="cancelEdit({{ loop.index0 }})">
 62 |                                         <i class="bi bi-x"></i>
 63 |                                     </button>
 64 |                                     <button class="btn btn-outline-danger" onclick="deleteTweet({{ loop.index0 }})">
 65 |                                         <i class="bi bi-trash"></i>
 66 |                                     </button>
 67 |                                 </div>
 68 |                             </div>
 69 |                             <div class="text-muted small mt-2">
 70 |                                 <i class="bi bi-hash"></i> Tweet {{ loop.index }}
 71 |                             </div>
 72 |                         </div>
 73 |                         {% endfor %}
 74 |                     {% else %}
 75 |                         <div class="alert alert-info">
 76 |                             <i class="bi bi-info-circle"></i> No tweets in your library yet. Add some tweets above to get started!
 77 |                         </div>
 78 |                     {% endif %}
 79 |                 </div>
 80 |             </div>
 81 |         </div>
 82 |     </div>
 83 | 
 84 |     <!-- Info Sidebar -->
 85 |     <div class="col-lg-4">
 86 |         <div class="card">
 87 |             <div class="card-header">
 88 |                 <i class="bi bi-info-circle"></i> About Tweet Library
 89 |             </div>
 90 |             <div class="card-body">
 91 |                 <p>Your tweet library is stored in <code>data/tweets.txt</code>.</p>
 92 | 
 93 |                 <h6 class="mt-3"><i class="bi bi-lightbulb"></i> Usage:</h6>
 94 |                 <ul class="small">
 95 |                     <li>Add multiple tweets to build your library</li>
 96 |                     <li>Use "Random from File" to post a random tweet</li>
 97 |                     <li>Schedule daily posts from your library</li>
 98 |                     <li>Edit or delete tweets anytime</li>
 99 |                 </ul>
100 | 
101 |                 <h6 class="mt-3"><i class="bi bi-trophy"></i> Tips:</h6>
102 |                 <ul class="small">
103 |                     <li>Create a diverse set of tweets</li>
104 |                     <li>Include different topics and styles</li>
105 |                     <li>Keep them evergreen and timeless</li>
106 |                     <li>Update regularly with fresh content</li>
107 |                 </ul>
108 |             </div>
109 |         </div>
110 | 
111 |         <div class="card mt-3">
112 |             <div class="card-header">
113 |                 <i class="bi bi-bar-chart"></i> Statistics
114 |             </div>
115 |             <div class="card-body">
116 |                 <div class="mb-2">
117 |                     <strong>Total Tweets:</strong> {{ tweets|length }}
118 |                 </div>
119 |                 <div class="mb-2">
120 |                     <strong>Average Length:</strong>
121 |                     {% if tweets %}
122 |                         {{ (tweets | map('length') | sum / tweets | length) | round | int }} chars
123 |                     {% else %}
124 |                         0 chars
125 |                     {% endif %}
126 |                 </div>
127 |             </div>
128 |         </div>
129 |     </div>
130 | </div>
131 | 
132 | {% endblock %}
133 | 
134 | {% block extra_js %}
135 | <script>
136 |     // Character counter for new tweet
137 |     document.getElementById('newTweet').addEventListener('input', function() {
138 |         const count = this.value.length;
139 |         document.getElementById('newTweetCharCount').textContent = count;
140 | 
141 |         if (count > 280) {
142 |             document.getElementById('newTweetCharCount').style.color = 'red';
143 |         } else {
144 |             document.getElementById('newTweetCharCount').style.color = '';
145 |         }
146 |     });
147 | 
148 |     async function addTweet() {
149 |         const text = document.getElementById('newTweet').value.trim();
150 | 
151 |         if (!text) {
152 |             showToast('Please enter some text for your tweet.', 'warning');
153 |             return;
154 |         }
155 | 
156 |         try {
157 |             const response = await fetch('/add-tweet', {
158 |                 method: 'POST',
159 |                 headers: {
160 |                     'Content-Type': 'application/json'
161 |                 },
162 |                 body: JSON.stringify({ tweet: text })
163 |             });
164 | 
165 |             const data = await response.json();
166 | 
167 |             if (data.success) {
168 |                 showToast('Tweet added successfully!', 'success');
169 |                 document.getElementById('newTweet').value = '';
170 |                 document.getElementById('newTweetCharCount').textContent = '0';
171 |                 setTimeout(() => location.reload(), 1000);
172 |             } else {
173 |                 showToast('Error: ' + data.error, 'danger');
174 |             }
175 |         } catch (error) {
176 |             showToast('Error: ' + error.message, 'danger');
177 |         }
178 |     }
179 | 
180 |     function editTweet(index) {
181 |         document.getElementById(`text-${index}`).classList.add('d-none');
182 |         document.getElementById(`edit-${index}`).classList.remove('d-none');
183 |         document.getElementById(`edit-btn-${index}`).classList.add('d-none');
184 |         document.getElementById(`save-btn-${index}`).classList.remove('d-none');
185 |         document.getElementById(`cancel-btn-${index}`).classList.remove('d-none');
186 |     }
187 | 
188 |     function cancelEdit(index) {
189 |         document.getElementById(`text-${index}`).classList.remove('d-none');
190 |         document.getElementById(`edit-${index}`).classList.add('d-none');
191 |         document.getElementById(`edit-btn-${index}`).classList.remove('d-none');
192 |         document.getElementById(`save-btn-${index}`).classList.add('d-none');
193 |         document.getElementById(`cancel-btn-${index}`).classList.add('d-none');
194 |     }
195 | 
196 |     async function saveTweet(index) {
197 |         const text = document.getElementById(`edit-${index}`).value.trim();
198 | 
199 |         if (!text) {
200 |             showToast('Tweet cannot be empty.', 'warning');
201 |             return;
202 |         }
203 | 
204 |         try {
205 |             const response = await fetch('/update-tweet', {
206 |                 method: 'POST',
207 |                 headers: {
208 |                     'Content-Type': 'application/json'
209 |                 },
210 |                 body: JSON.stringify({ index: index, text: text })
211 |             });
212 | 
213 |             const data = await response.json();
214 | 
215 |             if (data.success) {
216 |                 showToast('Tweet updated successfully!', 'success');
217 |                 setTimeout(() => location.reload(), 1000);
218 |             } else {
219 |                 showToast('Error: ' + data.error, 'danger');
220 |             }
221 |         } catch (error) {
222 |             showToast('Error: ' + error.message, 'danger');
223 |         }
224 |     }
225 | 
226 |     async function deleteTweet(index) {
227 |         if (!confirm('Are you sure you want to delete this tweet?')) {
228 |             return;
229 |         }
230 | 
231 |         try {
232 |             const response = await fetch('/delete-tweet', {
233 |                 method: 'POST',
234 |                 headers: {
235 |                     'Content-Type': 'application/json'
236 |                 },
237 |                 body: JSON.stringify({ index: index })
238 |             });
239 | 
240 |             const data = await response.json();
241 | 
242 |             if (data.success) {
243 |                 showToast('Tweet deleted successfully!', 'success');
244 |                 setTimeout(() => location.reload(), 1000);
245 |             } else {
246 |                 showToast('Error: ' + data.error, 'danger');
247 |             }
248 |         } catch (error) {
249 |             showToast('Error: ' + error.message, 'danger');
250 |         }
251 |     }
252 | </script>
253 | {% endblock %}
254 | 


--------------------------------------------------------------------------------
/templates/post.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block title %}Post Tweet - Twitter Bot{% endblock %}
  4 | 
  5 | {% block content %}
  6 | <div class="row">
  7 |     <div class="col-12">
  8 |         <h1 class="mb-4">
  9 |             <i class="bi bi-send"></i> Post a Tweet
 10 |         </h1>
 11 |     </div>
 12 | </div>
 13 | 
 14 | <div class="row">
 15 |     <div class="col-lg-8">
 16 |         <!-- AI Generated Tweet -->
 17 |         <div class="card mb-4">
 18 |             <div class="card-header">
 19 |                 <i class="bi bi-robot"></i> AI-Generated Tweet
 20 |             </div>
 21 |             <div class="card-body">
 22 |                 <p>Generate a tweet using OpenAI's GPT-5-nano with a custom prompt.</p>
 23 | 
 24 |                 <div class="mb-3">
 25 |                     <label for="aiPrompt" class="form-label">Prompt for AI</label>
 26 |                     <textarea class="form-control" id="aiPrompt" rows="3" placeholder="Example: Create a tweet about the future of technology">Create a short tweet about Motorbikes.</textarea>
 27 |                     <div class="form-text">Describe what you want the tweet to be about.</div>
 28 |                 </div>
 29 | 
 30 |                 <button class="btn btn-primary" onclick="postAITweet()">
 31 |                     <i class="bi bi-magic"></i> Generate & Post
 32 |                 </button>
 33 | 
 34 |                 <div id="aiResult" class="mt-3"></div>
 35 |             </div>
 36 |         </div>
 37 | 
 38 |         <!-- Random from File -->
 39 |         <div class="card mb-4">
 40 |             <div class="card-header">
 41 |                 <i class="bi bi-file-text"></i> Random Tweet from File
 42 |             </div>
 43 |             <div class="card-body">
 44 |                 <p>Post a random tweet from your tweets library (data/tweets.txt).</p>
 45 | 
 46 |                 <button class="btn btn-primary" onclick="postFileTweet()">
 47 |                     <i class="bi bi-shuffle"></i> Post Random Tweet
 48 |                 </button>
 49 | 
 50 |                 <div id="fileResult" class="mt-3"></div>
 51 |             </div>
 52 |         </div>
 53 | 
 54 |         <!-- Custom Text -->
 55 |         <div class="card mb-4">
 56 |             <div class="card-header">
 57 |                 <i class="bi bi-pencil"></i> Custom Tweet
 58 |             </div>
 59 |             <div class="card-body">
 60 |                 <p>Write and post your own custom tweet.</p>
 61 | 
 62 |                 <div class="mb-3">
 63 |                     <label for="customText" class="form-label">Tweet Text</label>
 64 |                     <textarea class="form-control" id="customText" rows="4" maxlength="280" placeholder="What's happening?"></textarea>
 65 |                     <div class="form-text">
 66 |                         <span id="charCount">0</span> / 280 characters
 67 |                     </div>
 68 |                 </div>
 69 | 
 70 |                 <button class="btn btn-primary" onclick="postCustomTweet()">
 71 |                     <i class="bi bi-send"></i> Post Tweet
 72 |                 </button>
 73 | 
 74 |                 <div id="customResult" class="mt-3"></div>
 75 |             </div>
 76 |         </div>
 77 |     </div>
 78 | 
 79 |     <!-- Tips Sidebar -->
 80 |     <div class="col-lg-4">
 81 |         <div class="card">
 82 |             <div class="card-header">
 83 |                 <i class="bi bi-lightbulb"></i> Tips
 84 |             </div>
 85 |             <div class="card-body">
 86 |                 <h6><i class="bi bi-check2"></i> Best Practices:</h6>
 87 |                 <ul class="small">
 88 |                     <li>Keep tweets concise and engaging</li>
 89 |                     <li>Use relevant hashtags (but not too many)</li>
 90 |                     <li>Include calls-to-action when appropriate</li>
 91 |                     <li>Check your tweet before posting</li>
 92 |                 </ul>
 93 | 
 94 |                 <h6 class="mt-3"><i class="bi bi-info-circle"></i> Character Limit:</h6>
 95 |                 <p class="small mb-0">Twitter allows up to 280 characters per tweet.</p>
 96 |             </div>
 97 |         </div>
 98 | 
 99 |         <div class="card mt-3">
100 |             <div class="card-header">
101 |                 <i class="bi bi-clock-history"></i> Quick Actions
102 |             </div>
103 |             <div class="card-body">
104 |                 <div class="d-grid gap-2">
105 |                     <a href="/manage-tweets" class="btn btn-outline-primary btn-sm">
106 |                         <i class="bi bi-list-ul"></i> Manage Tweet Library
107 |                     </a>
108 |                     <a href="/schedule" class="btn btn-outline-primary btn-sm">
109 |                         <i class="bi bi-calendar-check"></i> Schedule Posts
110 |                     </a>
111 |                 </div>
112 |             </div>
113 |         </div>
114 |     </div>
115 | </div>
116 | 
117 | {% endblock %}
118 | 
119 | {% block extra_js %}
120 | <script>
121 |     // Character counter for custom tweet
122 |     document.getElementById('customText').addEventListener('input', function() {
123 |         const count = this.value.length;
124 |         document.getElementById('charCount').textContent = count;
125 | 
126 |         if (count > 280) {
127 |             document.getElementById('charCount').style.color = 'red';
128 |         } else {
129 |             document.getElementById('charCount').style.color = '';
130 |         }
131 |     });
132 | 
133 |     async function postAITweet() {
134 |         const prompt = document.getElementById('aiPrompt').value;
135 |         const resultDiv = document.getElementById('aiResult');
136 | 
137 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Generating and posting tweet...';
138 | 
139 |         try {
140 |             const response = await fetch('/post-tweet', {
141 |                 method: 'POST',
142 |                 headers: {
143 |                     'Content-Type': 'application/json'
144 |                 },
145 |                 body: JSON.stringify({
146 |                     type: 'ai',
147 |                     prompt: prompt
148 |                 })
149 |             });
150 | 
151 |             const data = await response.json();
152 | 
153 |             if (data.success) {
154 |                 resultDiv.innerHTML = `
155 |                     <div class="alert alert-success">
156 |                         <strong><i class="bi bi-check-circle"></i> Tweet Posted Successfully!</strong>
157 |                         <div class="tweet-box mt-2">
158 |                             ${data.tweet}
159 |                         </div>
160 |                     </div>
161 |                 `;
162 |             } else {
163 |                 resultDiv.innerHTML = `
164 |                     <div class="alert alert-danger">
165 |                         <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
166 |                         ${data.error}
167 |                     </div>
168 |                 `;
169 |             }
170 |         } catch (error) {
171 |             resultDiv.innerHTML = `
172 |                 <div class="alert alert-danger">
173 |                     <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
174 |                     ${error.message}
175 |                 </div>
176 |             `;
177 |         }
178 |     }
179 | 
180 |     async function postFileTweet() {
181 |         const resultDiv = document.getElementById('fileResult');
182 | 
183 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Posting tweet...';
184 | 
185 |         try {
186 |             const response = await fetch('/post-tweet', {
187 |                 method: 'POST',
188 |                 headers: {
189 |                     'Content-Type': 'application/json'
190 |                 },
191 |                 body: JSON.stringify({
192 |                     type: 'file'
193 |                 })
194 |             });
195 | 
196 |             const data = await response.json();
197 | 
198 |             if (data.success) {
199 |                 resultDiv.innerHTML = `
200 |                     <div class="alert alert-success">
201 |                         <strong><i class="bi bi-check-circle"></i> Tweet Posted Successfully!</strong>
202 |                         <div class="tweet-box mt-2">
203 |                             ${data.tweet}
204 |                         </div>
205 |                     </div>
206 |                 `;
207 |             } else {
208 |                 resultDiv.innerHTML = `
209 |                     <div class="alert alert-danger">
210 |                         <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
211 |                         ${data.error}
212 |                     </div>
213 |                 `;
214 |             }
215 |         } catch (error) {
216 |             resultDiv.innerHTML = `
217 |                 <div class="alert alert-danger">
218 |                     <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
219 |                     ${error.message}
220 |                 </div>
221 |             `;
222 |         }
223 |     }
224 | 
225 |     async function postCustomTweet() {
226 |         const text = document.getElementById('customText').value;
227 |         const resultDiv = document.getElementById('customResult');
228 | 
229 |         if (!text.trim()) {
230 |             resultDiv.innerHTML = `
231 |                 <div class="alert alert-warning">
232 |                     <strong><i class="bi bi-exclamation-triangle"></i> Warning!</strong><br>
233 |                     Please enter some text for your tweet.
234 |                 </div>
235 |             `;
236 |             return;
237 |         }
238 | 
239 |         if (text.length > 280) {
240 |             resultDiv.innerHTML = `
241 |                 <div class="alert alert-warning">
242 |                     <strong><i class="bi bi-exclamation-triangle"></i> Warning!</strong><br>
243 |                     Your tweet is too long. Please keep it under 280 characters.
244 |                 </div>
245 |             `;
246 |             return;
247 |         }
248 | 
249 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Posting tweet...';
250 | 
251 |         try {
252 |             const response = await fetch('/post-tweet', {
253 |                 method: 'POST',
254 |                 headers: {
255 |                     'Content-Type': 'application/json'
256 |                 },
257 |                 body: JSON.stringify({
258 |                     type: 'text',
259 |                     text: text
260 |                 })
261 |             });
262 | 
263 |             const data = await response.json();
264 | 
265 |             if (data.success) {
266 |                 resultDiv.innerHTML = `
267 |                     <div class="alert alert-success">
268 |                         <strong><i class="bi bi-check-circle"></i> Tweet Posted Successfully!</strong>
269 |                         <div class="tweet-box mt-2">
270 |                             ${data.tweet}
271 |                         </div>
272 |                     </div>
273 |                 `;
274 |                 document.getElementById('customText').value = '';
275 |                 document.getElementById('charCount').textContent = '0';
276 |             } else {
277 |                 resultDiv.innerHTML = `
278 |                     <div class="alert alert-danger">
279 |                         <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
280 |                         ${data.error}
281 |                     </div>
282 |                 `;
283 |             }
284 |         } catch (error) {
285 |             resultDiv.innerHTML = `
286 |                 <div class="alert alert-danger">
287 |                     <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
288 |                     ${error.message}
289 |                 </div>
290 |             `;
291 |         }
292 |     }
293 | </script>
294 | {% endblock %}
295 | 


--------------------------------------------------------------------------------
/templates/schedule.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block title %}Schedule Tweets - Twitter Bot{% endblock %}
  4 | 
  5 | {% block content %}
  6 | <div class="row">
  7 |     <div class="col-12">
  8 |         <h1 class="mb-4">
  9 |             <i class="bi bi-calendar-check"></i> Schedule Tweets
 10 |         </h1>
 11 |     </div>
 12 | </div>
 13 | 
 14 | <div class="row">
 15 |     <div class="col-lg-8">
 16 |         <!-- Current Status -->
 17 |         <div class="card mb-4">
 18 |             <div class="card-header">
 19 |                 <i class="bi bi-activity"></i> Scheduler Status
 20 |             </div>
 21 |             <div class="card-body">
 22 |                 <div class="d-flex justify-content-between align-items-center">
 23 |                     <div>
 24 |                         <strong>Status:</strong>
 25 |                         <span id="schedulerStatus">
 26 |                             {% if scheduler_running %}
 27 |                                 <span class="status-badge status-running">
 28 |                                     <i class="bi bi-check-circle"></i> Running
 29 |                                 </span>
 30 |                             {% else %}
 31 |                                 <span class="status-badge status-stopped">
 32 |                                     <i class="bi bi-x-circle"></i> Stopped
 33 |                                 </span>
 34 |                             {% endif %}
 35 |                         </span>
 36 |                     </div>
 37 |                     <div>
 38 |                         {% if scheduler_running %}
 39 |                             <button class="btn btn-danger" onclick="stopScheduler()">
 40 |                                 <i class="bi bi-stop-circle"></i> Stop Scheduler
 41 |                             </button>
 42 |                         {% endif %}
 43 |                     </div>
 44 |                 </div>
 45 | 
 46 |                 {% if scheduled_jobs %}
 47 |                 <div class="mt-3">
 48 |                     <strong>Active Jobs:</strong>
 49 |                     <div id="activeJobs">
 50 |                         {% for job in scheduled_jobs %}
 51 |                         <div class="alert alert-info mt-2 mb-0">
 52 |                             <i class="bi bi-clock"></i> <strong>{{ job.time }}</strong> - {{ job.type }}
 53 |                             {% if job.prompt != 'N/A' %}
 54 |                             <br><small>Prompt: {{ job.prompt }}</small>
 55 |                             {% endif %}
 56 |                         </div>
 57 |                         {% endfor %}
 58 |                     </div>
 59 |                 </div>
 60 |                 {% endif %}
 61 |             </div>
 62 |         </div>
 63 | 
 64 |         <!-- Schedule AI Tweets -->
 65 |         <div class="card mb-4">
 66 |             <div class="card-header">
 67 |                 <i class="bi bi-robot"></i> Schedule AI-Generated Tweets
 68 |             </div>
 69 |             <div class="card-body">
 70 |                 <p>Automatically generate and post tweets daily using AI.</p>
 71 | 
 72 |                 <div class="row mb-3">
 73 |                     <div class="col-md-6">
 74 |                         <label for="aiScheduleTime" class="form-label">Time (24-hour format)</label>
 75 |                         <input type="time" class="form-control" id="aiScheduleTime" value="09:00">
 76 |                         <div class="form-text">When to post daily (e.g., 09:00 for 9:00 AM)</div>
 77 |                     </div>
 78 |                 </div>
 79 | 
 80 |                 <div class="mb-3">
 81 |                     <label for="aiSchedulePrompt" class="form-label">Prompt for AI</label>
 82 |                     <textarea class="form-control" id="aiSchedulePrompt" rows="3" placeholder="Example: Create a tweet about technology trends">Create a short tweet about Motorbikes.</textarea>
 83 |                     <div class="form-text">This prompt will be used to generate tweets daily.</div>
 84 |                 </div>
 85 | 
 86 |                 <button class="btn btn-primary" onclick="startAISchedule()">
 87 |                     <i class="bi bi-calendar-plus"></i> Start AI Schedule
 88 |                 </button>
 89 | 
 90 |                 <div id="aiScheduleResult" class="mt-3"></div>
 91 |             </div>
 92 |         </div>
 93 | 
 94 |         <!-- Schedule File Tweets -->
 95 |         <div class="card mb-4">
 96 |             <div class="card-header">
 97 |                 <i class="bi bi-file-text"></i> Schedule Tweets from File
 98 |             </div>
 99 |             <div class="card-body">
100 |                 <p>Automatically post random tweets from your library daily.</p>
101 | 
102 |                 <div class="row mb-3">
103 |                     <div class="col-md-6">
104 |                         <label for="fileScheduleTime" class="form-label">Time (24-hour format)</label>
105 |                         <input type="time" class="form-control" id="fileScheduleTime" value="12:00">
106 |                         <div class="form-text">When to post daily (e.g., 12:00 for noon)</div>
107 |                     </div>
108 |                 </div>
109 | 
110 |                 <button class="btn btn-primary" onclick="startFileSchedule()">
111 |                     <i class="bi bi-calendar-plus"></i> Start File Schedule
112 |                 </button>
113 | 
114 |                 <div id="fileScheduleResult" class="mt-3"></div>
115 |             </div>
116 |         </div>
117 |     </div>
118 | 
119 |     <!-- Info Sidebar -->
120 |     <div class="col-lg-4">
121 |         <div class="card">
122 |             <div class="card-header">
123 |                 <i class="bi bi-info-circle"></i> How Scheduling Works
124 |             </div>
125 |             <div class="card-body">
126 |                 <h6><i class="bi bi-gear"></i> Setup:</h6>
127 |                 <ul class="small">
128 |                     <li>Choose between AI or File-based tweets</li>
129 |                     <li>Set the time when tweets should post</li>
130 |                     <li>Start the scheduler</li>
131 |                     <li>The bot will post automatically each day</li>
132 |                 </ul>
133 | 
134 |                 <h6 class="mt-3"><i class="bi bi-exclamation-triangle"></i> Important:</h6>
135 |                 <ul class="small">
136 |                     <li>Only one scheduler can run at a time</li>
137 |                     <li>The web server must remain running</li>
138 |                     <li>Times are in 24-hour format (HH:MM)</li>
139 |                     <li>Stop the scheduler to change settings</li>
140 |                 </ul>
141 | 
142 |                 <h6 class="mt-3"><i class="bi bi-lightbulb"></i> Tips:</h6>
143 |                 <ul class="small">
144 |                     <li>Test your setup with a near-future time first</li>
145 |                     <li>Schedule during peak engagement hours</li>
146 |                     <li>Monitor the scheduler status regularly</li>
147 |                     <li>Keep diverse content in your tweet library</li>
148 |                 </ul>
149 |             </div>
150 |         </div>
151 | 
152 |         <div class="card mt-3">
153 |             <div class="card-header">
154 |                 <i class="bi bi-clock-history"></i> Time Zone
155 |             </div>
156 |             <div class="card-body">
157 |                 <p class="small mb-0">
158 |                     All times are based on your server's time zone.
159 |                     Current server time: <strong id="serverTime"></strong>
160 |                 </p>
161 |             </div>
162 |         </div>
163 |     </div>
164 | </div>
165 | 
166 | {% endblock %}
167 | 
168 | {% block extra_js %}
169 | <script>
170 |     // Update server time
171 |     function updateServerTime() {
172 |         const now = new Date();
173 |         document.getElementById('serverTime').textContent = now.toLocaleTimeString();
174 |     }
175 |     updateServerTime();
176 |     setInterval(updateServerTime, 1000);
177 | 
178 |     async function startAISchedule() {
179 |         const time = document.getElementById('aiScheduleTime').value;
180 |         const prompt = document.getElementById('aiSchedulePrompt').value;
181 |         const resultDiv = document.getElementById('aiScheduleResult');
182 | 
183 |         if (!time) {
184 |             resultDiv.innerHTML = `
185 |                 <div class="alert alert-warning">
186 |                     <i class="bi bi-exclamation-triangle"></i> Please select a time.
187 |                 </div>
188 |             `;
189 |             return;
190 |         }
191 | 
192 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Starting scheduler...';
193 | 
194 |         try {
195 |             const response = await fetch('/start-schedule', {
196 |                 method: 'POST',
197 |                 headers: {
198 |                     'Content-Type': 'application/json'
199 |                 },
200 |                 body: JSON.stringify({
201 |                     type: 'ai',
202 |                     time: time,
203 |                     prompt: prompt
204 |                 })
205 |             });
206 | 
207 |             const data = await response.json();
208 | 
209 |             if (data.success) {
210 |                 resultDiv.innerHTML = `
211 |                     <div class="alert alert-success">
212 |                         <strong><i class="bi bi-check-circle"></i> Success!</strong><br>
213 |                         ${data.message}
214 |                     </div>
215 |                 `;
216 |                 setTimeout(() => location.reload(), 2000);
217 |             } else {
218 |                 resultDiv.innerHTML = `
219 |                     <div class="alert alert-danger">
220 |                         <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
221 |                         ${data.error}
222 |                     </div>
223 |                 `;
224 |             }
225 |         } catch (error) {
226 |             resultDiv.innerHTML = `
227 |                 <div class="alert alert-danger">
228 |                     <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
229 |                     ${error.message}
230 |                 </div>
231 |             `;
232 |         }
233 |     }
234 | 
235 |     async function startFileSchedule() {
236 |         const time = document.getElementById('fileScheduleTime').value;
237 |         const resultDiv = document.getElementById('fileScheduleResult');
238 | 
239 |         if (!time) {
240 |             resultDiv.innerHTML = `
241 |                 <div class="alert alert-warning">
242 |                     <i class="bi bi-exclamation-triangle"></i> Please select a time.
243 |                 </div>
244 |             `;
245 |             return;
246 |         }
247 | 
248 |         resultDiv.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Starting scheduler...';
249 | 
250 |         try {
251 |             const response = await fetch('/start-schedule', {
252 |                 method: 'POST',
253 |                 headers: {
254 |                     'Content-Type': 'application/json'
255 |                 },
256 |                 body: JSON.stringify({
257 |                     type: 'file',
258 |                     time: time
259 |                 })
260 |             });
261 | 
262 |             const data = await response.json();
263 | 
264 |             if (data.success) {
265 |                 resultDiv.innerHTML = `
266 |                     <div class="alert alert-success">
267 |                         <strong><i class="bi bi-check-circle"></i> Success!</strong><br>
268 |                         ${data.message}
269 |                     </div>
270 |                 `;
271 |                 setTimeout(() => location.reload(), 2000);
272 |             } else {
273 |                 resultDiv.innerHTML = `
274 |                     <div class="alert alert-danger">
275 |                         <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
276 |                         ${data.error}
277 |                     </div>
278 |                 `;
279 |             }
280 |         } catch (error) {
281 |             resultDiv.innerHTML = `
282 |                 <div class="alert alert-danger">
283 |                     <strong><i class="bi bi-x-circle"></i> Error!</strong><br>
284 |                     ${error.message}
285 |                 </div>
286 |             `;
287 |         }
288 |     }
289 | 
290 |     async function stopScheduler() {
291 |         if (!confirm('Are you sure you want to stop the scheduler?')) {
292 |             return;
293 |         }
294 | 
295 |         try {
296 |             const response = await fetch('/stop-schedule', {
297 |                 method: 'POST'
298 |             });
299 | 
300 |             const data = await response.json();
301 | 
302 |             if (data.success) {
303 |                 showToast('Scheduler stopped successfully!', 'success');
304 |                 setTimeout(() => location.reload(), 1000);
305 |             } else {
306 |                 showToast('Error: ' + data.error, 'danger');
307 |             }
308 |         } catch (error) {
309 |             showToast('Error: ' + error.message, 'danger');
310 |         }
311 |     }
312 | 
313 |     // Auto-refresh scheduler status every 10 seconds
314 |     setInterval(async () => {
315 |         try {
316 |             const response = await fetch('/scheduler-status');
317 |             const data = await response.json();
318 | 
319 |             // Update status badge
320 |             const statusSpan = document.querySelector('#schedulerStatus span');
321 |             if (data.running) {
322 |                 statusSpan.className = 'status-badge status-running';
323 |                 statusSpan.innerHTML = '<i class="bi bi-check-circle"></i> Running';
324 |             } else {
325 |                 statusSpan.className = 'status-badge status-stopped';
326 |                 statusSpan.innerHTML = '<i class="bi bi-x-circle"></i> Stopped';
327 |             }
328 |         } catch (error) {
329 |             console.error('Error fetching scheduler status:', error);
330 |         }
331 |     }, 10000);
332 | </script>
333 | {% endblock %}
334 | 


--------------------------------------------------------------------------------