377 lines
14 KiB
Python
377 lines
14 KiB
Python
"""
|
|
Minecraft Update Bot - Detects new Minecraft releases and posts to Reddit
|
|
"""
|
|
|
|
import praw
|
|
import json
|
|
import time
|
|
import os
|
|
import threading
|
|
from datetime import datetime
|
|
import config
|
|
from minecraft_checker import get_latest_releases, parse_release_date
|
|
from bedrock_checker import get_latest_bedrock_release
|
|
from wiki_config import WikiConfig
|
|
from update_checker import start_update_checker
|
|
|
|
|
|
# Bot version (increment when making changes)
|
|
BOT_VERSION = "1.0.0"
|
|
|
|
# Database file to track posted versions
|
|
DB_DIR = os.path.join(os.path.dirname(__file__), 'DB')
|
|
POSTED_VERSIONS_FILE = os.path.join(DB_DIR, 'posted_versions.json')
|
|
|
|
# Wiki configuration manager (initialized on startup)
|
|
wiki_config = WikiConfig()
|
|
|
|
|
|
def init_db():
|
|
"""Initialize the database directory and posted versions file."""
|
|
os.makedirs(DB_DIR, exist_ok=True)
|
|
|
|
if not os.path.exists(POSTED_VERSIONS_FILE):
|
|
with open(POSTED_VERSIONS_FILE, 'w') as f:
|
|
json.dump({"posted": []}, f, indent=2)
|
|
|
|
|
|
def load_posted_versions():
|
|
"""Load the list of already-posted version IDs."""
|
|
try:
|
|
with open(POSTED_VERSIONS_FILE, 'r') as f:
|
|
data = json.load(f)
|
|
return set(data.get("posted", []))
|
|
except:
|
|
return set()
|
|
|
|
|
|
def save_posted_version(version_id):
|
|
"""Save a version ID as posted."""
|
|
try:
|
|
with open(POSTED_VERSIONS_FILE, 'r') as f:
|
|
data = json.load(f)
|
|
except:
|
|
data = {"posted": []}
|
|
|
|
if version_id not in data.get("posted", []):
|
|
data.setdefault("posted", []).append(version_id)
|
|
|
|
with open(POSTED_VERSIONS_FILE, 'w') as f:
|
|
json.dump(data, f, indent=2)
|
|
|
|
|
|
def make_reddit_connection():
|
|
"""Create a Reddit API connection using PRAW."""
|
|
try:
|
|
reddit = praw.Reddit(
|
|
client_id=config.REDDIT_CLIENT_ID,
|
|
client_secret=config.REDDIT_CLIENT_SECRET,
|
|
user_agent=config.REDDIT_USER_AGENT,
|
|
username=config.REDDIT_USERNAME,
|
|
password=config.REDDIT_PASSWORD
|
|
)
|
|
|
|
# Test the connection
|
|
reddit.user.me()
|
|
print("[BOT] ✓ Successfully connected to Reddit")
|
|
return reddit
|
|
except Exception as e:
|
|
print(f"[BOT] ✗ Failed to connect to Reddit: {e}")
|
|
return None
|
|
|
|
|
|
def post_to_subreddit(reddit, version_info):
|
|
"""
|
|
Post a message about a new Minecraft release to the subreddit.
|
|
|
|
Args:
|
|
reddit: PRAW Reddit instance
|
|
version_info: Dict with keys: id, type, releaseTime
|
|
|
|
Returns:
|
|
True if successful, False otherwise
|
|
"""
|
|
try:
|
|
version_id = version_info["id"]
|
|
release_type = version_info["type"]
|
|
release_date = parse_release_date(version_info["releaseTime"])
|
|
|
|
# Get title and body from wiki config
|
|
title, body = wiki_config.format_post(release_type, version_id, release_date)
|
|
|
|
subreddit = reddit.subreddit(config.SUBREDDIT)
|
|
submission = subreddit.submit(title, selftext=body)
|
|
|
|
print(f"[BOT] ✓ Posted Minecraft {version_id} ({release_type})")
|
|
print(f" URL: {submission.url}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"[BOT] ✗ Failed to post: {e}")
|
|
return False
|
|
|
|
|
|
def check_for_updates(reddit):
|
|
"""
|
|
Check for new Minecraft releases (Java & Bedrock) and post if any are new.
|
|
|
|
Args:
|
|
reddit: PRAW Reddit instance
|
|
"""
|
|
try:
|
|
posted_versions = load_posted_versions()
|
|
|
|
# Check Java Edition releases
|
|
java_releases = get_latest_releases(config.RELEASE_TYPES)
|
|
for version_info in java_releases:
|
|
version_id = version_info["id"]
|
|
|
|
if version_id not in posted_versions:
|
|
print(f"[BOT] New Java release found: {version_id}")
|
|
if post_to_subreddit(reddit, version_info):
|
|
save_posted_version(version_id)
|
|
else:
|
|
print(f"[BOT] Java version {version_id} already posted, skipping")
|
|
|
|
# Check Bedrock Edition releases if enabled
|
|
if config.CHECK_BEDROCK:
|
|
print(f"[BOT] Checking Bedrock Edition releases...")
|
|
bedrock_release = get_latest_bedrock_release()
|
|
if bedrock_release:
|
|
bedrock_id = f"bedrock-{bedrock_release['version']}"
|
|
source = bedrock_release.get('source', 'unknown')
|
|
|
|
if bedrock_id not in posted_versions:
|
|
print(f"[BOT] New Bedrock release found: {bedrock_release['version']} (from {source})")
|
|
if post_to_subreddit(reddit, bedrock_release):
|
|
save_posted_version(bedrock_id)
|
|
else:
|
|
print(f"[BOT] Bedrock version {bedrock_release['version']} already posted, skipping")
|
|
else:
|
|
print(f"[BOT] ⚠ No Bedrock release data available")
|
|
else:
|
|
print(f"[BOT] Bedrock Edition checking is disabled (REDDIT_CHECK_BEDROCK={config.CHECK_BEDROCK})")
|
|
|
|
except Exception as e:
|
|
print(f"[BOT] ✗ Error checking for updates: {e}")
|
|
|
|
|
|
def repost_latest_versions(reddit):
|
|
"""
|
|
Repost the latest Minecraft releases (Java & Bedrock).
|
|
|
|
This bypasses the "already posted" check, allowing moderators to
|
|
manually repost the latest versions via the "repost-latest" chat command.
|
|
|
|
Args:
|
|
reddit: PRAW Reddit instance
|
|
"""
|
|
try:
|
|
posted_count = 0
|
|
|
|
# Repost latest Java Edition releases
|
|
java_releases = get_latest_releases(config.RELEASE_TYPES)
|
|
for version_info in java_releases:
|
|
version_id = version_info["id"]
|
|
print(f"[BOT] Reposting Java release: {version_id}")
|
|
if post_to_subreddit(reddit, version_info):
|
|
posted_count += 1
|
|
|
|
# Repost latest Bedrock Edition release if enabled
|
|
if config.CHECK_BEDROCK:
|
|
bedrock_release = get_latest_bedrock_release()
|
|
if bedrock_release:
|
|
version_id = bedrock_release["id"]
|
|
print(f"[BOT] Reposting Bedrock release: {version_id}")
|
|
if post_to_subreddit(reddit, bedrock_release):
|
|
posted_count += 1
|
|
else:
|
|
print(f"[BOT] ⚠ No Bedrock release data available for repost")
|
|
|
|
print(f"[BOT] ✓ Reposted {posted_count} version(s)")
|
|
return posted_count > 0
|
|
|
|
except Exception as e:
|
|
print(f"[BOT] ✗ Error reposting latest versions: {e}")
|
|
return False
|
|
|
|
|
|
def chat_message_watcher(reddit):
|
|
"""
|
|
Background thread that watches for chat messages with reload commands.
|
|
|
|
Monitors Reddit chat messages for moderators sending "reload-config"
|
|
to trigger a reload of the wiki configuration without restarting the bot.
|
|
|
|
Args:
|
|
reddit: PRAW Reddit instance
|
|
"""
|
|
chat_requests_file = os.path.join(DB_DIR, 'chat_wiki_requests.txt')
|
|
processed_message_ids = set()
|
|
subreddit = reddit.subreddit(config.SUBREDDIT)
|
|
|
|
print("[CHAT] Chat message watcher started")
|
|
|
|
# Load previously processed message IDs
|
|
if os.path.exists(chat_requests_file):
|
|
try:
|
|
with open(chat_requests_file, 'r', encoding='utf-8') as f:
|
|
for line in f:
|
|
processed_message_ids.add(line.strip())
|
|
except Exception as e:
|
|
print(f"[CHAT] Error loading processed message IDs: {e}")
|
|
|
|
# Get the latest message timestamp at startup
|
|
last_seen_timestamp = None
|
|
try:
|
|
# Fetch the most recent message (limit=1)
|
|
latest = list(reddit.inbox.all(limit=1))
|
|
if latest and hasattr(latest[0], 'created_utc'):
|
|
last_seen_timestamp = latest[0].created_utc
|
|
print(f"[CHAT] Last seen message timestamp at startup: {last_seen_timestamp}")
|
|
except Exception as e:
|
|
print(f"[CHAT] Error fetching latest message timestamp: {e}")
|
|
|
|
while True:
|
|
try:
|
|
for message in reddit.inbox.stream():
|
|
# Skip if no ID, already processed, or message is older than startup
|
|
if (not hasattr(message, 'id') or message.id in processed_message_ids or
|
|
(last_seen_timestamp is not None and hasattr(message, 'created_utc') and message.created_utc <= last_seen_timestamp)):
|
|
continue
|
|
|
|
# Mark as processed
|
|
processed_message_ids.add(message.id)
|
|
try:
|
|
with open(chat_requests_file, 'a', encoding='utf-8') as f:
|
|
f.write(message.id + '\n')
|
|
except Exception as e:
|
|
print(f"[CHAT] Error saving message ID: {e}")
|
|
|
|
# Check for reload-config command
|
|
if hasattr(message, 'body') and 'reload-config' in message.body.lower():
|
|
author = getattr(message, 'author', None)
|
|
|
|
# Verify sender is a moderator
|
|
try:
|
|
if author and author in subreddit.moderator():
|
|
print(f"[CHAT] Moderator '{author}' requested config reload")
|
|
|
|
# Reload wiki configuration
|
|
try:
|
|
wiki_config.fetch_from_wiki()
|
|
print("[CHAT] Wiki config reloaded successfully")
|
|
reply_text = "✓ Wiki config reloaded successfully!"
|
|
except Exception as e:
|
|
print(f"[CHAT] Failed to reload wiki config: {e}")
|
|
reply_text = f"✗ Failed to reload wiki config: {e}"
|
|
|
|
# Reply to the message
|
|
try:
|
|
message.reply(reply_text)
|
|
print(f"[CHAT] Replied to message {message.id}")
|
|
except Exception as e:
|
|
print(f"[CHAT] Error replying to message {message.id}: {message.id}: {e}")
|
|
else:
|
|
print(f"[CHAT] Non-moderator '{author}' attempted reload-config (ignored)")
|
|
except Exception as e:
|
|
print(f"[CHAT] Error checking moderator status: {e}")
|
|
|
|
# Check for repost-latest command
|
|
elif hasattr(message, 'body') and 'repost-latest' in message.body.lower():
|
|
author = getattr(message, 'author', None)
|
|
|
|
# Verify sender is a moderator
|
|
try:
|
|
if author and author in subreddit.moderator():
|
|
print(f"[CHAT] Moderator '{author}' requested repost of latest versions")
|
|
|
|
# Repost latest versions
|
|
try:
|
|
if repost_latest_versions(reddit):
|
|
reply_text = "✓ Latest versions reposted successfully!"
|
|
else:
|
|
reply_text = "✗ Failed to repost latest versions."
|
|
except Exception as e:
|
|
print(f"[CHAT] Error reposting latest versions: {e}")
|
|
reply_text = f"✗ Error reposting latest versions: {e}"
|
|
|
|
# Reply to the message
|
|
try:
|
|
message.reply(reply_text)
|
|
print(f"[CHAT] Replied to message {message.id}")
|
|
except Exception as e:
|
|
print(f"[CHAT] Error replying to message {message.id}: {e}")
|
|
else:
|
|
print(f"[CHAT] Non-moderator '{author}' attempted repost-latest (ignored)")
|
|
except Exception as e:
|
|
print(f"[CHAT] Error checking moderator status: {e}")
|
|
|
|
except Exception as e:
|
|
print(f"[CHAT] Error in chat message watcher: {e}")
|
|
|
|
time.sleep(30)
|
|
|
|
|
|
def bot_thread(reddit):
|
|
"""
|
|
Background thread that periodically checks for Minecraft updates.
|
|
|
|
Args:
|
|
reddit: PRAW Reddit instance
|
|
"""
|
|
print(f"[BOT] Started update checker (checking every {config.CHECK_INTERVAL} seconds)")
|
|
|
|
while True:
|
|
try:
|
|
check_for_updates(reddit)
|
|
except Exception as e:
|
|
print(f"[BOT] ✗ Error in bot thread: {e}")
|
|
|
|
time.sleep(config.CHECK_INTERVAL)
|
|
|
|
|
|
def start_bot():
|
|
"""Start the Minecraft Update Bot."""
|
|
print("[BOT] Starting Minecraft Update Bot...")
|
|
|
|
# Initialize database
|
|
init_db()
|
|
|
|
# Connect to Reddit
|
|
reddit = make_reddit_connection()
|
|
if not reddit:
|
|
print("[BOT] ✗ Cannot start bot without Reddit connection")
|
|
return
|
|
|
|
# Initialize wiki configuration
|
|
wiki_config.init(reddit, config.SUBREDDIT)
|
|
wiki_config.fetch_from_wiki()
|
|
|
|
# Start update checker
|
|
start_update_checker(reddit, config.SUBREDDIT, "MinecraftUpdateBot", BOT_VERSION)
|
|
|
|
# Do an initial check
|
|
check_for_updates(reddit)
|
|
|
|
# Start background thread for update checking
|
|
thread = threading.Thread(target=bot_thread, args=(reddit,), daemon=True)
|
|
thread.start()
|
|
|
|
# Start background thread for chat commands
|
|
chat_thread = threading.Thread(target=chat_message_watcher, args=(reddit,), daemon=True)
|
|
chat_thread.start()
|
|
|
|
print("[BOT] ✓ Bot is running")
|
|
|
|
# Keep main thread alive
|
|
try:
|
|
while True:
|
|
time.sleep(1)
|
|
except KeyboardInterrupt:
|
|
print("\n[BOT] Shutting down...")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
start_bot()
|