BookIA/check_plagiat.py

#!/usr/bin/env python3
"""
Vérification anti-plagiat via l'API Copyscape Premium.

Envoie le texte d'un chapitre (fichier .md) à Copyscape (opération "csearch",
recherche sur Internet public) et affiche un rapport des pages trouvées
présentant des correspondances de texte.

Usage :
    python3 check_plagiat.py Manuscrit/01-chap01-mort-de-la-verite.md
    python3 check_plagiat.py Manuscrit/01-chap01-mort-de-la-verite.md --full-compare 5
    python3 check_plagiat.py --balance

Identifiants lus depuis .copyscape-credentials (voir ce fichier pour le format).

Coût : Copyscape facture 3 cents pour les 200 premiers mots, puis 1 cent par
100 mots supplémentaires. Un chapitre de 5000 mots coûte environ 0,50 $.
Utiliser --full-compare avec parcimonie (chaque comparaison complète a un coût
et un délai supplémentaire).
"""

import argparse
import re
import sys
from pathlib import Path

import requests

CREDENTIALS_FILE = Path(__file__).parent / ".copyscape-credentials"
API_URL = "https://www.copyscape.com/api/"


def load_credentials():
    if not CREDENTIALS_FILE.exists():
        sys.exit(f"Erreur : fichier introuvable {CREDENTIALS_FILE}")
    creds = {}
    with open(CREDENTIALS_FILE, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line and not line.startswith("#") and "=" in line:
                k, v = line.split("=", 1)
                creds[k.strip()] = v.strip()
    username = creds.get("COPYSCAPE_USERNAME", "")
    api_key = creds.get("COPYSCAPE_API_KEY", "")
    if not username or not api_key:
        sys.exit(
            "Erreur : COPYSCAPE_USERNAME ou COPYSCAPE_API_KEY manquant dans "
            f"{CREDENTIALS_FILE}"
        )
    return username, api_key


def clean_markdown_for_check(raw_text: str) -> str:
    """Nettoie le Markdown pour ne soumettre que la prose : retire les
    définitions de notes de bas de page, les titres Markdown (#), les
    tableaux et les citations en bloc ne sont volontairement CONSERVÉS
    car ils font partie du texte réel du chapitre (les citations d'experts
    sont attendues et légitimes, elles ne doivent pas déclencher de faux
    positifs excessifs mais restent utiles à vérifier)."""
    text = raw_text

    # Retire les blocs LaTeX ou HTML bruts : ```{=latex} ... ``` ou ```{=html} ... ```
    text = re.sub(r"```\{=\w+\}.*?```", "", text, flags=re.DOTALL)

    # Retire les commentaires HTML : <!-- ... -->
    text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)

    # Retire les définitions de notes de bas de page : [^c01-1]: texte...
    text = re.sub(r"^\[\^[^\]]+\]:.*$", "", text, flags=re.MULTILINE)

    # Retire les appels de note de bas de page dans le texte : [^c01-1]
    text = re.sub(r"\[\^[^\]]+\]", "", text)

    # Retire les marqueurs de titres Markdown mais garde le texte du titre
    text = re.sub(r"^#{1,6}\s*", "", text, flags=re.MULTILINE)

    # Compresse les lignes vides multiples
    text = re.sub(r"\n{3,}", "\n\n", text)

    return text.strip()


def check_balance(username: str, api_key: str):
    resp = requests.get(
        API_URL,
        params={"u": username, "k": api_key, "o": "balance", "f": "json"},
        timeout=30,
    )
    data = resp.json()
    if "error" in data:
        sys.exit(f"Erreur API : {data['error']}")
    print(f"Solde restant : {data.get('value', '?')} $")
    print(f"Recherches Internet restantes aujourd'hui : {data.get('today', '?')}")


def search_text(username: str, api_key: str, text: str, full_compare: int = 0):
    payload = {
        "u": username,
        "k": api_key,
        "o": "csearch",
        "e": "UTF-8",
        "t": text,
        "c": str(full_compare),
        "f": "json",
    }
    resp = requests.post(API_URL, data=payload, timeout=120)
    resp.raise_for_status()
    return resp.json()


def print_report(data: dict, chapter_name: str):
    print(f"\n{'=' * 70}")
    print(f"RAPPORT ANTI-PLAGIAT — {chapter_name}")
    print(f"{'=' * 70}")

    if "error" in data:
        print(f"ERREUR API : {data['error']}")
        return

    words_checked = data.get("querywords", "?")
    cost = data.get("cost", "?")
    count = data.get("count", 0)

    print(f"Mots analysés : {words_checked}")
    print(f"Coût de cette vérification : {cost} $")
    print(f"Pages avec correspondances trouvées : {count}")

    if count == 0:
        print("\nAucune correspondance trouvée sur Internet. Texte original. ✅")
        return

    if "allpercentmatched" in data:
        print(f"Pourcentage total du texte retrouvé ailleurs : {data['allpercentmatched']}%")

    print(f"\n{'-' * 70}")
    results = data.get("result", [])
    for r in results:
        print(f"\n[{r.get('index')}] {r.get('title', '(sans titre)')}")
        print(f"    URL : {r.get('url')}")
        if "percentmatched" in r:
            print(f"    Correspondance exacte : {r['percentmatched']}% ({r.get('wordsmatched', '?')} mots)")
        else:
            print(f"    Indication de correspondance (mots min.) : {r.get('minwordsmatched', '?')}")
        snippet = r.get("textsnippet", "")
        if snippet:
            print(f"    Extrait : {snippet}")

    print(f"\n{'-' * 70}")
    print("ATTENTION : la présence de correspondances ne signifie pas toujours")
    print("un plagiat. Vérifier s'il s'agit de citations attribuées (légitimes)")
    print("ou de passages recopiés sans reformulation (à corriger, voir section")
    print("3 septies de 00-COORDINATION.md).")


def main():
    parser = argparse.ArgumentParser(description="Vérification anti-plagiat via Copyscape Premium.")
    parser.add_argument("chapter_file", nargs="?", help="Fichier .md du chapitre à vérifier")
    parser.add_argument(
        "--full-compare",
        type=int,
        default=0,
        metavar="N",
        help="Nombre de comparaisons complètes à effectuer (0-10, coût et délai supplémentaires)",
    )
    parser.add_argument("--balance", action="store_true", help="Afficher le solde du compte Copyscape")
    args = parser.parse_args()

    username, api_key = load_credentials()

    if args.balance:
        check_balance(username, api_key)
        return

    if not args.chapter_file:
        parser.error("Fournir un fichier de chapitre, ou utiliser --balance")

    path = Path(args.chapter_file)
    if not path.exists():
        sys.exit(f"Erreur : fichier introuvable {path}")

    raw_text = path.read_text(encoding="utf-8")
    text_to_check = clean_markdown_for_check(raw_text)

    word_count = len(text_to_check.split())
    if word_count == 0:
        sys.exit("Erreur : le texte nettoyé est vide.")

    print(f"Envoi de {word_count} mots à Copyscape Premium...")
    if word_count > 30000:
        print(
            "Attention : Copyscape limite généralement la taille du texte par requête. "
            "Si l'appel échoue, découper le chapitre en sections plus courtes."
        )

    data = search_text(username, api_key, text_to_check, full_compare=args.full_compare)
    print_report(data, path.name)


if __name__ == "__main__":
    main()