目次
- Botでできること
- 前提・環境準備
- ディレクトリ構成と依存ライブラリ
- 環境変数の設定 (.env)
-
主要モジュール解説
- load/save 周り（JSON・YAML）
- 要約機能 (
summarize_article) - パーソナライズ推薦 (
get_personalized_recommendations) - 日次レコメンドタスク (
daily_recommendations) - Discord イベントハンドラ
- コマンド一覧
- デプロイと運用
- おわりに
- コード全文
このBotでできること
-
記事の自動要約
ユーザーがリアクションを付けたりリプライした記事URLをAzure OpenAIで日本語要約 -
ユーザー履歴の管理
反応・コメント履歴をJSONファイルで永続化し、TF-IDFで個人向け推薦を実施 -
RSSフィードの動的追加／削除
!recommend-news-add／!recommend-news-deleteなどでカテゴリ単位にRSSを管理 -
日次レコメンド配信
毎日決まった時刻にDMでその日のおすすめ記事を自動配信 -
権限管理
ロールベースでコマンド使用可否を制御
前提・環境準備
- Python 3.8+
- Discord Bot アカウント（トークン取得済み）
- Azure OpenAI サービス利用権限（APIキー・エンドポイント取得済み）
- サーバー or VPS などの常時稼働環境
# 必要ライブラリのインストール例
pip install discord.py feedparser openai pyyaml python-dotenv scikit-learn requests beautifulsoup4
ディレクトリ構成と依存ライブラリ
your-bot/
├─ bot.py # メインコード（以下サンプルと同等）
├─ news-config.yaml # RSSフィード設定 (YAML)
├─ news_user_history.json # ユーザー閲覧履歴 (JSON)
├─ reaction_history.json # リアクション・コメント履歴 (JSON)
└─ .env # 環境変数
- feedparser：RSS/Atomフィードの取得
- openai (Azure)：Chat API 呼び出し
- yaml：RSS設定管理
- sklearn：TF-IDF + コサイン類似度
-
dotenv：
.envからトークン・APIキー読み込み - requests + BeautifulSoup4：外部記事のHTML解析
環境変数の設定 (.env)
# Discord Bot
DISCORD_BOT_TOKEN=あなたのDiscordトークン
# Azure OpenAI
AZURE_OPENAI_API_KEY=あなたのAPIキー
AZURE_OPENAI_ENDPOINT=https://<あなたのリソース名>.openai.azure.com/
主要モジュール解説
1. load/save 周り（JSON・YAML）
# ユーザーニュース履歴をJSONから読み書き
def load_user_history():
# USER_HISTORY_FILE → news_user_history.json
…
def save_user_history():
…
# RSS設定をYAMLで管理
def load_news_config() -> Dict:
# NEWS_CONFIG_FILE → news-config.yaml
…
def save_news_config(config: Dict) -> bool:
…
- ユーザーごとにリアクション・コメントした記事URLを配列で保持。
- YAMLにはカテゴリ単位で
rss_feeds: { tech: [url1, url2], … }を記述可能。
2. 要約機能 (summarize_article)
async def summarize_article(url, user_request=None):
client = openai.AzureOpenAI(
api_key=AZURE_OPENAI_API_KEY,
api_version="2023-05-15",
azure_endpoint=AZURE_OPENAI_ENDPOINT
)
system_prompt = "あなたはニュース記事を要約するアシスタントです。要約は必ず日本語で出力してください。"
user_prompt = f"以下のニュース記事を日本語で要約してください。\n記事URL: {url}"
if user_request:
user_prompt += f"\nユーザーのリクエスト: 「{user_request}」を考慮してください。"
else:
user_prompt += "\n簡潔に要約してください。"
response = client.chat.completions.create(
model="gpt-4o", messages=[
{"role":"system","content":system_prompt},
{"role":"user","content":user_prompt}
],
max_tokens=250, temperature=0.5
)
return response.choices[0].message.content.strip()
- ポイント：system/user プロンプトを分けることで、要約時の出力トーンを安定させる。
3. パーソナライズ推薦 (get_personalized_recommendations)
async def get_personalized_recommendations(user_id, top_n=3):
history = user_news_history.get(user_id, [])
# 履歴が2件以上ない場合は推薦なし
if len(history) < 2: return []
# 全記事をRSSから収集
all_articles = []
config = load_news_config()
for feeds in config['rss_feeds'].values():
for url in feeds:
feed = feedparser.parse(url)
for e in feed.entries:
if e.link not in history:
all_articles.append({
'title': e.title, 'link': e.link,
'description': getattr(e, 'description', ''),
'published': getattr(e, 'published', '')
})
# TF-IDF行列を生成し、ユーザープロファイルと類似度計算
corpus = history + [a['link'] + a['title'] + a['description'] for a in all_articles]
vect = TfidfVectorizer(stop_words='english')
mat = vect.fit_transform(corpus)
user_vec = mat[:len(history)].mean(axis=0)
art_vecs = mat[len(history):]
scores = cosine_similarity(user_vec, art_vecs)[0]
ranked = sorted(zip(all_articles, scores), key=lambda x: x[1], reverse=True)
return [a for a, _ in ranked[:top_n]]
- ユーザ履歴と全記事を同一TF-IDF空間にマッピングし、平均ベクトルとのコサイン類似度で上位を抽出。
4. 日次レコメンドタスク (daily_recommendations)
async def daily_recommendations():
await asyncio.sleep(3600) # 起動直後は1時間待機
while True:
for user_id in user_news_history:
if len(user_news_history[user_id]) < 2: continue
user = await client.fetch_user(user_id)
recs = await get_personalized_recommendations(user_id, top_n=5)
if recs:
embed = discord.Embed(
title="📰 今日のニュース推薦",
description="あなたの閲覧履歴に基づくおすすめ記事",
color=discord.Color.blue()
)
for i, art in enumerate(recs, 1):
info = f"{i}. {art['title']} ({art['published']})"
embed.add_field(name=info, value=f"[読む]({art['link']})", inline=False)
await user.send(embed=embed)
await asyncio.sleep(24 * 3600)
- Bot起動から１時間後に最初の配信、その後24時間ごとに自動実行。
5. Discord イベントハンドラ
-
on_raw_reaction_add：指定チャンネルへのリアクションを検出し、ログ保存 → 要約 & 推薦 → DM -
on_message：-
!recommend-news-add／!recommend-news-delete等のコマンド - Techチャンネル内でのリプライをコンテキストとして要約・推薦
-
各ハンドラ内で共通して以下を実施：
- URL抽出（メッセージ本文・Embed含む）
- ログ記録（reaction_history.json）
- 履歴更新（news_user_history.json）
- 要約＆推薦生成 → DM
コマンド一覧
| コマンド | 概要 |
|---|---|
!recommend-news-add <カテゴリ> <RSS URL> |
RSSフィードをカテゴリに追加 |
!recommend-news-delete <カテゴリ> <RSS URL> |
RSSフィードをカテゴリから削除 |
!recommend-news-list [カテゴリ] |
登録中のRSSフィード一覧を表示 |
!recommend-history [@ユーザー] |
指定ユーザー（自身）の履歴をDM送信 |
!reaction-history |
リアクション履歴全体を表示（権限要） |
デプロイと運用
-
VPSへの配置
-
bot.py／.env／news-config.yaml／JSONファイル群 を同一ディレクトリに配置
-
-
永続化とプロセスマネージャ
-
systemdもしくはpm2で常時稼働
-
# /etc/systemd/system/news-bot.service の例
[Unit]
Description=Discord News Recommendation Bot
[Service]
Type=simple
WorkingDirectory=/home/youruser/your-bot
ExecStart=/usr/bin/python3 bot.py
Restart=always
[Install]
WantedBy=multi-user.target
-
運用ポイント
- RSS設定変更後はBot再起動不要（YAMLのreload処理あり）
- JSONファイルのバックアップを定期実行
- Botトークン・APIキー漏洩時は即座に再発行
おわりに
以上、DiscordとAzure OpenAI、TF-IDFベースの推薦システムを組み合わせたニュースBotの全体像と実装ポイントをご紹介しました。Noteでの公開にあわせ、必要なファイル構成や環境設定の手順、主要な関数解説をMarkdown形式でまとめています。皆さんのプロジェクトの参考になれば幸いです。
コード全文
import discord
import feedparser
import openai
import yaml
import os
import json
import datetime
from datetime import timezone
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from dotenv import load_dotenv
import asyncio
from typing import Dict, List
import requests
from bs4 import BeautifulSoup
import re
# Get the directory of this script
script_dir = os.path.dirname(os.path.abspath(__file__))
# Load environment variables
dotenv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
load_dotenv(dotenv_path=dotenv_path)
# Discord bot token
DISCORD_TOKEN = os.getenv("DISCORD_BOT_TOKEN","MTM0NDEyMzg2Njc1NDMxODQzOA.GUYnR_.lHmrq05qW82YyYM4uEQ4s7MFQwdv9r_wHgqWzY")
if not DISCORD_TOKEN:
print("Error: DISCORD_BOT_TOKEN not found in environment variables. Please set it.")
exit()
# Azure OpenAI API key and endpoint
AZURE_OPENAI_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
if not AZURE_OPENAI_API_KEY or not AZURE_OPENAI_ENDPOINT:
print("Error: AZURE_OPENAI_API_KEY or AZURE_OPENAI_ENDPOINT not found in environment variables. Please set them.")
exit()
openai.api_type = "azure"
openai.api_version = "2023-05-15"
openai.api_base = AZURE_OPENAI_ENDPOINT
openai.api_key = AZURE_OPENAI_API_KEY
# Discord client
intents = discord.Intents.default()
intents.message_content = True
intents.reactions = True
client = discord.Client(intents=intents)
# File to store user news history - using a separate file to avoid conflicts
USER_HISTORY_FILE = os.path.join(script_dir, "news_user_history.json")
# User news history and reaction history files
user_news_history = {}
REACTION_HISTORY_FILE = os.path.join(script_dir, "reaction_history.json")
def load_reaction_history():
"""リアクション履歴をJSONファイルから読み込む"""
if os.path.exists(REACTION_HISTORY_FILE):
try:
with open(REACTION_HISTORY_FILE, 'r', encoding='utf-8') as f:
data = json.load(f)
if not isinstance(data, dict) or "reactions" not in data:
print("Invalid reaction history format, initializing with empty history")
return {"reactions": []}
return data
except Exception as e:
print(f"Error loading reaction history: {e}")
return {"reactions": []}
else:
print("No reaction history file found, starting with empty history")
return {"reactions": []} # Ensure 'reactions' key exists
def save_reaction_history(reaction_data):
"""リアクション履歴をJSONファイルに保存"""
# Ensure the main key exists before saving
if "reactions" not in reaction_data:
reaction_data = {"reactions": []}
try:
with open(REACTION_HISTORY_FILE, 'w', encoding='utf-8') as f:
json.dump(reaction_data, f, ensure_ascii=False, indent=2)
# Check if 'reactions' key exists before accessing its length
num_entries = len(reaction_data.get("reactions", []))
print(f"Saved reaction history with {num_entries} entries")
return True
except Exception as e:
print(f"Error saving reaction history: {e}")
return False
def load_user_history():
"""ユーザー履歴をJSONファイルから読み込む"""
global user_news_history
if os.path.exists(USER_HISTORY_FILE):
try:
with open(USER_HISTORY_FILE, 'r', encoding='utf-8') as f:
# JSON形式（キーは文字列）からPython形式（キーは整数）に変換
data = json.load(f)
user_news_history = {int(user_id): urls for user_id, urls in data.items()}
print(f"Loaded user history for {len(user_news_history)} users")
except Exception as e:
print(f"Error loading user history: {e}")
user_news_history = {}
else:
print("No user history file found, starting with empty history")
user_news_history = {}
def save_user_history():
"""ユーザー履歴をJSONファイルに保存"""
try:
with open(USER_HISTORY_FILE, 'w', encoding='utf-8') as f:
json.dump(user_news_history, f, ensure_ascii=False, indent=2)
print(f"Saved user history for {len(user_news_history)} users")
return True
except Exception as e:
print(f"Error saving user history: {e}")
return False
# Configuration file - using absolute path with script directory
NEWS_CONFIG_FILE = os.path.join(script_dir, "news-config.yaml")
# Technology news channel ID
# Ensure this ID is correct for the channel you want to monitor
TECH_CHANNEL_ID = 856702707838484511
# Allowed roles
ALLOWED_ROLES = {
"news": ["G.state"], # Keep role check for commands
}
# Helper functions
def load_news_config() -> Dict:
"""ニュース設定ファイル (YAML) を読み込む"""
if not os.path.exists(NEWS_CONFIG_FILE):
return {'rss_feeds': {}}
try:
with open(NEWS_CONFIG_FILE, 'r', encoding='utf-8') as f:
# Use safe_load to prevent arbitrary code execution
config = yaml.safe_load(f)
# Ensure the base structure exists
if config is None:
return {'rss_feeds': {}}
if 'rss_feeds' not in config or not isinstance(config['rss_feeds'], dict):
config['rss_feeds'] = {}
return config
except yaml.YAMLError as e:
print(f"ニュース設定ファイル ({NEWS_CONFIG_FILE}) のYAMLパースエラー: {e}")
return {'rss_feeds': {}}
except IOError as e:
print(f"ニュース設定ファイル ({NEWS_CONFIG_FILE}) の読み込みエラー: {e}")
return {'rss_feeds': {}}
def save_news_config(config: Dict) -> bool:
"""ニュース設定ファイル (YAML) を保存する"""
try:
with open(NEWS_CONFIG_FILE, 'w', encoding='utf-8') as f:
# allow_unicode=True ensures Japanese characters are saved correctly
yaml.dump(config, f, allow_unicode=True, default_flow_style=False)
return True
except IOError as e:
print(f"ニュース設定ファイル ({NEWS_CONFIG_FILE}) の書き込みエラー: {e}")
return False
except yaml.YAMLError as e:
print(f"ニュース設定ファイル ({NEWS_CONFIG_FILE}) のYAML書き込みエラー: {e}")
return False
def has_required_roles(member, command_type: str) -> bool:
"""ユーザーが指定されたコマンドタイプに必要なロールを持っているか確認"""
# コマンドタイプの設定が存在しない場合は誰でも利用可能
if command_type not in ALLOWED_ROLES:
return True
# 許可ロールが空の場合は誰でも利用可能
if not ALLOWED_ROLES[command_type]:
return True
# DMの場合（memberがdiscord.Memberではない場合）、許可ロールが空なら許可
if not isinstance(member, discord.Member):
return not ALLOWED_ROLES[command_type] # 空リストならTrue、そうでなければFalse
# ユーザーのロールを確認
user_roles = [role.name for role in member.roles]
# 必要なロールのいずれかを持っているか確認
for allowed_role in ALLOWED_ROLES[command_type]:
if allowed_role in user_roles:
return True
# どのロールも持っていない場合は権限なし
return False
async def summarize_article(url, user_request=None):
"""記事の内容を要約する。ユーザーのリクエストがあれば考慮し、日本語で出力する。"""
try:
# Use new OpenAI API format (v1.0+)
client = openai.AzureOpenAI(
api_key=AZURE_OPENAI_API_KEY,
api_version="2023-05-15",
azure_endpoint=AZURE_OPENAI_ENDPOINT
)
# Construct the prompt
system_prompt = "あなたはニュース記事を要約するアシスタントです。要約は必ず日本語で出力してください。"
user_prompt = f"以下のニュース記事を日本語で要約してください。\n記事URL: {url}"
if user_request:
user_prompt += f"\n\nユーザーのリクエスト: 「{user_request}」\nこのリクエストを考慮して要約してください。"
else:
user_prompt += "\n簡潔に要約してください。" # Default request if none provided
print(f"--- Summarizer Prompt ---\nSystem: {system_prompt}\nUser: {user_prompt}\n-------------------------")
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=250, # Increased slightly for potentially more detail
temperature=0.5, # Slightly lower temp for more factual summary
)
# Extract the summary from the response
summary = response.choices[0].message.content.strip()
return summary
except Exception as e:
print(f"Error summarizing article: {e}")
return None
def log_interaction(user_id, username, article_url, interaction_details, log_type='reaction'):
"""リアクションまたはコメント情報をログに記録"""
history_data = load_reaction_history()
# Ensure the 'reactions' key exists
if "reactions" not in history_data:
history_data["reactions"] = []
timestamp = datetime.datetime.now(timezone.utc).isoformat()
log_entry = {
"user_id": user_id,
"username": username,
"article_url": article_url, # URL of the original message/article
"type": log_type, # 'reaction' or 'comment'
"timestamp": timestamp
}
if log_type == 'reaction':
log_entry["emoji"] = interaction_details # The emoji string
log_message = f"[REACTION LOG] {timestamp}: {username} ({user_id}) reacted with {interaction_details} to {article_url}"
elif log_type == 'comment':
log_entry["comment"] = interaction_details # The comment text
log_message = f"[COMMENT LOG] {timestamp}: {username} ({user_id}) commented on {article_url}: \"{interaction_details[:50]}...\""
else:
log_message = f"[UNKNOWN LOG] {timestamp}: {username} ({user_id}) interacted with {article_url}"
history_data["reactions"].append(log_entry)
save_reaction_history(history_data)
# Print to terminal
print(log_message)
return log_entry
def print_reaction_history():
"""リアクションとコメントの履歴をターミナルに表示"""
reaction_data = load_reaction_history()
print("\n===== INTERACTION HISTORY =====")
# Use .get() to safely access 'reactions', defaulting to an empty list
interactions = reaction_data.get("reactions", [])
if not interactions:
print("No interactions recorded yet.")
else:
for idx, entry in enumerate(interactions, 1):
print(f"{idx}. User: {entry.get('username', 'N/A')} ({entry.get('user_id', 'N/A')})")
log_type = entry.get('type', 'unknown')
print(f" Type: {log_type.capitalize()}")
if log_type == 'reaction':
print(f" Emoji: {entry.get('emoji', 'N/A')}")
elif log_type == 'comment':
print(f" Comment: {entry.get('comment', 'N/A')[:100]}...") # Show preview
print(f" URL/Item: {entry.get('article_url', 'N/A')}")
print(f" Time: {entry.get('timestamp', 'N/A')}")
print("---")
print("============================\n")
async def extract_article_content(url):
"""URLから記事のテキストコンテンツを抽出する"""
try:
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36'
}
response = requests.get(url, headers=headers, timeout=10)
response.raise_for_status()
soup = BeautifulSoup(response.text, 'html.parser')
# Remove script and style elements
for script in soup(["script", "style"]):
script.extract()
# Get text and clean it
text = soup.get_text()
lines = (line.strip() for line in text.splitlines())
chunks = (phrase.strip() for line in lines for phrase in line.split(" "))
text = '\n'.join(chunk for chunk in chunks if chunk)
# Limit to first 3000 characters for API efficiency
return text[:3000]
except Exception as e:
print(f"Error extracting content from {url}: {e}")
return f"コンテンツの抽出に失敗しました: {e}"
async def get_personalized_recommendations(user_id, top_n=3):
"""ユーザーの履歴に基づいてパーソナライズされたニュース記事を推薦する"""
if user_id not in user_news_history or len(user_news_history[user_id]) < 2:
return []
# ユーザーの履歴を取得
user_history = user_news_history[user_id]
# すべての記事を取得
all_articles = []
config = load_news_config()
for category, feeds in config.get("rss_feeds", {}).items():
for feed_url in feeds:
try:
feed = feedparser.parse(feed_url)
for entry in feed.entries:
if hasattr(entry, 'link') and entry.link not in user_history:
title = entry.title if hasattr(entry, 'title') else "無題"
description = entry.description if hasattr(entry, 'description') else ""
pub_date = entry.published if hasattr(entry, 'published') else ""
all_articles.append({
'title': title,
'link': entry.link,
'description': description,
'published': pub_date
})
except Exception as e:
print(f"Error parsing feed {feed_url}: {e}")
if not all_articles:
return []
# TF-IDFベクトルを作成
try:
# ユーザー履歴とすべての記事からコーパスを作成
corpus = user_history + [a['link'] + ' ' + a['title'] + ' ' + a['description'] for a in all_articles]
tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf_vectorizer.fit_transform(corpus)
# ユーザー履歴のベクトルと記事ベクトル間のコサイン類似度を計算
user_profile = tfidf_matrix[:len(user_history)].mean(axis=0)
article_vectors = tfidf_matrix[len(user_history):]
# 各記事の類似度スコアを計算
similarity_scores = cosine_similarity(user_profile, article_vectors)[0]
# 類似度に基づいて記事をランク付け
ranked_articles = [(all_articles[i], similarity_scores[i])
for i in range(len(all_articles))]
ranked_articles.sort(key=lambda x: x[1], reverse=True)
# 上位N件を返す
return [article for article, score in ranked_articles[:top_n]]
except Exception as e:
print(f"Error in recommendation algorithm: {e}")
return []
async def daily_recommendations():
"""一日一回、ニュース推薦を配信するタスク"""
try:
# 初回は起動時すぐに実行せず、次の指定時刻まで待機
await asyncio.sleep(3600) # 1時間待機（初期化時間）
while True:
# ユーザー履歴がある全ユーザーに推薦を送信
for user_id, history in user_news_history.items():
if len(history) < 2: # 履歴が少なすぎる場合はスキップ
continue
try:
# ユーザーオブジェクトを取得
user = await client.fetch_user(user_id)
# パーソナライズされた推薦記事を取得
recommendations = await get_personalized_recommendations(user_id, top_n=5)
if recommendations:
# DMを送信
embed = discord.Embed(
title="📰 今日のニュース推薦",
description="あなたの閲覧履歴に基づいたおすすめ記事です。",
color=discord.Color.blue()
)
for i, article in enumerate(recommendations, 1):
title = article['title']
link = article['link']
pub_date = article.get('published', '')
pub_info = f" ({pub_date})" if pub_date else ""
embed.add_field(
name=f"{i}. {title}{pub_info}",
value=f"[記事を読む]({link})",
inline=False
)
try:
await user.send(embed=embed)
print(f"Sent daily recommendations to {user.name} ({user_id})")
except Exception as e:
print(f"Failed to send daily recommendations to {user_id}: {e}")
except Exception as e:
print(f"Error processing daily recommendations for user {user_id}: {e}")
# 24時間待機
await asyncio.sleep(24 * 3600)
except asyncio.CancelledError:
print("Daily recommendations task was cancelled")
except Exception as e:
print(f"Error in daily recommendations task: {e}")
@client.event
async def on_ready():
print(f"We have logged in as {client.user}")
# Load user history from file
load_user_history()
# Print current reaction history
print_reaction_history()
# Start the daily recommendations task
client.loop.create_task(daily_recommendations())
@client.event
async def on_message(message):
if message.author == client.user:
return
# Add command to display reaction history
if message.content.startswith("!reaction-history"):
if not has_required_roles(message.author, "news"):
await message.channel.send("⚠️ リアクション履歴表示機能を使用する権限がありません。")
return
# Print to terminal
print_reaction_history()
# Send to channel
reaction_data = load_reaction_history()
if not reaction_data["reactions"]:
await message.channel.send("リアクション履歴はまだありません。")
return
embed = discord.Embed(
title="👍 リアクション履歴",
description="チャンネル内の投稿へのリアクション履歴",
color=discord.Color.blue()
)
# Group by URL for cleaner display
url_reactions = {}
for entry in reaction_data["reactions"]:
url = entry["article_url"]
if url not in url_reactions:
url_reactions[url] = []
url_reactions[url].append(entry)
# Add fields to embed (limited to avoid Discord's message size limits)
count = 0
for url, entries in list(url_reactions.items())[:10]: # Limit to 10 URLs
usernames = ", ".join([f"{e['username']}" for e in entries[:5]])
if len(entries) > 5:
usernames += f" and {len(entries)-5} more"
embed.add_field(
name=f"記事: {url[:75]}{'...' if len(url) > 75 else ''}",
value=f"リアクション: {len(entries)}件\nユーザー: {usernames}",
inline=False
)
count += 1
embed.set_footer(text=f"合計: {len(reaction_data['reactions'])}件のリアクション")
await message.channel.send(embed=embed)
return
# --- Reply Handling in Tech Channel ---
# Check if it's a reply and in the tech channel BEFORE checking commands
if message.reference and message.channel.id == TECH_CHANNEL_ID:
print(f"--- Reply detected in Tech Channel from {message.author.name} ---")
try:
# Fetch the original message being replied to
original_message = await message.channel.fetch_message(message.reference.message_id)
print(f"Original message fetched (ID: {original_message.id})")
# Extract URL from the original message (using the same logic as on_reaction_add)
original_content = original_message.content
article_url = None
url_pattern = re.compile(r'https?://\S+')
if "リンク:" in original_content:
article_url = original_content.split("リンク:", 1)[1].strip()
print(f"Extracted URL from original message 'リンク:': {article_url}")
else:
urls = url_pattern.findall(original_content)
if urls:
article_url = urls[0]
print(f"Found URL in original message content: {article_url}")
else:
for embed in original_message.embeds:
if embed.url and embed.url != "https://discord.com":
article_url = embed.url
print(f"Found URL in original message embed: {article_url}")
break
if article_url is None:
for field in embed.fields:
if field.value:
field_urls = url_pattern.findall(field.value)
if field_urls:
article_url = field_urls[0]
print(f"Found URL in original message embed field: {article_url}")
break
if article_url:
break
if not article_url:
# Fallback identifier for the original message
embed_identifier = None
if original_message.embeds:
embed = original_message.embeds[0]
if embed.title:
embed_identifier = f"Embed Title: {embed.title[:80]}"
elif embed.description:
embed_identifier = f"Embed Desc: {embed.description[:80]}"
if embed_identifier:
article_url = embed_identifier
print(f"No URL found in original, using embed identifier: {article_url}")
elif original_content:
article_url = f"Message Text: {original_content[:80]}"
print(f"No URL found in original, using message text: {article_url}")
else:
article_url = f"Message ID: {original_message.id}"
print(f"No URL/text in original, using message ID: {article_url}")
# Log the comment interaction
user_id = message.author.id
username = message.author.display_name or message.author.name
comment_text = message.content
log_interaction(user_id, username, article_url, comment_text, log_type='comment')
# Update user history with the URL from the original message
is_likely_url = article_url and article_url.startswith("http")
if is_likely_url:
if user_id not in user_news_history:
user_news_history[user_id] = []
if article_url not in user_news_history[user_id]:
user_news_history[user_id].append(article_url)
save_user_history()
print(f"Added URL from replied message to user history: {article_url}")
# --- Send DM with comment acknowledgement, summary, and recommendations ---
summary = None
if is_likely_url:
try:
print(f"Generating summary for original article: {article_url} with request: {comment_text}")
# Pass the user's comment as the request
summary = await summarize_article(article_url, user_request=comment_text)
if summary: print(f"Generated summary (Japanese requested): {summary[:100]}...")
else: print("Summary generation returned None.")
except Exception as e:
print(f"Error summarizing article from reply context: {e}")
recommendations = await get_personalized_recommendations(user_id, top_n=5)
if recommendations: print(f"Generated {len(recommendations)} recommendations for commenter")
else: print("No recommendations generated for commenter")
try:
dm_text = f"👋 こんにちは、{username}さん！\n\n✅ あなたのコメントを記録しました:\n> {comment_text}\n\n関連アイテム: {article_url}"
if summary:
dm_text += f"\n\n**元の記事の要約:**\n{summary}"
elif is_likely_url:
dm_text += "\n\n元の記事の要約生成に失敗しました。"
if recommendations:
embed = discord.Embed(
title="📰 あなたにおすすめの記事",
description="あなたの閲覧履歴に基づいておすすめします。",
color=discord.Color.blue()
)
for i, article in enumerate(recommendations, 1):
title = article['title']
link = article['link']
pub_date = article.get('published', '')
pub_info = f" ({pub_date})" if pub_date else ""
embed.add_field(name=f"{i}. {title}{pub_info}", value=f"[記事を読む]({link})", inline=False)
history_count = len(user_news_history.get(user_id, []))
embed.set_footer(text=f"あなたの履歴: {history_count}件")
await message.author.send(dm_text)
await message.author.send(embed=embed)
else:
await message.author.send(dm_text + "\n\n推薦記事を生成するにはもう少し閲覧履歴が必要です。")
print(f"Successfully sent comment acknowledgement DM to {username} (ID: {user_id})")
except discord.errors.Forbidden:
print(f"Error sending DM to user {user_id} (reply context): Bot is blocked or DMs are disabled.")
except Exception as e:
print(f"Error sending DM to user {user_id} (reply context): {e}")
except discord.NotFound:
print(f"Could not fetch original message (ID: {message.reference.message_id}). It might have been deleted.")
except Exception as e:
print(f"Error processing reply message: {e}")
# Return here to prevent processing the reply as a command
return
# --- End Reply Handling ---
# News management commands (ensure these are not triggered by replies handled above)
if message.content.startswith("!recommend-news-add"):
if not has_required_roles(message.author, "news"):
await message.channel.send("⚠️ ニュースフィード管理機能を使用する権限がありません。")
return
parts = message.content.split(maxsplit=2)
if len(parts) < 3:
await message.channel.send("正しい形式: `!recommend-news-add <tech(チャンネル名)> <RSSフィードURL>`")
return
category = parts[1]
url = parts[2].strip('<>') # Remove potential markdown <> around URL
# Basic URL validation (optional, can be more robust)
if not url.startswith("http://") and not url.startswith("https://"):
await message.channel.send("⚠️ 無効なURL形式です。http:// または https:// で始まる必要があります。")
return
config = load_news_config()
if 'rss_feeds' not in config:
config['rss_feeds'] = {}
if category not in config['rss_feeds']:
config['rss_feeds'][category] = []
await message.channel.send(f"ℹ️ 新しいカテゴリ '{category}' を作成しました。")
if url in config['rss_feeds'][category]:
await message.channel.send(f"⚠️ URL '{url}' はカテゴリ '{category}' に既に存在します。")
else:
config['rss_feeds'][category].append(url)
if save_news_config(config):
await message.channel.send(f"✅ URL '{url}' をカテゴリ '{category}' に追加しました。")
else:
await message.channel.send("❌ 設定ファイルの保存中にエラーが発生しました。")
return
elif message.content.startswith("!recommend-history"):
# Check if user has proper permissions
if not has_required_roles(message.author, "news"):
await message.channel.send("⚠️ 履歴表示機能を使用する権限がありません。")
return
# Get target user - use message author by default
target_user = message.author
# Acknowledge receipt of command in channel
await message.channel.send(f"📰 {message.author.mention} 履歴情報をDMで送信します。")
# Check if an admin is requesting someone else's history
parts = message.content.split()
if len(parts) > 1 and message.author.guild_permissions.administrator:
# Try to find user by mention
if len(message.mentions) > 0:
target_user = message.mentions[0]
else:
# Try to find by username
username = parts[1]
found = False
for member in message.guild.members:
if member.name.lower() == username.lower() or str(member.id) == username:
target_user = member
found = True
break
if not found:
await message.author.send(f"⚠️ ユーザー '{username}' が見つかりません。")
return
# Get the user's history
user_id = target_user.id
if user_id not in user_news_history or not user_news_history[user_id]:
await message.author.send(f"📰 {target_user.display_name} の履歴はありません。")
return
# Create embed with history
embed = discord.Embed(
title=f"📰 {target_user.display_name} のニュース履歴",
color=discord.Color.blue()
)
# Add history items (limited to 25 most recent to avoid hitting Discord's limits)
history = user_news_history[user_id][-25:]
history_text = []
for i, url in enumerate(history):
history_text.append(f"{i+1}. {url}")
# Split into multiple fields if needed (Discord has 1024 char limit per field)
chunks = []
current_chunk = []
current_length = 0
for item in history_text:
if current_length + len(item) + 1 > 1000: # +1 for newline
chunks.append("\n".join(current_chunk))
current_chunk = [item]
current_length = len(item)
else:
current_chunk.append(item)
current_length += len(item) + 1
if current_chunk:
chunks.append("\n".join(current_chunk))
# Add fields to embed
for i, chunk in enumerate(chunks):
embed.add_field(
name=f"最近の履歴 {i+1}/{len(chunks)}" if len(chunks) > 1 else "最近の履歴",
value=f"```\n{chunk}\n```",
inline=False
)
# Add total count
embed.set_footer(text=f"合計: {len(user_news_history[user_id])}件")
# Send the embed as a DM
try:
await message.author.send(embed=embed)
except Exception as e:
print(f"Error sending DM to user: {e}")
await message.channel.send("⚠️ DMの送信中にエラーが発生しました。プライバシー設定をご確認ください。")
return
elif message.content.startswith("!recommend-news-list"):
if not has_required_roles(message.author, "news"):
await message.channel.send("⚠️ ニュースフィード管理機能を使用する権限がありません。")
return
parts = message.content.split(maxsplit=1)
target_category = parts[1] if len(parts) > 1 else None
config = load_news_config()
feeds = config.get('rss_feeds', {})
if not feeds:
await message.channel.send("📰 現在登録されているRSSフィードはありません。")
return
embed = discord.Embed(title="📰 RSSフィードリスト", color=discord.Color.blue())
if target_category:
if target_category in feeds:
urls = feeds[target_category]
if urls:
# Use numbered list within code block for better readability
url_list = "\n".join([f"{i + 1}. {url}" for i, url in enumerate(urls)])
embed.add_field(name=f"カテゴリ: {target_category}", value=f"```\n{url_list}\n```",
inline=False)
else:
embed.add_field(name=f"カテゴリ: {target_category}", value="このカテゴリにはURLが登録されていません。",
inline=False)
else:
embed.description = f"❓ カテゴリ '{target_category}' は見つかりませんでした。"
else:
# List all categories and their URLs
if not feeds:
embed.description = "現在登録されているRSSフィードはありません。"
else:
for category, urls in feeds.items():
if urls:
# Limit URL display slightly for overview
url_list = "\n".join([f"- {url}" for url in urls[:5]]) # Show first 5
if len(urls) > 5:
url_list += f"\n- ...他{len(urls) - 5}件"
embed.add_field(name=f"カテゴリ: {category} ({len(urls)}件)", value=f"```{url_list}```",
inline=False)
else:
embed.add_field(name=f"カテゴリ: {category}", value="登録URLなし", inline=False)
await message.channel.send(embed=embed)
return
elif message.content.startswith("!recommend-news-delete"):
if not has_required_roles(message.author, "news"):
await message.channel.send("⚠️ ニュースフィード管理機能を使用する権限がありません。")
return
parts = message.content.split(maxsplit=2)
if len(parts) < 3:
await message.channel.send("正しい形式: `!recommend-news-delete <カテゴリ名> <RSSフィードURL>`")
return
category = parts[1]
url_to_delete = parts[2].strip('<>')
config = load_news_config()
feeds = config.get('rss_feeds', {})
if category not in feeds:
await message.channel.send(f"❓ カテゴリ '{category}' が見つかりません。")
return
if url_to_delete not in feeds[category]:
await message.channel.send(f"❓ URL '{url_to_delete}' はカテゴリ '{category}' に見つかりません。")
return
feeds[category].remove(url_to_delete)
# Option: Remove category if it becomes empty
# if not feeds[category]:
# del feeds[category]
# await message.channel.send(f"ℹ️ カテゴリ '{category}' が空になったため削除しました。")
if save_news_config(config):
await message.channel.send(f"✅ URL '{url_to_delete}' をカテゴリ '{category}' から削除しました。")
else:
await message.channel.send("❌ 設定ファイルの保存中にエラーが発生しました。")
return
# @client.event
# async def on_reaction_add(reaction, user):
# """ (Disabled - Using on_raw_reaction_add instead for reliability) """
# pass
@client.event
async def on_raw_reaction_add(payload: discord.RawReactionActionEvent):
"""Handles reaction additions using raw events for reliability."""
print(f"--- Raw reaction detected: User {payload.user_id}, Emoji {payload.emoji}, Msg {payload.message_id}, Chan {payload.channel_id} ---")
# Ignore reactions from the bot itself or not in the target channel
if payload.user_id == client.user.id or payload.channel_id != TECH_CHANNEL_ID:
print(f"--- Skipping raw reaction (Bot user or wrong channel: {payload.channel_id}) ---")
return
print(f"--- Processing raw reaction in TECH_CHANNEL_ID ({TECH_CHANNEL_ID}) ---")
try:
# Fetch necessary objects
channel = client.get_channel(payload.channel_id)
if not channel:
print(f"--- ERROR: Could not find channel {payload.channel_id} ---")
return
message = await channel.fetch_message(payload.message_id)
user = await client.fetch_user(payload.user_id)
if not user:
print(f"--- ERROR: Could not fetch user {payload.user_id} ---")
return
print(f"--- Fetched objects: User={user.name}, Message={message.id} ---")
emoji_str = str(payload.emoji)
username = user.display_name or user.name
# --- Extract URL from the reacted message ---
message_content = message.content
article_url = None
url_pattern = re.compile(r'https?://\S+')
if "リンク:" in message_content:
article_url = message_content.split("リンク:", 1)[1].strip()
print(f"Extracted URL from reacted message 'リンク:': {article_url}")
else:
urls = url_pattern.findall(message_content)
if urls:
article_url = urls[0]
print(f"Found URL in reacted message content: {article_url}")
else:
for embed in message.embeds:
if embed.url and embed.url != "https://discord.com":
article_url = embed.url
print(f"Found URL in reacted message embed: {article_url}")
break
if article_url is None:
for field in embed.fields:
if field.value:
field_urls = url_pattern.findall(field.value)
if field_urls:
article_url = field_urls[0]
print(f"Found URL in reacted message embed field: {article_url}")
break
if article_url:
break
if not article_url:
embed_identifier = None
if message.embeds:
embed = message.embeds[0]
if embed.title: embed_identifier = f"Embed Title: {embed.title[:80]}"
elif embed.description: embed_identifier = f"Embed Desc: {embed.description[:80]}"
if embed_identifier: article_url = embed_identifier
elif message_content: article_url = f"Message Text: {message_content[:80]}"
else: article_url = f"Message ID: {message.id}"
print(f"No URL found in reacted message, using identifier: {article_url}")
# --- End URL Extraction ---
# Log the interaction
log_interaction(user.id, username, article_url, emoji_str, log_type='reaction')
print(f"--- Logged reaction interaction for {username} ---")
# Update user history
is_likely_url = article_url and article_url.startswith("http")
if is_likely_url:
if user.id not in user_news_history: user_news_history[user.id] = []
if article_url not in user_news_history[user.id]:
user_news_history[user.id].append(article_url)
save_user_history()
print(f"Added URL from reaction to user history: {article_url}")
# --- Send DM with summary and recommendations ---
summary = None
if is_likely_url:
try:
print(f"Generating Japanese summary for reacted article: {article_url}")
# Request default Japanese summary for reactions
summary = await summarize_article(article_url)
if summary: print(f"Generated summary (Japanese requested): {summary[:100]}...")
else: print("Summary generation returned None.")
except Exception as e:
print(f"Error summarizing article from reaction context: {e}")
recommendations = await get_personalized_recommendations(user.id, top_n=5)
if recommendations: print(f"Generated {len(recommendations)} recommendations for reactor")
else: print("No recommendations generated for reactor")
try:
dm_text = f"👋 こんにちは、{username}さん！\n\n✅ あなたの反応を記録しました: {emoji_str} → {article_url}"
if summary:
dm_text += f"\n\n**記事の要約 (日本語):**\n{summary}"
elif is_likely_url:
dm_text += "\n\n記事の要約生成に失敗しました。"
if recommendations:
embed = discord.Embed(
title="📰 あなたにおすすめの記事",
description="あなたの閲覧履歴に基づいておすすめします。",
color=discord.Color.blue()
)
for i, article in enumerate(recommendations, 1):
title = article['title']
link = article['link']
pub_date = article.get('published', '')
pub_info = f" ({pub_date})" if pub_date else ""
embed.add_field(name=f"{i}. {title}{pub_info}", value=f"[記事を読む]({link})", inline=False)
history_count = len(user_news_history.get(user.id, []))
embed.set_footer(text=f"あなたの履歴: {history_count}件")
await user.send(dm_text)
await user.send(embed=embed)
else:
await user.send(dm_text + "\n\n推薦記事を生成するにはもう少し閲覧履歴が必要です。")
print(f"Successfully sent reaction acknowledgement DM to {username} (ID: {user.id})")
except discord.errors.Forbidden:
print(f"Error sending DM to user {user.id} (reaction context): Bot is blocked or DMs are disabled.")
except Exception as e:
print(f"Error sending DM to user {user.id} (reaction context): {e}")
except discord.NotFound:
print(f"--- ERROR: Could not fetch message {payload.message_id} or user {payload.user_id} (NotFound) ---")
except Exception as e:
print(f"--- ERROR: Unhandled exception in on_raw_reaction_add: {e} ---")
import traceback
traceback.print_exc() # Print full traceback for debugging
# Run the Discord client
if __name__ == "__main__":
print("Starting news recommendation bot...")
client.run(DISCORD_TOKEN)