"""Pilier « Avis clients », méthode v4 du 13/11/2026 (revue par six IA, arbitrage publié sur la page méthode). - Public visé : vendeurs et acquéreurs. Les avis de locataires, de bailleurs (location, gestion, conciergerie) et de copropriétaires (syndic) sont écartés ; les avis dont l'auteur n'est pas précisé sont gardés. - Avis uniques : un même avis publié sur plusieurs plateformes ne compte qu'une fois. Chaque avis compte 1, quelle que soit la plateforme (le coefficient x1,5 des plateformes certifiées est supprimé ; la certification reste affichée). - Qualité (30,1 % de la note, méthode v6) : moyenne pondérée par l'âge (demi-vie 36 mois) et lissée vers la moyenne de Nice comme si l'agence avait 15 avis de plus à cette moyenne ; 3/5 ou moins = 0, 5/5 = 100. Aucun avis : 50. - Volume (7,6 % de la note) : 100 × log(1 + N) / log(201) ; 200 avis ou plus = 100. - Régularité (5,9 % de la note) : mois des 12 derniers avec au moins un avis, sur min(12 ; max(3 ; avis reçus sur 12 mois)). """ import math, re, datetime from common import CERTIFIED, TODAY, strip REG_MONTHS = 12 # régularité : mois des 12 derniers avec au moins un avis PREF = ['opinionsystem', 'immodvisor', 'google'] # copie conservée en cas de doublon KIND_LABEL = {'vendeur': 'Vendeurs', 'acquereur': 'Acquéreurs', 'bailleur': 'Bailleurs', 'locataire': 'Locataires', 'syndic': 'Copropriétaires (syndic)', 'non_precise': 'Non précisé'} # weight() et wt() : ancienne règle v3 (avis des plateformes certifiées x1,5). Elles ne sont PLUS appelées par le calcul # du classement (voir score() : chaque avis compte 1, pondéré seulement par son âge et son partage entre agences). # Elles restent pour les scripts de simulation publiés, qui comparent l'ancienne et la nouvelle méthode. def weight(src): return CERTIFIED.get(src, 1.0) def wt(x): """Ancienne règle v3, non utilisée par le classement. Un avis importé d'une autre plateforme (« Avis externe ») n'avait pas la certification de la plateforme qui l'affiche.""" return 1.0 if (x.get('origin') or '').lower().startswith('avis externe') else weight(x['src']) def _tokens(t): return set(w for w in re.findall(r'[a-z0-9]+', strip(t or '')) if len(w) > 2) def _author(a): p = re.findall(r'[a-z]+', strip(a or '')) return (p[0], p[-1][0] if len(p) > 1 else None) if p else (None, None) def _days(d1, d2): try: return abs((datetime.date.fromisoformat(d1) - datetime.date.fromisoformat(d2)).days) except (TypeError, ValueError): return 9999 def same_review(x, y): tx, ty = x['_tok'], y['_tok'] if len(tx) >= 5 and len(ty) >= 5: inter = len(tx & ty) return inter / len(tx | ty) >= 0.7 or inter / min(len(tx), len(ty)) >= 0.9 # au moins un avis sans texte : même note, auteurs compatibles, dates proches if x.get('r') is None or y.get('r') is None or abs(float(x['r']) - float(y['r'])) > 0.5: return False (f1, i1), (f2, i2) = x['_aut'], y['_aut'] if not f1 or f1 != f2 or (i1 and i2 and i1 != i2): return False return _days(x.get('date'), y.get('date')) <= 45 def unique_reviews(store): """Fusionne les avis détaillés de toutes les plateformes ; renvoie (avis uniques, nombre de doublons retirés).""" kept, dups = [], 0 srcs = sorted(store, key=lambda s: PREF.index(s) if s in PREF else 99) for src in srcs: for it in store[src].get('items', []): if it.get('r') is None: continue # Données publiques anonymisées (export) : mots et auteur remplacés par des empreintes, même comparaison tok = set(it['tok']) if 'tok' in it else _tokens(it.get('text')) aut = tuple(it['aut']) if 'aut' in it else _author(it.get('author')) x = {**it, 'src': src, '_tok': tok, '_aut': aut} if any(k['src'] != src and same_review(x, k) for k in kept): dups += 1; continue kept.append(x) return kept, dups def months_back(n): y, m = TODAY.year, TODAY.month out = set() for _ in range(n): out.add(f'{y:04d}-{m:02d}'); m -= 1 if m == 0: y, m = y - 1, 12 return out HORS = ('locataire', 'bailleur', 'syndic') # le classement s'adresse aux vendeurs et aux acquéreurs (méthode v4) PRIOR = 15 # avis fictifs à la moyenne de Nice (médiane des propositions des 6 IA) HALF_LIFE = 36 # mois : un avis perd la moitié de son poids après 3 ans VOL_CAP = 200 # volume : 200 avis ou plus = 100 M_REF = 4.4 # moyenne de Nice (moyenne des notes moyennes des agences), recalculée à chaque passage par build.py AGG_AGE = 0.5 # avis comptés par la seule note globale de la plateforme (date inconnue) : poids d'un avis de 3 ans def age_weight(d): try: m = (TODAY - datetime.date.fromisoformat(d[:10])).days / 30.44 except (TypeError, ValueError): return AGG_AGE return 2 ** (-max(0.0, m) / HALF_LIFE) SHARED = {} # texte d'avis -> nombre d'agences sur les fiches desquelles il est publié (rempli par build.py) def text_key(t): t = ' '.join((t or '').lower().split()) return t[:120] if len(t) >= 60 else None def key_of(it): return it['key'] if 'key' in it else text_key(it.get('text')) def shared_weight(x): """Un même avis publié sur les fiches de plusieurs agences (bureaux d'une même société, transfert de fiche) est réparti entre elles : il compte 1/k dans chacune des k agences, au lieu de compter entièrement dans chacune.""" k = SHARED.get(key_of(x), 1) return 1.0 / k if k > 1 else 1.0 def tx(store): """Avis de transaction seulement : retire les avis de locataires, de bailleurs (location, gestion) et de copropriétaires.""" out = {} for s, v in (store or {}).items(): if isinstance(v, dict): out[s] = {**v, 'items': [x for x in v.get('items', []) if x.get('kind') not in HORS]} return out def score(agg, store): """Pilier Avis, méthode v4 (13/11/2026). agg : [(source, note, nombre, url)] des fiches ; store : avis détaillés. Une plateforme dont le relevé détaillé est complet est comptée avis par avis (avis de transaction seulement) ; sinon par sa note globale (date et profil inconnus : sans tri ni régularité possibles pour elle). """ full = store or {} n_hors = sum(1 for v in full.values() if isinstance(v, dict) for x in v.get('items', []) if x.get('kind') in HORS) store = tx(full) detailed = {s: v for s, v in store.items() if v.get('complete') and (v.get('items') or full[s].get('items'))} uniq, dups = unique_reviews(detailed) sh = [shared_weight(x) for x in uniq] sw = sum(age_weight(x.get('date')) * k for x, k in zip(uniq, sh)) sr = sum(age_weight(x.get('date')) * k * float(x['r']) for x, k in zip(uniq, sh)) n = float(sum(sh)) n_shared = sum(1 for k in sh if k < 1) for src, r, k, _ in agg: if src in detailed: continue sw += AGG_AGE * k; sr += AGG_AGE * r * k; n += k mean = (PRIOR * M_REF + sr) / (PRIOR + sw) if sw else None raw = sr / sw if sw else None q = round(max(0.0, min(100.0, (mean - 3) / 2 * 100)), 1) if mean else 50.0 v = round(min(100.0, 100 * math.log(1 + n) / math.log(VOL_CAP + 1)), 1) win = months_back(REG_MONTHS) covered = all(s in detailed for s, *_ in agg) if agg else True # Régularité (étalement) : mois des 12 derniers avec au moins un avis, rapportés au nombre de mois qu'on peut # raisonnablement couvrir vu le nombre d'avis reçus (3 au moins, 12 au plus). Sans aucun avis détaillé relevé : # critère non vérifiable (échec de collecte), le pilier est calculé sur la qualité et le volume. alld = [it for v in store.values() for it in v.get('items', [])] rec = [x for x in alld if (x.get('date') or '')[:7] in win] months = sorted({x['date'][:7] for x in rec}) if any(full[s].get('items') for s in full if isinstance(full[s], dict)): reg = round(min(1.0, len(months) / min(12, max(3, len(rec)))) * 100, 1) if rec else 0.0 else: reg = 0.0 if not agg else None # aucun avis nulle part : régularité nulle ; avis non relevés : non vérifiable # Méthode v6 : qualité 30,1 %, volume 7,6 %, régularité 5,9 % de la note (pilier = moyenne pondérée de ses critères) ; # régularité non vérifiable : son poids est réparti sur la qualité et le volume from common import CRIT_W wq, wv, wr = (CRIT_W['avis'][k] for k in ('qualite', 'volume', 'regularite')) total = (wq * q + wv * v + wr * reg) / (wq + wv + wr) if reg is not None else (wq * q + wv * v) / (wq + wv) kinds = {} for x in uniq: k = x.get('kind') or 'non_precise' e = kinds.setdefault(k, [0.0, 0.0, 0]) e[0] += float(x['r']); e[1] += 1; e[2] += 1 return {'avis': round(total, 1), 'q': q, 'v': v, 'reg': reg, 'mean': round(raw, 2) if raw else None, 'bayes': round(mean, 2) if mean else None, 'nHors': n_hors, 'n12': len(rec), 'nShared': n_shared, 'nUnique': int(n), 'nWeighted': round(sw, 1), 'dups': dups, 'months': len(months), 'detailed': sorted(detailed), 'covered': covered, 'kinds': [{'k': k, 'label': KIND_LABEL[k], 'r': round(e[0] / e[1], 2), 'n': e[2]} for k, e in sorted(kinds.items(), key=lambda kv: list(KIND_LABEL).index(kv[0]))]}