gpatruno
568 lines
22 KiB
Python
568 lines
22 KiB
Python
import json
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import threading
|
|
import time
|
|
from dataclasses import dataclass
|
|
from datetime import datetime
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
|
|
def _now_iso() -> str:
|
|
return datetime.now().isoformat(timespec="seconds")
|
|
|
|
|
|
def _lower(s: Optional[str]) -> Optional[str]:
|
|
return s.lower() if isinstance(s, str) else None
|
|
|
|
|
|
def _contains_case_insensitive(haystack: str, needle: str) -> bool:
|
|
return needle.lower() in haystack.lower()
|
|
|
|
|
|
def _normalize_accounts(accounts: List[str]) -> List[str]:
|
|
out: List[str] = []
|
|
for a in accounts:
|
|
a = (a or "").strip()
|
|
if not a:
|
|
continue
|
|
if a.startswith("@"):
|
|
a = a[1:]
|
|
out.append(a.lower())
|
|
return sorted(set(out))
|
|
|
|
|
|
def _extract_mentioned_accounts(message: str, registered_accounts: List[str]) -> List[str]:
|
|
msg = message or ""
|
|
hits: List[str] = []
|
|
for acc in registered_accounts:
|
|
if _contains_case_insensitive(msg, f"@{acc}"):
|
|
hits.append(acc)
|
|
return hits
|
|
|
|
|
|
def _strip_registered_mentions(message: str, registered_accounts: List[str]) -> str:
|
|
"""
|
|
Retire du texte les mentions @<compte> pour les comptes enregistrés.
|
|
Exemple: "@exoticnaturees hello" -> "hello"
|
|
"""
|
|
out = message or ""
|
|
for acc in registered_accounts:
|
|
# \b pour éviter de matcher des sous-chaînes
|
|
out = re.sub(rf"@{re.escape(acc)}\b", "", out, flags=re.IGNORECASE)
|
|
# Normaliser les espaces
|
|
out = re.sub(r"\s+", " ", out).strip()
|
|
return out
|
|
|
|
|
|
@dataclass
|
|
class InteractionRule:
|
|
id: str
|
|
enabled: bool
|
|
from_username: Optional[str] = None
|
|
mention_account: Optional[str] = None
|
|
contains_text: Optional[str] = None
|
|
action: str = "response" # response | tgpt | clip
|
|
response_text: str = ""
|
|
tgpt_preprompt: Optional[str] = None
|
|
clip_has_delay: bool = False
|
|
|
|
@staticmethod
|
|
def from_dict(d: Dict[str, Any]) -> "InteractionRule":
|
|
return InteractionRule(
|
|
id=str(d.get("id") or ""),
|
|
enabled=bool(d.get("enabled", True)),
|
|
from_username=d.get("from_username") or None,
|
|
mention_account=d.get("mention_account") or None,
|
|
contains_text=d.get("contains_text") or None,
|
|
action=str(d.get("action") or d.get("mode") or "response"),
|
|
response_text=str(d.get("response_text") or ""),
|
|
tgpt_preprompt=d.get("tgpt_preprompt") or None,
|
|
clip_has_delay=bool(d.get("clip_has_delay", False)),
|
|
)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"id": self.id,
|
|
"enabled": self.enabled,
|
|
"from_username": self.from_username,
|
|
"mention_account": self.mention_account,
|
|
"contains_text": self.contains_text,
|
|
"action": self.action,
|
|
"response_text": self.response_text,
|
|
"tgpt_preprompt": self.tgpt_preprompt,
|
|
"clip_has_delay": self.clip_has_delay,
|
|
}
|
|
|
|
def matches(self, *, username: str, message: str, mentioned_accounts: List[str]) -> bool:
|
|
if not self.enabled:
|
|
return False
|
|
if self.from_username and _lower(self.from_username) != _lower(username):
|
|
return False
|
|
if self.mention_account:
|
|
ma = self.mention_account.strip()
|
|
if ma.startswith("@"):
|
|
ma = ma[1:]
|
|
if ma.lower() not in mentioned_accounts:
|
|
return False
|
|
if self.contains_text and not _contains_case_insensitive(message, self.contains_text):
|
|
return False
|
|
return True
|
|
|
|
|
|
class InteractionChatConfig:
|
|
def __init__(self, data: Optional[Dict[str, Any]] = None):
|
|
data = data or {}
|
|
self.enabled: bool = bool(data.get("enabled", True))
|
|
# Mode principal: predefined (réponses) ou tgpt (IA)
|
|
self.mode: str = str(data.get("mode", "predefined")) # predefined | tgpt
|
|
# Backward compat: si tgpt_enabled est fourni, on le garde, sinon on déduit du mode.
|
|
self.tgpt_enabled: bool = bool(data.get("tgpt_enabled", self.mode == "tgpt"))
|
|
self.tgpt_preprompt: str = str(data.get("tgpt_preprompt", "") or "")
|
|
self.tgpt_max_chars: int = int(data.get("tgpt_max_chars", 100))
|
|
self.cooldown_seconds: int = int(data.get("cooldown_seconds", 8))
|
|
self.default_responses: List[str] = [
|
|
s.strip() for s in (data.get("default_responses") or ["salut"]) if isinstance(s, str) and s.strip()
|
|
]
|
|
self.rules: List[InteractionRule] = [
|
|
InteractionRule.from_dict(x) for x in (data.get("rules") or []) if isinstance(x, dict)
|
|
]
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {
|
|
"enabled": self.enabled,
|
|
"mode": self.mode,
|
|
"tgpt_enabled": self.tgpt_enabled,
|
|
"tgpt_preprompt": self.tgpt_preprompt,
|
|
"tgpt_max_chars": self.tgpt_max_chars,
|
|
"cooldown_seconds": self.cooldown_seconds,
|
|
"default_responses": self.default_responses,
|
|
"rules": [r.to_dict() for r in self.rules],
|
|
}
|
|
|
|
|
|
class InteractionChatStorage:
|
|
"""
|
|
Stockage simple en JSON dans storage/.
|
|
On évite d'utiliser PersistentStorage ici pour pouvoir stocker des listes (logs) proprement.
|
|
"""
|
|
|
|
def __init__(self, storage_dir: str = "storage"):
|
|
self.storage_dir = storage_dir
|
|
self._lock = threading.Lock()
|
|
|
|
def _path(self, filename: str) -> str:
|
|
if not filename.endswith(".json"):
|
|
filename = f"{filename}.json"
|
|
return os.path.join(self.storage_dir, filename)
|
|
|
|
def read_json(self, filename: str, default: Any) -> Any:
|
|
path = self._path(filename)
|
|
try:
|
|
with open(path, "r", encoding="utf-8") as f:
|
|
return json.load(f)
|
|
except (FileNotFoundError, json.JSONDecodeError):
|
|
return default
|
|
|
|
def write_json(self, filename: str, value: Any) -> None:
|
|
if not os.path.exists(self.storage_dir):
|
|
os.makedirs(self.storage_dir, exist_ok=True)
|
|
path = self._path(filename)
|
|
with self._lock:
|
|
with open(path, "w", encoding="utf-8") as f:
|
|
json.dump(value, f, indent=4, ensure_ascii=False)
|
|
|
|
|
|
class InteractionChatProcessor:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
channel_name: str,
|
|
get_registered_accounts: callable,
|
|
get_account_policies: Optional[callable] = None,
|
|
send_message_as: callable,
|
|
create_clip_as: Optional[callable] = None,
|
|
storage: Optional[InteractionChatStorage] = None,
|
|
):
|
|
self.channel_name = channel_name
|
|
self._get_registered_accounts = get_registered_accounts
|
|
self._get_account_policies = get_account_policies
|
|
self._send_message_as = send_message_as
|
|
self._create_clip_as = create_clip_as
|
|
self._storage = storage or InteractionChatStorage()
|
|
|
|
self._config_file = "interaction_chat_config"
|
|
self._log_file = "interaction_chat_log"
|
|
|
|
self._running = False
|
|
self._thread: Optional[threading.Thread] = None
|
|
|
|
self._last_seen_key: Optional[Tuple[str, str, str]] = None # (timestamp_iso, username, content)
|
|
self._last_reply_ts_by_user: Dict[str, float] = {}
|
|
|
|
def load_config(self) -> InteractionChatConfig:
|
|
data = self._storage.read_json(self._config_file, default={})
|
|
return InteractionChatConfig(data)
|
|
|
|
def save_config(self, config_dict: Dict[str, Any]) -> InteractionChatConfig:
|
|
cfg = InteractionChatConfig(config_dict)
|
|
self._storage.write_json(self._config_file, cfg.to_dict())
|
|
return cfg
|
|
|
|
def append_log(self, entry: Dict[str, Any]) -> None:
|
|
logs = self._storage.read_json(self._log_file, default=[])
|
|
if not isinstance(logs, list):
|
|
logs = []
|
|
logs.append(entry)
|
|
logs = logs[-300:] # borne simple
|
|
self._storage.write_json(self._log_file, logs)
|
|
|
|
def read_log(self, limit: int = 100) -> List[Dict[str, Any]]:
|
|
logs = self._storage.read_json(self._log_file, default=[])
|
|
if not isinstance(logs, list):
|
|
return []
|
|
return logs[-limit:]
|
|
|
|
def stop(self) -> None:
|
|
self._running = False
|
|
if self._thread and self._thread.is_alive():
|
|
self._thread.join(timeout=2)
|
|
|
|
def start_background(self, *, get_latest_messages: callable, poll_interval_s: float = 0.5) -> None:
|
|
if self._thread and self._thread.is_alive():
|
|
return
|
|
|
|
self._running = True
|
|
|
|
def loop() -> None:
|
|
while self._running:
|
|
try:
|
|
self.process_new_messages(get_latest_messages())
|
|
except Exception as e:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "error",
|
|
"channel": self.channel_name,
|
|
"error": str(e),
|
|
}
|
|
)
|
|
time.sleep(poll_interval_s)
|
|
|
|
self._thread = threading.Thread(target=loop, daemon=True)
|
|
self._thread.start()
|
|
|
|
def _cooldown_ok(self, username: str, cooldown_s: int) -> bool:
|
|
last = self._last_reply_ts_by_user.get(username.lower())
|
|
if last is None:
|
|
return True
|
|
return (time.time() - last) >= max(0, cooldown_s)
|
|
|
|
def _mark_replied(self, username: str) -> None:
|
|
self._last_reply_ts_by_user[username.lower()] = time.time()
|
|
|
|
def process_new_messages(self, messages: List[Any]) -> None:
|
|
"""
|
|
`messages` est typiquement une liste de ChatMessage (timestamp, username, content).
|
|
On traite uniquement les nouveaux messages depuis le dernier message vu.
|
|
"""
|
|
if not messages:
|
|
return
|
|
|
|
cfg = self.load_config()
|
|
if not cfg.enabled:
|
|
return
|
|
|
|
registered_accounts = _normalize_accounts(self._get_registered_accounts())
|
|
if not registered_accounts:
|
|
return
|
|
|
|
# On ne veut pas répondre aux comptes "enregistrés" (évite boucles)
|
|
registered_set = set(registered_accounts)
|
|
policies: Dict[str, Dict[str, Any]] = {}
|
|
try:
|
|
if self._get_account_policies:
|
|
policies = self._get_account_policies() or {}
|
|
except Exception:
|
|
policies = {}
|
|
|
|
# Construire une vue stable des derniers messages (sécurité)
|
|
tail = messages[-80:]
|
|
to_process: List[Any] = []
|
|
|
|
if self._last_seen_key is None:
|
|
# premier passage: ne répondre qu'aux prochains messages, pas au backlog
|
|
last = tail[-1]
|
|
self._last_seen_key = (getattr(last, "timestamp").isoformat(), getattr(last, "username"), getattr(last, "content"))
|
|
return
|
|
|
|
seen = False
|
|
for m in tail:
|
|
key = (getattr(m, "timestamp").isoformat(), getattr(m, "username"), getattr(m, "content"))
|
|
if seen:
|
|
to_process.append(m)
|
|
elif key == self._last_seen_key:
|
|
seen = True
|
|
|
|
if not to_process:
|
|
# Si la clé a disparu (tail trop court), on se recale sur le dernier message
|
|
last = tail[-1]
|
|
self._last_seen_key = (getattr(last, "timestamp").isoformat(), getattr(last, "username"), getattr(last, "content"))
|
|
return
|
|
|
|
for m in to_process:
|
|
ts_iso = getattr(m, "timestamp").isoformat()
|
|
username = str(getattr(m, "username") or "")
|
|
content = str(getattr(m, "content") or "")
|
|
|
|
# mise à jour last_seen à chaque itération
|
|
self._last_seen_key = (ts_iso, username, content)
|
|
|
|
if not username or not content:
|
|
continue
|
|
|
|
sender = username.strip().lower()
|
|
if sender in registered_set:
|
|
allow_bypass = bool((policies.get(sender) or {}).get("interaction_bypass_antiloop", False))
|
|
if not allow_bypass:
|
|
continue
|
|
|
|
mentioned = _extract_mentioned_accounts(content, registered_accounts)
|
|
if not mentioned:
|
|
continue
|
|
|
|
if not self._cooldown_ok(username, cfg.cooldown_seconds):
|
|
continue
|
|
|
|
# mode tgpt prévu mais inactif par défaut
|
|
response_text = ""
|
|
matched_rule_id: Optional[str] = None
|
|
responder_account: Optional[str] = None
|
|
rule_tgpt_preprompt: Optional[str] = None
|
|
rule_action: Optional[str] = None
|
|
rule_clip_has_delay: bool = False
|
|
|
|
for r in cfg.rules:
|
|
if r.matches(username=username, message=content, mentioned_accounts=mentioned):
|
|
response_text = (r.response_text or "").strip()
|
|
matched_rule_id = r.id
|
|
rule_action = (r.action or "response").strip().lower()
|
|
if r.mention_account:
|
|
ma = r.mention_account.strip()
|
|
if ma.startswith("@"):
|
|
ma = ma[1:]
|
|
responder_account = ma.lower() if ma else None
|
|
if r.tgpt_preprompt:
|
|
rule_tgpt_preprompt = str(r.tgpt_preprompt)
|
|
rule_clip_has_delay = bool(getattr(r, "clip_has_delay", False))
|
|
break
|
|
|
|
# Choisir le compte expéditeur
|
|
if mentioned and not responder_account:
|
|
responder_account = mentioned[0].lower()
|
|
|
|
# Priorité aux règles: si une règle match, on n'exécute QUE la règle.
|
|
if matched_rule_id is not None:
|
|
action = (rule_action or "response").strip().lower()
|
|
if action == "tgpt":
|
|
preprompt = (rule_tgpt_preprompt or cfg.tgpt_preprompt or "").strip()
|
|
cleaned_for_tgpt = _strip_registered_mentions(content, registered_accounts)
|
|
response_text = self._tgpt_generate(preprompt=preprompt, message=cleaned_for_tgpt)
|
|
response_text = self._truncate(response_text, cfg.tgpt_max_chars)
|
|
if not response_text:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "tgpt_empty",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"content_sent_to_tgpt": cleaned_for_tgpt,
|
|
"responder_account": responder_account,
|
|
"rule_id": matched_rule_id,
|
|
"mode": "rule_tgpt",
|
|
}
|
|
)
|
|
continue
|
|
elif action == "clip":
|
|
if not responder_account:
|
|
responder_account = mentioned[0].lower()
|
|
if not self._create_clip_as:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "clip_error",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"mentioned_accounts": mentioned,
|
|
"responder_account": responder_account,
|
|
"rule_id": matched_rule_id,
|
|
"error": "create_clip_not_configured",
|
|
}
|
|
)
|
|
continue
|
|
try:
|
|
clip = self._create_clip_as(
|
|
responder_account, # auth as responder account
|
|
self.channel_name, # clip current channel
|
|
rule_clip_has_delay,
|
|
)
|
|
clip_url = (clip or {}).get("url") or ""
|
|
response_text = f"Clip créé: {clip_url}".strip()
|
|
except Exception as e:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "clip_error",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"mentioned_accounts": mentioned,
|
|
"responder_account": responder_account,
|
|
"rule_id": matched_rule_id,
|
|
"error": str(e),
|
|
}
|
|
)
|
|
continue
|
|
else:
|
|
# response (préenregistrée)
|
|
if not response_text:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "rule_empty_response",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"mentioned_accounts": mentioned,
|
|
"responder_account": responder_account,
|
|
"rule_id": matched_rule_id,
|
|
"action": action,
|
|
}
|
|
)
|
|
continue
|
|
else:
|
|
if cfg.mode == "tgpt" and cfg.tgpt_enabled:
|
|
preprompt = (rule_tgpt_preprompt or cfg.tgpt_preprompt or "").strip()
|
|
cleaned_for_tgpt = _strip_registered_mentions(content, registered_accounts)
|
|
response_text = self._tgpt_generate(preprompt=preprompt, message=cleaned_for_tgpt)
|
|
response_text = self._truncate(response_text, cfg.tgpt_max_chars)
|
|
if not response_text:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "tgpt_empty",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"content_sent_to_tgpt": cleaned_for_tgpt,
|
|
"responder_account": responder_account,
|
|
}
|
|
)
|
|
continue
|
|
else:
|
|
if not response_text and cfg.default_responses:
|
|
response_text = cfg.default_responses[0].strip()
|
|
if not response_text:
|
|
continue
|
|
|
|
outgoing = f"@{username} {response_text}".strip()
|
|
# fallback: si on ne sait pas quel compte utiliser, on prend le 1er enregistré
|
|
if not responder_account:
|
|
responder_account = registered_accounts[0].lower()
|
|
|
|
self._send_message_as(responder_account, outgoing)
|
|
self._mark_replied(username)
|
|
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "responded",
|
|
"channel": self.channel_name,
|
|
"from": username,
|
|
"content": content,
|
|
"mentioned_accounts": mentioned,
|
|
"responder_account": responder_account,
|
|
"response": outgoing,
|
|
"rule_id": matched_rule_id,
|
|
"mode": cfg.mode,
|
|
"action": rule_action or ("tgpt" if (cfg.mode == "tgpt" and cfg.tgpt_enabled) else "response"),
|
|
}
|
|
)
|
|
|
|
def _truncate(self, text: str, max_chars: int) -> str:
|
|
t = (text or "").strip()
|
|
if max_chars is None:
|
|
return t
|
|
try:
|
|
n = int(max_chars)
|
|
except Exception:
|
|
n = 100
|
|
if n <= 0:
|
|
return ""
|
|
if len(t) <= n:
|
|
return t
|
|
# laisser de la place pour "..."
|
|
cut = max(0, n - 3)
|
|
return t[:cut].rstrip() + "..."
|
|
|
|
def _tgpt_generate(self, *, preprompt: str, message: str) -> str:
|
|
"""
|
|
Appelle tgpt (CLI) et retourne une réponse nettoyée.
|
|
"""
|
|
query = message.strip()
|
|
if preprompt:
|
|
query = f"{preprompt}\n\n{query}"
|
|
|
|
try:
|
|
proc = subprocess.run(
|
|
["tgpt", "-q", query],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=25,
|
|
check=False,
|
|
)
|
|
except FileNotFoundError:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "tgpt_error",
|
|
"channel": self.channel_name,
|
|
"error": "tgpt_not_found",
|
|
}
|
|
)
|
|
return ""
|
|
except subprocess.TimeoutExpired:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "tgpt_error",
|
|
"channel": self.channel_name,
|
|
"error": "tgpt_timeout",
|
|
}
|
|
)
|
|
return ""
|
|
except Exception as e:
|
|
self.append_log(
|
|
{
|
|
"ts": _now_iso(),
|
|
"type": "tgpt_error",
|
|
"channel": self.channel_name,
|
|
"error": str(e),
|
|
}
|
|
)
|
|
return ""
|
|
|
|
out = (proc.stdout or "").strip()
|
|
if not out:
|
|
out = (proc.stderr or "").strip()
|
|
|
|
# Nettoyage minimal (tgpt renvoie parfois "Assistant:" / "Answer:")
|
|
for prefix in ("Assistant:", "assistant:", "Answer:", "Réponse:", "Response:"):
|
|
if out.startswith(prefix):
|
|
out = out[len(prefix) :].strip()
|
|
return out.replace("\n", " ").strip()
|
|
|