from pypdf import PdfReader

def forme(chemin):
    """Données jointes, texte, ou image seule : ce qui décide de la façon de lire."""
    lecteur = PdfReader(chemin)
    if "factur-x.xml" in lecteur.attachments:
        return "Factur-X : lire le XML joint, sans modèle"
    texte = "".join(page.extract_text() or "" for page in lecteur.pages)
    if len(texte.strip()) > 50:
        return f"PDF avec texte ({len(texte)} caractères) : le modèle lit le texte"
    return "image seule : le modèle lit l'image, ou un OCR avant lui"

for nom in ("a.pdf", "b.pdf", "c.pdf"):
    print(nom, "→", forme(f"pdf/{nom}"))

import json
import xml.etree.ElementTree as ET
from pypdf import PdfReader

NS = {"rsm": "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100",
      "ram": "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100",
      "udt": "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"}
VENDEUR = "rsm:SupplyChainTradeTransaction/ram:ApplicableHeaderTradeAgreement/ram:SellerTradeParty/"
REGLEMENT = "rsm:SupplyChainTradeTransaction/ram:ApplicableHeaderTradeSettlement/"
TOTAUX = REGLEMENT + "ram:SpecifiedTradeSettlementHeaderMonetarySummation/"
CHAMPS = {
    "fournisseur": VENDEUR + "ram:Name",
    "siren": VENDEUR + "ram:SpecifiedLegalOrganization/ram:ID",
    "tva_intracom": VENDEUR + "ram:SpecifiedTaxRegistration/ram:ID[@schemeID='VA']",
    "numero": "rsm:ExchangedDocument/ram:ID",
    "date_emission": "rsm:ExchangedDocument/ram:IssueDateTime/udt:DateTimeString",
    "date_echeance": REGLEMENT + "ram:SpecifiedTradePaymentTerms/ram:DueDateDateTime/udt:DateTimeString",
    "total_ht": TOTAUX + "ram:TaxBasisTotalAmount",
    "taux_tva": REGLEMENT + "ram:ApplicableTradeTax/ram:RateApplicablePercent",
    "total_tva": TOTAUX + "ram:TaxTotalAmount",
    "total_ttc": TOTAUX + "ram:GrandTotalAmount",
}

def date_iso(s):   # format 102 : AAAAMMJJ
    return f"{s[:4]}-{s[4:6]}-{s[6:]}" if s else None

xml = PdfReader("pdf/a.pdf").attachments["factur-x.xml"][0]
racine = ET.fromstring(xml)
facture = {nom: racine.findtext(chemin, namespaces=NS) for nom, chemin in CHAMPS.items()}
facture["date_emission"] = date_iso(facture["date_emission"])
facture["date_echeance"] = date_iso(facture["date_echeance"])
print(json.dumps(facture, ensure_ascii=False, indent=1))
json.dump(facture, open("lecture_a.json", "w"), ensure_ascii=False)

import base64
from typing import Optional
import anthropic
from pydantic import BaseModel, Field

class Facture(BaseModel):
    fournisseur: Optional[str]
    siren: Optional[str] = Field(description="9 chiffres, sans espace")
    tva_intracom: Optional[str] = Field(description="numéro de TVA du fournisseur, sans espace")
    numero: Optional[str]
    date_emission: Optional[str] = Field(description="AAAA-MM-JJ")
    date_echeance: Optional[str] = Field(description="AAAA-MM-JJ")
    total_ht: Optional[str] = Field(description="tel qu'écrit, point décimal, sans symbole")
    taux_tva: Optional[str]
    total_tva: Optional[str]
    total_ttc: Optional[str]

CONSIGNE = ("Recopie les champs de cette facture. Ne calcule rien. "
            "Si un champ est absent ou illisible, laisse-le vide (null) : n'en devine aucun.")

client = anthropic.Anthropic()

def lire(contenu):
    reponse = client.messages.parse(
        model="claude-sonnet-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": contenu + [{"type": "text", "text": CONSIGNE}]}],
        output_format=Facture,
    )
    return reponse.parsed_output

# b.pdf : le texte de la page, tiré par pypdf
from pypdf import PdfReader
texte = PdfReader("pdf/b.pdf").pages[0].extract_text()
print(lire([{"type": "text", "text": texte}]))

# c.pdf : la page en image (un PNG tiré du scan)
png = base64.standard_b64encode(open("c.png", "rb").read()).decode()
print(lire([{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": png}}]))

import csv, json, re
from decimal import Decimal

TAUX = {Decimal("20"), Decimal("10"), Decimal("5.5"), Decimal("2.1")}

def cle_siren(siren):
    """Clé de Luhn : les chiffres de rang pair, lus de gauche à droite, comptent double."""
    total = 0
    for rang, c in enumerate(siren, start=1):
        d = int(c) * (2 if rang % 2 == 0 else 1)
        total += d - 9 if d > 9 else d
    return total % 10 == 0

def regles(f):
    vides = [nom for nom, v in f.items() if v in (None, "")]
    if vides:
        return [f"champ vide : {', '.join(vides)}"]
    ht, taux, tva, ttc = (Decimal(f[k]) for k in ("total_ht", "taux_tva", "total_tva", "total_ttc"))
    echecs = []
    if not (re.fullmatch(r"\d{9}", f["siren"]) and cle_siren(f["siren"])):
        echecs.append("SIREN invalide")
    if not re.fullmatch(r"FR\d{2}" + f["siren"], f["tva_intracom"]):
        echecs.append("le n° de TVA ne contient pas le SIREN")
    if taux not in TAUX:
        echecs.append(f"taux {taux} % inconnu en France métropolitaine")
    if abs(ht * taux / 100 - tva) > Decimal("0.01"):
        echecs.append("TVA ≠ HT × taux")
    if ht + tva != ttc:
        echecs.append("TTC ≠ HT + TVA")
    if f["date_echeance"] < f["date_emission"]:
        echecs.append("échéance avant l'émission")
    return echecs

lot = {"a": json.load(open("lecture_a.json"))} | {k: v for k, v in json.load(open("lectures_modele.json")).items() if k in "bc"}
retenues = []
for nom, f in lot.items():
    echecs = regles(f)
    print(f"{nom}  {f['fournisseur']:<20} {'à importer' if not echecs else 'à revoir : ' + ' ; '.join(echecs)}")
    if not echecs:
        retenues.append(f)
with open("import.csv", "w", newline="") as sortie:
    w = csv.DictWriter(sortie, fieldnames=list(lot["a"]), delimiter=";")
    w.writeheader(); w.writerows(retenues)
print(f"import.csv : {len(retenues)} facture(s)")

import json

# a.pdf a deux versions : ses données jointes (le corrigé) et la page, lue par le modèle
corrige = json.load(open("lecture_a.json"))
lue = json.load(open("lectures_modele.json"))["a_vue"]
justes = [nom for nom in corrige if lue[nom] == corrige[nom]]
for nom in corrige:
    if nom not in justes:
        print(f"écart sur {nom} : lu {lue[nom]!r}, attendu {corrige[nom]!r}")
print(f"{len(justes)} champs justes sur {len(corrige)}")