Récupérer les données produit d’une page marchande

"""
Lire un produit sur une page qui ne publie rien de structuré, en le demandant
à un modèle.

Niveau N3. C'est le niveau de la boutique qui n'émet pas de JSON-LD et dont
le rendu change tous les trimestres, où écrire des sélecteurs revient à les
réécrire. Il y gagne sa place, et nulle part au-dessus : sur une page qui
porte déjà son JSON-LD, le niveau N0 lit les mêmes valeurs pour rien.

Trois choses que ce code fait et que le modèle ne fait pas, et qui sont le
vrai travail de ce niveau.

Il coupe, et il coupe d'abord. Une page de boutique fait des centaines de
kilooctets de balisage, presque tous en menus, en mouchards et en styles ; le
balisage est plafonné avant d'être lu, les balises sautent, et ce qui reste
est plafonné à son tour. Le fournisseur facture ce qu'on envoie, donc le
second plafond est un budget — et la fiche sur l'estimation du coût d'un
appel est l'endroit où ce budget se calcule. Le premier, lui, protège le
serveur : les blocs `script` et `style` sont balayés plutôt que reconnus par
une expression régulière, exactement comme au niveau N0 et pour la même
raison — vingt mille balises jamais refermées faisaient passer des dizaines
de secondes de processeur à ce niveau, avant même l'appel au modèle.

Il refuse une valeur inventée. Chaque chaîne rendue par le modèle est
cherchée dans le texte qui a été envoyé : un nom, une référence ou un prix
qui ne figure nulle part dans la page est écarté, et `invented` dit lesquels.
C'est la seule garde qui sépare une lecture d'une réponse vraisemblable, et
elle vaut plus que la consigne.

Et il traite un refus comme un refus. Un fournisseur qui ne peut pas répondre
lève ; un contenu nul n'est pas une valeur, et il n'est pas passé au décodeur
JSON en comptant sur l'exception.
"""

from __future__ import annotations

import json
import re

# What the model is asked for, named as schema.org names it so that a caller
# can put an N0 answer and an N3 answer in the same table.
FIELDS = ("name", "sku", "brand", "price", "currency", "availability")

# A shop page is markup; this is what is left once the tags are gone. The
# pattern carries no nested quantifier on purpose: the one that reads
# « <(script|style)...>.*?</\1> » in a single line is the collapse the N0
# snippet of this entry was written to avoid, and it cost tens of seconds of
# CPU here, before the model was even called. The blocks are scanned instead,
# in `_without_scripts`.
TAGS = re.compile(r"<[^>]+>")
SPACES = re.compile(r"[ \t\r\f\v]*\n\s*|[ \t]{2,}")

# The budget in characters of markup, applied before anything reads the page.
# The charte asks that an input too large be refused before the call; a cap
# applied after the cleaning protects nothing, since the cleaning is the part
# that costs.
MAX_HTML = 400_000

# The budget, in characters of text. A page that does not fit is cut, not
# refused: a scraper that raises on a long page returns nothing at all.
MAX_CHARACTERS = 6000

# A single code fence around the whole answer is a common shape, and refusing
# it would buy another call for nothing.
FENCE = re.compile(r"\A\s*```(?:json)?\s*(.*?)\s*```\s*\Z", re.DOTALL)

MODEL = "gpt-4.1-mini"  # an example id: check the parameters your model accepts

PROMPT = (
    "Read this shop page and return the product it is about.\n"
    "Answer with JSON only, with these keys: {fields}.\n"
    "Copy each value from the page. Use null for anything the page does not say.\n\n"
    "Page:\n{page}"
)


class ProviderClient:
    """The one call this snippet makes, on top of the provider's SDK."""

    def __init__(self, sdk=None, model: str = MODEL):
        if sdk is None:  # pragma: no cover - needs a key and a network
            from openai import OpenAI

            sdk = OpenAI()
        self.sdk, self.model = sdk, model

    def complete(self, *, prompt: str, temperature: float) -> str:
        response = self.sdk.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,
        )
        return response.choices[0].message.content


class ReadingUnavailable(Exception):
    """The provider could not be reached, or answered something unusable."""


def _without_scripts(html: str) -> str:
    """
    The markup with every script and style block removed, scanned rather than
    matched — the same walk as `_blocks` in the N0 snippet, and for the same
    reason. An unclosed block swallows the rest of the page, which is what a
    browser does too.
    """
    kept, cursor, lower = [], 0, html.lower()
    while cursor < len(html):
        starts = [i for i in (lower.find("<script", cursor), lower.find("<style", cursor)) if i >= 0]
        if not starts:
            kept.append(html[cursor:])
            break
        start = min(starts)
        kept.append(html[cursor:start])
        tag = "script" if lower.startswith("<script", start) else "style"
        closing = lower.find(f"</{tag}", start)
        if closing < 0:
            break
        cursor = closing
    return "".join(kept)


def to_text(html: str) -> str:
    """The page without its markup, collapsed, and cut to the budget."""
    return SPACES.sub("\n", TAGS.sub(" ", _without_scripts(html[:MAX_HTML]))).strip()[:MAX_CHARACTERS]


def read_product(html: str, client=None, *, attempts: int = 3) -> dict:
    """
    The product a model reads on this page, with what it made up removed.

    `client` is injected so this function can be tested without a network call.
    In production it defaults to a real provider client.
    """
    client = client or ProviderClient()
    page = to_text(html)
    answer = _ask(client, page, attempts)

    product, invented = {}, []
    haystack = page.casefold()
    for field in FIELDS:
        value = answer.get(field) if isinstance(answer, dict) else None
        if value is None:
            product[field] = None
        elif str(value).strip().casefold() in haystack:
            product[field] = str(value).strip()
        else:
            # The model wrote something the page does not contain. It is not a
            # reading, so it is not kept — and the caller is told.
            product[field] = None
            invented.append(field)
    return {"source": "model", "product": product, "invented": invented,
            "characters_sent": len(page)}


def _ask(client, page: str, attempts: int) -> dict:
    prompt = PROMPT.format(fields=", ".join(FIELDS), page=page)
    last_error: Exception | None = None
    for _ in range(attempts):
        try:
            answer = client.complete(prompt=prompt, temperature=0)
            if not isinstance(answer, str):  # a refusal comes back as no content
                last_error = ValueError("the model answered no text")
                continue
            fenced = FENCE.match(answer)
            return json.loads(fenced.group(1) if fenced else answer)
        except Exception as error:  # noqa: BLE001 - any provider failure is retried
            last_error = error
    raise ReadingUnavailable(str(last_error))

/**
 * Lire un produit sur une page qui ne publie rien de structuré, en le demandant
 * à un modèle.
 *
 * Niveau N3. C'est le niveau de la boutique qui n'émet pas de JSON-LD et dont
 * le rendu change tous les trimestres, où écrire des sélecteurs revient à les
 * réécrire. Il y gagne sa place, et nulle part au-dessus : sur une page qui
 * porte déjà son JSON-LD, le niveau N0 lit les mêmes valeurs pour rien.
 *
 * Trois choses que ce code fait et que le modèle ne fait pas, et qui sont le
 * vrai travail de ce niveau.
 *
 * Il coupe, et il coupe d'abord. Une page de boutique fait des centaines de
 * kilooctets de balisage, presque tous en menus, en mouchards et en styles ; le
 * balisage est plafonné avant d'être lu, les balises sautent, et ce qui reste
 * est plafonné à son tour. Le fournisseur facture ce qu'on envoie, donc le
 * second plafond est un budget — et la fiche sur l'estimation du coût d'un
 * appel est l'endroit où ce budget se calcule. Le premier, lui, protège le
 * serveur : les blocs `script` et `style` sont balayés plutôt que reconnus par
 * une expression régulière, exactement comme au niveau N0 et pour la même
 * raison — vingt mille balises jamais refermées faisaient passer des dizaines
 * de secondes de processeur à ce niveau, avant même l'appel au modèle.
 *
 * Il refuse une valeur inventée. Chaque chaîne rendue par le modèle est
 * cherchée dans le texte qui a été envoyé : un nom, une référence ou un prix
 * qui ne figure nulle part dans la page est écarté, et `invented` dit lesquels.
 * C'est la seule garde qui sépare une lecture d'une réponse vraisemblable, et
 * elle vaut plus que la consigne.
 *
 * Et il traite un refus comme un refus. Un fournisseur qui ne peut pas répondre
 * lève ; un contenu nul n'est pas une valeur, et il n'est pas passé au décodeur
 * JSON en comptant sur l'exception.
 */

// What the model is asked for, named as schema.org names it so that a caller
// can put an N0 answer and an N3 answer in the same table.
export const FIELDS = ['name', 'sku', 'brand', 'price', 'currency', 'availability'];

// A shop page is markup; this is what is left once the tags are gone. The
// pattern carries no nested quantifier on purpose: the one that reads
// « <(script|style)...>[\s\S]*?</\1> » in a single line is the collapse the N0
// snippet of this entry was written to avoid. The blocks are scanned instead,
// in `withoutScripts`.
const TAGS = /<[^>]+>/g;
const SPACES = /[ \t\r\f\v]*\n\s*|[ \t]{2,}/g;

// The budget in characters of markup, applied before anything reads the page.
// The charte asks that an input too large be refused before the call; a cap
// applied after the cleaning protects nothing, since the cleaning is the part
// that costs.
export const MAX_HTML = 400_000;

// The budget, in characters of text. A page that does not fit is cut, not
// refused: a scraper that throws on a long page returns nothing at all.
export const MAX_CHARACTERS = 6000;

// A single code fence around the whole answer is a common shape, and refusing
// it would buy another call for nothing.
const FENCE = /^\s*```(?:json)?\s*([\s\S]*?)\s*```\s*$/;

export const MODEL = 'gpt-4.1-mini'; // an example id: check the parameters your model accepts

const PROMPT = [
  'Read this shop page and return the product it is about.',
  `Answer with JSON only, with these keys: ${FIELDS.join(', ')}.`,
  'Copy each value from the page. Use null for anything the page does not say.',
  '',
  'Page:',
].join('\n');

export async function providerClient(sdk, model = MODEL) {
  if (!sdk) {
    const { OpenAI } = await import('openai');
    sdk = new OpenAI();
  }
  return {
    async complete({ prompt, temperature }) {
      const response = await sdk.chat.completions.create({
        model,
        messages: [{ role: 'user', content: prompt }],
        temperature,
      });
      return response.choices[0].message.content;
    },
  };
}

export class ReadingUnavailable extends Error {}

/**
 * The markup with every script and style block removed, scanned rather than
 * matched — the same walk as `blocks` in the N0 snippet, and for the same
 * reason. An unclosed block swallows the rest of the page, which is what a
 * browser does too.
 */
function withoutScripts(html) {
  const lower = html.toLowerCase();
  const kept = [];
  let cursor = 0;
  while (cursor < html.length) {
    const starts = [lower.indexOf('<script', cursor), lower.indexOf('<style', cursor)]
      .filter((i) => i >= 0);
    if (starts.length === 0) { kept.push(html.slice(cursor)); break; }
    const start = Math.min(...starts);
    kept.push(html.slice(cursor, start));
    const tag = lower.startsWith('<script', start) ? 'script' : 'style';
    const closing = lower.indexOf(`</${tag}`, start);
    if (closing < 0) break;
    cursor = closing;
  }
  return kept.join('');
}

/** The page without its markup, collapsed, and cut to the budget. */
export function toText(html) {
  return withoutScripts(html.slice(0, MAX_HTML))
    .replace(TAGS, ' ').replace(SPACES, '\n').trim().slice(0, MAX_CHARACTERS);
}

/**
 * The product a model reads on this page, with what it made up removed.
 *
 * @param {string} html
 * @param {{client?: {complete: Function}, attempts?: number}} [options]
 */
export async function readProduct(html, { client, attempts = 3 } = {}) {
  client ??= await providerClient();
  const page = toText(html);
  const answer = await ask(client, page, attempts);

  const product = {};
  const invented = [];
  const haystack = page.toLowerCase();
  for (const field of FIELDS) {
    const value = answer && typeof answer === 'object' ? answer[field] : null;
    if (value === null || value === undefined) {
      product[field] = null;
    } else if (haystack.includes(String(value).trim().toLowerCase())) {
      product[field] = String(value).trim();
    } else {
      // The model wrote something the page does not contain. It is not a
      // reading, so it is not kept — and the caller is told.
      product[field] = null;
      invented.push(field);
    }
  }
  return { source: 'model', product, invented, characters_sent: page.length };
}

async function ask(client, page, attempts) {
  const prompt = `${PROMPT}\n${page}`;
  let lastError;
  for (let i = 0; i < attempts; i += 1) {
    try {
      const answer = await client.complete({ prompt, temperature: 0 });
      if (typeof answer !== 'string') {
        lastError = new Error('the model answered no text'); // a refusal has no content
        continue;
      }
      const fenced = FENCE.exec(answer);
      return JSON.parse(fenced ? fenced[1] : answer);
    } catch (error) {
      lastError = error;
    }
  }
  throw new ReadingUnavailable(String(lastError));
}