Court terme : upgrade majeur — 21 nouveaux connecteurs, 12 enrichis, fiches améliorées · bc6aef3 · lou-ka

Court terme : upgrade majeur — 21 nouveaux connecteurs, 12 enrichis, fiches améliorées

- 21 nouveaux connecteurs (chaleto, hébergement-charlevoix, chaletsalpins,
  memoria, pourvoiries FPQ, campingquebec, hebergia, rezerve, accestremblant,
  chaletsdanslenord, alouerauxiles, rvmt, boraboreal, homminichalets…)
- enrichissement des existants : airbnb (desc/capacité/commodités via PDP),
  booking/vrbo/expedia (Apollo SSR, bug slug vrbo corrigé), sepaq (desc+géo),
  tremblantliving (prix API Streamline), qldc/kijiji/parcscanada/bonjourquebec/
  gitespassant ; sinistar : prix vérifiés inaccessibles (documenté)
- fiches CT : /api/ct/listings/{uid}/context (analyse prix/nuit par segment,
  histogramme, centile) + badge marché + hébergements similaires à proximité
- registre sources_ct.json : 52 sources (7 mortes retirées, 21 ajoutées)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Simon-Pierre Boucher committed 2 mo ago (Aug 25, 2026) parent bf51f56 Browse files

41 changed files +5,841 −109

modified data/sources_ct.json +324 −34

+ {
++ "sources": [
++  {
++   "id": "airbnb",
++   "name": "Airbnb",
++   "url": "https://www.airbnb.ca",
++   "category": "internationale"
++  },
++  {
++   "id": "booking",
++   "name": "Booking.com",
++   "url": "https://www.booking.com",
++   "category": "internationale"
++  },
++  {
++   "id": "vrbo",
++   "name": "Vrbo",
++   "url": "https://www.vrbo.com",
++   "category": "internationale"
++  },
++  {
++   "id": "expedia",
++   "name": "Expedia (locations de vacances)",
++   "url": "https://www.expedia.ca",
++   "category": "internationale"
++  },
++  {
++   "id": "agoda",
++   "name": "Agoda Homes",
++   "url": "https://www.agoda.com",
++   "category": "internationale",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "plumguide",
++   "name": "Plum Guide",
++   "url": "https://www.plumguide.com",
++   "category": "internationale",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "glampinghub",
++   "name": "Glamping Hub",
++   "url": "https://glampinghub.com",
++   "category": "internationale"
++  },
++  {
++   "id": "hipcamp",
++   "name": "Hipcamp",
++   "url": "https://www.hipcamp.com",
++   "category": "internationale"
++  },
++  {
++   "id": "marriott_hvmi",
++   "name": "Marriott Homes & Villas",
++   "url": "https://homes-and-villas.marriott.com",
++   "category": "internationale",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "furnishedfinder",
++   "name": "Furnished Finder",
++   "url": "https://www.furnishedfinder.com",
++   "category": "internationale",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "corporatestays",
++   "name": "Corporate Stays",
++   "url": "https://www.corporatestays.com",
++   "category": "internationale"
++  },
++  {
++   "id": "monsieurchalets",
++   "name": "MonsieurChalets",
++   "url": "https://www.monsieurchalets.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "wechalet",
++   "name": "WeChalet",
++   "url": "https://wechalet.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "chaletsarabais",
++   "name": "Chalets à Rabais",
++   "url": "https://www.chaletsarabais.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "chaletsalouer",
++   "name": "ChaletsÀLouer.com",
++   "url": "https://www.chaletsalouer.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "mcal",
++   "name": "Maisons et chalets à louer",
++   "url": "https://maisonsetchaletsalouer.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "qldc",
++   "name": "Québec Location de Chalets",
++   "url": "https://www.quebeclocationdechalets.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "rsvpchalets",
++   "name": "RSVP Chalets",
++   "url": "https://rsvpchalets.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "chaletsauquebec",
++   "name": "Chalets au Québec",
++   "url": "https://www.chaletsauquebec.com",
++   "category": "quebecoise"
++  },
++  {
++   "id": "tremblant_living",
++   "name": "Tremblant Living",
++   "url": "https://www.tremblantliving.com",
++   "category": "agence"
++  },
++  {
++   "id": "gites_passant",
++   "name": "Gîtes et Auberges du Passant",
++   "url": "https://www.terroiretsaveurs.com",
++   "category": "gites"
++  },
++  {
++   "id": "bonjourquebec",
++   "name": "Bonjour Québec (CITQ)",
++   "url": "https://www.bonjourquebec.com",
++   "category": "officielle"
++  },
++  {
++   "id": "sepaq",
++   "name": "Sépaq",
++   "url": "https://www.sepaq.com",
++   "category": "officielle"
++  },
++  {
++   "id": "parcscanada",
++   "name": "Parcs Canada",
++   "url": "https://reservation.pc.gc.ca",
++   "category": "officielle"
++  },
++  {
++   "id": "sinistar",
++   "name": "Sinistar",
++   "url": "https://www.sinistar.ca",
++   "category": "relogement"
++  },
++  {
++   "id": "louer_ca_ct",
++   "name": "Louer.ca (court terme)",
++   "url": "https://www.louer.ca",
++   "category": "relogement",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "kijiji_ct",
++   "name": "Kijiji (court terme)",
++   "url": "https://www.kijiji.ca",
++   "category": "petites-annonces"
++  },
++  {
++   "id": "lespac_ct",
++   "name": "LesPAC (court terme)",
++   "url": "https://www.lespac.com",
++   "category": "petites-annonces",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "fb_marketplace_ct",
++   "name": "Facebook Marketplace (court terme)",
++   "url": "https://www.facebook.com/marketplace",
++   "category": "petites-annonces",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "craigslist_ct",
++   "name": "Craigslist (court terme)",
++   "url": "https://montreal.craigslist.org",
++   "category": "petites-annonces",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "bonjourresidences",
++   "name": "Bonjour Résidences",
++   "url": "https://www.bonjourresidences.com",
++   "category": "cas-particuliers",
++   "status": "en attente de connecteur"
++  },
++  {
++   "id": "chaleto",
++   "name": "Chaletô",
++   "url": "https://chaleto.ca",
++   "category": "quebecoise"
++  },
++  {
++   "id": "hebergia",
++   "name": "Hebergia",
++   "url": "https://hebergia.ca",
++   "category": "quebecoise"
++  },
++  {
++   "id": "rezerve",
++   "name": "Rëzerve",
++   "url": "https://reserver.ca",
++   "category": "quebecoise"
++  },
++  {
++   "id": "campingquebec",
++   "name": "Camping Québec",
++   "url": "https://www.campingquebec.com",
++   "category": "officielle"
++  },
++  {
++   "id": "pourvoiries",
++   "name": "Pourvoiries du Québec (FPQ)",
++   "url": "https://www.pourvoiries.com",
++   "category": "officielle"
++  },
++  {
++   "id": "gitesauquebec",
++   "name": "Gîtes au Québec",
++   "url": "https://www.gitesauquebec.com",
++   "category": "gites"
++  },
++  {
++   "id": "hebergementcharlevoix",
++   "name": "Hébergement Charlevoix",
++   "url": "https://www.hebergement-charlevoix.com",
++   "category": "agence"
++  },
++  {
++   "id": "chaletsalpins",
++   "name": "Les Chalets Alpins",
++   "url": "https://chaletsalpins.ca",
++   "category": "agence"
++  },
++  {
++   "id": "memoriachalets",
++   "name": "Memoria Chalets",
++   "url": "https://memoriachalets.com",
++   "category": "agence"
++  },
++  {
++   "id": "accestremblant",
++   "name": "Accès Tremblant",
++   "url": "https://accestremblant.ca",
++   "category": "agence"
++  },
++  {
++   "id": "chaletsdanslenord",
++   "name": "Les Chalets dans le Nord",
++   "url": "https://leschaletsdanslenord.com",
++   "category": "agence"
++  },
++  {
++   "id": "alouerauxiles",
++   "name": "À louer aux Îles",
++   "url": "https://www.alouerauxiles.com",
++   "category": "agence"
++  },
++  {
++   "id": "lesversants",
++   "name": "Les Versants Mont-Tremblant",
++   "url": "https://www.lesversants.com",
++   "category": "agence"
++  },
++  {
++   "id": "captremblant",
++   "name": "Cap Tremblant",
++   "url": "https://captremblant.com",
++   "category": "agence"
++  },
++  {
++   "id": "rvmt",
++   "name": "Rendez-vous Mont-Tremblant",
++   "url": "https://www.rvmt.com",
++   "category": "agence"
++  },
++  {
++   "id": "locationdechalets",
++   "name": "Location de Chalets 4 Saisons",
++   "url": "https://www.locationdechalets.com",
++   "category": "agence"
++  },
++  {
++   "id": "chaletsbsl",
++   "name": "Chalets BSL",
++   "url": "https://www.chaletsbsl.com",
++   "category": "agence"
++  },
++  {
++   "id": "panoraloges",
++   "name": "Panora Loges",
++   "url": "https://www.panoraloges.ca",
++   "category": "agence"
++  },
++  {
++   "id": "domesstcome",
++   "name": "Dômes St-Côme",
++   "url": "https://www.domesstcome.com",
++   "category": "agence"
++  },
++  {
++   "id": "boraboreal",
++   "name": "Bora Boréal",
++   "url": "https://www.boraboreal.com",
++   "category": "agence"
++  },
++  {
++   "id": "homminichalets",
++   "name": "HOM Mini-Chalets",
++   "url": "https://homminichalets.com",
++   "category": "agence"
++  }
++ ]
++}
+ \ No newline at end of file

added frontend/src/components/CtPriceAnalysis.tsx +96 −0

++// -----------------------------------------------------------------------------
++// Lou-Ka — Location court terme
++// components/CtPriceAnalysis.tsx : bloc « Analyse du prix / nuit » (fiche CT)
++//   Position du tarif dans la distribution des hébergements comparables
++//   (segment : type + capacité + région touristique, calculé par l'API).
++// -----------------------------------------------------------------------------
++import { CtPriceContext, fmtNight } from "../ctapi";
++
++export function ctDealBadge(p: CtPriceContext | null) {
++  if (!p || p.deviation == null || p.verdict == null) return null;
++  const pct = Math.round(Math.abs(p.deviation) * 100);
++  if (p.verdict === "sous")
++    return { cls: "deal-good", txt: `≈ ${pct} % sous le prix médian du segment` };
++  if (p.verdict === "dessus")
++    return { cls: "deal-high", txt: `≈ ${pct} % au-dessus du prix médian` };
++  return { cls: "deal-ok", txt: "Dans les prix du segment" };
++}
++
++function Histo({ p, price }: { p: CtPriceContext; price: number }) {
++  const bins = p.histogram;
++  if (!bins || bins.length < 4) return null;
++  const W = 320, H = 96, top = 18, bottom = 16;
++  const lo = bins[0].x0, hi = bins[bins.length - 1].x1;
++  if (hi <= lo) return null;
++  const max = Math.max(...bins.map((b) => b.n), 1);
++  const x = (v: number) => ((Math.min(Math.max(v, lo), hi) - lo) / (hi - lo)) * W;
++  const bw = W / bins.length;
++  const plotH = H - top - bottom;
++  const priceX = x(price), medX = x(p.median);
++  const close = Math.abs(priceX - medX) < 64;
++  const lblAnchor = (px: number) => (px < 56 ? "start" : px > W - 56 ? "end" : "middle");
++  return (
++    <svg className="fv-histo" viewBox={`0 0 ${W} ${H}`} role="img"
++         aria-label={`Position du prix (${price} $/nuit) parmi ${p.n} hébergements comparables`}>
++      {bins.map((b, i) => {
++        const h = Math.max(1.5, (b.n / max) * plotH);
++        const inBin = price >= b.x0 && price < b.x1;
++        return (
++          <rect key={i} x={i * bw + 1} y={H - bottom - h} rx="2"
++                width={Math.max(1, bw - 2)} height={h}
++                fill={inBin ? "var(--accent, #ff6a00)" : "rgba(204, 85, 0, 0.28)"}>
++            <title>{`${b.x0} $ – ${b.x1} $ : ${b.n} hébergement${b.n > 1 ? "s" : ""}`}</title>
++          </rect>
++        );
++      })}
++      {/* fourchette interquartile (bande) */}
++      <rect x={x(p.p25)} y={H - bottom} width={Math.max(2, x(p.p75) - x(p.p25))}
++            height="3.5" rx="1.5" fill="rgba(204, 85, 0, 0.45)" />
++      {/* marqueur médiane */}
++      <line x1={medX} x2={medX} y1={top - 2} y2={H - bottom}
++            stroke="var(--accent-deep, #cc5500)" strokeWidth="1.6" strokeDasharray="3 3" />
++      {!close && (
++        <text x={medX} y={top - 7} textAnchor={lblAnchor(medX)}
++              className="fv-histo-lbl fv-histo-lbl-fv">Médiane</text>
++      )}
++      {/* marqueur du prix demandé */}
++      <line x1={priceX} x2={priceX} y1={top - 2} y2={H - bottom}
++            stroke="var(--ink, #141814)" strokeWidth="2" />
++      <text x={priceX} y={close ? top - 7 : H - 4} textAnchor={lblAnchor(priceX)}
++            className="fv-histo-lbl">Ce prix{close ? " / médiane" : ""}</text>
++      <text x="1" y={H - 4} className="fv-histo-axis" textAnchor="start">{lo} $</text>
++      <text x={W - 1} y={H - 4} className="fv-histo-axis" textAnchor="end">{hi} $</text>
++    </svg>
++  );
++}
++
++export default function CtPriceAnalysis({ p, price }:
++    { p: CtPriceContext | null; price: number | null }) {
++  if (!p || price == null) return null;
++  const badge = ctDealBadge(p);
++  return (
++    <section className="f-bloc f-fairvalue" id="analyse-prix">
++      <h2>Analyse du prix Lou-Ka</h2>
++      <div className="fv-head">
++        <div>
++          <div className="fv-value">{fmtNight(p.median)} <small>/ nuit</small></div>
++          <div className="fv-range">
++            Prix médian du segment · 50 % des prix entre {fmtNight(p.p25)} et {fmtNight(p.p75)}
++          </div>
++        </div>
++        {badge && <div className={`fv-badge ${badge.cls}`}>{badge.txt}</div>}
++      </div>
++      <Histo p={p} price={price} />
++      <div className="fv-meta">
++        <span>Segment : <b>{p.segment}</b></span>
++        <span>{p.n.toLocaleString("fr-CA")} hébergements comparables</span>
++        <span>Moins cher que {100 - p.percentile} % du segment</span>
++      </div>
++      <p className="fine">
++        Comparaison indicative des tarifs affichés (« à partir de ») par les
++        sources pour des hébergements du même type dans la même région — les
++        prix réels varient selon les dates et la durée du séjour.
++      </p>
++    </section>
++  );
++}

modified frontend/src/ctapi.ts +19 −0

				`@@ -87,6 +87,23 @@ export interface CtFilters {`
87	sort?: string; // recent \| prix \| prix_desc \| note	87	sort?: string; // recent \| prix \| prix_desc \| note
88	}	88	}
89		89
		90	+export interface CtPriceContext {
		91	+ segment: string;
		92	+ n: number;
		93	+ median: number;
		94	+ p25: number;
		95	+ p75: number;
		96	+ deviation: number \| null; // (prix − médiane) / médiane
		97	+ verdict: "sous" \| "dans" \| "dessus" \| null;
		98	+ percentile: number; // position du prix dans le segment (0-100)
		99	+ histogram: { x0: number; x1: number; n: number }[];
		100	+}
		101	+
		102	+export interface CtContext {
		103	+ price: CtPriceContext \| null;
		104	+ similar: (CtListing & { distance_km?: number })[];
		105	+}
		106	+
90	const CT_SOURCE_NAMES: Record<string, string> = {};	107	const CT_SOURCE_NAMES: Record<string, string> = {};
91	export function registerCtSourceNames(sources: CtSource[]) {	108	export function registerCtSourceNames(sources: CtSource[]) {
92	for (const s of sources) CT_SOURCE_NAMES[s.id] = s.name;	109	for (const s of sources) CT_SOURCE_NAMES[s.id] = s.name;
				`@@ -118,6 +135,8 @@ export function fetchCtListings(f: CtFilters, limit?: number, offset?: number) {`
118		135
119	export const fetchCtListing = (uid: string) =>	136	export const fetchCtListing = (uid: string) =>
120	get<CtListing>(`/api/ct/listings/${encodeURIComponent(uid)}`);	137	get<CtListing>(`/api/ct/listings/${encodeURIComponent(uid)}`);
		138	+export const fetchCtContext = (uid: string) =>
		139	+ get<CtContext>(`/api/ct/listings/${encodeURIComponent(uid)}/context`);
121	export const fetchCtFacets = () => get<CtFacets>("/api/ct/facets");	140	export const fetchCtFacets = () => get<CtFacets>("/api/ct/facets");
122	export const fetchCtStats = () => get<CtStats>("/api/ct/stats");	141	export const fetchCtStats = () => get<CtStats>("/api/ct/stats");
123	export const fetchCtSources = () =>	142	export const fetchCtSources = () =>

modified frontend/src/pages/CourtTermeFiche.tsx +27 −2

				`@@ -8,10 +8,12 @@`
8	import { lazy, Suspense, useEffect, useRef, useState } from "react";	8	import { lazy, Suspense, useEffect, useRef, useState } from "react";
9	import { Link, useParams } from "react-router-dom";	9	import { Link, useParams } from "react-router-dom";
10	import {	10	import {
11	− CtListing, ctSourceName, fetchCtListing, fetchCtSources, fmtNight,	11	+ CtContext, CtListing, ctSourceName, fetchCtContext, fetchCtListing,
12	− registerCtSourceNames,	12	+ fetchCtSources, fmtNight, registerCtSourceNames,
13	} from "../ctapi";	13	} from "../ctapi";
14	import SmartImg from "../components/SmartImg";	14	import SmartImg from "../components/SmartImg";
		15	+import CtListingCard from "../components/CtListingCard";
		16	+import CtPriceAnalysis, { ctDealBadge } from "../components/CtPriceAnalysis";
15	import { IcoAlert } from "../components/Icons";	17	import { IcoAlert } from "../components/Icons";
16		18
17	const CtFicheMap = lazy(() => import("../components/CtFicheMap"));	19	const CtFicheMap = lazy(() => import("../components/CtFicheMap"));
				`@@ -84,12 +86,15 @@ function Galerie({ images, titre, typeLabel }:`
84	export default function CourtTermeFichePage() {	86	export default function CourtTermeFichePage() {
85	const { uid } = useParams<{ uid: string }>();	87	const { uid } = useParams<{ uid: string }>();
86	const [l, setL] = useState<CtListing \| null>(null);	88	const [l, setL] = useState<CtListing \| null>(null);
		89	+ const [ctx, setCtx] = useState<CtContext \| null>(null);
87	const [error, setError] = useState<string \| null>(null);	90	const [error, setError] = useState<string \| null>(null);
88		91
89	useEffect(() => {	92	useEffect(() => {
90	fetchCtSources().then((r) => registerCtSourceNames(r.sources)).catch(() => {});	93	fetchCtSources().then((r) => registerCtSourceNames(r.sources)).catch(() => {});
91	if (!uid) return;	94	if (!uid) return;
		95	+ setCtx(null);
92	fetchCtListing(uid).then(setL).catch((e) => setError(String(e)));	96	fetchCtListing(uid).then(setL).catch((e) => setError(String(e)));
		97	+ fetchCtContext(uid).then(setCtx).catch(() => setCtx(null));
93	window.scrollTo(0, 0);	98	window.scrollTo(0, 0);
94	}, [uid]);	99	}, [uid]);
95		100
				`@@ -152,6 +157,12 @@ export default function CourtTermeFichePage() {`
152	{fmtNight(l.price_night, l.price_label)}	157	{fmtNight(l.price_night, l.price_label)}
153	{l.price_night != null && <small> /{NBSP}nuit</small>}	158	{l.price_night != null && <small> /{NBSP}nuit</small>}
154	</div>	159	</div>
		160	+ {(() => {
		161	+ const badge = ctDealBadge(ctx?.price ?? null);
		162	+ return badge && (
		163	+ <div className={`deal-badge ${badge.cls}`}>{badge.txt}</div>
		164	+ );
		165	+ })()}
155	{l.rating != null && (	166	{l.rating != null && (
156	<div className="deal-badge deal-ok">	167	<div className="deal-badge deal-ok">
157	★ {l.rating.toLocaleString("fr-CA", { maximumFractionDigits: 1 })} / 5	168	★ {l.rating.toLocaleString("fr-CA", { maximumFractionDigits: 1 })} / 5
				`@@ -218,6 +229,7 @@ export default function CourtTermeFichePage() {`
218	</div>	229	</div>
219		230
220	<div className="f-col">	231	<div className="f-col">
		232	+ <CtPriceAnalysis p={ctx?.price ?? null} price={l.price_night} />
221	{l.lat != null && l.lng != null && (	233	{l.lat != null && l.lng != null && (
222	<section className="f-bloc f-carte" id="emplacement">	234	<section className="f-bloc f-carte" id="emplacement">
223	<h2>Emplacement</h2>	235	<h2>Emplacement</h2>
				`@@ -232,6 +244,19 @@ export default function CourtTermeFichePage() {`
232	</div>	244	</div>
233	</div>	245	</div>
234		246
		247	+ {ctx && ctx.similar.length > 0 && (
		248	+ <section className="f-bloc f-similaires" aria-label="Hébergements similaires">
		249	+ <h2>
		250	+ {l.lat != null && ctx.similar[0]?.distance_km != null
		251	+ ? "Hébergements similaires à proximité"
		252	+ : `Hébergements similaires — ${l.region \|\| "même région"}`}
		253	+ </h2>
		254	+ <div className="grid">
		255	+ {ctx.similar.map((s) => <CtListingCard key={s.uid} l={s} />)}
		256	+ </div>
		257	+ </section>
		258	+ )}
		259	+
235	<div className="fine f-foot">	260	<div className="fine f-foot">
236	{synced && <>Dernière synchronisation : {synced}. </>}	261	{synced && <>Dernière synchronisation : {synced}. </>}
237	Les prix et disponibilités sont ceux affichés par la source — chaque fiche	262	Les prix et disponibilités sont ceux affichés par la source — chaque fiche

modified frontend/src/styles.css +4 −0

				`@@ -1055,6 +1055,10 @@ html { scroll-padding-top: 76px; } /* header sticky au-dessus des ancres */`
1055	}	1055	}
1056	.f-foot { margin-top: 26px; }	1056	.f-foot { margin-top: 26px; }
1057		1057
		1058	+/* --- Fiche court terme : hébergements similaires (pleine largeur) --- */
		1059	+.f-similaires { margin-top: 22px; }
		1060	+.f-similaires .grid { margin-top: 4px; }
		1061	+
1058	/* --- Passerelle vers l'annonce originale ------------------------------------ */	1062	/* --- Passerelle vers l'annonce originale ------------------------------------ */
1059	.passerelle {	1063	.passerelle {
1060	min-height: calc(100dvh - 120px); display: flex; align-items: center;	1064	min-height: calc(100dvh - 120px); display: flex; align-items: center;

added louka/shortterm/connectors/_expediadetail.py +155 −0

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/_expediadetail.py : parseur partagé des pages détail de la
++# plateforme Expedia (Vrbo + Expedia — même moteur, même SSR).
++#
++# La page détail (…/location/pXXXXXX[vb] ou …hXXXXXX.Hotel-Information),
++# récupérée via Scrapfly ASP SANS rendu JS, embarque :
++#   - __APOLLO_STATE__ (JSON.parse("…")) → PropertyInfo :
++#       . propertyContentSectionGroups(…).aboutThisProperty → description
++#         (blocs PropertyContentItemMarkup, HTML — inclut souvent le n° CITQ)
++#       . summary.amenities(…) → commodités localisées (infoItems[].text)
++#   - microdonnées schema.org SSR : lat/lng (itemProp latitude/longitude),
++#     capacité (occupancy → value), municipalité (addressLocality)
++#   - galerie : URLs media.vrbo.com / images.trvl-media.com (~6 photos SSR)
++# Vérifié live 2026-08-25 sur p3363083vb (Vrbo) et h130341845 (Expedia).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++_APOLLO_RE = re.compile(
++    r'__APOLLO_STATE__\s*=\s*JSON\.parse\("(.*?)(?<!\\)"\)', re.S)
++_LAT_RE = re.compile(r'itemProp="latitude" content="(-?[\d.]+)"')
++_LNG_RE = re.compile(r'itemProp="longitude" content="(-?[\d.]+)"')
++_OCC_RE = re.compile(
++    r'itemProp="occupancy".{0,200}?itemProp="value" content="(\d+)"', re.S)
++_CITY_RE = re.compile(r'itemProp="addressLocality" content="([^"]+)"')
++_IMG_RE = re.compile(
++    r'https://(?:media\.vrbo\.com|images\.trvl-media\.com)/lodging/'
++    r'[^"\s\\)&?]+')
++
++
++def _apollo(html: str) -> dict:
++    """Entités du store Apollo SSR ({} si absent/illisible)."""
++    m = _APOLLO_RE.search(html or "")
++    if not m:
++        return {}
++    try:
++        # la chaîne est un littéral JSON : la re-quoter puis parser deux fois
++        return json.loads(json.loads('"' + m.group(1) + '"'))
++    except ValueError:
++        return {}
++
++
++def _markup_texts(node, out: list[str]) -> None:
++    """Collecte récursive des blocs PropertyContentItemMarkup (description)."""
++    if isinstance(node, dict):
++        if node.get("__typename") == "PropertyContentItemMarkup":
++            txt = ((node.get("content") or {}).get("text") or "").strip()
++            if txt:
++                out.append(txt)
++            return
++        for v in node.values():
++            _markup_texts(v, out)
++    elif isinstance(node, list):
++        for v in node:
++            _markup_texts(v, out)
++
++
++def _strip_html(raw: str) -> str:
++    t = re.sub(r"<br\s*/?>|</p>", "\n", raw)
++    t = re.sub(r"<[^>]+>", " ", t)
++    t = _html.unescape(t)
++    lines = [re.sub(r"\s+", " ", ln).strip() for ln in t.split("\n")]
++    return "\n".join(ln for ln in lines if ln).strip()
++
++
++def parse_detail(html: str) -> dict:
++    """Payload détail {description, amenities, capacity, lat, lng, city,
++    images} d'une page hébergement Vrbo/Expedia ({} si page invalide)."""
++    store = _apollo(html or "")
++    pinfo = next((v for k, v in store.items()
++                  if k.startswith("PropertyInfo") and isinstance(v, dict)), {})
++    if not pinfo and not _LAT_RE.search(html or ""):
++        return {}                       # page vide / redirection hors fiche
++
++    out: dict = {}
++
++    # description : sections « À propos de cet hébergement »
++    paras: list[str] = []
++    for k, v in pinfo.items():
++        if k.startswith("propertyContentSectionGroups") and isinstance(v, dict):
++            _markup_texts(v.get("aboutThisProperty"), paras)
++    if not paras:                       # repli : éditorial du quartier
++        loc = (pinfo.get("summary") or {}).get("location") or {}
++        ed = ((loc.get("whatsAround") or {}).get("editorial") or {})
++        paras = [t for t in (ed.get("content") or []) if isinstance(t, str)]
++    desc = "\n\n".join(_strip_html(p) for p in paras).strip()
++    if desc:
++        out["description"] = desc[:6000]
++
++    # commodités localisées (summary.amenities → sections → infoItems)
++    amenities: list[str] = []
++    for k, v in (pinfo.get("summary") or {}).items():
++        if not (k.startswith("amenities") and isinstance(v, dict)):
++            continue
++        for sec in v.get("amenities") or []:
++            for cont in (sec or {}).get("contents") or []:
++                for it in (cont or {}).get("infoItems") or []:
++                    txt = ((it or {}).get("text") or "").strip()
++                    if txt and txt not in amenities:
++                        amenities.append(txt)
++    if amenities:
++        out["amenities"] = amenities[:80]
++
++    # microdonnées SSR : géo, capacité, municipalité
++    m = _LAT_RE.search(html)
++    n = _LNG_RE.search(html)
++    if m and n:
++        try:
++            out["lat"], out["lng"] = float(m.group(1)), float(n.group(1))
++        except ValueError:
++            pass
++    m = _OCC_RE.search(html)
++    if m:
++        out["capacity"] = float(m.group(1))
++    m = _CITY_RE.search(html)
++    if m:
++        out["city"] = _html.unescape(m.group(1)).strip()
++
++    # galerie SSR : dédupliquée par chemin, servie en 1200 px
++    images: list[str] = []
++    for u in _IMG_RE.findall(html):
++        big = u + "?impolicy=resizecrop&rw=1200&ra=fit"
++        if big not in images:
++            images.append(big)
++        if len(images) >= 15:
++            break
++    if images:
++        out["images"] = images
++    return out
++
++
++def apply_detail(lst, d: dict) -> None:
++    """Applique le payload détail sans écraser ce que la carte a fourni
++    (sauf galerie : on garde la plus grande)."""
++    if not d:
++        return
++    if d.get("description") and len(d["description"]) > len(lst.description or ""):
++        lst.description = d["description"]
++    if d.get("amenities"):
++        seen = {a.lower() for a in lst.amenities}
++        for a in d["amenities"]:
++            if a.lower() not in seen:
++                lst.amenities.append(a)
++                seen.add(a.lower())
++    for f in ("capacity", "lat", "lng"):
++        if d.get(f) is not None and getattr(lst, f, None) is None:
++            setattr(lst, f, d[f])
++    if d.get("city") and not lst.city:
++        lst.city = d["city"]
++    if d.get("images") and len(d["images"]) > len(lst.images):
++        lst.images = list(d["images"])

added louka/shortterm/connectors/accestremblant.py +173 −0

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/accestremblant.py : Accès Tremblant (accestremblant.ca)
++#
++# Agence de condos à Mont-Tremblant (~17 fiches) — WordPress Avada
++# (portfolio) + moteur Guesty (guestybookings.com).
++#
++# Méthode :
++#   1. LISTE : sitemap https://accestremblant.ca/avada_portfolio-sitemap.xml
++#      → /condos/<slug>/ (lastmod = clé du cache détail).
++#   2. DÉTAIL (cache self.detail) : la fiche WP fournit spécs (spans
++#      icon-condos : « 8 Personnes », « 3 chambres », « 3 salles de bain » +
++#      extras type « Foyer au gaz »), description (JSON-LD Yoast), photos
++#      (wp-content/uploads) et l'id Guesty (lien guestybookings.com).
++#   3. PRIX : chaque fiche contient un carrousel « autres condos » avec
++#      « À partir de N $ » pour les AUTRES fiches ; chaque payload détail
++#      mémorise cette carte slug→prix et fetch() fusionne le tout (le prix
++#      d'une fiche vient donc des autres pages, même à froid depuis le cache).
++#   External_id = slug WP (stable) ; l'id Guesty est gardé dans details.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://accestremblant.ca"
++SITEMAP = f"{SITE}/avada_portfolio-sitemap.xml"
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++class AccesTremblant(StConnector):
++    source_id = "accestremblant"
++
++    # -- liste (sitemap) ----------------------------------------------------
++    def _sitemap(self) -> list[tuple[str, str]]:
++        """[(url fiche, lastmod)] — dédupliqué, sans la page index."""
++        xml = self.get(SITEMAP).text
++        seen: dict[str, str] = {}
++        for m in re.finditer(r"(?s)<url>\s*<loc>([^<]+)</loc>"
++                             r"(?:\s*<lastmod>([^<]+)</lastmod>)?", xml):
++            url, lastmod = m.group(1).strip(), (m.group(2) or "").strip()
++            if re.fullmatch(rf"{re.escape(SITE)}/condos/[^/]+/", url):
++                seen.setdefault(url, lastmod)
++        return sorted(seen.items())
++
++    # -- page détail ------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        # spécs : <span class="icon-condos">… 8 Personnes / 3 chambres / …
++        extras: list[str] = []
++        for raw in re.findall(r'(?s)<span class="icon-condos"[^>]*>(.*?)</span>',
++                              h):
++            t = _text(raw)
++            if not t:
++                continue
++            m = re.match(r"(\d+)\s*[Pp]ersonnes?", t)
++            if m:
++                d["capacity"] = float(m.group(1))
++                continue
++            m = re.match(r"(\d+)\s*[Cc]hambres?", t)
++            if m:
++                d["bedrooms"] = float(m.group(1))
++                continue
++            m = re.match(r"(\d+)\s*[Ss]alles?\s*de\s*bain", t)
++            if m:
++                d["bathrooms"] = float(m.group(1))
++                continue
++            if len(t) <= 60:
++                extras.append(t)
++        if extras:
++            d["amenities"] = extras
++
++        # description : JSON-LD Yoast (WebPage.description)
++        m = re.search(r'(?s)<script type="application/ld\+json"[^>]*>'
++                      r"(.*?)</script>", h)
++        if m:
++            try:
++                graph = json.loads(m.group(1)).get("@graph") or []
++                for node in graph:
++                    if node.get("@type") == "WebPage" and node.get("description"):
++                        d["description"] = _text(node["description"])[:4000]
++                        break
++            except ValueError:
++                pass
++
++        # id Guesty (lien « réserver » guestybookings.com)
++        m = re.search(r"guestybookings\.com/(?:fr/)?properties/([a-f0-9]{24})",
++                      h)
++        if m:
++            d["guesty_id"] = m.group(1)
++
++        # photos : uploads WP (originaux, sans logos ni vignettes -NxN)
++        imgs: list[str] = []
++        for u in re.findall(r'(https://accestremblant\.ca/wp-content/uploads/'
++                            r'20\d\d/\d\d/[^" ]+\.(?:jpe?g|png|webp))', h):
++            if re.search(r"-\d{2,4}x\d{2,4}\.", u):
++                continue
++            if re.search(r"logo|favicon|icon", u, re.I):
++                continue
++            if u not in imgs:
++                imgs.append(u)
++        d["images"] = imgs[:20]
++
++        # carte des prix « autres condos » : slug → à partir de N $
++        prices: dict[str, float] = {}
++        for slug, val in re.findall(
++                r'href="https://accestremblant\.ca/condos/([^"/]+)/"[^>]*>'
++                r"\s*À partir de\s*([\d ,]+)\s*\$", h):
++            try:
++                prices[slug] = float(val.replace(" ", "").replace(",", "."))
++            except ValueError:
++                continue
++        d["prices_seen"] = prices
++        return d
++
++    # -- contrat ----------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        rows = []
++        price_map: dict[str, float] = {}
++        for url, lastmod in self._sitemap():
++            slug = url.rstrip("/").rsplit("/", 1)[-1]
++            try:
++                det = self.detail(slug, lastmod, lambda u=url: self._detail(u))
++            except Exception:
++                continue
++            price_map.update(det.get("prices_seen") or {})
++            rows.append((slug, url, det))
++
++        listings: list[StListing] = []
++        for slug, url, det in rows:
++            title = slug.replace("-", " ").title()
++            desc = det.get("description") or ""
++            m = re.match(r"([^|]{2,60})\|", desc)
++            if m:                      # « Verbier C | Découvrez… »
++                title = m.group(1).strip()
++                desc = desc.split("|", 1)[1].strip()
++            price = price_map.get(slug)
++
++            details = {k: v for k, v in {
++                "guesty_id": det.get("guesty_id"),
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=url,
++                title=title,
++                property_type="Condo",
++                city="Mont-Tremblant",
++                region="Laurentides",
++                price_night=price,
++                price_label=(f"à partir de {price:.0f} $ / nuit"
++                             if price else ""),
++                capacity=det.get("capacity"),
++                bedrooms=det.get("bedrooms"),
++                bathrooms=det.get("bathrooms"),
++                description=desc[:4000],
++                amenities=det.get("amenities") or [],
++                details=details,
++                images=det.get("images") or [],
++            ))
++        return listings

modified louka/shortterm/connectors/airbnb.py +183 −1

+ # L'ordre des cellules est mélangé à chaque run pour que les cellules restantes
+ # après épuisement du budget tournent d'un run à l'autre.
+ #
++# Enrichissement détail : la fiche /rooms/<id> embarque le même genre de JSON
++# (<script data-deferred-state-0> → data.node.pdpPresentation) avec description
++# longue (descriptions.longDescriptionHtml), capacité (personCapacity +
++# overview.items "6 guests · 2 bedrooms…"), commodités groupées
++# (amenities.seeAllAmenitiesGroups, drapeau available), règles (rules.groupItems
++# → animaux) et municipalité (localizedLocation). Visite via le cache détail
++# self.detail() (louka_ct.db) avec budget par run : le parc (~15 000) se
++# remplit au fil des syncs. Les échecs réseau/anti-bot ne sont PAS mis en
++# cache (retentés au prochain run) ; 8 échecs consécutifs coupent
++# l'enrichissement du run (tempête anti-bot).
++#
+ # Réglages env : LOUKA_AIRBNB_PAGES (pages par cellule feuille, défaut 15),
+ #                LOUKA_AIRBNB_BUDGET (budget de requêtes HTML, défaut 1200),
++#                LOUKA_AIRBNB_DEPTH (profondeur max du quadtree, défaut 7),
++#                LOUKA_AIRBNB_DETAIL_LIMIT (fiches détail par run, défaut 800).
+ # -----------------------------------------------------------------------------
+ from __future__ import annotations
+ _MONEY_RE = re.compile(r"\$\s*([\d,]+(?:\.\d+)?)")
+ _NUM_RE = re.compile(r"(\d+(?:\.\d+)?)")
++# Clé de version du parseur de fiche détail (bump → re-visite du parc)
++_PDP_KEY = "pdp-v1"
++
++
++class _DetailSkip(Exception):
++    """Fiche détail indisponible ce run (budget épuisé, blocage anti-bot) —
++    on ne met RIEN en cache pour retenter au prochain sync."""
++
++
++def _html_to_text(fragment: str) -> str:
++    """HTML de description Airbnb (<br />, <b>…) → texte propre."""
++    import html as _h
++    txt = re.sub(r"<br\s*/?>", "\n", fragment)
++    txt = re.sub(r"<[^>]+>", " ", txt)
++    txt = _h.unescape(txt)
++    txt = re.sub(r"[ \t]+", " ", txt)
++    txt = re.sub(r" ?\n ?", "\n", txt)
++    return re.sub(r"\n{3,}", "\n\n", txt).strip()
++
+ def _b64_room_id(demand_id: str) -> str:
+     """"RGVtYW5kU3RheUxpc3Rpbmc6MTIz" → "123" (DemandStayListing:<id>)."""
+         return self.get_scrapfly(url, render_js=True, asp=True,
+                                  rendering_wait=3000)
++    # -- fiche détail (/rooms/<id>) --------------------------------------------
++    def _pdp_html(self, room_id: str) -> str:
++        """HTML d'une fiche : Bright Data d'abord, Scrapfly ASP en secours
++        (pas de rendu JS : le JSON est embarqué côté serveur)."""
++        url = f"https://www.airbnb.ca/rooms/{room_id}?locale=en&currency=CAD"
++        html = self._brightdata(url)
++        if "data-deferred-state" in html:
++            return html
++        try:
++            return self.get_scrapfly(url, render_js=False, asp=True)
++        except Exception:  # noqa: BLE001 — 429/403/timeout : simple échec
++            return ""
++
++    @staticmethod
++    def _parse_pdp(html: str) -> dict:
++        """Champs riches depuis data.node.pdpPresentation du JSON embarqué."""
++        pp = None
++        for blob in re.findall(
++                r'<script[^>]+id="data-deferred-state[^"]*"[^>]*>(.*?)</script>',
++                html, re.S):
++            try:
++                data = json.loads(blob)
++            except ValueError:
++                continue
++            for entry in data.get("niobeClientData") or []:
++                if not (isinstance(entry, list) and len(entry) > 1
++                        and isinstance(entry[1], dict)):
++                    continue
++                node = ((entry[1].get("data") or {}).get("node") or {})
++                if isinstance(node.get("pdpPresentation"), dict):
++                    pp = node["pdpPresentation"]
++                    break
++            if pp:
++                break
++        if not pp:
++            return {}
++
++        out: dict = {}
++        # description longue : texte ORIGINAL de l'hôte (souvent français au
++        # Québec), repli sur la version traduite
++        desc = (pp.get("descriptions") or {}).get("longDescriptionHtml") or {}
++        txt = (desc.get("localizedString")
++               or desc.get("localizedStringWithTranslationPreference") or "")
++        if txt:
++            out["description"] = _html_to_text(txt)[:6000]
++
++        cap = pp.get("personCapacity")
++        if isinstance(cap, (int, float)) and 0 < cap <= 200:
++            out["capacity"] = float(cap)
++
++        # overview.items : "6 guests", "2 bedrooms", "3 beds", "2 baths"
++        ov = pp.get("overview") or {}
++        for item in ov.get("items") or []:
++            low = (item or "").lower()
++            m = _NUM_RE.search(low)
++            if not m:
++                continue
++            val = float(m.group(1))
++            if "guest" in low:
++                out.setdefault("capacity", val)
++            elif "bedroom" in low:
++                out["bedrooms"] = val
++            elif "bed" in low:
++                out["beds"] = val
++            elif "bath" in low:
++                out["bathrooms"] = val
++        if ov.get("title"):
++            out["overview_title"] = ov["title"]
++
++        # commodités disponibles (les groupes "Not included" ont available=False)
++        amen: list[str] = []
++        for grp in (pp.get("amenities") or {}).get("seeAllAmenitiesGroups") or []:
++            for a in grp.get("amenities") or []:
++                t = (a.get("title") or "").strip()
++                if a.get("available") and t and t not in amen:
++                    amen.append(t)
++        if amen:
++            out["amenities"] = amen[:120]
++
++        # règles de la maison → animaux ("No pets", "Pets allowed", "2 pets…")
++        for grp in (pp.get("rules") or {}).get("groupItems") or []:
++            for it in grp.get("items") or []:
++                if it.get("type") != "HOUSE_RULES_PETS":
++                    continue
++                t = (it.get("title") or "").lower()
++                if "no pets" in t or "pas d" in t or "aucun animal" in t:
++                    out["pets"] = "non"
++                elif "pets allowed" in t or "animaux accept" in t:
++                    out["pets"] = "oui"
++                elif t:
++                    out["pets"] = "conditions"
++
++        loc = (pp.get("localizedLocation") or "").split(",")[0].strip()
++        if loc:
++            out["city"] = loc
++        return out
++
++    @staticmethod
++    def _apply_pdp(lst: StListing, p: dict) -> None:
++        """Applique un payload détail sans écraser ce que la carte a fourni."""
++        if p.get("description") and not lst.description:
++            lst.description = p["description"]
++        if p.get("amenities") and not lst.amenities:
++            lst.amenities = list(p["amenities"])
++        for attr in ("capacity", "bedrooms", "beds", "bathrooms"):
++            if getattr(lst, attr) is None and p.get(attr) is not None:
++                setattr(lst, attr, p[attr])
++        if p.get("pets") and lst.pets is None:
++            lst.pets = p["pets"]
++        if p.get("city") and not lst.city:
++            lst.city = p["city"]
++        if not lst.property_type and p.get("overview_title"):
++            ptype, _ = _card_type_and_city(p["overview_title"])
++            lst.property_type = ptype
++        lst.finalize()   # drapeaux/citq/pets dérivés du nouveau texte
++
++    def _enrich_details(self, listings: list[StListing]) -> None:
++        """Visite les fiches détail via le cache self.detail() sous budget :
++        les hits de cache sont gratuits, seuls les fetchs réseau comptent."""
++        limit = max(0, int(os.environ.get("LOUKA_AIRBNB_DETAIL_LIMIT", "800")
++                           or 800))
++        used = enriched = 0
++        streak = 0                       # échecs réseau consécutifs
++
++        for lst in listings:
++            def fetch_fn(rid=lst.external_id):
++                nonlocal used, streak
++                if used >= limit or streak >= 8:
++                    raise _DetailSkip
++                used += 1
++                html = self._pdp_html(rid)
++                if "data-deferred-state" not in html:
++                    streak += 1
++                    raise _DetailSkip    # blocage/vide : pas de mise en cache
++                streak = 0
++                return self._parse_pdp(html)
++
++            try:
++                payload = self.detail(lst.external_id, _PDP_KEY, fetch_fn)
++            except _DetailSkip:
++                continue
++            except Exception:  # noqa: BLE001 — une fiche ne bloque pas le run
++                continue
++            if payload:
++                self._apply_pdp(lst, payload)
++                enriched += 1
++        print(f"[airbnb] détail : {enriched} annonces enrichies"
++              f" ({used}/{limit} fetchs réseau, série d'échecs {streak})",
++              file=sys.stderr)
++
+     # -- parse JSON embarqué ----------------------------------------------------
+     @staticmethod
+     def _deferred_results(html: str) -> tuple[list[dict], list[str]]:
+         if stack:
+             print(f"[airbnb] budget épuisé ({budget} req),"
+                   f" {len(stack)} cellules non visitées", file=sys.stderr)
++        self._enrich_details(out)
+         return out

added louka/shortterm/connectors/alouerauxiles.py +202 −0

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/alouerauxiles.py : À louer aux Îles (alouerauxiles.com)
++#
++# Annuaire local des Îles-de-la-Madeleine (~100 maisons/chalets, région très
++# mal couverte ailleurs). Site statique « Tactical Soft » : cartes par île.
++#
++# Méthode :
++#   1. LISTE : les pages d'île FR (/havre-aubert, /cap-aux-meules, …) sont du
++#      HTML serveur contenant un bloc `<div class=item id=<id> tag=rent …>`
++#      par annonce : id stable, nom (alt="…"), capacité/chambres
++#      (cap="3 chambres (5 pers. max)"), prix (dayrate=186, $/nuit calculé)
++#      et lien public (href=https://alouerauxiles.com/<slug>). Dédup par id
++#      (une annonce peut apparaître sur plusieurs pages).
++#   2. DÉTAIL (cache self.detail) : /php/page_fr.php?id=<id> → type
++#      d'hébergement, personnes/chambres/salles de bain (attributs title=),
++#      animaux, description, permis CITQ, adresse + ville (après le code
++#      postal), commodités (« Commodités : ») et photos (pages/idlm/rent/…).
++#   External_id = id du bloc item (numérique ou slug, stable).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://alouerauxiles.com"
++WWW = "https://www.alouerauxiles.com"
++
++# pages d'île francophones (les slugs anglais sont des doublons)
++ISLANDS = ["havre-aubert", "cap-aux-meules", "havre-aux-maisons",
++           "pointe-aux-loups", "grosse-ile", "grande-entree", "ile-d-entree"]
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++# libellé du site → type canonique Lou-Ka
++_TYPES = {"chalet": "Chalet", "maison": "Maison", "résidence": "Maison",
++          "studio": "Studio", "appartement": "Appartement", "loft": "Loft",
++          "chambre": "Chambre", "gîte": "Gîte", "auberge": "Auberge"}
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))
++                          ).replace("", "").strip()
++
++
++def _num(raw) -> float | None:
++    m = re.search(r"\d+(?:[.,]\d+)?", str(raw or ""))
++    return float(m.group(0).replace(",", ".")) if m else None
++
++
++class ALouerAuxIles(StConnector):
++    source_id = "alouerauxiles"
++
++    # -- liste (pages d'île) --------------------------------------------------
++    def _island_items(self) -> dict[str, dict]:
++        items: dict[str, dict] = {}
++        for island in ISLANDS:
++            try:
++                h = self.get(f"{WWW}/{island}").text
++            except Exception:
++                continue
++            for block in re.findall(r"<div class=item ([^>]+)>", h):
++                if "tag=rent" not in block:
++                    continue
++                m = re.search(r"\bid=([\w-]+)", block)
++                if not m:
++                    continue
++                lid = m.group(1)
++                it = items.setdefault(lid, {"island": island})
++                m = re.search(r'alt="([^"]+)"', block)
++                if m:
++                    it["name"] = _text(m.group(1))
++                m = re.search(r'cap="(\d+)\s*chambres?\s*\((\d+)\s*pers',
++                              block)
++                if m:
++                    it["bedrooms"] = float(m.group(1))
++                    it["capacity"] = float(m.group(2))
++                m = re.search(r"\bdayrate=(\d+(?:\.\d+)?)", block)
++                if m:
++                    it["dayrate"] = float(m.group(1))
++                m = re.search(r"href=(https://alouerauxiles\.com/[\w-]+)\b",
++                              block)
++                if m:
++                    it["url"] = m.group(1)
++        return items
++
++    # -- page détail ------------------------------------------------------
++    def _detail(self, lid: str) -> dict:
++        h = self.get(f"{SITE}/php/page_fr.php", params={"id": lid}).text
++        d: dict = {}
++
++        m = re.search(r"<b class=t1>([^<]+)</b>", h)
++        if m:
++            d["type_label"] = _text(m.group(1))
++
++        m = re.search(r'title="(\d+)\s*personnes', h)
++        if m:
++            d["capacity"] = float(m.group(1))
++        m = re.search(r'title="(\d+)\s*chambres?"', h)
++        if m:
++            d["bedrooms"] = float(m.group(1))
++        m = re.search(r'title="(\d+)\s*salle\(?s?\)?\s*de\s*bain', h)
++        if m:
++            d["bathrooms"] = float(m.group(1))
++        m = re.search(r'title="\s*animaux([^"]*)"', h)
++        if m:
++            d["pets"] = "non" if "non" in m.group(1).lower() else "oui"
++
++        # description : bloc txtdiv (nom + texte de présentation)
++        m = re.search(r"(?s)<div id=txtdiv>(.*?)</div>", h)
++        if m:
++            frag = re.sub(r"(?s)<b class=t2>.*?</b>", " ", m.group(1))
++            d["description"] = _text(frag)[:4000]
++        m = re.search(r"(?s)<b class=t2>([^<]+)</b>",
++                      h[h.find("txtdiv"):] if "txtdiv" in h else "")
++        if m:
++            d["title"] = _text(m.group(1))
++
++        m = re.search(r"CITQ\D{0,12}(\d{6})", h, re.I)
++        if m:
++            d["citq"] = m.group(1)
++
++        # adresse : rue + « G4T 3H6 l'Étang-du-Nord » → ville après le code
++        m = re.search(r"(?s)Adresse\s*:\s*</b>(.*?)(?:<b class|Contact)", h)
++        if m:
++            lines = [_text(x) for x in re.split(r"<br\s*/?>", m.group(1))]
++            lines = [x for x in lines if x]
++            if lines:
++                d["address"] = lines[0]
++            for x in lines:
++                pm = re.search(r"[A-Z]\d[A-Z]\s?\d[A-Z]\d\s+(.{3,40})$", x)
++                if pm:
++                    d["city"] = pm.group(1).strip()
++                    break
++
++        # commodités : lignes « - … » entre « Commodités : » et « À proximité »
++        m = re.search(r"(?s)Commodités\s*:(.*?)(?:À proximité|Contact\s*:|$)",
++                      h)
++        if m:
++            amens = [_text(x).lstrip("- ").strip()
++                     for x in re.split(r"<br\s*/?>", m.group(1))]
++            d["amenities"] = [a for a in amens if 2 <= len(a) <= 80][:50]
++
++        # photos du dossier de l'annonce (originaux img/, pas les vignettes)
++        imgs: list[str] = []
++        for u in re.findall(r"[\"'=](?:\.\./)?(pages/idlm/rent/[\w-]+/img/"
++                            r"[^\"'\s>]+\.(?:jpe?g|png|webp))", h, re.I):
++            full = f"{SITE}/{u}"
++            if full not in imgs:
++                imgs.append(full)
++        d["images"] = imgs[:20]
++        return d
++
++    # -- contrat ----------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for lid, it in self._island_items().items():
++            key = f"{it.get('name', '')}|{it.get('capacity', '')}|" \
++                  f"{it.get('dayrate', '')}|{it.get('bedrooms', '')}"
++            try:
++                det = self.detail(lid, key, lambda i=lid: self._detail(i))
++            except Exception:
++                det = {}
++            title = det.get("title") or it.get("name") or ""
++            if not title:
++                continue
++
++            type_label = (det.get("type_label") or "").lower()
++            ptype = ""
++            for needle, canon in _TYPES.items():
++                if needle in type_label:
++                    ptype = canon
++                    break
++
++            price = it.get("dayrate")
++            city = det.get("city") or it["island"].replace("-", " ").title()
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=lid,
++                url=it.get("url") or f"{SITE}/php/page_fr.php?id={lid}",
++                title=title,
++                property_type=ptype or "Maison",
++                address=det.get("address") or "",
++                city=city,
++                region="Îles-de-la-Madeleine",
++                price_night=price,
++                price_label=(f"à partir de {price:.0f} $ / nuit"
++                             if price else ""),
++                capacity=det.get("capacity") or it.get("capacity"),
++                bedrooms=det.get("bedrooms") or it.get("bedrooms"),
++                bathrooms=det.get("bathrooms"),
++                pets=det.get("pets"),
++                citq=det.get("citq") or "",
++                description=det.get("description") or "",
++                amenities=det.get("amenities") or [],
++                details={"ile": it["island"]},
++                images=det.get("images") or [],
++            ))
++        return listings

modified louka/shortterm/connectors/bonjourquebec.py +55 −5

				`@@ -18,10 +18,16 @@`
18	# quelques milliers max) — gîtes et insolites sont gardés en entier ;	18	# quelques milliers max) — gîtes et insolites sont gardés en entier ;
19	# 3. fiche /fiche/<id> (cache self.detail — 1 seule visite par fiche) :	19	# 3. fiche /fiche/<id> (cache self.detail — 1 seule visite par fiche) :
20	# région touristique, ville, adresse, no d'enregistrement CITQ,	20	# région touristique, ville, adresse, no d'enregistrement CITQ,
21	−# description, services/équipements, animaux, tarifs max (détails),	21	+# description, services/équipements, animaux, tarifs, photos.
22	−# photos. Pas de prix « à partir de » sur le site → seuls les maximums	22	+# PRIX : le site ne publie QUE des maximums par nuitée (widget Tarifs :
23	−# affichés sont conservés dans details (jamais utilisés comme	23	+# « Maximum pour l'unité la plus chère », « Prix maximum par nuitée
24	−# price_night pour ne pas fausser le « à partir de »).	24	+# prêt-à-camper »). On les expose honnêtement via price_label
		25	+# (« maximum X $ / nuit ») — finalize() en déduit price_night ; le
		26	+# libellé garde la nuance (ce n'est pas un « à partir de »). Les
		27	+# emplacements de camping nu sont ignorés (hors mandat).
		28	+# CAPACITÉ : jamais publiée en « personnes » sur les fiches — on récupère
		29	+# ce qui existe : chambres des gîtes (« Chambre : N unités ») et
		30	+# mentions « N personnes » dans la description (rare).
25	# -----------------------------------------------------------------------------	31	# -----------------------------------------------------------------------------
26	from __future__ import annotations	32	from __future__ import annotations
27		33
				`@@ -60,6 +66,38 @@ _TYPE_KEYWORDS = [`
60	]	66	]
61		67
62		68
		69	+_PRICE_VAL_RE = re.compile(r"\d[\d\s ,.]*\$")
		70	+_CAP_RE = re.compile(r"(\d{1,2})\s*personnes")
		71	+_CHAMBRES_RE = re.compile(r"^Chambre\s:\s(\d+)\s*unité", re.I)
		72	+
		73	+
		74	+def _price_label(tarifs: list[str]) -> str:
		75	+ """Libellé prix/nuit depuis le widget Tarifs (le site n'affiche que des
		76	+ maximums par nuitée). Priorité : unité la plus chère > prêt-à-camper >
		77	+ autre « par nuitée » — emplacements de camping nu exclus."""
		78	+ pairs: list[tuple[str, str]] = []
		79	+ label = ""
		80	+ for txt in tarifs or []:
		81	+ m = _PRICE_VAL_RE.search(txt)
		82	+ if m and label:
		83	+ pairs.append((label.lower(), re.sub(r"[\s ]+", " ",
		84	+ m.group(0)).strip()))
		85	+ label = ""
		86	+ elif not m and txt:
		87	+ label = txt
		88	+
		89	+ def pick(needle: str, exclude: str = "") -> str:
		90	+ for lab, val in pairs:
		91	+ if needle in lab and (not exclude or exclude not in lab):
		92	+ return val
		93	+ return ""
		94	+
		95	+ val = (pick("unité la plus chère")
		96	+ or pick("prêt-à-camper")
		97	+ or pick("nuit", exclude="camping"))
		98	+ return f"maximum {val} / nuit" if val else ""
		99	+
		100	+
63	def _abs(url: str) -> str:	101	def _abs(url: str) -> str:
64	url = _html.unescape(url or "").strip()	102	url = _html.unescape(url or "").strip()
65	if not url:	103	if not url:
				`@@ -233,6 +271,16 @@ class BonjourQuebec(StConnector):`
233	"unites": d.get("unites"),	271	"unites": d.get("unites"),
234	}.items() if v}	272	}.items() if v}
235		273
		274	+ # capacité : mention « N personnes » dans la description (rare)
		275	+ caps = [int(x) for x in _CAP_RE.findall(desc) if 1 <= int(x) <= 40]
		276	+ capacity = float(max(caps)) if caps else None
		277	+ # chambres : les gîtes déclarent « Chambre : N unités »
		278	+ bedrooms = None
		279	+ for u in d.get("unites") or []:
		280	+ m = _CHAMBRES_RE.match(u)
		281	+ if m and 0 < int(m.group(1)) <= 30:
		282	+ bedrooms = float(m.group(1))
		283	+
236	url = d.get("url_final") or f"{BASE}/fiche/{ext}"	284	url = d.get("url_final") or f"{BASE}/fiche/{ext}"
237	lst = StListing(	285	lst = StListing(
238	source=self.source_id,	286	source=self.source_id,
				`@@ -243,7 +291,9 @@ class BonjourQuebec(StConnector):`
243	address=d.get("address", ""),	291	address=d.get("address", ""),
244	city=d.get("city", ""),	292	city=d.get("city", ""),
245	region=d.get("region", ""),	293	region=d.get("region", ""),
246	− capacity=None,	294	+ price_label=_price_label(d.get("tarifs") or []),
		295	+ capacity=capacity,
		296	+ bedrooms=bedrooms,
247	pets=d.get("pets"),	297	pets=d.get("pets"),
248	citq=d.get("citq", ""),	298	citq=d.get("citq", ""),
249	description=desc,	299	description=desc,

modified louka/shortterm/connectors/booking.py +124 −1

+ # Recherche AVEC dates génériques (~30 jours, 2 nuits) : sans dates, Booking
+ # ne renvoie ni prix ni configuration des unités. Le prix est donc indicatif
+ # → price_label « à partir de … » + price_night (le plus bas trouvé).
++#
++# Enrichissement : la page détail /hotel/ca/<pageName>.fr.html (Scrapfly ASP
++# SANS rendu JS) embarque son propre store Apollo SSR : description complète
++# (data-testid="property-description"), commodités localisées (entités
++# Instance/SimpleFacility) et galerie (AccommodationPhoto). Vérifié live
++# 2026-08-25 sur /hotel/ca/renarde.fr.html.
++# Réglage env : LOUKA_BOOKING_DETAIL_LIMIT (fetchs détail par sync, défaut
++# 150 ; cache permanent dans louka_ct.db, le parc se complète au fil des syncs).
+ # -----------------------------------------------------------------------------
+ from __future__ import annotations
+ import datetime
+ import html as _html
+ import json
++import os
+ import re
+ import sys
+ from urllib.parse import quote
+ from ..schema import StListing
+ from .base import StConnector
++
++class _DetailSkip(Exception):
++    """Fiche détail sautée (budget épuisé / page bloquée) — pas de cache."""
++
+ # (texte de recherche Booking, région touristique QC)
+ DESTINATIONS = [
+     ("Mont-Tremblant", "Laurentides"),
+ _CAPLA_RE = re.compile(
+     r'<script[^>]*data-capla-store-data="apollo"[^>]*>(.*?)</script>', re.S)
+ _IMG_BASE = "https://cf.bstatic.com"
++_DESC_RE = re.compile(
++    r'data-testid="property-description"[^>]*>(.*?)</(?:p|div)>', re.S)
+ class Booking(StConnector):
+             lng=loc.get("longitude"),
+         )
++    # -- page détail ------------------------------------------------------------
++    @staticmethod
++    def _parse_detail(html: str) -> dict:
++        """Payload {description, amenities, images} d'une page détail Booking
++        ({} si page bloquée/invalide)."""
++        out: dict = {}
++
++        # description complète (SSR) — HTML → texte
++        m = _DESC_RE.search(html or "")
++        if m:
++            txt = re.sub(r"<br\s*/?>|</p>", "\n", m.group(1))
++            txt = _html.unescape(re.sub(r"<[^>]+>", " ", txt))
++            lines = [re.sub(r"\s+", " ", ln).strip() for ln in txt.split("\n")]
++            desc = "\n".join(ln for ln in lines if ln).strip()
++            if desc:
++                out["description"] = desc[:6000]
++
++        # store Apollo de la page détail : commodités localisées + galerie
++        mm = _CAPLA_RE.search(html or "")
++        if mm:
++            try:
++                store = json.loads(mm.group(1))
++            except ValueError:
++                try:
++                    store = json.loads(_html.unescape(mm.group(1)))
++                except ValueError:
++                    store = {}
++            amenities: list[str] = []
++            for key, val in store.items():
++                if not isinstance(val, dict):
++                    continue
++                name = ""
++                if key.startswith("Instance:"):          # équipements du lieu
++                    name = (val.get("title") or "").strip()
++                elif key.startswith("SimpleFacility:"):  # équipements des unités
++                    name = (val.get("name") or "").strip()
++                if name and name not in amenities:
++                    amenities.append(name)
++            if amenities:
++                out["amenities"] = amenities[:80]
++
++            images: list[str] = []
++            for key, val in store.items():
++                if not (key.startswith("AccommodationPhoto:")
++                        and isinstance(val, dict)):
++                    continue
++                for k2, v2 in val.items():
++                    if k2.startswith("resource(") and isinstance(v2, dict) \
++                            and v2.get("relativeUrl"):
++                        rel = re.sub(r"/(?:square|max)\w+/", "/max1024x768/",
++                                     v2["relativeUrl"], count=1)
++                        u = _IMG_BASE + rel
++                        if u not in images:
++                            images.append(u)
++                        break
++                if len(images) >= 15:
++                    break
++            if images:
++                out["images"] = images
++        return out
++
++    def _enrich_details(self, listings: list[StListing]) -> None:
++        """Visite les fiches détail via le cache self.detail() sous budget :
++        les hits de cache sont gratuits, seuls les fetchs réseau comptent."""
++        limit = max(0, int(os.environ.get("LOUKA_BOOKING_DETAIL_LIMIT", "150")
++                           or 150))
++        used = enriched = streak = 0
++        for lst in listings:
++            def fetch_fn(url=lst.url):
++                nonlocal used, streak
++                if used >= limit or streak >= 5:   # tempête anti-bot : on coupe
++                    raise _DetailSkip
++                used += 1
++                res = self.scrapfly(url, render_js=False, asp=True)
++                if res.get("status_code") in (404, 410):
++                    return {}                      # fiche retirée : cacher vide
++                payload = self._parse_detail(res.get("content") or "")
++                if not payload:
++                    streak += 1
++                    raise _DetailSkip              # blocage/vide : pas de cache
++                streak = 0
++                return payload
++
++            try:
++                d = self.detail(lst.external_id, "v1", fetch_fn)
++            except _DetailSkip:
++                continue
++            except Exception:  # noqa: BLE001 — une fiche ne bloque pas le run
++                continue
++            if not d:
++                continue
++            if d.get("description") and len(d["description"]) > \
++                    len(lst.description or ""):
++                lst.description = d["description"]
++            if d.get("amenities"):
++                seen = {a.lower() for a in lst.amenities}
++                for a in d["amenities"]:
++                    if a.lower() not in seen:
++                        lst.amenities.append(a)
++                        seen.add(a.lower())
++            if d.get("images") and len(d["images"]) > len(lst.images):
++                lst.images = list(d["images"])
++            enriched += 1
++        print(f"[booking] détail : {enriched} annonces enrichies"
++              f" ({used}/{limit} fetchs réseau)", file=sys.stderr)
++
+     # -- contrat ---------------------------------------------------------------
+     def fetch(self) -> list[StListing]:
+         today = datetime.date.today()
+                         continue
+                     if lst and lst.external_id not in listings:
+                         listings[lst.external_id] = lst
++        out = list(listings.values())
++        self._enrich_details(out)
++        return out

added louka/shortterm/connectors/boraboreal.py +174 −0

Large diff (174 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/campingquebec.py +274 −0

Large diff (274 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/captremblant.py +157 −0

Large diff (157 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/chaleto.py +198 −0

Large diff (198 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/chaletsalpins.py +200 −0

Large diff (200 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/chaletsbsl.py +168 −0

Large diff (168 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/chaletsdanslenord.py +219 −0

Large diff (219 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/domesstcome.py +157 −0

Large diff (157 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/expedia.py +51 −3

Large diff (83 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/gitesauquebec.py +218 −0

Large diff (218 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/gitespassant.py +29 −4

Large diff (72 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/glampinghub.py +71 −2

Large diff (101 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/hebergementcharlevoix.py +164 −0

Large diff (164 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/hebergia.py +164 −0

Large diff (164 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/homminichalets.py +142 −0

Large diff (142 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/kijiji.py +95 −25

Large diff (174 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/lesversants.py +156 −0

Large diff (156 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/locationdechalets.py +265 −0

Large diff (265 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/memoriachalets.py +248 −0

Large diff (248 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/panoraloges.py +135 −0

Large diff (135 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/parcscanada.py +135 −15

Large diff (193 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/pourvoiries.py +288 −0

Large diff (288 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/qldc.py +54 −7

Large diff (100 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/rezerve.py +116 −0

Large diff (116 lines) is not loaded by default to keep the page fast.Load diff

added louka/shortterm/connectors/rvmt.py +215 −0

Large diff (215 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/sepaq.py +141 −2

Large diff (182 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/sinistar.py +4 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/tremblantliving.py +63 −2

Large diff (103 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/connectors/vrbo.py +55 −6

Large diff (101 lines) is not loaded by default to keep the page fast.Load diff

modified louka/shortterm/web.py +123 −0

Large diff (136 lines) is not loaded by default to keep the page fast.Load diff

spb/lou-ka

Court terme : upgrade majeur — 21 nouveaux connecteurs, 12 enrichis, fiches améliorées

Theme